public void TestBasicFunctionality()
{
INetworksProvider provider = Bootstrapper.CreateNetworksProvider();
string networkName = UnitTestNetworkPrefix + Path.GetRandomFileName();
string cidr = "192.0.2.0/24";
CloudNetwork network;
try
{
network = provider.CreateNetwork(cidr, networkName);
}
catch (BadServiceRequestException ex)
{
if (ex.Message == "Quota exceeded, too many networks.")
{
Assert.Inconclusive("The required test network could not be created due to a quota.");
}
throw;
}
Assert.IsNotNull(network);
CloudNetwork showNetwork = provider.ShowNetwork(network.Id);
Assert.IsNotNull(showNetwork);
Assert.AreEqual(network.Id, showNetwork.Id);
Assert.AreEqual(network.Label, showNetwork.Label);
Assert.AreEqual(network.Cidr, showNetwork.Cidr);
}
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;
}
internal static UserName CreateRandomUserName(string host)
{
if (host == null)
{
return(new UserName(Path.GetRandomFileName().Replace('.', '_')));
}
else
{
return(new UserName(Path.GetRandomFileName().Replace('.', '_'), host));
}
}
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));
}
private void ChangeToSyntax(IBackgroundTaskContext context)
{
var study = (StudyTableItem)context.UserState;
try
{
_tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ClearCanvas");
_tempPath = System.IO.Path.Combine(_tempPath, "Compression");
_tempPath = System.IO.Path.Combine(_tempPath, Path.GetRandomFileName());
string message = String.Format("Changing transfer syntax to: {0}", _syntax);
context.ReportProgress(new BackgroundTaskProgress(0, message));
var loader = study.Server.GetService <IStudyLoader>();
int numberOfSops = loader.Start(new StudyLoaderArgs(study.StudyInstanceUid, null));
if (numberOfSops <= 0)
{
return;
}
for (int i = 0; i < numberOfSops; ++i)
{
Sop sop = loader.LoadNextSop();
if (sop != null)
{
if (sop.DataSource is ILocalSopDataSource)
{
string filename = Path.Combine(_tempPath, string.Format("{0}.dcm", i));
DicomFile file = ((ILocalSopDataSource)sop.DataSource).File;
file.ChangeTransferSyntax(_syntax);
file.Save(filename);
}
}
int progressPercent = (int)Math.Floor((i + 1) / (float)numberOfSops * 100);
context.ReportProgress(new BackgroundTaskProgress(progressPercent, message));
}
//trigger an import of the anonymized files.
var client = new DicomFileImportBridge();
client.ImportFileList(new List <string> {
_tempPath
}, BadFileBehaviourEnum.Move, FileImportBehaviourEnum.Move);
context.Complete();
}
catch (Exception e)
{
context.Error(e);
}
}
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;
}
internal static void TestOutputPaneBehavior(IOutputWindowPane pane, string initialName)
{
Assert.IsNotNull(pane);
Assert.AreEqual(initialName, pane.Name);
pane.Activate();
pane.Hide();
pane.Activate();
string newName = pane.Name + " - " + Path.GetRandomFileName();
pane.Name = newName;
Assert.AreEqual(newName, pane.Name);
pane.Write("Writing text...");
pane.WriteLine(" done.");
}
private static string GetTemporaryDirectory(out bool removeDirectory)
{
string packagesPath = Path.GetFullPath(@"..\..\..");
if (Directory.Exists(Path.Combine(packagesPath, "packages")))
{
removeDirectory = false;
return(Path.Combine(packagesPath, "packages"));
}
string path = Path.Combine(Path.GetTempPath(), "CompatibilityChecker-" + Path.GetRandomFileName());
Directory.CreateDirectory(path);
removeDirectory = true;
return(path);
}
public void TestBasicVolumeFeatures()
{
IBlockStorageProvider provider = Bootstrapper.CreateBlockStorageProvider();
string displayName = UnitTestVolumePrefix + Path.GetRandomFileName();
Volume result = provider.CreateVolume(MinimumVolumeSize, displayName: displayName);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Id);
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
Volume updated = provider.WaitForVolumeAvailable(result.Id);
Assert.IsNotNull(updated);
Assert.AreEqual(result.Id, updated.Id);
Assert.AreEqual(VolumeState.Available, updated.Status);
bool deleted = provider.DeleteVolume(result.Id);
Assert.IsTrue(deleted);
deleted = provider.WaitForVolumeDeleted(result.Id);
Assert.IsTrue(deleted);
try
{
provider.ShowVolume(result.Id);
Assert.Fail("Expected an exception after a volume is deleted.");
}
catch (ItemNotFoundException)
{
// this makes the most sense
}
catch (UserNotAuthorizedException)
{
// this is allowed by the interface, and some providers could report it for security reasons
}
catch (ResponseException)
{
// this is allowed by the interface
}
}
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 static async void InitializeCache()
{
IList <IFolder> previouseCache = null;
using (var writerLock = await _locker.WriterLockAsync())
{
_deviceService = DependencyService.Get <IDeviceService>();
var deviceCache = await _deviceService.GetCacheFolder();
var cacheRootFolder =
await deviceCache.CreateFolderAsync(CacheFolderName, CreationCollisionOption.OpenIfExists);
previouseCache = await cacheRootFolder.GetFoldersAsync();
_cacheFolder = await cacheRootFolder.CreateFolderAsync(Path.GetRandomFileName(),
CreationCollisionOption.ReplaceExisting);
}
//Clear previous cache every time application launches
//foreach (var folder in previouseCache)
//{
// await folder.DeleteAsync();
//}
}
internal static string CreateRandomDatabaseInstanceName()
{
return(TestDatabaseInstancePrefix + Path.GetRandomFileName());
}
internal static string CreateRandomBackupName()
{
return(TestDatabaseBackupPrefix + Path.GetRandomFileName());
}
internal static string CreateRandomPassword()
{
return(Path.GetRandomFileName().Replace('.', '_'));
}
/// <summary>
/// Gets a unique, randomly generated username which can be added by a unit test.
/// </summary>
/// <remarks>
/// The generated username will include the <see cref="TestUserPrefix"/> prefix to
/// allow for automatic identification of orphaned users which were created by the
/// integration tests. The <see cref="CleanupUsers"/> test can be executed to
/// delete orphaned users.
/// </remarks>
/// <returns>The username.</returns>
private static string GenerateUsername()
{
return(TestUserPrefix + Path.GetRandomFileName());
}
public static string CreateTemporaryPath()
{
return(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
}
/// <summary>
/// Creates a random queue name with the proper prefix for integration testing.
/// </summary>
/// <returns>A unique, randomly-generated queue name.</returns>
private QueueName CreateRandomQueueName()
{
return(new QueueName(TestQueuePrefix + Path.GetRandomFileName().Replace('.', '_')));
}
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);
}
public void TestBasicSnapshotFeatures()
{
IBlockStorageProvider provider = Bootstrapper.CreateBlockStorageProvider();
//
// Volume setup...
//
string volumeDisplayName = UnitTestVolumePrefix + Path.GetRandomFileName();
VolumeType ssdType = GetSsdVolumeTypeOrDefault(provider);
if (ssdType != null)
{
Console.WriteLine("Using an SSD volume to improve snapshot test performance.");
}
else
{
Console.WriteLine("No SSD volume type is available for the snapshot test... falling back to the default.");
}
Volume result = provider.CreateVolume(MinimumVolumeSize, displayName: volumeDisplayName, volumeType: ssdType != null ? ssdType.Id : null);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Id);
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
Volume updated = provider.WaitForVolumeAvailable(result.Id);
Assert.IsNotNull(updated);
Assert.AreEqual(result.Id, updated.Id);
Assert.AreEqual(VolumeState.Available, updated.Status);
//
// Snapshot testing
//
string snapshotDisplayName = UnitTestSnapshotPrefix + Path.GetRandomFileName();
Snapshot snapshot = provider.CreateSnapshot(result.Id, displayName: snapshotDisplayName);
Assert.IsNotNull(snapshot);
Assert.IsNotNull(snapshot.Id);
Console.WriteLine(JsonConvert.SerializeObject(snapshot, Formatting.Indented));
Snapshot updatedSnapshot = provider.WaitForSnapshotAvailable(snapshot.Id);
Assert.IsNotNull(updatedSnapshot);
Assert.AreEqual(snapshot.Id, updatedSnapshot.Id);
Assert.AreEqual(SnapshotState.Available, updatedSnapshot.Status);
bool deleted = provider.DeleteSnapshot(snapshot.Id);
Assert.IsTrue(deleted);
deleted = provider.WaitForSnapshotDeleted(snapshot.Id);
Assert.IsTrue(deleted);
try
{
provider.ShowSnapshot(snapshot.Id);
Assert.Fail("Expected an exception after a snapshot is deleted.");
}
catch (ItemNotFoundException)
{
// this makes the most sense
}
catch (UserNotAuthorizedException)
{
// this is allowed by the interface, and some providers could report it for security reasons
}
catch (ResponseException)
{
// this is allowed by the interface
}
//
// Volume cleanup...
//
bool deletedVolume = provider.DeleteVolume(result.Id);
Assert.IsTrue(deletedVolume);
deletedVolume = provider.WaitForVolumeDeleted(result.Id);
Assert.IsTrue(deletedVolume);
}
internal static DatabaseName CreateRandomDatabaseName()
{
return(new DatabaseName(Path.GetRandomFileName().Replace('.', '_')));
}
internal static string CreateRandomDomainName()
{
return(TestDomainPrefix + Path.GetRandomFileName().Replace('.', '-') + ".com");
}
public void TestUnknownPane()
{
Assert.IsNull(OutputWindowService.TryGetPane(Path.GetRandomFileName()));
}
public static string GetRandomFileName() => MSIOP.GetRandomFileName();