private static void QueueMessage(string messageType, VirtualMachine virtualMachine)
{
if (VirtualMachine.IsValid(virtualMachine) == false)
{
throw new ArgumentException("Invalid virtual machine.", "virtualMachine");
}
var connectionString = CloudConfigurationManager.GetSetting("ServiceBus.ConnectionString");
var queueName = CloudConfigurationManager.GetSetting("QueueName");
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(queueName))
{
var queue = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = new TimeSpan(7, 0, 0, 0)
};
namespaceManager.CreateQueue(queue);
}
var message = PrepareMessage(messageType, virtualMachine);
var client = QueueClient.CreateFromConnectionString(connectionString, queueName);
client.Send(message);
}
public static bool IsValid(VirtualMachine virtualMachine)
{
var result = true;
if (virtualMachine == null)
{
result = false;
}
else if (String.IsNullOrWhiteSpace(virtualMachine.Name))
{
result = false;
}
else if (virtualMachine.Size == AzureVirtualMachineSize.None)
{
result = false;
}
else if (String.IsNullOrWhiteSpace(virtualMachine.AdminUserName))
{
result = false;
}
else if (String.IsNullOrWhiteSpace(virtualMachine.AdminPassword))
{
result = false;
}
else if (String.IsNullOrWhiteSpace(virtualMachine.TimeZone))
{
result = false;
}
else if (String.IsNullOrWhiteSpace(virtualMachine.Location))
{
result = false;
}
return result;
}
public void QueueCreateMessage_InvalidVirtualMachine_ThrowsArgumentException()
{
var messenger = new Messenger();
var virtualMachine = new VirtualMachine();
Assert.That(() => messenger.QueueCreateMessage(virtualMachine), Throws.ArgumentException);
}
private static void DeleteDataDisk(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName, string diskName, int logicalUnitNumber)
{
DetachDiskFromVirtualMachine(executor, virtualMachine, serviceName, logicalUnitNumber);
WaitForDiskToBeFree(executor, diskName);
DeleteDisk(executor, diskName);
}
private static BrokeredMessage PrepareMessage(string messageType, VirtualMachine virtualMachine)
{
var message = new BrokeredMessage();
message.SetMessageType(messageType);
message.SetObject(virtualMachine);
return message;
}
private static bool AzureVirtualMachineExists(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName)
{
var getAzureVmCommand = new GetAzureVmCommand
{
ServiceName = serviceName,
Name = virtualMachine.Name
};
var results = executor.Execute(getAzureVmCommand);
var result = results.Any();
return result;
}
public void Delete(string name)
{
var virtualMachine = new VirtualMachine
{
AdminPassword = "******",
AdminUserName = "******",
Location = ".",
Name = name,
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "."
}; //TODO: This feels hacky
_repository.Delete(name);
_messenger.QueueDeleteMessage(virtualMachine);
}
public void SetAndGetVirtualMachine_AdminUserNameIsPersisted()
{
var message = new BrokeredMessage();
var expected = new VirtualMachine
{
Name = "Name",
AdminUserName = "******",
AdminPassword = "******",
Location = "Location",
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "TimeZone"
};
message.SetObject(expected);
var actual = message.GetObject<VirtualMachine>();
Assert.That(actual.AdminUserName, Is.EqualTo(expected.AdminUserName));
}
private static void AttachAzureDrive(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName, string dataDiskName)
{
var getAzureVm = new GetAzureVmCommand
{
Name = virtualMachine.Name,
ServiceName = serviceName
};
var addAzureDataDisk = new AddAzureDataDiskCommand
{
Import = true,
DiskName = dataDiskName,
LogicalUnitNumber = 0
};
var updateAzureVm = new UpdateAzureVmCommand();
var result = executor.Execute(getAzureVm, addAzureDataDisk, updateAzureVm);
}
public void QueueCreateMessage_ValidVirtualMachine_QueuesMessage()
{
var messenger = new Messenger();
var virtualMachine = new VirtualMachine
{
Name = "Test",
AdminPassword = "******",
AdminUserName = "******",
Location = "a;sdgh;",
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "kl;agh;"
};
messenger.QueueCreateMessage(virtualMachine);
//Verify message on test queue
var result = RetrieveQueuedMessage();
Assert.That(result, Is.Not.Null);
Assert.That(result.Properties["VirtualMachine.Name"], Is.EqualTo("Test"));
result.Complete();
}
private static void CreateNewVirtualMachine(IPowershellExecutor executor, VirtualMachine virtualMachine, string imageName, string serviceName, string sourceVhdName, string storageAccountUrl, string vhdContainerName, string dataDiskName)
{
ProvisionVirtualMachine(executor, virtualMachine, imageName, serviceName);
PrepareAzureDrive(executor, sourceVhdName, storageAccountUrl, vhdContainerName, dataDiskName);
AttachAzureDrive(executor, virtualMachine, serviceName, dataDiskName);
}
public void Create(VirtualMachine machine)
{
//VirtualMachines[machine.Name] = machine;
}
public void QueueDeleteMessage(VirtualMachine virtualMachine)
{
QueueMessage("Delete", virtualMachine);
}
public void Get_NoVirtualMachines_ReturnsEmptyList()
{
// Arrange
var machineList = new VirtualMachine[0];
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Read())
.Repeat.Once()
.Return(machineList.AsQueryable());
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
// Act
var result = controller.Get();
// Assert
Assert.That(result.Any(), Is.False);
}
private static void DeleteExistingArtifacts(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName)
{
if (AzureVirtualMachineExists(executor, virtualMachine, serviceName))
{
var osDisk = GetAttachedOsDisks(executor, virtualMachine, serviceName);
var dataDisks = GetAttachedDataDisks(executor, virtualMachine, serviceName);
foreach (var dataDisk in dataDisks)
{
DeleteDataDisk(executor, virtualMachine, serviceName, dataDisk.Key, dataDisk.Value);
}
DeleteExistingVirtualMachine(executor, virtualMachine, serviceName);
DeleteOsDisk(executor, osDisk);
}
}
private static string GetAttachedOsDisks(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName)
{
var getAzureVmCommand = new GetAzureVmCommand
{
ServiceName = serviceName,
Name = virtualMachine.Name
};
var getAzureOsDiskCommand = new GetAzureOsDiskCommand();
var osDisk = executor.Execute(getAzureVmCommand, getAzureOsDiskCommand)
.Select(x => x.Properties["DiskName"].Value)
.Cast<string>()
.FirstOrDefault();
return osDisk;
}
public void Get_RepositoryIsCalled()
{
// Arrange
var machineList = new VirtualMachine[0];
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Read())
.Repeat.Once()
.Return(machineList.AsQueryable());
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
// Act
controller.Get();
// Assert
repository.VerifyAllExpectations();
}
private static void DetachDiskFromVirtualMachine(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName, int logicalUnitNumber)
{
var getAzureVmCommand = new GetAzureVmCommand
{
ServiceName = serviceName,
Name = virtualMachine.Name
};
var removeAzureDataDiskCommand = new RemoveAzureDataDiskCommand
{
LogicalUnitNumber = logicalUnitNumber
};
var updateAzureVmCommand = new UpdateAzureVmCommand();
executor.Execute(getAzureVmCommand, removeAzureDataDiskCommand, updateAzureVmCommand);
}
private static IEnumerable<KeyValuePair<string, int>> GetAttachedDataDisks(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName)
{
var getAzureVmCommand = new GetAzureVmCommand
{
ServiceName = serviceName,
Name = virtualMachine.Name
};
var getAzureDataDiskCommand = new GetAzureDataDiskCommand();
var dataDisks = executor.Execute(getAzureVmCommand, getAzureDataDiskCommand)
.ToDictionary(x => (string) x.Properties["DiskName"].Value, y => (int) y.Properties["LUN"].Value);
//.Select(x => x.Properties["DiskName"].Value)
//.Cast<string>();
return dataDisks;
}
public void Post_InvalidVirtualMachine_RepositoryIsNotCalled()
{
// Arrange
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Create(Arg<VirtualMachine>.Is.TypeOf))
.Repeat.Never();
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
var machine = new VirtualMachine();
// Act
try
{
controller.Post(machine);
}
catch (HttpException) { }
// Assert
repository.VerifyAllExpectations();
}
private static void DeleteExistingVirtualMachine(IPowershellExecutor executor, VirtualMachine virtualMachine, string serviceName)
{
var removeAzureVmCommand = new RemoveAzureVmCommand
{
ServiceName = serviceName,
Name = virtualMachine.Name
};
executor.Execute(removeAzureVmCommand);
}
private static void ProvisionVirtualMachine(IPowershellExecutor executor, VirtualMachine virtualMachine, string imageName, string serviceName)
{
var newAzureVmConfigCommand = new NewAzureVmConfigCommand
{
Name = virtualMachine.Name,
ImageName = imageName,
InstanceSize = virtualMachine.Size
};
var addAzureProvisioningConfigCommand = new AddAzureProvisioningConfigCommand
{
Windows = true,
AdminPassword = virtualMachine.AdminPassword,
AdminUsername = virtualMachine.AdminUserName,
TimeZone = virtualMachine.TimeZone
};
var newAzureVmCommand = new NewAzureVmCommand
{
//Location = virtualMachine.Location,
ServiceName = serviceName,
DeploymentName = serviceName,
WaitForBoot = false
};
var results = executor.Execute(newAzureVmConfigCommand, addAzureProvisioningConfigCommand, newAzureVmCommand);
}
public void QueueCreateMessage(VirtualMachine virtualMachine)
{
QueueMessage("Create", virtualMachine);
}
public void Post_VirtualMachineAlreadyExists_ThrowsHttpException()
{
// Arrange
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Read())
.Repeat.Once()
.Return(new EnumerableQuery<VirtualMachine>(new[] {new VirtualMachine {Name = "Machine"}}));
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
// Act
var virtualMachine = new VirtualMachine
{
Name = "Machine",
AdminPassword = "******",
AdminUserName = "******",
Location = "a;sdgh;",
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "kl;agh;"
};
// Assert
Assert.That(() => controller.Post(virtualMachine), Throws.InstanceOf<HttpException>());
repository.VerifyAllExpectations();
}
public void Post_ValidVirtualMachine_ReturnsMachine()
{
// Arrange
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Read())
.Repeat.Once()
.Return(new EnumerableQuery<VirtualMachine>(Enumerable.Empty<VirtualMachine>()));
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
// Act
var virtualMachine = new VirtualMachine
{
Name = "Machine",
AdminPassword = "******",
AdminUserName = "******",
Location = "a;sdgh;",
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "kl;agh;"
};
var result = controller.Post(virtualMachine);
// Assert
Assert.That(result.Name, Is.EqualTo("Machine"));
}
public void Post_ValidVirtualMachine_RepositoryIsCalled()
{
// Arrange
var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
repository.Expect(x => x.Read())
.Repeat.Once()
.Return(new EnumerableQuery<VirtualMachine>(Enumerable.Empty<VirtualMachine>()));
repository.Expect(x => x.Create(Arg<VirtualMachine>.Is.TypeOf));
var messenger = MockRepository.GenerateStub<IMessenger>();
var controller = new VirtualMachinesController(repository, messenger);
var virtualMachine = new VirtualMachine
{
Name = "Machine",
AdminPassword = "******",
AdminUserName = "******",
Location = "a;sdgh;",
Size = AzureVirtualMachineSize.ExtraSmall,
TimeZone = "kl;agh;"
};
// Act
controller.Post(virtualMachine);
// Assert
repository.VerifyAllExpectations();
}
