public TestsFixtureWithCacheCreate()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
_context = new MockContext();
MockContext.Start(this.GetType().FullName, ".ctor");
try
{
_redisCacheManagementHelper = new RedisCacheManagementHelper(this, _context);
_redisCacheManagementHelper.TryRegisterSubscriptionForResource();
ResourceGroupName = TestUtilities.GenerateName("RedisGetList");
RedisCacheName = TestUtilities.GenerateName("RedisGetList");
_redisCacheManagementHelper.TryCreateResourceGroup(ResourceGroupName, RedisCacheManagementHelper.Location);
_redisCacheManagementHelper.TryCreatingCache(ResourceGroupName, RedisCacheName, RedisCacheManagementHelper.Location);
}
catch (Exception)
{
Cleanup();
throw;
}
finally
{
HttpMockServer.Flush();
}
}
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 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 TestsFixture()
{
_context = new MockContext();
MockContext.Start(this.GetType().FullName, ".ctor");
try
{
_redisCacheManagementHelper = new RedisCacheManagementHelper(this, _context);
_redisCacheManagementHelper.TryRegisterSubscriptionForResource();
ResourceGroupName = TestUtilities.GenerateName("hydra2");
_redisCacheManagementHelper.TryCreateResourceGroup(ResourceGroupName, Location);
}
catch (Exception)
{
Cleanup();
throw;
}
finally
{
HttpMockServer.Flush();
}
}
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 TestsFixture()
{
TestUtilities.StartTest();
try
{
UndoContext.Current.Start();
RedisCacheManagementHelper redisCacheManagementHelper = new RedisCacheManagementHelper(this);
redisCacheManagementHelper.TryRegisterSubscriptionForResource();
ResourceGroupName = TestUtilities.GenerateName("hydra2");
redisCacheManagementHelper.TryCreateResourceGroup(ResourceGroupName, Location);
}
catch (Exception)
{
Cleanup();
throw;
}
finally
{
TestUtilities.EndTest();
}
}
public TestsFixture()
{
TestUtilities.StartTest();
try
{
UndoContext.Current.Start();
RedisCacheManagementHelper redisCacheManagementHelper = new RedisCacheManagementHelper(this);
redisCacheManagementHelper.TryRegisterSubscriptionForResource();
ResourceGroupName = TestUtilities.GenerateName("hydra2");
redisCacheManagementHelper.TryCreateResourceGroup(ResourceGroupName, Location);
}
catch (Exception)
{
Cleanup();
throw;
}
finally
{
TestUtilities.EndTest();
}
}
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 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);
}
}
