Adds Async overloads to Consume

Source/Esendex.TokenBucket.Tests/TokenBucketTests.cs

@@ -87,6 +87,15 @@ public void ConsumeWhenTokenAvailable()
             _sleepStrategy.Verify(s => s.Sleep(), Times.Never());
         }
 
+        [Test, Timeout(ConsumeTimeout)]
+        public void ConsumeAsyncWhenTokenAvailable()
+        {
+            _refillStrategy.AddToken();
+            _bucket.ConsumeAsync().Wait();
+
+            _sleepStrategy.Verify(s => s.Sleep(), Times.Never());
+        }
+
         [Test, Timeout(ConsumeTimeout)]
         public void ConsumeWhenTokensAvailable()
         {
@@ -97,6 +106,16 @@ public void ConsumeWhenTokensAvailable()
             _sleepStrategy.Verify(s => s.Sleep(), Times.Never());
         }
 
+        [Test, Timeout(ConsumeTimeout)]
+        public void ConsumeAsyncWhenTokensAvailable()
+        {
+            const int tokensToConsume = 2;
+            _refillStrategy.AddTokens(tokensToConsume);
+            _bucket.ConsumeAsync(tokensToConsume).Wait();
+
+            _sleepStrategy.Verify(s => s.Sleep(), Times.Never());
+        }
+
         [Test, Timeout(ConsumeTimeout)]
         public void ConsumeWhenTokenUnavailable()
         {
@@ -110,6 +129,19 @@ public void ConsumeWhenTokenUnavailable()
             _sleepStrategy.Verify();
         }
 
+        [Test, Timeout(ConsumeTimeout)]
+        public void ConsumeAsyncWhenTokenUnavailable()
+        {
+            _sleepStrategy
+                .Setup(s => s.Sleep())
+                .Callback(_refillStrategy.AddToken)
+                .Verifiable();
+
+            _bucket.ConsumeAsync().Wait();
+
+            _sleepStrategy.Verify();
+        }
+
         [Test, Timeout(ConsumeTimeout)]
         public void ConsumeWhenTokensUnavailable()
         {
@@ -124,6 +156,20 @@ public void ConsumeWhenTokensUnavailable()
             _sleepStrategy.Verify();
         }
 
+        [Test, Timeout(ConsumeTimeout)]
+        public void ConsumeAsyncWhenTokensUnavailable()
+        {
+            const int tokensToConsume = 7;
+            _sleepStrategy
+                .Setup(s => s.Sleep())
+                .Callback(() => _refillStrategy.AddTokens(tokensToConsume))
+                .Verifiable();
+
+            _bucket.ConsumeAsync(tokensToConsume).Wait();
+
+            _sleepStrategy.Verify();
+        }
+
         private sealed class MockRefillStrategy : IRefillStrategy
         {
             private long _numTokensToAdd;

Source/Esendex.TokenBucket/ITokenBucket.cs

@@ -1,3 +1,5 @@
+using System.Threading.Tasks;
+
 namespace Esendex.TokenBucket
 {
     /// <summary>
@@ -29,10 +31,23 @@ public interface ITokenBucket
         /// </summary>
         void Consume();
 
+        /// <summary>
+        /// Consume a single token from the bucket asynchronously. This method does not block
+        /// <returns>A task that returns once a token has been consumed</returns>
+        /// </summary>
+        Task ConsumeAsync();
+
         /// <summary>
         /// Consumes multiple tokens from the bucket.  If enough tokens are not currently available then this method will block
         /// </summary>
         /// <param name="numTokens">The number of tokens to consume from the bucket, must be a positive number.</param>
         void Consume(long numTokens);
+
+        /// <summary>
+        /// Consume multiple tokens from the bucket asynchronously. This method does not block
+        /// <param name="numTokens">The number of tokens to consume from the bucket, must be a positive number.</param>
+        /// <returns>A task that returns once the requested tokens have been consumed</returns>
+        /// </summary>
+        Task ConsumeAsync(long numTokens);
     }
 }

Source/Esendex.TokenBucket/TokenBucket.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 
 namespace Esendex.TokenBucket
 {
@@ -72,25 +73,44 @@ public bool TryConsume(long numTokens)
         /// <summary>
         /// Consume a single token from the bucket.  If no token is currently available then this method will block until a
         /// token becomes available.
-        /// </summary>
-        public void Consume()
-        {
-            Consume(1);
+        /// </summary>
+        public void Consume()
+        {
+            Consume(1);
+        }
+
+        /// <summary>
+        /// Consume a single token from the bucket asynchronously. This method does not block
+        /// <returns>A task that returns once a token has been consumed</returns>
+        /// </summary>
+        public Task ConsumeAsync()
+        {
+            return ConsumeAsync(1);
         }
 
         /// <summary>
         /// Consumes multiple tokens from the bucket.  If enough tokens are not currently available then this method will block
         /// </summary>
-        /// <param name="numTokens">The number of tokens to consume from the bucket, must be a positive number.</param>
-        public void Consume(long numTokens)
-        {
-            while (true) {
-                if (TryConsume(numTokens)) {
-                    break;
-                }
-
-                _sleepStrategy.Sleep();
-            }
+        /// <param name="numTokens">The number of tokens to consume from the bucket, must be a positive number.</param>
+        public void Consume(long numTokens)
+        {
+            while (true) {
+                if (TryConsume(numTokens)) {
+                    break;
+                }
+
+                _sleepStrategy.Sleep();
+            }
+        }
+
+        /// <summary>
+        /// Consume multiple tokens from the bucket asynchronously. This method does not block
+        /// <param name="numTokens">The number of tokens to consume from the bucket, must be a positive number.</param>
+        /// <returns>A task that returns once the requested tokens have been consumed</returns>
+        /// </summary>
+        public Task ConsumeAsync(long numTokens)
+        {
+            return Task.Factory.StartNew(() => Consume(numTokens));
         }
     }
 }