public void ListStorageAccounts()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.StorageAccountListResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);

            var result = client.StorageAccounts.List(Constants.ResourceGroupName, Constants.FarmId, null, true);

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Get);

            var expectedUri = string.Format(
                ListUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                "true");

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Get, handler.Method);

            Assert.True(result.StorageAccounts.Count == 3);

            CompareExpectedListResultCommon(result);

            CompareExpectedListResultWacProperties(result, true);
        }
        public void GetFarmMetricDefinitions()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.MetricDefinitionResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);

            var client = GetClient(handler, token);

            const string filter = "name";

            var result = client.Farms.GetMetricDefinitions(Constants.ResourceGroupName, Constants.FarmId, filter);

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Get);

            var expectedUri = string.Format(
                FarmMetricDefinitionsUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                filter);

            Assert.Equal(expectedUri, handler.Uri.AbsoluteUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Get, handler.Method);

            CompareMetricDefinition(result);
        }
        public void ListRoleInstance()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.RoleInstanceListResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);

            var result = client.TableMasterInstances.List(Constants.ResourceGroupName, Constants.FarmId).ToList();

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Get);

            var expectedUri = string.Format(
                ListUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                Constants.TableMasterRole);

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Get, handler.Method);

            CompareExpectedResult(result[0]);

            //TODO: deployment information?
        }
        public void GetShare()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.ShareGetResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);

            var result = client.Shares.Get(Constants.ResourceGroupName, Constants.FarmId, Constants.ShareAName);

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Get);

            var expectedUri = string.Format(
                GetUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId, 
                Uri.EscapeDataString(Constants.ShareAName)
                );

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Get, handler.Method);
            
            CompareExpectedResult(result.Share);
        }
        public void UndeleteStorageAccounts()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);
            StorageAccountUndeleteParameters para = new StorageAccountUndeleteParameters();
            var result = client.StorageAccounts.Undelete(Constants.ResourceGroupName, Constants.FarmId, "myaccount", para);

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Post);

            var expectedUri = string.Format(
                UndeleteUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                "myaccount");

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Post, handler.Method);
        }
        public void PatchTableService()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.TableServiceGetResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);

            var settings = new TableServiceWritableSettings
            {
                FrontEndCallbackThreadsCount = 100
            };

            var patchParam = new TableServicePatchParameters
            {
                TableService = new TableServiceRequest()
                {
                    Settings = settings
                }
            };

            var result = client.TableService.Patch(
                Constants.ResourceGroupName,
                Constants.FarmId,
                patchParam);

            // validate requestor
            Assert.Equal(handler.Method.Method, "PATCH", StringComparer.OrdinalIgnoreCase);

            var expectedUri = string.Format(
                TableServiceUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId);

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            CompareExpectedResult(result.Resource.TableService);
        }
 protected StorageAdminManagementClient GetClient(RecordedDelegatingHandler handler, TokenCloudCredentials token)
 {
     handler.IsPassThrough = false;
     var client = new StorageAdminManagementClient(token, new Uri(Constants.BaseUri)).WithHandler(handler);
     return client;
 }
        public void StopBlobServerRoleInstance()
        {
            var response = new HttpResponseMessage(HttpStatusCode.Accepted);

            var subscriptionId = Guid.NewGuid().ToString();
            string locationUri = string.Format(
                LocationUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                Constants.TableMasterRole,
                Constants.NodeId,
                Guid.NewGuid()
                );
            response.Headers.Add("Location", locationUri);

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.Accepted,
                SubsequentStatusCodeToReturn = HttpStatusCode.OK
            };

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);
            var result = client.BlobServerInstances.Stop(
                Constants.ResourceGroupName,
                Constants.FarmId,
                Constants.NodeId
                );
            Assert.Equal(HttpStatusCode.OK, result.StatusCode);

            Assert.Equal(locationUri, handler.Uri.AbsoluteUri);
        }
        private void VerifyGetSubResourceMetrics(string subResourceType, string subResourceName, string metricsUriTemplate,
            Func<StorageAdminManagementClient, string, string, string, string, MetricsResult> func)
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.MetricResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);

            var client = GetClient(handler, token);

            const string filter = "name";

            var result = func(client, Constants.ResourceGroupName, Constants.FarmId, subResourceName, filter);

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Get);

            var expectedUri = string.Format(
                metricsUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                subResourceType,
                Uri.EscapeDataString(subResourceName),
                filter);

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            // Validate headers 
            Assert.Equal(HttpMethod.Get, handler.Method);

            CompareMetric(result);
        }
Beispiel #10
0
        public void GetEventQuery()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.EventQueryResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);
            var filter = "startTime eq '2015-05-10T18:02:00Z' and endTime eq '2015-05-28T18:02:00Z'";

            var result = client.Farms.GetEventQuery(
                Constants.ResourceGroupName,
                Constants.FarmId,
                filter
                );

            // validate requestor
            Assert.Equal(handler.Method, HttpMethod.Post);

            var expectedUri = string.Format(
                GetEventQueryTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId,
                Uri.EscapeDataString(filter));

            Assert.Equal(expectedUri, handler.Uri.AbsoluteUri);
            EventQueryResultValidator.ValidateGetEventQueryResult(result);
        }
Beispiel #11
0
        public void PatchFarm()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(ExpectedResults.FarmGetResponse)
            };

            var handler = new RecordedDelegatingHandler(response)
            {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            var subscriptionId = Guid.NewGuid().ToString();

            var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
            var client = GetClient(handler, token);

            var settings = new FarmSettings
            {
                SettingsPollingIntervalInSecond = 100
            };

            var farmReq = new FarmUpdateParameters
            {
                Farm = new FarmBase
                {
                    Settings = settings
                }
            };

            var result = client.Farms.Update(
                Constants.ResourceGroupName,
                Constants.FarmId,
                farmReq);

            // validate requestor
            Assert.Equal(handler.Method.Method, "PATCH", StringComparer.OrdinalIgnoreCase);

            var expectedUri = string.Format(
                GetUriTemplate,
                Constants.BaseUri,
                subscriptionId,
                Constants.ResourceGroupName,
                Constants.FarmId);

            Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);

            CompareExpectedResult(result.Farm);
        }