public void CheckNameAvailability_409()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.Conflict);
Assert.Throws <ErrorResponseException>(() => client.Redis.CheckNameAvailability(parameters: new CheckNameAvailabilityParameters
{
Name = "cachename",
Type = "Microsoft.Cache/Redis"
}));
}
public void CheckNameAvailability_200()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.OK);
client.Redis.CheckNameAvailability(parameters: new CheckNameAvailabilityParameters
{
Name = "cachename",
Type = "Microsoft.Cache/Redis"
});
}
public void CommonErrModel_BasicTests()
{
PlaybackTestHandler testHandler = new PlaybackTestHandler(CloudErrorTestResponse.MockCreateOrUpdateWithTwoTries());
RedisManagementClient redisClient = GetRedisClient(testHandler);
CloudException cEx = Assert.Throws <CloudException>(() =>
redisClient.RedisOperations.CreateOrUpdate(RGroupName, ResourceName, RedisCreateUpdateParams, SubId)
);
Assert.Equal("BadArgument", cEx.Body.Code);
}
public void Get_EmptyJSONFromCSM()
{
string responseString = (@"{}");
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
RedisResource response = client.Redis.Get(resourceGroupName: "resource-group", name: "cachename");
Assert.Null(response.Id);
Assert.Null(response.Location);
Assert.Null(response.Name);
Assert.Null(response.Type);
}
public void List_404()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.ListByResourceGroup(resourceGroupName: "resource-group"));
client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.ListByResourceGroupNext(nextPageLink: nextLinkForAllInResourceGroup));
client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.ListBySubscription());
client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.ListBySubscriptionNext(nextPageLink: nextLinkForAllInSubscription));
}
public void RegenerateKey_Basic()
{
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
RedisManagementClient client = Utility.GetRedisManagementClient(null, requestIdHeader, HttpStatusCode.OK);
AzureOperationResponse response = client.Redis.RegenerateKey(resourceGroupName: "resource-group", name: "cachename", parameters: new RedisRegenerateKeyParameters()
{
KeyType = RedisKeyType.Primary
});
Assert.Equal(requestIdHeader, response.RequestId);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void CommonErrModel_NonEmptyAdditionalInfo()
{
PlaybackTestHandler testHandler = new PlaybackTestHandler(CloudErrorTestResponse.CreateUpdate_ErrWithNonEmptyAdditionalInfo());
RedisManagementClient redisClient = GetRedisClient(testHandler);
CloudException cEx = Assert.Throws <CloudException>(() =>
redisClient.RedisOperations.CreateOrUpdate(RGroupName, ResourceName, RedisCreateUpdateParams, SubId)
);
Assert.Equal("BadArgument", cEx.Body.Code);
Assert.Equal(1, cEx.Body.AdditionalInfo.Count);
Assert.Equal("PolicyViolation", cEx.Body.AdditionalInfo[0].Type);
}
public void List_InvalidJSONFromCSM()
{
string responseString = (@"Exception: Any exception from CSM");
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <Newtonsoft.Json.JsonReaderException>(() => client.Redis.List(resourceGroupName: "resource-group"));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <Newtonsoft.Json.JsonReaderException>(() => client.Redis.ListNext(nextLink: nextLinkForAllInResourceGroup));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <Newtonsoft.Json.JsonReaderException>(() => client.Redis.List(null));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <Newtonsoft.Json.JsonReaderException>(() => client.Redis.ListNext(nextLink: nextLinkForAllInSubscription));
}
public void List_InvalidJSONFromCSM()
{
string responseString = (@"Exception: Any exception from CSM");
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListByResourceGroup(resourceGroupName: "resource-group"));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListByResourceGroupNext(nextPageLink: nextLinkForAllInResourceGroup));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListBySubscription());
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListBySubscriptionNext(nextPageLink: nextLinkForAllInSubscription));
}
public void List_InvalidCastFromJSONValueToJSONArray()
{
string responseString = (@" {""value"" : ""Invalid Non-Array Value""} ");
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListByResourceGroup(resourceGroupName: "resource-group"));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListByResourceGroupNext(nextPageLink: nextLinkForAllInResourceGroup));
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListBySubscription());
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
Assert.Throws <SerializationException>(() => client.Redis.ListBySubscriptionNext(nextPageLink: nextLinkForAllInSubscription));
}
public void ListKeys_Basic()
{
string responseString = (@"{
""primaryKey"": ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa="",
""secondaryKey"": ""bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=""
}
");
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
var response = client.Redis.ListKeys(resourceGroupName: "resource-group", name: "cachename");
Assert.Equal("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=", response.PrimaryKey);
Assert.Equal("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=", response.SecondaryKey);
}
//private static RedisManagementClient GetClient(DelegatingHandler handlerToAdd)
//{
// var tokenCredentials = new TokenCredentials("123", "abc");
// var fakeClient = new RedisManagementClient(tokenCredentials, handlerToAdd);
// fakeClient.LongRunningOperationInitialTimeout = fakeClient.LongRunningOperationRetryTimeout = 0;
// return fakeClient;
//}
//private static void VerifyRequestCount(string httpStrMethod, PlaybackTestHandler handler, int putCount = 0, int patchCount = 0)
//{
// if (httpStrMethod.Equals("PUT"))
// Assert.Equal(putCount, handler.Requests.Count);
// else if (httpStrMethod.Equals("PATCH"))
// Assert.Equal(patchCount, handler.Requests.Count);
//}
////private static void VerifyHttpMethod(HttpMethod expectedStrMethod, PlaybackTestHandler handler, int requestIndex = 0)
////{
//// Assert.Equal(expectedStrMethod, handler.Requests[requestIndex].Method);
////}
//private static void VerifyHttpMethod(string expectedStrMethod, PlaybackTestHandler handler, int requestIndex = 0)
//{
// HttpMethod expMethod = null;
// switch (expectedStrMethod)
// {
// case "PUT":
// expMethod = HttpMethod.Put;
// break;
// case "PATCH":
// expMethod = new HttpMethod("PATCH");
// break;
// case "POST":
// expMethod = HttpMethod.Post;
// break;
// case "DELETE":
// expMethod = HttpMethod.Delete;
// break;
// }
// Assert.Equal(expMethod, handler.Requests[requestIndex].Method);
//}
//private static void VerifyRequestUrl(string expectedUrl, PlaybackTestHandler handler, int requestIndex = 0)
//{
// Assert.Equal(expectedUrl, handler.Requests[requestIndex].RequestUri.ToString());
//}
private static RedisResource ExecuteOperation(string httpMethod, RedisManagementClient fakeClient)
{
if (httpMethod.Equals("PUT"))
{
return(fakeClient.RedisOperations.CreateOrUpdate("rg", "redis", new RedisCreateOrUpdateParameters(), "1234"));
}
else if (httpMethod.Equals("PATCH"))
{
return(fakeClient.RedisOperations.Patch("rg", "redis", new RedisCreateOrUpdateParameters(), "1234"));
}
else
{
return(null);
}
}
public void Get_Basic()
{
string responseString = (@"
{
""id"" : ""/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache"",
""location"" : ""North Europe"",
""name"" : ""hydraradiscache"",
""type"" : ""Microsoft.Cache/Redis"",
""tags"" : {""update"": ""done""},
""properties"" : {
""provisioningState"" : ""Succeeded"",
""sku"": {
""name"": ""Basic"",
""family"": ""C"",
""capacity"": 1
},
""redisVersion"" : ""2.8"",
""redisConfiguration"": {""maxmemory-policy"": ""allkeys-lru""},
""accessKeys"" : null,
""hostName"" : ""hydraradiscache.cache.icbbvt.windows-int.net"",
""port"" : 6379,
""sslPort"" : 6380,
""minimumTlsVersion"": ""1.2""
}
}
");
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
RedisResource response = client.Redis.Get(resourceGroupName: "resource-group", name: "cachename");
Assert.Equal("/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache", response.Id);
Assert.Equal("North Europe", response.Location);
Assert.Equal("hydraradiscache", response.Name);
Assert.Equal("Microsoft.Cache/Redis", response.Type);
Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState);
Assert.Equal(SkuName.Basic, response.Sku.Name);
Assert.Equal(SkuFamily.C, response.Sku.Family);
Assert.Equal(1, response.Sku.Capacity);
Assert.Equal("2.8", response.RedisVersion);
Assert.Equal("allkeys-lru", response.RedisConfiguration["maxmemory-policy"]);
Assert.Equal("hydraradiscache.cache.icbbvt.windows-int.net", response.HostName);
Assert.Equal(6379, response.Port);
Assert.Equal(6380, response.SslPort);
Assert.Equal(TlsVersion.OneFullStopTwo, response.MinimumTlsVersion);
}
public static RedisManagementClient GetRedisManagementClient(string responseString, string requestIdHeader, HttpStatusCode statusCode)
{
var httpResponse = new HttpResponseMessage();
httpResponse.Content = new StreamContent(GenerateStreamFromString(responseString));
if (!String.IsNullOrEmpty(requestIdHeader))
{
httpResponse.Headers.Add("x-ms-request-id", requestIdHeader);
}
httpResponse.StatusCode = statusCode;
var token = new TokenCloudCredentials(Guid.NewGuid().ToString(), "abc123");
RedisManagementClient client = new RedisManagementClient(token).WithHandler(new DummyResponseDelegatingHandler(httpResponse));
return(client);
}
public void CreateOrUpdate_404()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
}
}));
}
public void ListKeys_Basic()
{
string responseString = (@"
{
""primaryKey"": ""sJ+jruGKPHDKsEC8kmoybobH3TZx2njBR3ipEsquZFo="",
""secondaryKey"": ""LwizcpMV3wyVjXJEd/lxMhIlpM3rYx5UlB/aVSl3lUE=""
}
");
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
RedisListKeysResponse response = client.Redis.ListKeys(resourceGroupName: "resource-group", name: "cachename");
Assert.Equal(requestIdHeader, response.RequestId);
Assert.Equal("sJ+jruGKPHDKsEC8kmoybobH3TZx2njBR3ipEsquZFo=", response.PrimaryKey);
Assert.Equal("LwizcpMV3wyVjXJEd/lxMhIlpM3rYx5UlB/aVSl3lUE=", response.SecondaryKey);
}
static void Main(string[] args)
{
//https://msdn.microsoft.com/en-us/library/azure/dn790557.aspx#bk_portal
string token = GetAuthorizationHeader();
TokenCloudCredentials creds = new TokenCloudCredentials(subscriptionId, token);
RedisManagementClient client = new RedisManagementClient(creds);
var redisProperties = new RedisProperties();
redisProperties.Sku = new Sku(redisSKUName, redisSKUFamily, redisSKUCapacity);
redisProperties.RedisVersion = redisVersion;
var redisParams = new RedisCreateOrUpdateParameters(redisProperties, redisCacheRegion);
client.Redis.CreateOrUpdate(resourceGroupName, cacheName, redisParams);
}
public static RedisManagementClient GetRedisManagementClient(string responseString, string requestIdHeader, HttpStatusCode statusCode)
{
var httpResponse = new HttpResponseMessage();
httpResponse.Content = new StreamContent(GenerateStreamFromString(responseString));
if (!String.IsNullOrEmpty(requestIdHeader))
{
httpResponse.Headers.Add("x-ms-request-id", requestIdHeader);
}
httpResponse.StatusCode = statusCode;
var token = new TokenCredentials(Guid.NewGuid().ToString(), "abc123");
RedisManagementClient client = new RedisManagementClient(token, new DummyResponseDelegatingHandler(httpResponse));
client.SubscriptionId = "a559b6fd-3a84-40bb-a450-b0db5ed37dfe";
return(client);
}
public void RegenerateKey_ParametersChecking()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Exception e = Assert.Throws <ValidationException>(() => client.Redis.RegenerateKey(resourceGroupName: null, name: "cachename", parameters: new RedisRegenerateKeyParameters()
{
KeyType = RedisKeyType.Primary
}));
Assert.Contains("resourceGroupName", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.RegenerateKey(resourceGroupName: "resource-group", name: null, parameters: new RedisRegenerateKeyParameters()
{
KeyType = RedisKeyType.Primary
}));
Assert.Contains("name", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.RegenerateKey(resourceGroupName: "resource-group", name: "cachename", parameters: null));
Assert.Contains("parameters", e.Message);
}
private static void CreateRedisCache(Dictionary <string, string> jsonSecurityToken)
{
TokenCredentials serviceClientCredentials = CreateTokenCredential(jsonSecurityToken);
Microsoft.Azure.Management.Redis.RedisManagementClient redisClient =
new RedisManagementClient(serviceClientCredentials);
redisClient.SubscriptionId = jsonSecurityToken["subscriptionId"];
var redisResource = redisClient.Redis.Create(jsonSecurityToken["resourcegroupname"],
jsonSecurityToken["storagegroupname"], new RedisCreateParameters()
{
EnableNonSslPort = false,
Location = LocationNames.NorthEurope,
Sku = new Sku()
{
Family = SkuFamily.C,
Name = SkuName.Basic
}
}
);
}
public void CreateOrUpdate_EmptyJSONFromCSM()
{
string responseString = (@"{}");
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
var response = client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
}
});
Assert.Null(response.Id);
Assert.Null(response.Location);
Assert.Null(response.Name);
Assert.Null(response.Type);
}
public void List_EmptyJSONFromCSM()
{
string responseString = (@"{}");
IPage <RedisResource>[] list = new IPage <RedisResource> [4];
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[0] = client.Redis.ListByResourceGroup(resourceGroupName: "resource-group");
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[1] = client.Redis.ListByResourceGroupNext(nextPageLink: nextLinkForAllInResourceGroup);
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[2] = client.Redis.ListBySubscription();
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[3] = client.Redis.ListBySubscriptionNext(nextPageLink: nextLinkForAllInSubscription);
foreach (IPage <RedisResource> responseList in list)
{
Assert.Empty(responseList);
Assert.Null(responseList.NextPageLink);
}
}
public void List_EmptyJSONFromCSM()
{
string responseString = (@"{}");
RedisListResponse[] list = new RedisListResponse[4];
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[0] = client.Redis.List(resourceGroupName: "resource-group");
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[1] = client.Redis.ListNext(nextLink: nextLinkForAllInResourceGroup);
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[2] = client.Redis.List(null);
client = Utility.GetRedisManagementClient(responseString, null, HttpStatusCode.OK);
list[3] = client.Redis.ListNext(nextLink: nextLinkForAllInSubscription);
foreach (RedisListResponse responseList in list)
{
Assert.Equal(0, responseList.Value.Count);
Assert.Null(responseList.NextLink);
}
}
public void CommonErrModel_DetailsWithAdditionalInfo()
{
PlaybackTestHandler testHandler = new PlaybackTestHandler(CloudErrorTestResponse.CreateUpdate_DetailsWithAdditionalInfo());
RedisManagementClient redisClient = GetRedisClient(testHandler);
CloudException cEx = Assert.Throws <CloudException>(() =>
redisClient.RedisOperations.CreateOrUpdate(RGroupName, ResourceName, RedisCreateUpdateParams, SubId)
);
CloudError ce = cEx.Body;
Assert.Equal(1, ce.Details.Count);
Assert.Equal("PolicyViolation", ce.Details[0].AdditionalInfo[0].Type);
AdditionalErrorInfo aInfo = ce.Details[0].AdditionalInfo[0];
JObject jo = aInfo.Info;
Assert.NotNull(jo);
string infoVal = jo.Value <string>("policySetDefinitionDisplayName");
Assert.Equal("Secure the environment", infoVal);
}
public void Get_404()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Assert.Throws <ErrorResponseException>(() => client.Redis.Get(resourceGroupName: "resource-group", name: "cachename"));
}
public RedisCacheClient(IAzureContext context)
{
_client = AzureSession.Instance.ClientFactory.CreateArmClient <RedisManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_insightsClient = AzureSession.Instance.ClientFactory.CreateClient <InsightsManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_resourceManagementClient = AzureSession.Instance.ClientFactory.CreateArmClient <ResourceManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public RedisCacheClient(AzureContext context)
{
_client = AzureSession.ClientFactory.CreateClient <RedisManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public void List_Basic()
{
string responseString = (@"
{
""value"": [{
""id"": ""/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache3"",
""location"": ""NorthCentralUS"",
""name"": ""hydraradiscache3"",
""type"": ""Microsoft.Cache/Redis"",
""tags"": {},
""properties"": {
""provisioningState"": ""Succeeded"",
""sku"": {
""name"": ""Basic"",
""family"": ""C"",
""capacity"": 1
},
""redisVersion"" : ""2.8"",
""accessKeys"": null,
""hostName"": ""hydraradiscache3.cache.icbbvt.windows-int.net"",
""port"": 6379,
""sslPort"": 6380,
""minimumTlsVersion"": ""1.2""
}
},
{
""id"": ""/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache"",
""location"": ""NorthEurope"",
""name"": ""hydraradiscache"",
""type"": ""Microsoft.Cache/Redis"",
""tags"": {""update"": ""done""},
""properties"": {
""provisioningState"": ""Succeeded"",
""sku"": {
""name"": ""Basic"",
""family"": ""C"",
""capacity"": 1
},
""redisVersion"" : ""2.8"",
""maxMemoryPolicy"": ""AllKeysLRU"",
""accessKeys"": null,
""hostName"": ""hydraradiscache.cache.icbbvt.windows-int.net"",
""port"": 6379,
""sslPort"": 6380,
""minimumTlsVersion"": ""1.2""
}
}]
}");
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
IPage <RedisResource>[] list = new IPage <RedisResource> [4];
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
list[0] = client.Redis.ListByResourceGroup(resourceGroupName: "resource-group");
client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
list[1] = client.Redis.ListByResourceGroupNext(nextPageLink: nextLinkForAllInResourceGroup);
client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
list[2] = client.Redis.ListBySubscription();
client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.OK);
list[3] = client.Redis.ListBySubscriptionNext(nextPageLink: nextLinkForAllInSubscription);
foreach (IPage <RedisResource> responseList in list)
{
Assert.Equal(2, responseList.Count());
foreach (RedisResource response in responseList)
{
Assert.Contains("/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache", response.Id);
Assert.Contains("North", response.Location);
Assert.Contains("hydraradiscache", response.Name);
Assert.Equal("Microsoft.Cache/Redis", response.Type);
Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState);
Assert.Equal(SkuName.Basic, response.Sku.Name);
Assert.Equal(SkuFamily.C, response.Sku.Family);
Assert.Equal(1, response.Sku.Capacity);
Assert.Equal("2.8", response.RedisVersion);
Assert.Contains(".cache.icbbvt.windows-int.net", response.HostName);
Assert.Equal(6379, response.Port);
Assert.Equal(6380, response.SslPort);
Assert.Equal(TlsVersion.OneFullStopTwo, response.MinimumTlsVersion);
}
}
}
public void CreateOrUpdate_BasicWithTagsAndConfig()
{
string responseString = (@"
{
""id"" : ""/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache"",
""location"" : ""North Europe"",
""name"" : ""hydraradiscache"",
""type"" : ""Microsoft.Cache/Redis"",
""tags"" : {""update"": ""done""},
""properties"" : {
""provisioningState"" : ""Succeeded"",
""sku"": {
""name"": ""Basic"",
""family"": ""C"",
""capacity"": 1
},
""redisVersion"" : ""2.8"",
""redisConfiguration"": {""maxmemory-policy"": ""allkeys-lru""},
""accessKeys"" : {
""primaryKey"" : ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa="",
""secondaryKey"" : ""bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb=""
},
""hostName"" : ""hydraradiscache.cache.icbbvt.windows-int.net"",
""port"" : 6379,
""sslPort"" : 6380,
""minimumTlsVersion"": ""1.2"",
""replicasPerMaster"": ""2"",
""instances"": [
{
""sslPort"": 15000,
""nonSslPort"": 13000
},
{
""sslPort"": 15001,
""nonSslPort"": 13001
},
{
""sslPort"": 15002,
""nonSslPort"": 13002
},
]
}
}
");
string requestIdHeader = "0d33aff8-8a4e-4565-b893-a10e52260de0";
RedisManagementClient client = Utility.GetRedisManagementClient(responseString, requestIdHeader, HttpStatusCode.Created);
var response = client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
},
RedisConfiguration = new Dictionary <string, string>()
{
{ "maxmemory-policy", "allkeys-lru" }
},
MinimumTlsVersion = TlsVersion.OneFullStopTwo,
ReplicasPerMaster = 2
});
Assert.Equal("/subscriptions/a559b6fd-3a84-40bb-a450-b0db5ed37dfe/resourceGroups/HydraTest07152014/providers/Microsoft.Cache/Redis/hydraradiscache", response.Id);
Assert.Equal("North Europe", response.Location);
Assert.Equal("hydraradiscache", response.Name);
Assert.Equal("Microsoft.Cache/Redis", response.Type);
Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState);
Assert.Equal(SkuName.Basic, response.Sku.Name);
Assert.Equal(SkuFamily.C, response.Sku.Family);
Assert.Equal(1, response.Sku.Capacity);
Assert.Equal("2.8", response.RedisVersion);
Assert.Equal("allkeys-lru", response.RedisConfiguration["maxmemory-policy"]);
Assert.Equal("hydraradiscache.cache.icbbvt.windows-int.net", response.HostName);
Assert.Equal(6379, response.Port);
Assert.Equal(6380, response.SslPort);
Assert.Equal(TlsVersion.OneFullStopTwo, response.MinimumTlsVersion);
Assert.Equal(2, response.ReplicasPerMaster);
Assert.Equal(3, response.Instances.Count);
for (int i = 0; i < response.Instances.Count; i++)
{
Assert.Equal(15000 + i, response.Instances[i].SslPort);
Assert.Equal(13000 + i, response.Instances[i].NonSslPort);
Assert.Null(response.Instances[i].ShardId);
Assert.Null(response.Instances[i].Zone);
}
}
public void CreateOrUpdate_ParametersChecking()
{
RedisManagementClient client = Utility.GetRedisManagementClient(null, null, HttpStatusCode.NotFound);
Exception e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: null, name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
}
}));
Assert.Contains("resourceGroupName", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: null,
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
}
}));
Assert.Contains("name", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename", parameters: null));
Assert.Contains("parameters", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = null,
Sku = new Sku()
{
Name = SkuName.Basic,
Family = SkuFamily.C,
Capacity = 1
}
}));
Assert.Contains("Location", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = null
}));
Assert.Contains("Sku", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = null,
Family = SkuFamily.C,
Capacity = 1
}
}));
Assert.Contains("Name", e.Message);
e = Assert.Throws <ValidationException>(() => client.Redis.Create(resourceGroupName: "resource-group", name: "cachename",
parameters: new RedisCreateParameters
{
Location = "North Europe",
Sku = new Sku()
{
Name = SkuName.Basic,
Family = null,
Capacity = 1
}
}));
Assert.Contains("Family", e.Message);
}
