public void TestRebuildServer()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault();
if (flavor == null)
{
Assert.Inconclusive("Couldn't find a flavor to use for the test server.");
}
SimpleServerImage[] images = UserComputeTests.ListAllImages(provider).ToArray();
SimpleServerImage image = images.FirstOrDefault(i => i.Name.IndexOf(TestImageNameSubstring, StringComparison.OrdinalIgnoreCase) >= 0);
if (image == null)
{
Assert.Inconclusive(string.Format("Couldn't find the {0} image to use for the test server.", TestImageNameSubstring));
}
Server rebuilt = provider.RebuildServer(_server.Id, null, image.Id, flavor.Id, _password);
Assert.IsNotNull(rebuilt);
Server rebuiltServer = provider.WaitForServerActive(rebuilt.Id);
Assert.AreEqual(ServerState.Active, rebuiltServer.Status);
_server = rebuiltServer;
}
public void TestListAddresses()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
ServerAddresses serverAddresses = provider.ListAddresses(_server.Id);
if (serverAddresses.Count == 0)
{
Assert.Inconclusive("Couldn't find any addresses listed for the server.");
}
bool foundAddress = false;
foreach (KeyValuePair <string, IPAddressList> addresses in serverAddresses)
{
Console.WriteLine("Network: {0}", addresses.Key);
foreach (IPAddress address in addresses.Value)
{
foundAddress = true;
Console.WriteLine(" {0}", address);
}
}
if (!foundAddress)
{
Assert.Inconclusive("Couldn't find addresses on any network for the server.");
}
}
public void TestRevertServerResize()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
string serverName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName();
Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault(i => !i.Id.Equals(_server.Flavor.Id, StringComparison.OrdinalIgnoreCase));
if (flavor == null)
{
Assert.Inconclusive("Couldn't find a flavor to use for the test server.");
}
bool resized = provider.ResizeServer(_server.Id, serverName, flavor.Id);
Assert.IsTrue(resized);
Server resizedServer = provider.WaitForServerState(_server.Id, ServerState.VerifyResize, new[] { ServerState.Active, ServerState.Error, ServerState.Unknown, ServerState.Suspended });
Assert.AreEqual(ServerState.VerifyResize, resizedServer.Status);
_server = resizedServer;
bool reverted = provider.RevertServerResize(resizedServer.Id);
Assert.IsTrue(reverted);
Server revertedServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, revertedServer.Status);
_server = revertedServer;
}
public void TestListAddressesByNetwork()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
INetworksProvider networksProvider = Bootstrapper.CreateNetworksProvider();
IEnumerable <CloudNetwork> networks = networksProvider.ListNetworks();
bool foundAddress = false;
foreach (CloudNetwork network in networks)
{
Console.WriteLine("Network: {0}", network.Label);
IEnumerable <IPAddress> addresses = provider.ListAddressesByNetwork(_server.Id, network.Label);
bool foundAddressOnNetwork = false;
foreach (IPAddress address in addresses)
{
foundAddress = true;
foundAddressOnNetwork = true;
Console.WriteLine(" {0}", address);
}
if (!foundAddressOnNetwork)
{
Console.WriteLine(" Server is not attached to this network.");
}
}
if (!foundAddress)
{
Assert.Inconclusive("Couldn't find addresses on any network for the server.");
}
}
public void TestSoftRebootServer()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
bool rebootResult = provider.RebootServer(_server.Id, RebootType.Soft);
Assert.IsTrue(rebootResult);
Server rebootServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, rebootServer.Status);
}
public void TestInitialize()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
Server server = provider.GetDetails(_server.Id);
if (server.Status != ServerState.Active)
{
Assert.Inconclusive("Could not run test because the server is in the '{0}' state (expected '{1}').", server.Status, ServerState.Active);
}
}
public void TestServerMetadata()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
Metadata initialMetadata = provider.ListServerMetadata(_server.Id);
if (initialMetadata.Count > 0)
{
Console.WriteLine("Actual metadata");
foreach (KeyValuePair <string, string> meta in initialMetadata)
{
Console.WriteLine(" {0}: {1}", meta.Key, meta.Value);
}
Assert.Inconclusive("Expected the server to not have any initial metadata.");
}
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 1", "Value"));
Assert.AreEqual("Value", provider.GetServerMetadataItem(_server.Id, "Item 1"));
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 2", "Value ²"));
Assert.AreEqual("Value ²", provider.GetServerMetadataItem(_server.Id, "Item 2"));
// setting the same key overwrites the previous value
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 1", "Value 1"));
Assert.AreEqual("Value 1", provider.GetServerMetadataItem(_server.Id, "Item 1"));
Assert.IsTrue(provider.DeleteServerMetadataItem(_server.Id, "Item 1"));
Assert.IsFalse(provider.ListServerMetadata(_server.Id).ContainsKey("Item 1"));
Metadata metadata = new Metadata()
{
{ "Different", "Variables" },
};
Assert.IsTrue(provider.UpdateServerMetadata(_server.Id, metadata));
Metadata actual = provider.ListServerMetadata(_server.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Value ²", actual["Item 2"]);
Assert.AreEqual("Variables", actual["Different"]);
// a slight tweak
metadata["Different"] = "Values";
Assert.IsTrue(provider.SetServerMetadata(_server.Id, metadata));
actual = provider.ListServerMetadata(_server.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual("Values", actual["Different"]);
Assert.IsTrue(provider.SetServerMetadata(_server.Id, new Metadata()));
Assert.AreEqual(0, provider.ListServerMetadata(_server.Id).Count);
}
public void TestAttachServerVolume()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IBlockStorageProvider blockStorageProvider = Bootstrapper.CreateBlockStorageProvider();
VolumeType volumeType = UserBlockStorageTests.GetSsdVolumeTypeOrDefault(blockStorageProvider);
string volumeName = UserBlockStorageTests.UnitTestVolumePrefix + Path.GetRandomFileName();
Volume volume = blockStorageProvider.CreateVolume(UserBlockStorageTests.MinimumVolumeSize, displayName: volumeName, volumeType: volumeType != null ? volumeType.Id : null);
Assert.AreEqual(VolumeState.Available, blockStorageProvider.WaitForVolumeAvailable(volume.Id).Status);
/* AttachServerVolume
*/
ServerVolume serverVolume = provider.AttachServerVolume(_server.Id, volume.Id);
Assert.IsNotNull(serverVolume);
Assert.IsFalse(string.IsNullOrEmpty(serverVolume.Id));
Assert.AreEqual(_server.Id, serverVolume.ServerId);
Assert.AreEqual(volume.Id, serverVolume.VolumeId);
Assert.AreEqual(VolumeState.InUse, blockStorageProvider.WaitForVolumeState(volume.Id, VolumeState.InUse, new[] { VolumeState.Available, VolumeState.Error }).Status);
/* ListServerVolumes
*/
ServerVolume[] serverVolumes = provider.ListServerVolumes(_server.Id).ToArray();
Assert.IsNotNull(serverVolumes);
Assert.AreEqual(1, serverVolumes.Length);
Assert.AreEqual(serverVolume.Id, serverVolumes[0].Id);
Assert.AreEqual(serverVolume.ServerId, serverVolumes[0].ServerId);
Assert.AreEqual(serverVolume.VolumeId, serverVolumes[0].VolumeId);
/* GetServerVolumeDetails
*/
ServerVolume volumeDetails = provider.GetServerVolumeDetails(_server.Id, volume.Id);
Assert.IsNotNull(volumeDetails);
Assert.AreEqual(serverVolume.Id, volumeDetails.Id);
Assert.AreEqual(serverVolume.ServerId, volumeDetails.ServerId);
Assert.AreEqual(serverVolume.VolumeId, volumeDetails.VolumeId);
bool detach = provider.DetachServerVolume(_server.Id, volume.Id);
Assert.IsTrue(detach);
provider.WaitForServerActive(_server.Id);
ServerVolume[] remainingVolumes = provider.ListServerVolumes(_server.Id).ToArray();
Assert.AreEqual(0, remainingVolumes.Length);
Assert.AreEqual(VolumeState.Available, blockStorageProvider.WaitForVolumeAvailable(volume.Id).Status);
bool deleted = blockStorageProvider.DeleteVolume(volume.Id);
Assert.IsTrue(blockStorageProvider.WaitForVolumeDeleted(volume.Id));
}
public void TestChangeAdministratorPassword()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
string password = Path.GetTempPath();
bool changePasswordResult = provider.ChangeAdministratorPassword(_server.Id, password);
Assert.IsTrue(changePasswordResult);
_password = password;
Server changePasswordServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, changePasswordServer.Status);
}
public static void ClassCleanup()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
Stopwatch timer = Stopwatch.StartNew();
Console.Write(" Deleting...");
bool deleted = provider.DeleteServer(_server.Id);
Assert.IsTrue(deleted);
provider.WaitForServerDeleted(_server.Id);
Console.Write("done. {0} seconds", timer.Elapsed.TotalSeconds);
}
public void TestUpdateServer()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
string newName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName() + "²";
bool updated = provider.UpdateServer(_server.Id, name: newName);
Assert.IsTrue(updated);
Server updatedServer = provider.GetDetails(_server.Id);
Assert.AreEqual(_server.Id, updatedServer.Id);
Assert.AreEqual(newName, updatedServer.Name);
Assert.AreNotEqual(_server.Name, updatedServer.Name);
_server = updatedServer;
}
public void TestGetImage()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <ServerImage> images = ListAllImagesWithDetails(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
foreach (ServerImage image in images)
{
Assert.IsNotNull(image);
ServerImage details = provider.GetImage(image.Id);
Assert.AreEqual(image.Created, details.Created);
Assert.AreEqual(image.DiskConfig, details.DiskConfig);
Assert.AreEqual(image.Id, details.Id);
Assert.IsNotNull(details.Links);
Assert.AreEqual(image.Links.Length, details.Links.Length);
for (int i = 0; i < image.Links.Length; i++)
{
// this could start to fail if the server reorders links; if that occurs the test should be rewritten to allow it
Assert.AreEqual(image.Links[i].Href, details.Links[i].Href);
Assert.AreEqual(image.Links[i].Rel, details.Links[i].Rel);
}
Assert.AreEqual(image.MinDisk, details.MinDisk);
Assert.AreEqual(image.MinRAM, details.MinRAM);
Assert.AreEqual(image.Name, details.Name);
Assert.IsTrue(details.Progress >= 0 && details.Progress <= 100);
if (image.Server != null)
{
Assert.IsNotNull(details.Server);
Assert.AreEqual(image.Server.Id, details.Server.Id);
}
Assert.IsNotNull(details.Status);
Assert.AreEqual(image.Updated, details.Updated);
}
}
public void TestRescueServer()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
string rescueResult = provider.RescueServer(_server.Id);
Assert.IsFalse(string.IsNullOrEmpty(rescueResult));
Server rescueServer = provider.WaitForServerState(_server.Id, ServerState.Rescue, new[] { ServerState.Active, ServerState.Error, ServerState.Unknown, ServerState.Suspended });
Assert.AreEqual(ServerState.Rescue, rescueServer.Status);
bool unrescueResult = provider.UnRescueServer(_server.Id);
Assert.IsTrue(unrescueResult);
Server unrescueServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, unrescueServer.Status);
}
public void TestGetImageMetadataItem()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <ServerImage> images = ListAllImagesWithDetails(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
int hadMetadata = 0;
int metadataCount = 0;
foreach (ServerImage image in images)
{
Assert.IsNotNull(image);
Metadata metadata = provider.ListImageMetadata(image.Id);
if (metadata.Count == 0)
{
continue;
}
hadMetadata++;
metadataCount += metadata.Count;
Console.WriteLine("Checking {0} metadata items for image '{1}'...", metadata.Count, image.Name);
foreach (KeyValuePair <string, string> pair in metadata)
{
Assert.AreEqual(pair.Value, provider.GetImageMetadataItem(image.Id, pair.Key));
}
if (hadMetadata >= 3 && metadataCount >= 30)
{
// this can be slow for a large number of images and metadata items,
// so stop after several are tested
break;
}
}
if (hadMetadata == 0)
{
Assert.Inconclusive("None of the images contained metadata.");
}
}
public static IEnumerable<Server> ListAllServersWithDetails(IComputeProvider provider, int? blockSize = null, string imageId = null, string flavorId = null, string name = null, ServerState status = null, DateTimeOffset? changesSince = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
throw new ArgumentOutOfRangeException("blockSize");
Server lastServer = null;
do
{
string marker = lastServer != null ? lastServer.Id : null;
IEnumerable<Server> servers = provider.ListServersWithDetails(imageId, flavorId, name, status, marker, blockSize, changesSince, region, identity);
lastServer = null;
foreach (Server server in servers)
{
lastServer = server;
yield return server;
}
} while (lastServer != null);
}
public static IEnumerable<SimpleServerImage> ListAllImages(IComputeProvider provider, int? blockSize = null, string server = null, string imageName = null, ImageState imageStatus = null, DateTimeOffset? changesSince = null, ImageType imageType = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
throw new ArgumentOutOfRangeException("blockSize");
SimpleServerImage lastImage = null;
do
{
string marker = lastImage != null ? lastImage.Id : null;
IEnumerable<SimpleServerImage> images = provider.ListImages(server, imageName, imageStatus, changesSince, marker, blockSize, imageType, region, identity);
lastImage = null;
foreach (SimpleServerImage image in images)
{
lastImage = image;
yield return image;
}
} while (lastImage != null);
}
public static IEnumerable <FlavorDetails> ListAllFlavorsWithDetails(IComputeProvider provider, int?blockSize = null, int?minDiskInGB = null, int?minRamInMB = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
{
throw new ArgumentOutOfRangeException("blockSize");
}
FlavorDetails lastFlavor = null;
do
{
string marker = lastFlavor != null ? lastFlavor.Id : null;
IEnumerable <FlavorDetails> flavors = provider.ListFlavorsWithDetails(minDiskInGB, minRamInMB, marker, blockSize, region, identity);
lastFlavor = null;
foreach (FlavorDetails flavor in flavors)
{
lastFlavor = flavor;
yield return(flavor);
}
} while (lastFlavor != null);
}
public static IEnumerable <Server> ListAllServersWithDetails(IComputeProvider provider, int?blockSize = null, string imageId = null, string flavorId = null, string name = null, ServerState status = null, DateTimeOffset?changesSince = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
{
throw new ArgumentOutOfRangeException("blockSize");
}
Server lastServer = null;
do
{
string marker = lastServer != null ? lastServer.Id : null;
IEnumerable <Server> servers = provider.ListServersWithDetails(imageId, flavorId, name, status, marker, blockSize, changesSince, region, identity);
lastServer = null;
foreach (Server server in servers)
{
lastServer = server;
yield return(server);
}
} while (lastServer != null);
}
public static IEnumerable <SimpleServerImage> ListAllImages(IComputeProvider provider, int?blockSize = null, string server = null, string imageName = null, ImageState imageStatus = null, DateTimeOffset?changesSince = null, ImageType imageType = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
{
throw new ArgumentOutOfRangeException("blockSize");
}
SimpleServerImage lastImage = null;
do
{
string marker = lastImage != null ? lastImage.Id : null;
IEnumerable <SimpleServerImage> images = provider.ListImages(server, imageName, imageStatus, changesSince, marker, blockSize, imageType, region, identity);
lastImage = null;
foreach (SimpleServerImage image in images)
{
lastImage = image;
yield return(image);
}
} while (lastImage != null);
}
public void TestListFlavors()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <Flavor> flavors = ListAllFlavors(provider);
Assert.IsNotNull(flavors);
if (!flavors.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured flavors.");
}
Console.WriteLine("Flavors");
foreach (Flavor flavor in flavors)
{
Assert.IsNotNull(flavor);
Console.WriteLine(" {0}: {1}", flavor.Id, flavor.Name);
Assert.IsFalse(string.IsNullOrEmpty(flavor.Id));
Assert.IsFalse(string.IsNullOrEmpty(flavor.Name));
}
}
public void TestListImages()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <SimpleServerImage> images = ListAllImages(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
Console.WriteLine("Images");
foreach (SimpleServerImage image in images)
{
Assert.IsNotNull(image);
Console.WriteLine(" {0}: {1}", image.Id, image.Name);
Assert.IsFalse(string.IsNullOrEmpty(image.Id));
Assert.IsFalse(string.IsNullOrEmpty(image.Name));
}
}
public void TestVirtualInterfaces()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
INetworksProvider networksProvider = Bootstrapper.CreateNetworksProvider();
CloudNetwork publicNetwork = networksProvider.ListNetworks().Single(i => i.Label.Equals("public", StringComparison.OrdinalIgnoreCase));
VirtualInterface publicVirtualInterface = provider.CreateVirtualInterface(_server.Id, publicNetwork.Id);
Assert.IsNotNull(publicVirtualInterface);
Assert.IsFalse(string.IsNullOrEmpty(publicVirtualInterface.Id));
Assert.IsNotNull(publicVirtualInterface.MACAddress);
IEnumerable <VirtualInterface> virtualInterfaces = provider.ListVirtualInterfaces(_server.Id);
Assert.IsNotNull(virtualInterfaces);
Assert.IsTrue(virtualInterfaces.Where(i => i.Id.Equals(publicVirtualInterface.Id, StringComparison.OrdinalIgnoreCase)).Any());
bool deleted;
deleted = provider.DeleteVirtualInterface(_server.Id, publicVirtualInterface.Id);
Assert.IsTrue(deleted);
}
public void TestListServers()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <SimpleServer> servers = UserComputeTests.ListAllServers(provider);
Assert.IsNotNull(servers);
if (!servers.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured servers.");
}
Console.WriteLine("Servers");
foreach (SimpleServer server in servers)
{
Assert.IsNotNull(server);
Console.WriteLine(" {0}: {1}", server.Id, server.Name);
Assert.IsFalse(string.IsNullOrEmpty(server.Id));
Assert.IsFalse(string.IsNullOrEmpty(server.Name));
}
}
public void TestListImageMetadata()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <ServerImage> images = ListAllImagesWithDetails(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
Console.WriteLine("Image metadata");
Console.WriteLine();
bool hadMetadata = false;
foreach (ServerImage image in images)
{
Assert.IsNotNull(image);
Metadata metadata = provider.ListImageMetadata(image.Id);
if (metadata.Count == 0)
{
continue;
}
hadMetadata = true;
Console.WriteLine("Image: {0}", image.Name);
foreach (KeyValuePair <string, string> pair in metadata)
{
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
}
}
if (!hadMetadata)
{
Assert.Inconclusive("None of the images contained metadata.");
}
}
public void CleanupTestServers()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <SimpleServer> servers = ListAllServers(provider).ToArray();
foreach (SimpleServer server in servers)
{
if (string.IsNullOrEmpty(server.Name))
{
continue;
}
if (!server.Name.StartsWith(UnitTestServerPrefix))
{
continue;
}
Console.WriteLine("Deleting unit test server... {0} ({1})", server.Name, server.Id);
bool deleted = provider.DeleteServer(server.Id);
Assert.IsTrue(deleted);
provider.WaitForServerDeleted(server.Id);
}
}
public void CleanupTestImages()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <SimpleServerImage> images = ListAllImages(provider).ToArray();
foreach (SimpleServerImage image in images)
{
if (string.IsNullOrEmpty(image.Name))
{
continue;
}
if (!image.Name.StartsWith(UnitTestImagePrefix))
{
continue;
}
Console.WriteLine("Deleting unit test image... {0} ({1})", image.Name, image.Id);
bool deleted = provider.DeleteImage(image.Id);
Assert.IsTrue(deleted);
provider.WaitForImageDeleted(image.Id);
}
}
public static void ClassInitialize(TestContext testContext)
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
string serverName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName();
Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault();
if (flavor == null)
{
Assert.Inconclusive("Couldn't find a flavor to use for the test server.");
}
SimpleServerImage[] images = UserComputeTests.ListAllImages(provider).ToArray();
SimpleServerImage image = images.FirstOrDefault(i => i.Name.IndexOf(TestImageNameSubstring, StringComparison.OrdinalIgnoreCase) >= 0);
if (image == null)
{
Assert.Inconclusive(string.Format("Couldn't find the {0} image to use for the test server.", TestImageNameSubstring));
}
Stopwatch timer = Stopwatch.StartNew();
Console.Write("Creating server for image {0}...", image.Name);
NewServer server = provider.CreateServer(serverName, image.Id, flavor.Id, attachToServiceNetwork: true);
Assert.IsNotNull(server);
Assert.IsFalse(string.IsNullOrEmpty(server.Id));
_password = server.AdminPassword;
_server = provider.WaitForServerActive(server.Id);
Assert.IsNotNull(_server);
Assert.AreEqual(server.Id, _server.Id);
Assert.AreEqual(ServerState.Active, _server.Status);
Console.WriteLine("done. {0} seconds", timer.Elapsed.TotalSeconds);
}
public void TestGetFlavor()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <FlavorDetails> flavors = ListAllFlavorsWithDetails(provider);
Assert.IsNotNull(flavors);
if (!flavors.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured flavors.");
}
foreach (FlavorDetails flavor in flavors)
{
Assert.IsNotNull(flavor);
FlavorDetails details = provider.GetFlavor(flavor.Id);
Assert.AreEqual(flavor.Disabled, details.Disabled);
Assert.AreEqual(flavor.DiskSizeInGB, details.DiskSizeInGB);
Assert.AreEqual(flavor.Id, details.Id);
//Assert.AreEqual(flavor.Links, details.Links);
Assert.AreEqual(flavor.Name, details.Name);
Assert.AreEqual(flavor.RAMInMB, details.RAMInMB);
Assert.AreEqual(flavor.VirtualCPUCount, details.VirtualCPUCount);
}
}
public void TestGetDetails()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
IEnumerable <Server> servers = UserComputeTests.ListAllServersWithDetails(provider);
Assert.IsNotNull(servers);
if (!servers.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured servers.");
}
foreach (Server server in servers)
{
Assert.IsNotNull(server);
Server details = provider.GetDetails(server.Id);
Assert.AreEqual(server.AccessIPv4, details.AccessIPv4);
Assert.AreEqual(server.AccessIPv6, details.AccessIPv6);
//Assert.AreEqual(server.Addresses, details.Addresses);
Assert.AreEqual(server.Created, details.Created);
Assert.AreEqual(server.DiskConfig, details.DiskConfig);
Assert.AreEqual(server.Flavor.Id, details.Flavor.Id);
Assert.AreEqual(server.HostId, details.HostId);
Assert.AreEqual(server.Id, details.Id);
Assert.AreEqual(server.Image.Id, details.Image.Id);
//Assert.AreEqual(server.Links, details.Links);
Assert.AreEqual(server.Name, details.Name);
Assert.AreEqual(server.PowerState, details.PowerState);
//Assert.AreEqual(server.Progress, details.Progress);
//Assert.AreEqual(server.Status, details.Status);
//Assert.AreEqual(server.TaskState, details.TaskState);
Assert.AreEqual(server.TenantId, details.TenantId);
Assert.AreEqual(server.Updated, details.Updated);
Assert.AreEqual(server.UserId, details.UserId);
//Assert.AreEqual(server.VMState, details.VMState);
}
}
public static IEnumerable<FlavorDetails> ListAllFlavorsWithDetails(IComputeProvider provider, int? blockSize = null, int? minDiskInGB = null, int? minRamInMB = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
throw new ArgumentOutOfRangeException("blockSize");
FlavorDetails lastFlavor = null;
do
{
string marker = lastFlavor != null ? lastFlavor.Id : null;
IEnumerable<FlavorDetails> flavors = provider.ListFlavorsWithDetails(minDiskInGB, minRamInMB, marker, blockSize, region, identity);
lastFlavor = null;
foreach (FlavorDetails flavor in flavors)
{
lastFlavor = flavor;
yield return flavor;
}
} while (lastFlavor != null);
}
public void TestCreateImage()
{
IComputeProvider provider = Bootstrapper.CreateComputeProvider();
/* Create the image
*/
string imageName = UserComputeTests.UnitTestImagePrefix + Path.GetRandomFileName();
bool imaged = provider.CreateImage(_server.Id, imageName);
Assert.IsTrue(imaged);
ServerImage[] images = provider.ListImagesWithDetails(server: _server.Id, imageName: imageName).ToArray();
Assert.IsNotNull(images);
Assert.AreEqual(1, images.Length);
ServerImage image = images[0];
Assert.AreEqual(imageName, image.Name);
Assert.IsFalse(string.IsNullOrEmpty(image.Id));
Assert.AreEqual(ImageState.Active, provider.WaitForImageActive(image.Id).Status);
/* Test metadata operations on the image
*/
Assert.IsTrue(provider.SetImageMetadataItem(image.Id, "Item 1", "Value"));
Assert.AreEqual("Value", provider.GetImageMetadataItem(image.Id, "Item 1"));
Assert.IsTrue(provider.SetImageMetadataItem(image.Id, "Item 2", "Value ²"));
Assert.AreEqual("Value ²", provider.GetImageMetadataItem(image.Id, "Item 2"));
// setting the same key overwrites the previous value
Assert.IsTrue(provider.SetImageMetadataItem(image.Id, "Item 1", "Value 1"));
Assert.AreEqual("Value 1", provider.GetImageMetadataItem(image.Id, "Item 1"));
Assert.IsTrue(provider.DeleteImageMetadataItem(image.Id, "Item 1"));
Assert.IsFalse(provider.ListImageMetadata(image.Id).ContainsKey("Item 1"));
Metadata metadata = new Metadata()
{
{ "Different", "Variables" },
};
Assert.IsTrue(provider.UpdateImageMetadata(image.Id, metadata));
Metadata actual = provider.ListImageMetadata(image.Id);
Assert.IsNotNull(actual);
Assert.AreEqual("Value ²", actual["Item 2"]);
Assert.AreEqual("Variables", actual["Different"]);
// a slight tweak
metadata["Different"] = "Values";
Assert.IsTrue(provider.SetImageMetadata(image.Id, metadata));
actual = provider.ListImageMetadata(image.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual("Values", actual["Different"]);
Assert.IsTrue(provider.SetImageMetadata(image.Id, new Metadata()));
Assert.AreEqual(0, provider.ListImageMetadata(image.Id).Count);
/* Cleanup
*/
bool deleted = provider.DeleteImage(images[0].Id);
Assert.IsTrue(deleted);
provider.WaitForImageDeleted(images[0].Id);
}
