Implement support and tests for listing historical billable load balancers

Author: sharwell

src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs

@@ -945,7 +945,37 @@ public Task<IEnumerable<string>> ListAllowedDomainsAsync(CancellationToken cance
         /// <inheritdoc/>
         public Task<IEnumerable<LoadBalancer>> ListBillableLoadBalancersAsync(DateTimeOffset? startTime, DateTimeOffset? endTime, int? offset, int? limit, CancellationToken cancellationToken)
         {
-            throw new NotImplementedException();
+            if (endTime < startTime)
+                throw new ArgumentOutOfRangeException("endTime");
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException("offset");
+            if (limit <= 0)
+                throw new ArgumentOutOfRangeException("limit");
+
+            UriTemplate template = new UriTemplate("/loadbalancers/billable?startTime={startTime}&endTime={endTime}&offset={offset}&limit={limit}");
+            var parameters = new Dictionary<string, string>();
+            if (startTime != null)
+                parameters.Add("startTime", startTime.Value.ToString("yyyy-MM-dd"));
+            if (endTime != null)
+                parameters.Add("endTime", endTime.Value.ToString("yyyy-MM-dd"));
+            if (offset != null)
+                parameters.Add("offset", offset.ToString());
+            if (limit != null)
+                parameters.Add("limit", limit.ToString());
+
+            Func<Task<Tuple<IdentityToken, Uri>>, HttpWebRequest> prepareRequest =
+                PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
+
+            Func<Task<HttpWebRequest>, Task<ListLoadBalancersResponse>> requestResource =
+                GetResponseAsyncFunc<ListLoadBalancersResponse>(cancellationToken);
+
+            Func<Task<ListLoadBalancersResponse>, IEnumerable<LoadBalancer>> resultSelector =
+                task => (task.Result != null ? task.Result.LoadBalancers : null) ?? Enumerable.Empty<LoadBalancer>();
+
+            return AuthenticateServiceAsync(cancellationToken)
+                .ContinueWith(prepareRequest)
+                .ContinueWith(requestResource).Unwrap()
+                .ContinueWith(resultSelector);
         }
 
         /// <inheritdoc/>

src/testing/integration/Providers/Rackspace/UserLoadBalancerTests.cs

@@ -692,9 +692,39 @@ public async Task TestListAllowedDomains()
         [TestMethod]
         [TestCategory(TestCategories.User)]
         [TestCategory(TestCategories.LoadBalancers)]
-        public void TestListBillableLoadBalancers()
+        public async Task TestListBillableLoadBalancers()
         {
-            Assert.Inconclusive("Not yet implemented.");
+            ILoadBalancerService provider = CreateProvider();
+            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60))))
+            {
+                IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token);
+                LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase));
+
+                string loadBalancerName = CreateRandomLoadBalancerName();
+
+                LoadBalancerConfiguration configuration = new LoadBalancerConfiguration(
+                    name: loadBalancerName,
+                    nodes: null,
+                    protocol: httpProtocol,
+                    virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) },
+                    algorithm: LoadBalancingAlgorithm.RoundRobin);
+                LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+
+                IEnumerable<LoadBalancer> billable = await provider.ListBillableLoadBalancersAsync(DateTimeOffset.Now.Date.AddDays(-60), DateTimeOffset.Now.Date.AddDays(1), null, null, cancellationTokenSource.Token);
+                Assert.IsNotNull(billable);
+                LoadBalancer[] loadBalancers = billable.ToArray();
+                if (loadBalancers.Length == 0)
+                    Assert.Inconclusive("No billable load balancers were reported.");
+
+                Console.WriteLine("Billable Load Balancers:");
+                foreach (LoadBalancer loadBalancer in loadBalancers)
+                    Console.WriteLine("  {0}", loadBalancer.Id);
+
+                /* Cleanup
+                 */
+
+                await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
+            }
         }
 
         [TestMethod]