public void DeleteVolumeWithSnapshotPresent()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the account and pool
ResourceUtils.CreateSnapshot(netAppMgmtClient);
// try and delete the account
try
{
netAppMgmtClient.Volumes.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.True(false); // expecting exception
}
catch (Exception ex)
{
Assert.Contains("Conflict", ex.Message);
}
// clean up
ResourceUtils.DeleteSnapshot(netAppMgmtClient);
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListAccounts()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var accountsBefore = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
int count = accountsBefore.Count();
// create two accounts
ResourceUtils.CreateAccount(netAppMgmtClient);
ResourceUtils.CreateAccount(netAppMgmtClient, ResourceUtils.accountName2);
// get the account list and check
var accounts = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
Assert.Equal(accounts.ElementAt(0).Name, ResourceUtils.accountName1);
Assert.Equal(accounts.ElementAt(1).Name, ResourceUtils.accountName2);
Assert.Equal(count + 2, accounts.Count());
// clean up - delete the two accounts
ResourceUtils.DeleteAccount(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient, ResourceUtils.accountName2);
}
}
public void ListBackupPolices()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
ResourceUtils.CreateAccount(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName: ResourceUtils.volumeBackupAccountName1);
// create two backupPolicies under same account
var backupPolicy1 = CreateBackupPolicy(ResourceUtils.backupLocation, ResourceUtils.backupPolicyName1);
var backupPolicy2 = CreateBackupPolicy(ResourceUtils.backupLocation, ResourceUtils.backupPolicyName2);
var resultbackupPolicy1 = netAppMgmtClient.BackupPolicies.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, backupPolicy1);
var resultbackupPolicy2 = netAppMgmtClient.BackupPolicies.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName2, backupPolicy2);
// get the backupPolicy list and check
var backupPolicies = netAppMgmtClient.BackupPolicies.List(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1);
Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupPolicyName1}", backupPolicies.ElementAt(0).Name);
Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupPolicyName2}", backupPolicies.ElementAt(1).Name);
Assert.Equal(2, backupPolicies.Count());
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
{
Thread.Sleep(delay);
}
// clean up
netAppMgmtClient.BackupPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
netAppMgmtClient.BackupPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName2);
WaitForBackupPolicyDeleted(netAppMgmtClient, resourceGroup: ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1);
ResourceUtils.DeleteAccount(netAppMgmtClient, resourceGroup: ResourceUtils.resourceGroup, accountName: ResourceUtils.volumeBackupAccountName1);
}
}
public void DeletePoolWithVolumePresent()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the account and pool
ResourceUtils.CreateVolume(netAppMgmtClient);
var poolsBefore = netAppMgmtClient.Pools.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Single(poolsBefore);
// try and delete the pool
try
{
netAppMgmtClient.Pools.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.True(false); // expecting exception
}
catch (Exception ex)
{
Assert.Contains("Can not delete resource before nested resources are deleted", ex.Message);
}
// clean up
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeleteVolume()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create a volume, get all and check
var resource = ResourceUtils.CreateVolume(netAppMgmtClient);
Assert.Equal(ResourceUtils.defaultExportPolicy.ToString(), resource.ExportPolicy.ToString());
Assert.Null(resource.Tags);
// check DP properties exist but unassigned because
// dataprotection volume was not created
Assert.Null(resource.VolumeType);
Assert.Null(resource.DataProtection);
var volumesBefore = netAppMgmtClient.Volumes.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.Single(volumesBefore);
// delete the volume and check again
netAppMgmtClient.Volumes.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
var volumesAfter = netAppMgmtClient.Volumes.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.Empty(volumesAfter);
// cleanup
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListPools()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create two pools under same account
// throw in a quick check on tags on the first
var dict = new Dictionary <string, string>();
dict.Add("Tag2", "Value2");
var resource = ResourceUtils.CreatePool(netAppMgmtClient, tags: dict);
Assert.True(resource.Tags.ContainsKey("Tag2"));
Assert.Equal("Value2", resource.Tags["Tag2"]);
ResourceUtils.CreatePool(netAppMgmtClient, ResourceUtils.poolName2, poolOnly: true);
// get the account list and check
var pools = netAppMgmtClient.Pools.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Equal(pools.ElementAt(0).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName1);
Assert.Equal(pools.ElementAt(1).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName2);
Assert.Equal(2, pools.Count());
// clean up - delete the two pools and the account
ResourceUtils.DeletePool(netAppMgmtClient, ResourceUtils.poolName2);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void GetVolumeByNameNotFound()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create volume
ResourceUtils.CreatePool(netAppMgmtClient);
// try and get a volume in the pool - none have been created yet
try
{
var volume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.True(false); // expecting exception
}
catch (Exception ex)
{
Assert.Contains("was not found", ex.Message);
}
// cleanup
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateVolumeWithProperties()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create a volume with tags and export policy
var dict = new Dictionary <string, string>();
dict.Add("Tag2", "Value2");
var resource = ResourceUtils.CreateVolume(netAppMgmtClient, tags: dict, exportPolicy: exportPolicy);
Assert.Equal(exportPolicy.ToString(), resource.ExportPolicy.ToString());
Assert.True(resource.Tags.ToString().Contains("Tag2") && resource.Tags.ToString().Contains("Value2"));
var volumesBefore = netAppMgmtClient.Volumes.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.Single(volumesBefore);
// delete the volume and check again
netAppMgmtClient.Volumes.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
var volumesAfter = netAppMgmtClient.Volumes.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.Empty(volumesAfter);
// cleanup
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateVolumeFromSnapshot()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the snapshot
ResourceUtils.CreateSnapshot(netAppMgmtClient);
// get and check the snapshot
var snapshot = netAppMgmtClient.Snapshots.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1, ResourceUtils.snapshotName1);
ResourceUtils.CreateVolume(netAppMgmtClient, ResourceUtils.volumeName2, volumeOnly: true, snapshotId: snapshot.SnapshotId);
// name assertion is performed in the volume create
// clean up
ResourceUtils.DeleteSnapshot(netAppMgmtClient);
ResourceUtils.DeleteVolume(netAppMgmtClient, ResourceUtils.volumeName2);
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void PatchPool()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the pool
var pool = ResourceUtils.CreatePool(netAppMgmtClient);
Assert.Equal("Premium", pool.ServiceLevel);
Assert.Null(pool.Tags);
var dict = new Dictionary <string, string>();
dict.Add("Tag1", "Value1");
// Now try and modify it
// set only two of the three possibles
// size should remain unchanged
var poolPatch = new CapacityPoolPatch()
{
Tags = dict,
};
var resource = netAppMgmtClient.Pools.Update(poolPatch, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.True(resource.Tags.ContainsKey("Tag1"));
Assert.Equal("Value1", resource.Tags["Tag1"]);
// cleanup
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void PatchAccount()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the account
ResourceUtils.CreateAccount(netAppMgmtClient);
var dict = new Dictionary <string, string>();
dict.Add("Tag1", "Value1");
// Now try and modify it
var netAppAccountPatch = new NetAppAccountPatch()
{
Tags = dict
};
var resource = netAppMgmtClient.Accounts.Update(netAppAccountPatch, ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.True(resource.Tags.ToString().Contains("Tag1") && resource.Tags.ToString().Contains("Value1"));
// cleanup - remove the account
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void PatchVolume()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the volume
var volume = ResourceUtils.CreateVolume(netAppMgmtClient);
Assert.Equal("Premium", volume.ServiceLevel);
// Now try and modify it
var volumePatch = new VolumePatch()
{
ServiceLevel = "Standard"
};
// patch
var updatedVolume = netAppMgmtClient.Volumes.Update(volumePatch, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Equal("Standard", updatedVolume.ServiceLevel);
// cleanup
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void UpdateVolume()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the volume
var volume = ResourceUtils.CreateVolume(netAppMgmtClient);
Assert.Equal("Premium", volume.ServiceLevel);
//Assert.Equal(100 * ResourceUtils.gibibyte, volume.UsageThreshold);
// update
volume.ServiceLevel = "Standard";
//volume.UsageThreshold = 100 * ResourceUtils.gibibyte * 2;
var updatedVolume = netAppMgmtClient.Volumes.CreateOrUpdate(volume, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Equal("Standard", updatedVolume.ServiceLevel);
//Assert.Equal(100 * ResourceUtils.gibibyte * 2, updatedVolume.UsageThreshold);
// cleanup
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeleteSnapshot()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the snapshot
ResourceUtils.CreateSnapshot(netAppMgmtClient);
// check snapshot exists
var snapshotsBefore = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Single(snapshotsBefore);
// delete the pool and check again
netAppMgmtClient.Snapshots.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1, ResourceUtils.snapshotName1);
var snapshotsAfter = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Empty(snapshotsAfter);
// cleanup - remove the account
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeletePool()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the account
var resource = ResourceUtils.CreateAccount(netAppMgmtClient);
Assert.Null(resource.Tags);
// create the pool, get all pools and check
ResourceUtils.CreatePool(netAppMgmtClient, ResourceUtils.poolName1, ResourceUtils.accountName1, poolOnly: true);
var poolsBefore = netAppMgmtClient.Pools.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Single(poolsBefore);
// delete the pool and check again
netAppMgmtClient.Pools.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
var poolsAfter = netAppMgmtClient.Pools.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Empty(poolsAfter);
// cleanup - remove the account
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void PatchSnapshot()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the snapshot
ResourceUtils.CreateSnapshot(netAppMgmtClient);
var dict = new Dictionary <string, string>();
dict.Add("Tag1", "Value1");
// Now try and modify it
//SnapshotPatch object was removed and not supported
var snapshotPatch = new object();
var exception = Record.Exception(() => netAppMgmtClient.Snapshots.Update(snapshotPatch, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1, ResourceUtils.snapshotName1));
Assert.NotNull(exception);
Assert.IsType <CloudException>(exception);
Assert.Contains("Patch operation is not supported", exception.Message);
// cleanup
ResourceUtils.DeleteSnapshot(netAppMgmtClient);
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void UpdatePool()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the pool
var pool = ResourceUtils.CreatePool(netAppMgmtClient);
Assert.Equal("Premium", pool.ServiceLevel);
Assert.Null(pool.Tags);
// update. Add tags and change service level
// size is already present in the object
// and must also be provided otherwise Bad Request
var dict = new Dictionary <string, string>();
dict.Add("Tag3", "Value3");
pool.Tags = dict;
pool.ServiceLevel = "Standard";
var updatedPool = netAppMgmtClient.Pools.CreateOrUpdate(pool, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
Assert.Equal("Standard", updatedPool.ServiceLevel);
Assert.Equal(4398046511104, updatedPool.Size); // unchanged
Assert.True(updatedPool.Tags.ContainsKey("Tag3"));
Assert.Equal("Value3", updatedPool.Tags["Tag3"]);
// cleanup
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeleteSnapshot()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the snapshot
ResourceUtils.CreateSnapshot(netAppMgmtClient);
// check snapshot exists
var snapshotsBefore = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Single(snapshotsBefore);
// check date created has been set to something
// can't check exact times becausefails in playback mode
Assert.True(true);
Assert.NotNull(snapshotsBefore.First().Created);
// delete the snapshot and check again
netAppMgmtClient.Snapshots.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1, ResourceUtils.snapshotName1);
var snapshotsAfter = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Empty(snapshotsAfter);
// cleanup - remove the resources
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListVolumes()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create two volumes under same pool
ResourceUtils.CreateVolume(netAppMgmtClient);
ResourceUtils.CreateVolume(netAppMgmtClient, ResourceUtils.volumeName2, volumeOnly: true);
// get the account list and check
var volumes = netAppMgmtClient.Volumes.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
//Assert.Equal(volumes.ElementAt(1).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName1 + '/' + ResourceUtils.volumeName1);
//Assert.Equal(volumes.ElementAt(0).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName1 + '/' + ResourceUtils.volumeName2);
Assert.Contains(volumes, item => item.Name == $"{ResourceUtils.accountName1}/{ResourceUtils.poolName1}/{ResourceUtils.volumeName1}");
Assert.Contains(volumes, item => item.Name == $"{ResourceUtils.accountName1}/{ResourceUtils.poolName1}/{ResourceUtils.volumeName2}");
Assert.Equal(2, volumes.Count());
// clean up - delete the two volumes, the pool and the account
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeleteVolume(netAppMgmtClient, ResourceUtils.volumeName2);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListSnapshots()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create two snapshots under same account
ResourceUtils.CreateSnapshot(netAppMgmtClient);
ResourceUtils.CreateSnapshot(netAppMgmtClient, ResourceUtils.snapshotName2, snapshotOnly: true);
// get the volume list and check
var snapshots = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Equal(snapshots.ElementAt(0).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName1 + '/' + ResourceUtils.volumeName1 + '/' + ResourceUtils.snapshotName1);
Assert.Equal(snapshots.ElementAt(1).Name, ResourceUtils.accountName1 + '/' + ResourceUtils.poolName1 + '/' + ResourceUtils.volumeName1 + '/' + ResourceUtils.snapshotName2);
Assert.Equal(2, snapshots.Count());
// clean up
ResourceUtils.DeleteSnapshot(netAppMgmtClient, ResourceUtils.snapshotName2);
ResourceUtils.DeleteSnapshot(netAppMgmtClient);
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateVolumePoolNotFound()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
ResourceUtils.CreateAccount(netAppMgmtClient);
// try and create a volume before the pool exist
try
{
ResourceUtils.CreateVolume(netAppMgmtClient, volumeOnly: true);
Assert.True(false); // expecting exception
}
catch (Exception ex)
{
Assert.Contains("not found", ex.Message);
}
// cleanup - remove the account
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeleteSnapshotPolicy()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
//create account
ResourceUtils.CreateAccount(netAppMgmtClient);
var snapshotPolicy = CreatePolicy(ResourceUtils.location, ResourceUtils.snapshotPolicyName1);
// create the snapshotPolicy
//ResourceUtils.CreateSnapshot(netAppMgmtClient);
var snapshotsBefore = netAppMgmtClient.SnapshotPolicies.Create(snapshotPolicy, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
// check snapshotPolicy exists
var snapshotPolciesBefore = netAppMgmtClient.SnapshotPolicies.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Single(snapshotPolciesBefore);
var resultSnapshotPolicy = netAppMgmtClient.SnapshotPolicies.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
Assert.Equal($"{ResourceUtils.accountName1}/{ResourceUtils.snapshotPolicyName1}", resultSnapshotPolicy.Name);
// delete the snapshotPolicy and check again
netAppMgmtClient.SnapshotPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
var snapshotsAfter = netAppMgmtClient.SnapshotPolicies.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Empty(snapshotsAfter);
// cleanup - remove the resources
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void UpdateVolume()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create the volume
var oldVolume = ResourceUtils.CreateVolume(netAppMgmtClient);
Assert.Equal("Premium", oldVolume.ServiceLevel);
Assert.Equal(100 * ResourceUtils.gibibyte, oldVolume.UsageThreshold);
// The returned volume contains some items which cnanot be part of the payload, such as baremetaltenant, therefore create a new object selectively from the old one
var volume = new Volume
{
Location = oldVolume.Location,
ServiceLevel = oldVolume.ServiceLevel,
CreationToken = oldVolume.CreationToken,
SubnetId = oldVolume.SubnetId,
};
// update
volume.UsageThreshold = 2 * oldVolume.UsageThreshold;
var updatedVolume = netAppMgmtClient.Volumes.CreateOrUpdate(volume, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Equal("Premium", updatedVolume.ServiceLevel); // didn't attempt to change - it would be rejected
Assert.Equal(100 * ResourceUtils.gibibyte * 2, updatedVolume.UsageThreshold);
// cleanup
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListSnapshotPolicies()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
ResourceUtils.CreateAccount(netAppMgmtClient);
// create two snapshots under same account
var snapshotPolicy1 = CreatePolicy(ResourceUtils.location, ResourceUtils.snapshotPolicyName1);
var snapshotPolicy2 = CreatePolicy(ResourceUtils.location, ResourceUtils.snapshotPolicyName2);
var resultSnapshotPolicy1 = netAppMgmtClient.SnapshotPolicies.Create(snapshotPolicy1, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
var resultSnapshotPolicy2 = netAppMgmtClient.SnapshotPolicies.Create(snapshotPolicy2, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName2);
// get the snapshotPolicy list and check
var snapshotPolicies = netAppMgmtClient.SnapshotPolicies.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Equal($"{ResourceUtils.accountName1}/{ResourceUtils.snapshotPolicyName1}", snapshotPolicies.ElementAt(0).Name);
Assert.Equal($"{ResourceUtils.accountName1}/{ResourceUtils.snapshotPolicyName2}", snapshotPolicies.ElementAt(1).Name);
Assert.Equal(2, snapshotPolicies.Count());
// clean up
netAppMgmtClient.SnapshotPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
netAppMgmtClient.SnapshotPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName2);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void ListMountTargets()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create two volumes under same pool
ResourceUtils.CreateVolume(netAppMgmtClient, resourceGroup: ResourceUtils.resourceGroup, accountName: ResourceUtils.accountName1, poolName: ResourceUtils.poolName1, volumeName: ResourceUtils.volumeName1);
// get the account list and check
var volume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Single(volume.MountTargets);
// clean up - delete the volumes, pool and account
netAppMgmtClient.Volumes.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
{
Thread.Sleep(10000);
}
WaitForVolumesDeleted(netAppMgmtClient, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
netAppMgmtClient.Pools.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1);
WaitForPoolsDeleted(netAppMgmtClient, ResourceUtils.resourceGroup, ResourceUtils.accountName1);
netAppMgmtClient.Accounts.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
}
}
public void GetSnapshotPolicyByName()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
//Create account
ResourceUtils.CreateAccount(netAppMgmtClient);
var snapshotPolicy = CreatePolicy(ResourceUtils.location, ResourceUtils.snapshotPolicyName1);
// create the snapshotPolicy
var createSnapshotPolicy = netAppMgmtClient.SnapshotPolicies.Create(snapshotPolicy, ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
var resultSnapshotPolicy = netAppMgmtClient.SnapshotPolicies.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
Assert.Equal($"{ResourceUtils.accountName1}/{ResourceUtils.snapshotPolicyName1}", resultSnapshotPolicy.Name);
Assert.Equal(createSnapshotPolicy.Name, resultSnapshotPolicy.Name);
// cleanup - remove the resources
netAppMgmtClient.SnapshotPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.snapshotPolicyName1);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void CreateDeleteAccount()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var accountsInitial = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
int initialCount = accountsInitial.Count();
// create the account with only the one required property
var netAppAccount = new NetAppAccount()
{
Location = ResourceUtils.location
};
var resource = netAppMgmtClient.Accounts.CreateOrUpdate(netAppAccount, ResourceUtils.resourceGroup, ResourceUtils.accountName1);
Assert.Equal(resource.Name, ResourceUtils.accountName1);
Assert.Null(resource.Tags);
Assert.Null(resource.ActiveDirectories);
// get all accounts and check
var accountsBefore = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
Assert.Equal(initialCount + 1, accountsBefore.Count());
// remove the account and check
netAppMgmtClient.Accounts.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1);
// get all accounts and check
var accountsAfter = netAppMgmtClient.Accounts.List(ResourceUtils.resourceGroup);
Assert.Equal(initialCount, accountsAfter.Count());
}
}
public void GetPoolByNameAccountNotFound()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
// create an account and pool
ResourceUtils.CreatePool(netAppMgmtClient);
// get and check the pool in a non-existent account
try
{
var pool = netAppMgmtClient.Pools.Get(ResourceUtils.resourceGroup, ResourceUtils.accountName2, ResourceUtils.poolName1);
Assert.True(false); // expecting exception
}
catch (Exception ex)
{
Assert.Contains("was not found", ex.Message);
}
// cleanup - remove pool and account
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
public void GetBackupPolicyByName()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
//Create account
ResourceUtils.CreateAccount(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName: ResourceUtils.volumeBackupAccountName1);
var backupPolicy = CreateBackupPolicy(ResourceUtils.backupLocation, ResourceUtils.backupPolicyName1);
// create the backupPolicy
var createBackupPolicy = netAppMgmtClient.BackupPolicies.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, backupPolicy);
var resultBackupPolicy = netAppMgmtClient.BackupPolicies.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupPolicyName1}", resultBackupPolicy.Name);
Assert.Equal(createBackupPolicy.Name, resultBackupPolicy.Name);
if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
{
Thread.Sleep(delay);
}
// cleanup - remove the resources
netAppMgmtClient.BackupPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
ResourceUtils.DeletePool(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
ResourceUtils.DeleteAccount(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
}
}
public void CreateDeleteSnapshot()
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType()))
{
var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var timeNow = DateTime.UtcNow;
// create the snapshot
ResourceUtils.CreateSnapshot(netAppMgmtClient);
// check snapshot exists
var snapshotsBefore = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Single(snapshotsBefore);
// check date created - might have taken a few minutes
// possible issue with recording times. Commenting out
Assert.True(true);
//Assert.True((timeNow < snapshotsBefore.First().Created) &&
// (snapshotsBefore.First().Created <(timeNow.AddMinutes(20))));
// delete the snapshot and check again
netAppMgmtClient.Snapshots.Delete(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1, ResourceUtils.snapshotName1);
var snapshotsAfter = netAppMgmtClient.Snapshots.List(ResourceUtils.resourceGroup, ResourceUtils.accountName1, ResourceUtils.poolName1, ResourceUtils.volumeName1);
Assert.Empty(snapshotsAfter);
// cleanup - remove the resources
ResourceUtils.DeleteVolume(netAppMgmtClient);
ResourceUtils.DeletePool(netAppMgmtClient);
ResourceUtils.DeleteAccount(netAppMgmtClient);
}
}
