public void ListWithoutResourceGroupTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisListResponse listResponse = _client.Redis.List(null); Assert.NotNull(listResponse.RequestId); Assert.True(listResponse.Value.Count >= 1); bool found = false; foreach (RedisResource response in listResponse.Value) { if (response.Id.Contains(fixture.RedisCacheName)) { found = true; Assert.Contains(fixture.RedisCacheName, response.Id); Assert.Equal(fixture.RedisCacheName, response.Name); Assert.True("succeeded".Equals(response.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)); Assert.Equal(SkuName.Basic, response.Properties.Sku.Name); Assert.Equal(SkuFamily.C, response.Properties.Sku.Family); Assert.Equal(0, response.Properties.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, response.Properties.HostName); Assert.Equal(6379, response.Properties.Port); Assert.Equal(6380, response.Properties.SslPort); } } Assert.True(found, "Cache created by fixture is not found."); TestUtilities.EndTest(); }
public void ListWithoutResourceGroupTest() { using (var context = MockContext.Start(this.GetType())) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); IPage <RedisResource> listResponse = _client.Redis.ListBySubscription(); Assert.True(listResponse.Count() >= 1); bool found = false; foreach (RedisResource response in listResponse) { if (response.Id.Contains(fixture.RedisCacheName)) { found = true; Assert.Contains(fixture.RedisCacheName, response.Id); Assert.Equal(fixture.RedisCacheName, response.Name); Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Basic, response.Sku.Name); Assert.Equal(SkuFamily.C, response.Sku.Family); Assert.Equal(0, response.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, response.HostName); Assert.Equal(6379, response.Port); Assert.Equal(6380, response.SslPort); } } Assert.True(found, "Cache created by fixture is not found."); } }
public void TryCreatingCache(string resourceGroupName, string cacheName, string location) { var redisClient = RedisCacheManagementTestUtilities.GetRedisManagementClient(_testBase, _context); var createResponse = redisClient.Redis.Create(resourceGroupName: resourceGroupName, name: cacheName, parameters: new RedisCreateParameters { Location = location, Sku = new Microsoft.Azure.Management.Redis.Models.Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 } }); RedisResource response = redisClient.Redis.Get(resourceGroupName: resourceGroupName, name: cacheName); ThrowIfTrue(!response.Id.Contains(cacheName), "Cache name not found inside Id."); ThrowIfTrue(!response.Name.Equals(cacheName), string.Format("Cache name is not equal to {0}", cacheName)); ThrowIfTrue(!response.HostName.Contains(cacheName), "Cache name not found inside host name."); // wait for maximum 30 minutes for cache to create for (int i = 0; i < 60; i++) { TestUtilities.Wait(new TimeSpan(0, 0, 30)); RedisResource responseGet = redisClient.Redis.Get(resourceGroupName: resourceGroupName, name: cacheName); if ("succeeded".Equals(responseGet.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } ThrowIfTrue(i == 60, "Cache is not in succeeded state even after 30 min."); } }
public void BeginCreateFunctionalTest() { using (var context = MockContext.Start(this.GetType())) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisBegin"); var redisCacheName = TestUtilities.GenerateName("RedisBegin"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); RedisResource response = _client.Redis.BeginCreate(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 }, MinimumTlsVersion = TlsVersion.OneFullStopTwo, ReplicasPerMaster = 2, RedisVersion = "6", }); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal(ProvisioningState.Creating, response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); Assert.Equal(TlsVersion.OneFullStopTwo, response.MinimumTlsVersion); Assert.Equal(2, response.ReplicasPerMaster); Assert.Equal("6", response.RedisVersion.Split(".")[0]); Assert.Equal(3, response.Instances.Count); for (int i = 0; i < response.Instances.Count; i++) { Assert.Equal(15000 + i, response.Instances[i].SslPort); Assert.Null(response.Instances[i].NonSslPort); Assert.Null(response.Instances[i].ShardId); Assert.Null(response.Instances[i].Zone); } for (int i = 0; i < 60; i++) { response = _client.Redis.Get(resourceGroupName, redisCacheName); if (ProvisioningState.Succeeded.Equals(response.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } TestUtilities.Wait(new TimeSpan(0, 0, 30)); } _client.Redis.Delete(resourceGroupName: resourceGroupName, name: redisCacheName); _redisCacheManagementHelper.DeleteResourceGroup(resourceGroupName); } }
public void ListKeysTest() { using (var context = MockContext.Start(this.GetType())) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); var response = _client.Redis.ListKeys(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); Assert.NotNull(response.PrimaryKey); Assert.NotNull(response.SecondaryKey); } }
public void ListKeysTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisListKeysResponse response = _client.Redis.ListKeys(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); Assert.NotNull(response.PrimaryKey); Assert.NotNull(response.SecondaryKey); TestUtilities.EndTest(); }
public void RegenerateKeyTest() { using (var context = MockContext.Start(this.GetType())) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); var beforeRegenerateResponse = _client.Redis.ListKeys(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); var afterRegenerateResponse = _client.Redis.RegenerateKey(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisRegenerateKeyParameters() { KeyType = RedisKeyType.Primary }); Assert.NotEqual(beforeRegenerateResponse.PrimaryKey, afterRegenerateResponse.PrimaryKey); Assert.Equal(beforeRegenerateResponse.SecondaryKey, afterRegenerateResponse.SecondaryKey); } }
public void BeginCreateFunctionalTest() { using (var context = MockContext.Start(this.GetType().FullName)) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisBegin"); var redisCacheName = TestUtilities.GenerateName("RedisBegin"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); RedisResource response = _client.Redis.BeginCreate(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal("creating", response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); for (int i = 0; i < 60; i++) { response = _client.Redis.Get(resourceGroupName, redisCacheName); if ("succeeded".Equals(response.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } TestUtilities.Wait(new TimeSpan(0, 0, 30)); } _client.Redis.Delete(resourceGroupName: resourceGroupName, name: redisCacheName); _redisCacheManagementHelper.DeleteResourceGroup(resourceGroupName); } }
public void GetTest() { using (var context = MockContext.Start(this.GetType())) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); RedisResource response = _client.Redis.Get(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); Assert.Contains(fixture.RedisCacheName, response.Id); Assert.Equal(fixture.RedisCacheName, response.Name); Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Basic, response.Sku.Name); Assert.Equal(SkuFamily.C, response.Sku.Family); Assert.Equal(0, response.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, response.HostName); Assert.Equal(6379, response.Port); Assert.Equal(6380, response.SslPort); } }
public void GetTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisGetResponse response = _client.Redis.Get(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); Assert.NotNull(response.RequestId); Assert.Contains(fixture.RedisCacheName, response.Resource.Id); Assert.Equal(fixture.RedisCacheName, response.Resource.Name); Assert.True("succeeded".Equals(response.Resource.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)); Assert.Equal(SkuName.Basic, response.Resource.Properties.Sku.Name); Assert.Equal(SkuFamily.C, response.Resource.Properties.Sku.Family); Assert.Equal(0, response.Resource.Properties.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, response.Resource.Properties.HostName); Assert.Equal(6379, response.Resource.Properties.Port); Assert.Equal(6380, response.Resource.Properties.SslPort); TestUtilities.EndTest(); }
public void RegenerateKeyTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisListKeysResponse beforeRegenerateResponse = _client.Redis.ListKeys(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); AzureOperationResponse response = _client.Redis.RegenerateKey(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisRegenerateKeyParameters() { KeyType = RedisKeyType.Primary }); Assert.NotNull(response.RequestId); RedisListKeysResponse afterRegenerateResponse = _client.Redis.ListKeys(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); Assert.NotEqual(beforeRegenerateResponse.PrimaryKey, afterRegenerateResponse.PrimaryKey); Assert.Equal(beforeRegenerateResponse.SecondaryKey, afterRegenerateResponse.SecondaryKey); TestUtilities.EndTest(); }
public void RebootBothNodesTest() { using (var context = MockContext.Start(this.GetType().FullName)) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); // First try to get cache and verify that it is premium cache RedisResource response = _client.Redis.Get(resourceGroupName: "MyResourceGroup", name: "sunnyprimary"); Assert.Contains("sunnyprimary", response.Id); Assert.Equal("sunnyprimary", response.Name); Assert.True("succeeded".Equals(response.ProvisioningState, StringComparison.OrdinalIgnoreCase)); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); RedisRebootParameters rebootParameter = new RedisRebootParameters { RebootType = RebootType.AllNodes }; _client.Redis.ForceReboot(resourceGroupName: "MyResourceGroup", name: "sunnyprimary", parameters: rebootParameter); } }
public void PatchSchedules_PutGetDelete() { using (var context = MockContext.Start(this.GetType().FullName)) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); // First try to get cache and verify that it is premium cache RedisResource response = _client.Redis.Get(resourceGroupName: "sunnyjapan", name: "sunny-scheduling-dv2"); Assert.Contains("sunny-scheduling-dv2", response.Id); Assert.Equal("sunny-scheduling-dv2", response.Name); Assert.True("succeeded".Equals(response.ProvisioningState, StringComparison.OrdinalIgnoreCase)); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); ScheduleEntry[] entries = new ScheduleEntry[] { new ScheduleEntry { DayOfWeek = DayOfWeekEnum.Monday, StartHourUtc = 10, MaintenanceWindow = TimeSpan.FromHours(10) }, new ScheduleEntry { DayOfWeek = DayOfWeekEnum.Tuesday, StartHourUtc = 11, MaintenanceWindow = TimeSpan.FromHours(11) } }; ValidateResponseForSchedulePatch(_client.PatchSchedules.CreateOrUpdate(resourceGroupName: "sunnyjapan", name: "sunny-scheduling-dv2", parameters: new RedisPatchSchedulesRequest(entries))); ValidateResponseForSchedulePatch(_client.PatchSchedules.Get(resourceGroupName: "sunnyjapan", name: "sunny-scheduling-dv2")); _client.PatchSchedules.Delete(resourceGroupName: "sunnyjapan", name: "sunny-scheduling-dv2"); var ex = Assert.Throws <CloudException>(() => _client.PatchSchedules.Get(resourceGroupName: "sunnyjapan", name: "sunny-scheduling-dv2")); Assert.Contains("There are no patch schedules found for redis cache 'sunny-scheduling-dv2'", ex.Message); Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode); } }
public void RebootBothNodesTest() { using (var context = MockContext.Start(this.GetType().FullName)) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisReboot"); var redisCacheName = TestUtilities.GenerateName("RedisReboot"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); _client.Redis.Create(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); // First try to get cache and verify that it is premium cache RedisResource response = _client.Redis.Get(resourceGroupName, redisCacheName); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal("succeeded", response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); RedisRebootParameters rebootParameter = new RedisRebootParameters { RebootType = RebootType.AllNodes }; _client.Redis.ForceReboot(resourceGroupName, redisCacheName, parameters: rebootParameter); } }
public void UpdateEnableNonSslPortBugTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisGetResponse responseGet = _client.Redis.Get(resourceGroupName: "SunnySDK25", name: "sunnysdk25-centralus"); Assert.True(responseGet.Resource.Properties.EnableNonSslPort.Value); Dictionary <string, string> redisConfiguration = new Dictionary <string, string>(); redisConfiguration.Add("maxmemory-policy", "allkeys-lru"); RedisCreateOrUpdateResponse responseCreate = _client.Redis.CreateOrUpdate(resourceGroupName: "SunnySDK25", name: "sunnysdk25-centralus", parameters: new RedisCreateOrUpdateParameters { Location = "Central US", Properties = new RedisProperties { RedisVersion = "2.8", Sku = new Sku() { Name = SkuName.Standard, Family = SkuFamily.C, Capacity = 2 }, RedisConfiguration = redisConfiguration } }); Assert.Equal(6379, responseCreate.Resource.Properties.Port); Assert.Equal(6380, responseCreate.Resource.Properties.SslPort); Assert.True(responseCreate.Resource.Properties.EnableNonSslPort.Value); TestUtilities.EndTest(); }
public void CreateUpdateDeleteTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisCreateOrUpdateResponse responseCreate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.Location, Properties = new RedisProperties { RedisVersion = "2.8", Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 } } }); Assert.NotNull(responseCreate.RequestId); Assert.Contains(fixture.RedisCacheName, responseCreate.Resource.Id); Assert.Equal(fixture.Location, responseCreate.Resource.Location); Assert.Equal(fixture.RedisCacheName, responseCreate.Resource.Name); Assert.Equal("Microsoft.Cache/Redis", responseCreate.Resource.Type); Assert.True("creating".Equals(responseCreate.Resource.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)); Assert.Equal(SkuName.Basic, responseCreate.Resource.Properties.Sku.Name); Assert.Equal(SkuFamily.C, responseCreate.Resource.Properties.Sku.Family); Assert.Equal(0, responseCreate.Resource.Properties.Sku.Capacity); Assert.Contains("2.8", responseCreate.Resource.Properties.RedisVersion); Assert.Contains(fixture.RedisCacheName, responseCreate.Resource.Properties.HostName); Assert.Equal(6379, responseCreate.Resource.Properties.Port); Assert.Equal(6380, responseCreate.Resource.Properties.SslPort); Assert.False(responseCreate.Resource.Properties.EnableNonSslPort); // wait for maximum 30 minutes for cache to create for (int i = 0; i < 60; i++) { TestUtilities.Wait(new TimeSpan(0, 0, 30)); RedisGetResponse responseGet = _client.Redis.Get(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); if ("succeeded".Equals(responseGet.Resource.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)) { break; } Assert.False(i == 60, "Cache is not in succeeded state even after 30 min."); } RedisCreateOrUpdateResponse responseUpdate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.Location, Properties = new RedisProperties { RedisVersion = "2.8", Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 }, RedisConfiguration = new Dictionary <string, string>() { { "maxmemory-policy", "allkeys-lru" } }, EnableNonSslPort = true } }); Assert.NotNull(responseUpdate.RequestId); Assert.Contains(fixture.RedisCacheName, responseUpdate.Resource.Id); Assert.Equal(fixture.Location, responseUpdate.Resource.Location); Assert.Equal(fixture.RedisCacheName, responseUpdate.Resource.Name); Assert.Equal("Microsoft.Cache/Redis", responseUpdate.Resource.Type); Assert.Equal(SkuName.Basic, responseUpdate.Resource.Properties.Sku.Name); Assert.Equal(SkuFamily.C, responseUpdate.Resource.Properties.Sku.Family); Assert.Equal(0, responseUpdate.Resource.Properties.Sku.Capacity); Assert.Contains("2.8", responseUpdate.Resource.Properties.RedisVersion); Assert.Equal("allkeys-lru", responseUpdate.Resource.Properties.RedisConfiguration["maxmemory-policy"]); Assert.Contains(fixture.RedisCacheName, responseUpdate.Resource.Properties.HostName); Assert.Equal(6379, responseUpdate.Resource.Properties.Port); Assert.Equal(6380, responseUpdate.Resource.Properties.SslPort); Assert.True(responseUpdate.Resource.Properties.EnableNonSslPort); AzureOperationResponse responseDelete = _client.Redis.Delete(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); List <HttpStatusCode> acceptedStatusCodes = new List <HttpStatusCode>(); acceptedStatusCodes.Add(HttpStatusCode.OK); acceptedStatusCodes.Add(HttpStatusCode.Accepted); acceptedStatusCodes.Add(HttpStatusCode.NotFound); Assert.Contains <HttpStatusCode>(responseDelete.StatusCode, acceptedStatusCodes); Assert.NotNull(responseDelete.RequestId); TestUtilities.EndTest(); }
public RedisCacheManagementHelper(TestBase testBase, MockContext context) { _client = RedisCacheManagementTestUtilities.GetResourceManagementClient(testBase, context); _testBase = testBase; _context = context; }
public void PatchSchedules_PutGetDelete() { using (var context = MockContext.Start(this.GetType().FullName)) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisSchedules"); var redisCacheName = TestUtilities.GenerateName("RedisSchedules"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); _client.Redis.Create(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); // First try to get cache and verify that it is premium cache RedisResource response = _client.Redis.Get(resourceGroupName, redisCacheName); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal("succeeded", response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); ScheduleEntry[] entries = new ScheduleEntry[] { new ScheduleEntry { DayOfWeek = DayOfWeekEnum.Monday, StartHourUtc = 10, MaintenanceWindow = TimeSpan.FromHours(10) }, new ScheduleEntry { DayOfWeek = DayOfWeekEnum.Tuesday, StartHourUtc = 11, MaintenanceWindow = TimeSpan.FromHours(11) } }; ValidateResponseForSchedulePatch( _client.PatchSchedules.CreateOrUpdate( resourceGroupName, redisCacheName, parameters: new RedisPatchSchedule(entries)), redisCacheName); ValidateResponseForSchedulePatch( _client.PatchSchedules.Get(resourceGroupName, redisCacheName), redisCacheName); _client.PatchSchedules.Delete(resourceGroupName, redisCacheName); var ex = Assert.Throws <CloudException>(() => _client.PatchSchedules.Get(resourceGroupName, redisCacheName)); Assert.Contains("There are no patch schedules found for redis cache", ex.Message); } }
public void CreateUpdateDeleteTest() { using (var context = MockContext.Start(this.GetType().FullName)) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); RedisResourceWithAccessKey responseCreate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.Location, Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 } }); Assert.Contains(fixture.RedisCacheName, responseCreate.Id); Assert.Equal(fixture.Location, responseCreate.Location); Assert.Equal(fixture.RedisCacheName, responseCreate.Name); Assert.Equal("Microsoft.Cache/Redis", responseCreate.Type); Assert.True("creating".Equals(responseCreate.ProvisioningState, StringComparison.OrdinalIgnoreCase)); Assert.Equal(SkuName.Basic, responseCreate.Sku.Name); Assert.Equal(SkuFamily.C, responseCreate.Sku.Family); Assert.Equal(0, responseCreate.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, responseCreate.HostName); Assert.Equal(6379, responseCreate.Port); Assert.Equal(6380, responseCreate.SslPort); Assert.False(responseCreate.EnableNonSslPort); // wait for maximum 30 minutes for cache to create for (int i = 0; i < 60; i++) { TestUtilities.Wait(new TimeSpan(0, 0, 30)); RedisResource responseGet = _client.Redis.Get(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); if ("succeeded".Equals(responseGet.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } Assert.False(i == 60, "Cache is not in succeeded state even after 30 min."); } RedisResourceWithAccessKey responseUpdate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.Location, Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 }, RedisConfiguration = new Dictionary <string, string>() { { "maxmemory-policy", "allkeys-lru" } }, EnableNonSslPort = true }); Assert.Contains(fixture.RedisCacheName, responseUpdate.Id); Assert.Equal(fixture.Location, responseUpdate.Location); Assert.Equal(fixture.RedisCacheName, responseUpdate.Name); Assert.Equal("Microsoft.Cache/Redis", responseUpdate.Type); Assert.Equal(SkuName.Basic, responseUpdate.Sku.Name); Assert.Equal(SkuFamily.C, responseUpdate.Sku.Family); Assert.Equal(0, responseUpdate.Sku.Capacity); Assert.Equal("allkeys-lru", responseUpdate.RedisConfiguration["maxmemory-policy"]); Assert.Contains(fixture.RedisCacheName, responseUpdate.HostName); Assert.Equal(6379, responseUpdate.Port); Assert.Equal(6380, responseUpdate.SslPort); Assert.True(responseUpdate.EnableNonSslPort); _client.Redis.Delete(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); } }
public void CreateUpdateDeleteTest() { using (var context = MockContext.Start(this.GetType())) { var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _client.Redis.CheckNameAvailability( parameters: new CheckNameAvailabilityParameters { Name = fixture.RedisCacheName, Type = "Microsoft.Cache/Redis" }); var responseCreate = _client.Redis.Create(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 } }); Assert.Contains(fixture.RedisCacheName, responseCreate.Id); Assert.Equal(RedisCacheManagementHelper.Location, responseCreate.Location); Assert.Equal(fixture.RedisCacheName, responseCreate.Name); Assert.Equal("Microsoft.Cache/Redis", responseCreate.Type); Assert.Equal("succeeded", responseCreate.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Basic, responseCreate.Sku.Name); Assert.Equal(SkuFamily.C, responseCreate.Sku.Family); Assert.Equal(0, responseCreate.Sku.Capacity); Assert.Contains(fixture.RedisCacheName, responseCreate.HostName); Assert.Equal(6379, responseCreate.Port); Assert.Equal(6380, responseCreate.SslPort); Assert.False(responseCreate.EnableNonSslPort); var responseUpdate = _client.Redis.Update(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName, parameters: new RedisUpdateParameters { Sku = new Sku() { Name = SkuName.Basic, Family = SkuFamily.C, Capacity = 0 }, RedisConfiguration = new RedisCommonPropertiesRedisConfiguration() { MaxmemoryPolicy = "allkeys-lru" }, EnableNonSslPort = true }); Assert.Contains(fixture.RedisCacheName, responseUpdate.Id); Assert.Equal(RedisCacheManagementHelper.Location, responseUpdate.Location); Assert.Equal(fixture.RedisCacheName, responseUpdate.Name); Assert.Equal("Microsoft.Cache/Redis", responseUpdate.Type); Assert.Equal(SkuName.Basic, responseUpdate.Sku.Name); Assert.Equal(SkuFamily.C, responseUpdate.Sku.Family); Assert.Equal(0, responseUpdate.Sku.Capacity); Assert.Equal("allkeys-lru", responseUpdate.RedisConfiguration.MaxmemoryPolicy); Assert.Contains(fixture.RedisCacheName, responseUpdate.HostName); Assert.Equal(6379, responseUpdate.Port); Assert.Equal(6380, responseUpdate.SslPort); Assert.True(responseUpdate.EnableNonSslPort); _client.Redis.Delete(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisCacheName); } }
public RedisCacheManagementHelper(TestBase testBase) { _client = RedisCacheManagementTestUtilities.GetResourceManagementClient(testBase); _testBase = testBase; }
public void ManagedIdentityCreateUpdateFunctionalTest() { using (var context = MockContext.Start(this.GetType())) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisBegin"); var redisCacheName = TestUtilities.GenerateName("RedisBegin"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); RedisResource response; _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); response = _client.Redis.BeginCreate(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 }, Identity = new ManagedServiceIdentity(type: ManagedServiceIdentityType.SystemAssignedUserAssigned , userAssignedIdentities: new Dictionary <String, UserAssignedIdentity> { { "/subscriptions/0ee2a145-4d40-44f4-b764-67b40274f1ac/resourceGroups/prn-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test", new UserAssignedIdentity() }, } ) }); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal(ProvisioningState.Creating, response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); Assert.Equal(ManagedServiceIdentityType.SystemAssignedUserAssigned, response.Identity.Type); Assert.NotNull(response.Identity.PrincipalId); Assert.NotEmpty(response.Identity.UserAssignedIdentities); for (int i = 0; i < 60; i++) { response = _client.Redis.Get(resourceGroupName, redisCacheName); if (ProvisioningState.Succeeded.Equals(response.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } TestUtilities.Wait(new TimeSpan(0, 0, 30)); } response = _client.Redis.Update(resourceGroupName, redisCacheName, parameters: new RedisUpdateParameters { Identity = new ManagedServiceIdentity(type: ManagedServiceIdentityType.SystemAssigned ) }); Assert.Equal(ManagedServiceIdentityType.SystemAssigned, response.Identity.Type); Assert.NotNull(response.Identity.PrincipalId); Assert.Null(response.Identity.UserAssignedIdentities); if (Utility.IsLiveTest()) { Thread.Sleep(60000); } response = _client.Redis.Update(resourceGroupName, redisCacheName, parameters: new RedisUpdateParameters { Identity = new ManagedServiceIdentity(type: ManagedServiceIdentityType.UserAssigned , userAssignedIdentities: new Dictionary <String, UserAssignedIdentity> { { "/subscriptions/0ee2a145-4d40-44f4-b764-67b40274f1ac/resourceGroups/prn-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test", new UserAssignedIdentity() }, } ) }); Assert.Equal(ManagedServiceIdentityType.UserAssigned, response.Identity.Type); Assert.NotEmpty(response.Identity.UserAssignedIdentities); Assert.Null(response.Identity.PrincipalId); if (Utility.IsLiveTest()) { Thread.Sleep(60000); } response = _client.Redis.Update(resourceGroupName, redisCacheName, parameters: new RedisUpdateParameters { Identity = new ManagedServiceIdentity(type: ManagedServiceIdentityType.None ) }); Assert.Null(response.Identity); _client.Redis.Delete(resourceGroupName: resourceGroupName, name: redisCacheName); _redisCacheManagementHelper.DeleteResourceGroup(resourceGroupName); } }
public void GeoReplicationFunctionalTest() { using (var context = MockContext.Start(this.GetType())) { var resourceGroupName = TestUtilities.GenerateName("RedisGeo"); var redisCacheName1 = TestUtilities.GenerateName("RedisGeo1"); var redisCacheName2 = TestUtilities.GenerateName("RedisGeo2"); var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); // Create cache in ncus RedisResource ncResponse = _client.Redis.BeginCreate(resourceGroupName, redisCacheName1, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); Assert.Contains(redisCacheName1, ncResponse.Id); Assert.Equal(redisCacheName1, ncResponse.Name); Assert.Equal("creating", ncResponse.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, ncResponse.Sku.Name); Assert.Equal(SkuFamily.P, ncResponse.Sku.Family); // Create cache in scus RedisResource scResponse = _client.Redis.BeginCreate(resourceGroupName, redisCacheName2, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.SecondaryLocation, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); Assert.Contains(redisCacheName2, scResponse.Id); Assert.Equal(redisCacheName2, scResponse.Name); Assert.Equal("creating", scResponse.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, scResponse.Sku.Name); Assert.Equal(SkuFamily.P, scResponse.Sku.Family); // Wait for both cache creation to comeplete for (int i = 0; i < 120; i++) { ncResponse = _client.Redis.Get(resourceGroupName, redisCacheName1); scResponse = _client.Redis.Get(resourceGroupName, redisCacheName2); if ("succeeded".Equals(ncResponse.ProvisioningState, StringComparison.OrdinalIgnoreCase) && "succeeded".Equals(scResponse.ProvisioningState, StringComparison.OrdinalIgnoreCase)) { break; } TestUtilities.Wait(new TimeSpan(0, 0, 30)); } // Fail if any of 2 cache is not created successfully Assert.Equal("succeeded", ncResponse.ProvisioningState, ignoreCase: true); Assert.Equal("succeeded", scResponse.ProvisioningState, ignoreCase: true); // Set up replication link RedisLinkedServerWithProperties linkServerWithProperties = _client.LinkedServer.Create(resourceGroupName, redisCacheName1, redisCacheName2, new RedisLinkedServerCreateParameters { LinkedRedisCacheId = scResponse.Id, LinkedRedisCacheLocation = RedisCacheManagementHelper.SecondaryLocation, ServerRole = ReplicationRole.Secondary }); Assert.Equal(redisCacheName2, linkServerWithProperties.Name); Assert.Equal(scResponse.Id, linkServerWithProperties.LinkedRedisCacheId); Assert.Equal(RedisCacheManagementHelper.SecondaryLocation, linkServerWithProperties.LinkedRedisCacheLocation); Assert.Equal(ReplicationRole.Secondary, linkServerWithProperties.ServerRole); Assert.Equal("succeeded", linkServerWithProperties.ProvisioningState, ignoreCase: true); // test get response from primary RedisLinkedServerWithProperties primaryLinkProperties = _client.LinkedServer.Get(resourceGroupName, redisCacheName1, redisCacheName2); Assert.Equal(scResponse.Id, primaryLinkProperties.LinkedRedisCacheId); Assert.Equal(RedisCacheManagementHelper.SecondaryLocation, primaryLinkProperties.LinkedRedisCacheLocation); Assert.Equal(ReplicationRole.Secondary, primaryLinkProperties.ServerRole); // test list response from primary IPage <RedisLinkedServerWithProperties> allPrimaryLinkProperties = _client.LinkedServer.List(resourceGroupName, redisCacheName1); Assert.Single(allPrimaryLinkProperties); // test get response from secondary RedisLinkedServerWithProperties secondaryLinkProperties = _client.LinkedServer.Get(resourceGroupName, redisCacheName2, redisCacheName1); Assert.Equal(ncResponse.Id, secondaryLinkProperties.LinkedRedisCacheId); Assert.Equal(RedisCacheManagementHelper.Location, secondaryLinkProperties.LinkedRedisCacheLocation); Assert.Equal(ReplicationRole.Primary, secondaryLinkProperties.ServerRole); // test list response from secondary IPage <RedisLinkedServerWithProperties> allSecondaryLinkProperties = _client.LinkedServer.List(resourceGroupName, redisCacheName2); Assert.Single(allSecondaryLinkProperties); // Delete link on primary _client.LinkedServer.Delete(resourceGroupName, redisCacheName1, redisCacheName2); // links should disappear in 5 min IPage <RedisLinkedServerWithProperties> afterDeletePrimaryLinkProperties = null; IPage <RedisLinkedServerWithProperties> afterDeleteSecondaryLinkProperties = null; for (int i = 0; i < 10; i++) { TestUtilities.Wait(new TimeSpan(0, 0, 30)); afterDeletePrimaryLinkProperties = _client.LinkedServer.List(resourceGroupName, redisCacheName1); afterDeleteSecondaryLinkProperties = _client.LinkedServer.List(resourceGroupName, redisCacheName2); if (afterDeletePrimaryLinkProperties.Count() == 0 && afterDeleteSecondaryLinkProperties.Count() == 0) { break; } } Assert.NotNull(afterDeletePrimaryLinkProperties); Assert.Empty(afterDeletePrimaryLinkProperties); Assert.NotNull(afterDeleteSecondaryLinkProperties); Assert.Empty(afterDeleteSecondaryLinkProperties); // Clean up both caches and delete resource group _client.Redis.Delete(resourceGroupName: resourceGroupName, name: redisCacheName1); _client.Redis.Delete(resourceGroupName: resourceGroupName, name: redisCacheName2); _redisCacheManagementHelper.DeleteResourceGroup(resourceGroupName); } }
public void FirewallFunctionalTest() { using (var context = MockContext.Start(this.GetType())) { var _redisCacheManagementHelper = new RedisCacheManagementHelper(this, context); _redisCacheManagementHelper.TryRegisterSubscriptionForResource(); var resourceGroupName = TestUtilities.GenerateName("RedisFirewall"); var redisCacheName = TestUtilities.GenerateName("RedisFirewall"); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this, context); _redisCacheManagementHelper.TryCreateResourceGroup(resourceGroupName, RedisCacheManagementHelper.Location); _client.Redis.Create(resourceGroupName, redisCacheName, parameters: new RedisCreateParameters { Location = RedisCacheManagementHelper.Location, Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 } }); // First try to get cache and verify that it is premium cache RedisResource response = _client.Redis.Get(resourceGroupName, redisCacheName); Assert.Contains(redisCacheName, response.Id); Assert.Equal(redisCacheName, response.Name); Assert.Equal(ProvisioningState.Succeeded, response.ProvisioningState, ignoreCase: true); Assert.Equal(SkuName.Premium, response.Sku.Name); Assert.Equal(SkuFamily.P, response.Sku.Family); // Set firewall rule for 10.0.0.0 to 10.0.0.32 RedisFirewallRule ruleOne = _client.FirewallRules.CreateOrUpdate(resourceGroupName, redisCacheName, "RuleOne", new RedisFirewallRuleCreateParameters { StartIP = "10.0.0.0", EndIP = "10.0.0.32" }); Assert.Equal("10.0.0.0", ruleOne.StartIP); Assert.Equal("10.0.0.32", ruleOne.EndIP); // Set firewall rule for 10.0.0.64 to 10.0.0.128 RedisFirewallRule ruleTwo = _client.FirewallRules.CreateOrUpdate(resourceGroupName, redisCacheName, "RuleTwo", new RedisFirewallRuleCreateParameters { StartIP = "10.0.0.64", EndIP = "10.0.0.128" }); Assert.Equal("10.0.0.64", ruleTwo.StartIP); Assert.Equal("10.0.0.128", ruleTwo.EndIP); // Get test ruleOne = _client.FirewallRules.Get(resourceGroupName, redisCacheName, "RuleOne"); Assert.Equal("10.0.0.0", ruleOne.StartIP); Assert.Equal("10.0.0.32", ruleOne.EndIP); ruleTwo = _client.FirewallRules.Get(resourceGroupName, redisCacheName, "RuleTwo"); Assert.Equal("10.0.0.64", ruleTwo.StartIP); Assert.Equal("10.0.0.128", ruleTwo.EndIP); // List test IPage <RedisFirewallRule> rules = _client.FirewallRules.List(resourceGroupName, redisCacheName); Assert.Equal(2, rules.Count()); // Delete _client.FirewallRules.Delete(resourceGroupName, redisCacheName, "RuleTwo"); if (Utility.IsLiveTest()) { Thread.Sleep(6000); } rules = _client.FirewallRules.List(resourceGroupName, redisCacheName); Assert.Single(rules); Assert.Equal("10.0.0.0", rules.First().StartIP); Assert.Equal("10.0.0.32", rules.First().EndIP); } }
public void CreateUpdateDeleteClusterCacheTest() { TestUtilities.StartTest(); var _client = RedisCacheManagementTestUtilities.GetRedisManagementClient(this); RedisCreateOrUpdateResponse responseCreate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisClusterCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.ClusterCacheLocation, Properties = new RedisProperties { RedisVersion = "3.0", Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 }, ShardCount = 2, TenantSettings = new Dictionary <string, string>() { { "some-key", "some-value" } } } }); Assert.Contains(fixture.RedisClusterCacheName, responseCreate.Resource.Id); Assert.Equal(fixture.ClusterCacheLocation, responseCreate.Resource.Location); Assert.Equal(fixture.RedisClusterCacheName, responseCreate.Resource.Name); Assert.True("creating".Equals(responseCreate.Resource.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)); Assert.Equal(SkuName.Premium, responseCreate.Resource.Properties.Sku.Name); Assert.Equal(SkuFamily.P, responseCreate.Resource.Properties.Sku.Family); Assert.Equal(1, responseCreate.Resource.Properties.Sku.Capacity); Assert.Contains(fixture.RedisClusterCacheName, responseCreate.Resource.Properties.HostName); Assert.Equal(6379, responseCreate.Resource.Properties.Port); Assert.Equal(6380, responseCreate.Resource.Properties.SslPort); Assert.False(responseCreate.Resource.Properties.EnableNonSslPort.Value); Assert.Equal(2, responseCreate.Resource.Properties.ShardCount.Value); Assert.Equal("some-value", responseCreate.Resource.Properties.TenantSettings["some-key"]); // wait for maximum 30 minutes for cache to create for (int i = 0; i < 60; i++) { TestUtilities.Wait(new TimeSpan(0, 0, 30)); RedisGetResponse responseGet = _client.Redis.Get(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisClusterCacheName); if ("succeeded".Equals(responseGet.Resource.Properties.ProvisioningState, StringComparison.InvariantCultureIgnoreCase)) { break; } Assert.False(i == 60, "Cache is not in succeeded state even after 30 min."); } RedisCreateOrUpdateResponse responseUpdate = _client.Redis.CreateOrUpdate(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisClusterCacheName, parameters: new RedisCreateOrUpdateParameters { Location = fixture.ClusterCacheLocation, Properties = new RedisProperties { Sku = new Sku() { Name = SkuName.Premium, Family = SkuFamily.P, Capacity = 1 }, TenantSettings = new Dictionary <string, string>() { { "some-key-1", "some-value-1" } } } }); Assert.Equal("some-value-1", responseUpdate.Resource.Properties.TenantSettings["some-key-1"]); AzureOperationResponse responseDelete = _client.Redis.Delete(resourceGroupName: fixture.ResourceGroupName, name: fixture.RedisClusterCacheName); List <HttpStatusCode> acceptedStatusCodes = new List <HttpStatusCode>(); acceptedStatusCodes.Add(HttpStatusCode.OK); acceptedStatusCodes.Add(HttpStatusCode.Accepted); acceptedStatusCodes.Add(HttpStatusCode.NotFound); Assert.Contains <HttpStatusCode>(responseDelete.StatusCode, acceptedStatusCodes); Assert.NotNull(responseDelete.RequestId); TestUtilities.EndTest(); }