public void SaveAzureVhdThreadNumberTest()
{
testName = MethodBase.GetCurrentMethod().Name;
StartTest(testName, testStartTime);
// Choose the vhd path in your local machine
string vhdName = Convert.ToString(TestContext.DataRow["vhdLocalPath"]) + Utilities.GetUniqueShortName();
FileInfo vhdLocalPath = new FileInfo(vhdName);
DateTime start = DateTime.Now;
// Download with 2 threads and verify it.
SaveVhdAndAssertContent(blobHandle, vhdLocalPath, 2, false, true);
TimeSpan duration = DateTime.Now - start;
// Choose the vhd path in your local machine
string vhdName2 = Convert.ToString(TestContext.DataRow["vhdLocalPath"]) + Utilities.GetUniqueShortName();
FileInfo vhdLocalPath2 = new FileInfo(vhdName2);
// Download with 16 threads and verify it.
start = DateTime.Now;
SaveVhdAndAssertContent(blobHandle, vhdLocalPath2, 16, false, true);
//Assert.IsTrue(DateTime.Now - start < duration, "16 threads took longer!");
if (DateTime.Now - start > duration)
{
Console.WriteLine("16 threads took longer than 2 threads!");
}
DateTime testEndTime = DateTime.Now;
Console.WriteLine("{0} test passed at {1}.", testName, testEndTime);
Console.WriteLine("Duration of the test pass: {0} seconds", (testEndTime - testStartTime).TotalSeconds);
System.IO.File.AppendAllLines(perfFile, new string[] { String.Format("{0},{1}", testName, (testEndTime - testStartTime).TotalSeconds) });
}
public void AzureEndpointTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string ep1Name = "tcp1";
int ep1LocalPort = 60010;
int ep1PublicPort = 60011;
string ep1LBSetName = "lbset1";
int ep1ProbePort = 60012;
string ep1ProbePath = string.Empty;
int? ep1ProbeInterval = 7;
int? ep1ProbeTimeout = null;
NetworkAclObject ep1AclObj = null;
bool ep1DirectServerReturn = false;
string ep2Name = "tcp2";
int ep2LocalPort = 60020;
int ep2PublicPort = 60021;
int ep2LocalPortChanged = 60030;
int ep2PublicPortChanged = 60031;
string ep2LBSetName = "lbset2";
int ep2ProbePort = 60022;
string ep2ProbePath = @"/";
int? ep2ProbeInterval = null;
int? ep2ProbeTimeout = 32;
NetworkAclObject ep2AclObj = null;
bool ep2DirectServerReturn = false;
AzureEndPointConfigInfo ep1Info = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep1LocalPort,
ep1PublicPort,
ep1Name,
ep1LBSetName,
ep1ProbePort,
ProtocolInfo.tcp,
ep1ProbePath,
ep1ProbeInterval,
ep1ProbeTimeout,
ep1AclObj,
ep1DirectServerReturn);
AzureEndPointConfigInfo ep2Info = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPort,
ep2PublicPort,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
string defaultVm = Utilities.GetUniqueShortName(vmNamePrefix);
Assert.IsNull(vmPowershellCmdlets.GetAzureVM(defaultVm, serviceName));
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, defaultVm, serviceName, imageName, username, password, locationName);
Console.WriteLine("Service Name: {0} is created.", serviceName);
try
{
foreach (AzureEndPointConfigInfo.ParameterSet p in Enum.GetValues(typeof(AzureEndPointConfigInfo.ParameterSet)))
{
string pSetName = Enum.GetName(typeof(AzureEndPointConfigInfo.ParameterSet), p);
Console.WriteLine("--Begin Endpoint Test with '{0}' parameter set.", pSetName);
ep1Info.ParamSet = p;
ep2Info.ParamSet = p;
ep1Info.Acl = vmPowershellCmdlets.NewAzureAclConfig();
ep2Info.Acl = vmPowershellCmdlets.NewAzureAclConfig();
ep2Info.EndpointLocalPort = ep2LocalPort;
ep2Info.EndpointPublicPort = ep2PublicPort;
// Add two new endpoints
Console.WriteLine("-----Add 2 new endpoints.");
vmPowershellCmdlets.AddEndPoint(defaultVm, serviceName, new[] { ep1Info, ep2Info }); // Add-AzureEndpoint with Get-AzureVM and Update-AzureVm
CheckEndpoint(defaultVm, serviceName, new[] { ep1Info, ep2Info });
// Change the endpoint
if (p == AzureEndPointConfigInfo.ParameterSet.NoLB)
{
Console.WriteLine("-----Change the second endpoint.");
ep2Info.EndpointLocalPort = ep2LocalPortChanged;
ep2Info.EndpointPublicPort = ep2PublicPortChanged;
vmPowershellCmdlets.SetEndPoint(defaultVm, serviceName, ep2Info); // Set-AzureEndpoint with Get-AzureVM and Update-AzureVm
CheckEndpoint(defaultVm, serviceName, new[] { ep2Info });
}
else
{
Console.WriteLine("-----Change the second endpoint.");
ep2Info.ServiceName = serviceName;
ep2Info.EndpointLocalPort = ep2LocalPortChanged;
ep2Info.EndpointPublicPort = ep2PublicPortChanged;
vmPowershellCmdlets.SetLBEndPoint(defaultVm, serviceName, ep2Info, p);
CheckEndpoint(defaultVm, serviceName, new[] { ep2Info });
}
// Remove Endpoint
Console.WriteLine("-----Remove endpoints.");
vmPowershellCmdlets.RemoveEndPoint(defaultVm, serviceName, new[] { ep1Name, ep2Name }); // Remove-AzureEndpoint
CheckEndpointRemoved(defaultVm, serviceName, new[] { ep1Info, ep2Info });
Console.WriteLine("Endpoint Test passed with '{0}' parameter set.", pSetName);
}
pass = true;
}
catch (Exception e)
{
pass = false;
Assert.Fail("Exception occurred: {0}", e.ToString());
}
}
public void SaveAzureVhdResumeTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Choose the vhd path in your local machine
string vhdName = Convert.ToString(TestContext.DataRow["vhdLocalPath"]) + Utilities.GetUniqueShortName();
FileInfo vhdLocalPath = new FileInfo(vhdName);
Assert.IsFalse(File.Exists(vhdLocalPath.FullName), "VHD file already exist={0}", vhdLocalPath);
// Start uploading and stop after 5 seconds...
Console.WriteLine("downloading {0} to {1}", vhdBlobLocation, vhdLocalPath);
string result = vmPowershellCmdlets.SaveAzureVhdStop(blobHandle.Blob.Uri, vhdLocalPath, null, null, false, 5000);
if (result.ToLowerInvariant() == "stopped")
{
Console.WriteLine("successfully stopped");
SaveVhdAndAssertContent(blobHandle, vhdLocalPath, false, true);
}
else
{
Console.WriteLine("didn't stop!");
}
DateTime testEndTime = DateTime.Now;
Console.WriteLine("{0} test passed at {1}.", testName, testEndTime);
Console.WriteLine("Duration of the test pass: {0} seconds", (testEndTime - testStartTime).TotalSeconds);
System.IO.File.AppendAllLines(perfFile, new string[] { String.Format("{0},{1}", testName, (testEndTime - testStartTime).TotalSeconds) });
}
public void AzureVMImageListRemoveTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newImageName = Utilities.GetUniqueShortName("vmimage");
string oldLabel = "old label";
string newLabel = Utilities.GetUniqueShortName("vmimage");
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
string serviceName1 = Utilities.GetUniqueShortName("Pstestsvc");
try
{
string mediaLocation = UploadVhdFile();
Console.WriteLine("------------------------------Add an OS image---------------------------------");
// a. Add an OS image
var result = vmPowershellCmdlets.AddAzureVMImage(newImageName, mediaLocation, OS.Windows, newImageName);
Console.WriteLine("------------------------------Add an OS image: Completed---------------------------------");
//b. Deploy a new IaaS VM
Console.WriteLine("------------------------------Deploy a new IaaS VM---------------------------------");
var vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, newImageName, true, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
Console.WriteLine("------------------------------Deploy a new IaaS VM: Completed---------------------------------");
//c. Stop the VM
Console.WriteLine("------------------------------Stop the VM---------------------------------");
vmPowershellCmdlets.StopAzureVM(vm, serviceName, true);
Console.WriteLine("------------------------------Stop the VM: Completed---------------------------------");
//d. Try to save the OS image with an existing os image name. (should fail)
Console.WriteLine("------------------------------Try to save the OS image with an existing os image name---------------------------------");
Utilities.VerifyFailure(() => vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, oldLabel, CONSTANT_SPECIALIZED, oldLabel), BadRequestException);
Console.WriteLine("------------------------------Try to save the OS image with an existing os image name: Completed---------------------------------");
//e. Save the OS image with a new image name.
Console.WriteLine("------------------------------Save the OS image with a new image name.---------------------------------");
vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, newLabel);
Console.WriteLine("------------------------------Save the OS image with a new image name: Completed---------------------------------");
//f. Deploy a new IaaS VM
Console.WriteLine("------------------------------Deploy a new IaaS VM---------------------------------");
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
vm = CreateIaaSVMObjectWithDisk(vmName1, InstanceSize.Small, newLabel, true, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName1, new[] { vm }, locationName);
var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName1);
Console.WriteLine("------------------------------Deploy a new IaaS VM: Completed---------------------------------");
//g. Stop the VM
Console.WriteLine("------------------------------Stop the VM---------------------------------");
vmPowershellCmdlets.StopAzureVM(vm, serviceName1, true);
Console.WriteLine("------------------------------Stop the VM: Completed---------------------------------");
//h. Save the VM image with the existing os image name (should fail)
Console.WriteLine("------------------------------Save the VM image with the existing os image name---------------------------------");
vmImageName = vmName1 + "Image";
Utilities.VerifyFailure(() => vmPowershellCmdlets.SaveAzureVMImage(serviceName1, vmName1, newLabel, CONSTANT_SPECIALIZED, vmImageName), "OSImage");
Console.WriteLine("------------------------------Save the VM image with the existing os image name: Completed---------------------------------");
//i. List VM Images
//i. Get-AzureVMImage
//VerifyVMImage(vmImageName, OS.Windows, vmImageName, CONSTANT_SPECIALIZED, cahcing, lunSlot1, diskSize1, 1);
Console.WriteLine("------------------------------Get-AzureVMImage---------------------------------");
VerifyOsImage(newLabel, new OSImageContext()
{
ImageName = newLabel,
Category = CONSTANT_CATEGORY,
Location = locationName,
Label = newLabel,
OS = OS.Windows.ToString()
});
Console.WriteLine("------------------------------Get-AzureVMImage: Completed---------------------------------");
//j. Try to remove a wrong vm
Console.WriteLine("------------------------------Try to remove a wrong vm---------------------------------");
Utilities.VerifyFailure(() => vmPowershellCmdlets.RemoveAzureVMImage(Utilities.GetUniqueShortName()), ResourceNotFoundException);
Console.WriteLine("------------------------------Try to remove a wrong vm: Completed---------------------------------");
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
finally
{
//k. Remove the VM Images
DeleteVMImageIfExists(newLabel);
vmPowershellCmdlets.RemoveAzureService(serviceName1);
}
}
public void CaptureSpecializedVMAndDeploy()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string serviceName1 = Utilities.GetUniqueShortName(serviceNamePrefix);
try
{
// a. Deploy a new IaaS VM
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0}--------------------------------", vmName);
var vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, imageName, true, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
//b. Stop the VM
Console.WriteLine("--------------------------------Stopping vm :{0}--------------------------------", vmName);
vmPowershellCmdlets.StopAzureVM(vmName, serviceName, force: true);
Console.WriteLine("--------------------------------Stopped vm :{0}--------------------------------", vmName);
//c. Save the VM image
Console.WriteLine("--------------------------------Save the VM image--------------------------------");
vmImageName = vmName + "Image";
vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, vmImageName, CONSTANT_SPECIALIZED, vmImageName);
Console.WriteLine("--------------------------------Saved VM image with name {0}----------------------");
//d. Verify the VM image by Get-AzureVMImage
Console.WriteLine("--------------------------------Verify the VM image--------------------------------");
VerifyVMImage(vmImageName, OS.Windows, vmImageName, CONSTANT_SPECIALIZED, cahcing, lunSlot1, diskSize1, 1);
Console.WriteLine("--------------------------------Verified that the VM image is saved successfully--------------------------------");
//e. Deploy a new IaaS VM with the save VM image
Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
vm = Utilities.CreateIaaSVMObject(vmName1, InstanceSize.Small, vmImageName);
vmPowershellCmdlets.NewAzureVM(serviceName1, new[] { vm }, locationName);
Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName1, vmImageName);
//f. Verify the VM by Get-AzureVM
Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName1, vmImageName);
var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName1);
Utilities.PrintContext(vmRoleContext);
VerifyVM(vmRoleContext.VM, OS.Windows, HostCaching.ReadWrite, diskSize1, 1);
Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName1);
//g. Add another IaaS VM with the save VM image to the existing service
string vmName2 = Utilities.GetUniqueShortName(vmNamePrefix);
Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName2, serviceName1, vmImageName);
Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName2, vmImageName);
//h. Verify the VM by Get-AzureVM
Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName2, vmImageName);
vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName2, serviceName1);
VerifyVM(vmRoleContext.VM, OS.Windows, HostCaching.ReadWrite, diskSize1, 1);
Utilities.PrintContext(vmRoleContext);
Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName2);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
finally
{
CleanupService(serviceName1);
// Delete the VM image
Console.WriteLine("------------------------------Delete the VM image---------------------------------");
DeleteVMImageIfExists(vmImageName);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
}
}
public void Initialize()
{
serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
pass = false;
testStartTime = DateTime.Now;
}
public void AzureVMImageSizeTest()
{
string mediaLocation = UploadVhdFile();
string newImageName = Utilities.GetUniqueShortName("vmimage");
try
{
var instanceSizes = vmPowershellCmdlets.GetAzureRoleSize().Where(r => r.Cores <= 2 && !r.InstanceSize.StartsWith("Standard_"));
const int numOfMinimumInstSize = 3;
Assert.IsTrue(instanceSizes.Count() >= numOfMinimumInstSize);
var instanceSizesArr = instanceSizes.Take(numOfMinimumInstSize).ToArray();
int arrayLength = instanceSizesArr.Count();
for (int i = 0; i < arrayLength; i++)
{
Utilities.PrintContext(instanceSizesArr[i]);
// Add-AzureVMImage test for VM size
OSImageContext result = vmPowershellCmdlets.AddAzureVMImage(newImageName, mediaLocation, OS.Windows, null, instanceSizesArr[i].InstanceSize);
OSImageContext resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));
// Update-AzureVMImage test for VM size
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
result = vmPowershellCmdlets.UpdateAzureVMImage(newImageName, resultReturned.ImageName, instanceSizesArr[Math.Max((i + 1) % arrayLength, 1)].InstanceSize);
resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));
vmPowershellCmdlets.RemoveAzureVMImage(newImageName);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
pass = true;
}
}
catch (Exception e)
{
pass = false;
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
vmPowershellCmdlets.RemoveAzureVMImage(newImageName, true);
Console.WriteLine("Exception occurred: {0}", e.ToString());
throw;
}
finally
{
try
{
vmPowershellCmdlets.GetAzureVMImage(newImageName);
vmPowershellCmdlets.RemoveAzureVMImage(newImageName);
}
catch (Exception e)
{
if (e.ToString().Contains("ResourceNotFound"))
{
Console.WriteLine("The vm image, {0}, is already deleted.", newImageName);
}
else
{
throw;
}
}
}
}
public void AzureReservedIPTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
try
{
// IP1 and IP2 on AG1
vmPowershellCmdlets.NewAzureAffinityGroup(affName1, locationName, null, null);
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName1, affName1, rsvIPLabel);
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName2, affName1, rsvIPLabel);
var reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0];
Verify.AzureReservedIPNotInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1);
// Create an affinity group in another location
var anotherLocation = GetLocation("PersistentVMRole", locationName);
vmPowershellCmdlets.NewAzureAffinityGroup(affName2, anotherLocation.Name, null, null);
string rsvIpName3 = rsvIpNamePrefix + Utilities.GetUniqueShortName();
string rsvIpName4 = rsvIpNamePrefix + Utilities.GetUniqueShortName();
var rsvIPNames = new[] { rsvIpName1, rsvIpName2, rsvIpName3, rsvIpName4 };
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName3, affName2, rsvIPLabel); // IP3 on AG2
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName4, affName2, rsvIPLabel); // IP4 on AG2
var rsvIPs = vmPowershellCmdlets.GetAzureReservedIP();
foreach (var ip in rsvIPs)
{
if (rsvIPNames.Contains(ip.ReservedIPName))
{
reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(ip.ReservedIPName)[0];
Verify.AzureReservedIPNotInUse(reservedIPReturned, ip.ReservedIPName, ip.Label, ip.Location,
ip.Id);
}
}
// Remove IP1
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1);
Utilities.CheckRemove(vmPowershellCmdlets.GetAzureReservedIP, rsvIpName1);
rsvIPs = vmPowershellCmdlets.GetAzureReservedIP();
foreach (var ip in rsvIPs)
{
if (rsvIPNames.Contains(ip.ReservedIPName))
{
reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(ip.ReservedIPName)[0];
Verify.AzureReservedIPNotInUse(reservedIPReturned, ip.ReservedIPName, ip.Label, ip.Location,
ip.Id);
}
}
// Remove IP3
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName3);
Utilities.CheckRemove(vmPowershellCmdlets.GetAzureReservedIP, rsvIpName3);
rsvIPs = vmPowershellCmdlets.GetAzureReservedIP();
foreach (var ip in rsvIPs)
{
if (rsvIPNames.Contains(ip.ReservedIPName))
{
reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(ip.ReservedIPName)[0];
Verify.AzureReservedIPNotInUse(reservedIPReturned, ip.ReservedIPName, ip.Label, ip.Location,
ip.Id);
}
}
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName4);
Utilities.CheckRemove(vmPowershellCmdlets.GetAzureReservedIP, rsvIpName4);
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName2);
Utilities.CheckRemove(vmPowershellCmdlets.GetAzureReservedIP, rsvIpName2);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
private string StoreConfigFileWithReservedIp(string configFileName, string reservedIpName)
{
var originalConfigPath = new FileInfo(Directory.GetCurrentDirectory() + "\\" + configFileName);
var tempConfigPath = new FileInfo(Directory.GetCurrentDirectory() + "\\" + Utilities.GetUniqueShortName(configFileName));
string _config1_format = File.ReadAllText(originalConfigPath.FullName);
File.WriteAllText(tempConfigPath.FullName, string.Format(_config1_format, reservedIpName));
return(tempConfigPath.FullName);
}
public void CreateDeploymentWithReservedIPNegativeTest()
{
try
{
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.Small.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
var azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.CustomProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", 80, ProtocolInfo.http, @"/", null, null);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
var persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig, azureDataDiskConfigInfo, null);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
// AG1 on location 1
vmPowershellCmdlets.NewAzureAffinityGroup(affName1, locationName, null, null);
// AG2 on location 2
var anotherLocation = GetLocation("PersistentVMRole", locationName);
vmPowershellCmdlets.NewAzureAffinityGroup(affName2, anotherLocation.Name, null, null);
// Reserve an ip on AG1
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName1, affName2);
var rsvIPreturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0];
Verify.AzureReservedIPNotInUse(rsvIPreturned, rsvIpName1, null, affName2);
// Try to create a new deployment with AG2 and the reserved IP
Utilities.VerifyFailure(
() => vmPowershellCmdlets.NewAzureVMWithReservedIP(svcNameAG, VMs, rsvIpName1, affName1),
BadRequestException);
// Create a new deployment with location 2, and then reserved the IP of it
vmPowershellCmdlets.NewAzureVM(svcNameLoc, VMs, locationName);
Utilities.VerifyFailure(
() => vmPowershellCmdlets.NewAzureReservedIP(rsvIpName2, affName2, svcNameLoc, svcNameLoc),
BadRequestException);
// Remove the reserved IP and verify
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1);
Utilities.VerifyFailure(
() => vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1), ResourceNotFoundException);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void RemoveAzureReservedIPWithDeploymentTest()
{
try
{
vmPowershellCmdlets.NewAzureAffinityGroup(affName1, locationName, null, null);
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
var azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
var azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.CustomProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", 80, ProtocolInfo.http, @"/", null, null);
var persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
//PersistentVM[] VMs = { persistentVM1, persistentVM2 };
PersistentVM[] VMs = { persistentVM1 };
// Create a new deployment
vmPowershellCmdlets.NewAzureVMWithAG(svcNameAG, VMs, affName1);
// Reserve the ip of the deployment
vmPowershellCmdlets.NewAzureReservedIP(rsvIpName1, affName1, svcNameAG, svcNameAG, rsvIPLabel);
// Get the deployment and verify
var deploymentReturned = vmPowershellCmdlets.GetAzureDeployment(svcNameAG);
// Verify the reserved ip
var reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0];
Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1,
deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName,
deploymentReturned.ServiceName);
// Stop-deallocate the first VM and verify reserved ip
Utilities.VerifyFailure(() => vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1), BadRequestException);
vmPowershellCmdlets.StopAzureVM(newAzureVM1Name, svcNameAG, false, true);
// Verify the reserved ip
reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0];
Verify.AzureReservedIPInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1,
deploymentReturned.VirtualIPs[0].Address, deploymentReturned.DeploymentName,
deploymentReturned.ServiceName);
// Stop-deallocate the second VM and verify reserved ip
Utilities.VerifyFailure(() => vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1), BadRequestException);
// Remove all VMs and service and verify reserved ip
vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, svcNameAG, true);
// Verify the reserved ip
reservedIPReturned = vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1)[0];
Verify.AzureReservedIPNotInUse(reservedIPReturned, rsvIpName1, rsvIPLabel, affName1);
// Remove the reserved IP and verify
vmPowershellCmdlets.RemoveAzureReservedIP(rsvIpName1);
Utilities.VerifyFailure(
() => vmPowershellCmdlets.GetAzureReservedIP(rsvIpName1), ResourceNotFoundException);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void AzureVMImageTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
vhdName = "os1.vhd";
string newImageName = Utilities.GetUniqueShortName("vmimage");
string mediaLocation = string.Format("{0}{1}/{2}", blobUrlRoot, vhdContainerName, vhdName);
string oldLabel = "old label";
string newLabel = "new label";
string vmSize = "Small";
var iconUri = "http://www.bing.com";
var smallIconUri = "http://www.bing.com";
bool showInGui = true;
try
{
// BVT Tests for OS Images
OSImageContext result = vmPowershellCmdlets.AddAzureVMImage(newImageName, mediaLocation, OS.Windows, oldLabel, vmSize, iconUri, smallIconUri, showInGui);
OSImageContext resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));
result = vmPowershellCmdlets.UpdateAzureVMImage(newImageName, newLabel);
resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
Assert.IsTrue(!string.IsNullOrEmpty(resultReturned.IOType));
Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));
result = vmPowershellCmdlets.UpdateAzureVMImage(newImageName, newLabel, true);
resultReturned = vmPowershellCmdlets.GetAzureVMImage(newImageName)[0];
Assert.IsTrue(resultReturned.ShowInGui.HasValue && !resultReturned.ShowInGui.Value);
Assert.IsTrue(CompareContext <OSImageContext>(result, resultReturned));
vmPowershellCmdlets.RemoveAzureVMImage(newImageName, false);
Assert.IsTrue(Utilities.CheckRemove(vmPowershellCmdlets.GetAzureVMImage, newImageName));
// BVT Tests for VM Images
// Unique Container Prefix
var containerPrefix = Utilities.GetUniqueShortName("vmimg");
// Disk Blobs
var srcVhdName = "os1.vhd";
var srcVhdContainer = vhdContainerName;
var dstOSVhdContainer = containerPrefix.ToLower() + "os" + vhdContainerName;
CredentialHelper.CopyTestData(srcVhdContainer, srcVhdName, dstOSVhdContainer);
string osVhdLink = string.Format("{0}{1}/{2}", blobUrlRoot, dstOSVhdContainer, srcVhdName);
var dstDataVhdContainer = containerPrefix.ToLower() + "data" + vhdContainerName;
CredentialHelper.CopyTestData(srcVhdContainer, srcVhdName, dstDataVhdContainer);
string dataVhdLink = string.Format("{0}{1}/{2}", blobUrlRoot, dstDataVhdContainer, srcVhdName);
// VM Image OS/Data Disk Configuration
var addVMImageName = containerPrefix + "Image";
var diskConfig = new VirtualMachineImageDiskConfigSet
{
OSDiskConfiguration = new OSDiskConfiguration
{
HostCaching = HostCaching.ReadWrite.ToString(),
OS = OSType.Windows.ToString(),
OSState = "Generalized",
MediaLink = new Uri(osVhdLink)
},
DataDiskConfigurations = new DataDiskConfigurationList
{
new DataDiskConfiguration
{
HostCaching = HostCaching.ReadOnly.ToString(),
Lun = 0,
MediaLink = new Uri(dataVhdLink)
}
}
};
// Add-AzureVMImage
string label = addVMImageName;
string description = "test";
string eula = "http://www.bing.com/";
string imageFamily = "Windows";
DateTime?publishedDate = new DateTime(2015, 1, 1);
string privacyUri = "http://www.bing.com/";
string recommendedVMSize = vmSize;
string iconName = "iconName";
string smallIconName = "smallIconName";
vmPowershellCmdlets.AddAzureVMImage(
addVMImageName,
label,
diskConfig,
description,
eula,
imageFamily,
publishedDate,
privacyUri,
recommendedVMSize,
iconName,
smallIconName,
showInGui);
// Get-AzureVMImage
var vmImage = vmPowershellCmdlets.GetAzureVMImageReturningVMImages(addVMImageName).First();
Assert.IsTrue(vmImage.ImageName == addVMImageName);
Assert.IsTrue(vmImage.Label == label);
Assert.IsTrue(vmImage.Description == description);
Assert.IsTrue(vmImage.Eula == eula);
Assert.IsTrue(vmImage.ImageFamily == imageFamily);
Assert.IsTrue(vmImage.PublishedDate.Value.Year == publishedDate.Value.Year);
Assert.IsTrue(vmImage.PublishedDate.Value.Month == publishedDate.Value.Month);
Assert.IsTrue(vmImage.PublishedDate.Value.Day == publishedDate.Value.Day);
Assert.IsTrue(vmImage.PrivacyUri.AbsoluteUri.ToString() == privacyUri);
Assert.IsTrue(vmImage.RecommendedVMSize == recommendedVMSize);
Assert.IsTrue(vmImage.IconName == iconName);
Assert.IsTrue(vmImage.IconUri == iconName);
Assert.IsTrue(vmImage.SmallIconName == smallIconName);
Assert.IsTrue(vmImage.SmallIconUri == smallIconName);
Assert.IsTrue(vmImage.ShowInGui == showInGui);
Assert.IsTrue(vmImage.OSDiskConfiguration.HostCaching == diskConfig.OSDiskConfiguration.HostCaching);
Assert.IsTrue(vmImage.OSDiskConfiguration.OS == diskConfig.OSDiskConfiguration.OS);
Assert.IsTrue(vmImage.OSDiskConfiguration.OSState == diskConfig.OSDiskConfiguration.OSState);
Assert.IsTrue(vmImage.OSDiskConfiguration.MediaLink == diskConfig.OSDiskConfiguration.MediaLink);
Assert.IsTrue(vmImage.DataDiskConfigurations.First().HostCaching == diskConfig.DataDiskConfigurations.First().HostCaching);
Assert.IsTrue(vmImage.DataDiskConfigurations.First().Lun == diskConfig.DataDiskConfigurations.First().Lun);
Assert.IsTrue(vmImage.DataDiskConfigurations.First().MediaLink == diskConfig.DataDiskConfigurations.First().MediaLink);
// Remove-AzureVMImage
vmPowershellCmdlets.RemoveAzureVMImage(addVMImageName);
pass = true;
}
catch (Exception e)
{
pass = false;
Assert.Fail("Exception occurred: {0}", e.ToString());
}
finally
{
if (!Utilities.CheckRemove(vmPowershellCmdlets.GetAzureVMImage, newImageName))
{
vmPowershellCmdlets.RemoveAzureVMImage(newImageName, false);
}
}
}
public void AzureDiskTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
vhdName = Utilities.GetUniqueShortName("os0vhd");
CopyCommonVhd(vhdContainerName, "os0.vhd", vhdName);
string mediaLocation = String.Format("{0}{1}/{2}", blobUrlRoot, vhdContainerName, vhdName);
try
{
vmPowershellCmdlets.AddAzureDisk(vhdName, mediaLocation, vhdName, null);
bool found = false;
foreach (DiskContext disk in vmPowershellCmdlets.GetAzureDisk(vhdName))
{
Console.WriteLine("Disk: Name - {0}, Label - {1}, Size - {2},", disk.DiskName, disk.Label, disk.DiskSizeInGB);
if (disk.DiskName == vhdName && disk.Label == vhdName)
{
found = true;
Console.WriteLine("{0} is found", disk.DiskName);
}
}
Assert.IsTrue(found, "Error: Disk is not added");
// Update only label
string newLabel = "NewLabel";
vmPowershellCmdlets.UpdateAzureDisk(vhdName, newLabel);
DiskContext virtualDisk = vmPowershellCmdlets.GetAzureDisk(vhdName)[0];
Console.WriteLine("Disk: Name - {0}, Label - {1}, Size - {2},", virtualDisk.DiskName, virtualDisk.Label, virtualDisk.DiskSizeInGB);
Assert.AreEqual(newLabel, virtualDisk.Label);
Console.WriteLine("Disk Label is successfully updated");
// Update only size
int newSize = 50;
vmPowershellCmdlets.UpdateAzureDisk(vhdName, null, newSize);
virtualDisk = vmPowershellCmdlets.GetAzureDisk(vhdName)[0];
Console.WriteLine("Disk: Name - {0}, Label - {1}, Size - {2},", virtualDisk.DiskName, virtualDisk.Label, virtualDisk.DiskSizeInGB);
Assert.AreEqual(newLabel, virtualDisk.Label);
Assert.AreEqual(newSize, virtualDisk.DiskSizeInGB);
Console.WriteLine("Disk size is successfully updated");
// Update both label and size
newLabel = "NewLabel2";
newSize = 100;
vmPowershellCmdlets.UpdateAzureDisk(vhdName, newLabel, newSize);
virtualDisk = vmPowershellCmdlets.GetAzureDisk(vhdName)[0];
Console.WriteLine("Disk: Name - {0}, Label - {1}, Size - {2},", virtualDisk.DiskName, virtualDisk.Label, virtualDisk.DiskSizeInGB);
Assert.AreEqual(newLabel, virtualDisk.Label);
Assert.AreEqual(newSize, virtualDisk.DiskSizeInGB);
Console.WriteLine("Both disk label and size are successfully updated");
vmPowershellCmdlets.RemoveAzureDisk(vhdName, true);
Assert.IsTrue(Utilities.CheckRemove(vmPowershellCmdlets.GetAzureDisk, vhdName), "The disk was not removed");
pass = true;
}
catch (Exception e)
{
pass = false;
if (e.ToString().Contains("ResourceNotFound"))
{
Console.WriteLine("Please upload {0} file to \\vhdtest\\ blob directory before running this test", vhdName);
}
try
{
vmPowershellCmdlets.RemoveAzureDisk(vhdName, true);
}
catch (Exception cleanupError)
{
Console.WriteLine("Error during cleaning up the disk.. Continue..:{0}", cleanupError);
}
Assert.Fail("Exception occurs: {0}", e.ToString());
}
}
public void TestVirtualIPLifecycle()
{
try
{
string dnsName = Utilities.GetUniqueShortName("Dns");
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
string vipName = Utilities.GetUniqueShortName("Vip");
string endpointName = Utilities.GetUniqueShortName("Endpoint");
// Create a new VM with the reserved ip.
DnsServer dns = null;
Utilities.ExecuteAndLog(() => { dns = vmPowershellCmdlets.NewAzureDns(dnsName, DNS_IP); },
"Create a new Azure DNS");
PersistentVM vm = null;
Utilities.ExecuteAndLog(() =>
{
vm = Utilities.CreateVMObjectWithDataDiskSubnetAndAvailibilitySet(vmName, OS.Windows,
username, password, subnet);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, vnet, new[] { dns }, location: locationName);
}, "Create a new windows azure vm without reserved ip.");
Utilities.ExecuteAndLog(() => vmPowershellCmdlets.AddAzureVirtualIP(vipName, serviceName), "Adding Azure VirtualIP");
var deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production);
var retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName));
Assert.IsNotNull(retrievedVip);
Assert.IsTrue(string.IsNullOrEmpty(retrievedVip.Address));
AzureEndPointConfigInfo endpointInfo = new AzureEndPointConfigInfo
{
EndpointName = endpointName,
EndpointProtocol = ProtocolInfo.tcp,
EndpointLocalPort = 1000,
EndpointPublicPort = 444,
VirtualIPName = vipName,
Vm = vm
};
var updatedVM = vmPowershellCmdlets.AddAzureEndPoint(endpointInfo);
vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, updatedVM);
deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production);
retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName));
Assert.IsNotNull(retrievedVip);
Assert.IsTrue(!string.IsNullOrEmpty(retrievedVip.Address));
AzureEndPointConfigInfo removeEndpointInfo = new AzureEndPointConfigInfo
{
EndpointName = endpointName,
EndpointProtocol = ProtocolInfo.tcp,
EndpointLocalPort = 1000,
EndpointPublicPort = 444,
VirtualIPName = vipName,
Vm = updatedVM
};
updatedVM = vmPowershellCmdlets.RemoveAzureEndPoint(endpointName, updatedVM);
vmPowershellCmdlets.UpdateAzureVM(vmName, serviceName, updatedVM);
deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production);
retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName));
Assert.IsNotNull(retrievedVip);
Assert.IsTrue(string.IsNullOrEmpty(retrievedVip.Address));
Utilities.ExecuteAndLog(() => vmPowershellCmdlets.RemoveAzureVirtualIP(vipName, serviceName), "Adding Azure VirtualIP");
deployment = vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production);
retrievedVip = deployment.VirtualIPs.FirstOrDefault(vip => string.Equals(vip.Name, vipName));
Assert.IsNull(retrievedVip);
cleanupIfPassed = false;
vmPowershellCmdlets.RemoveAzureDeployment(serviceName, "Production", true);
pass = true;
}
catch (Exception ex)
{
pass = false;
Console.WriteLine(ex.ToString());
throw;
}
}
public void PatchNormalSasUriBase()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Choose the base vhd file from local machine
var baseVhdName = Convert.ToString(TestContext.DataRow["baseImage"]);
var baseVhdLocalPath = new FileInfo(Directory.GetCurrentDirectory() + "\\" + baseVhdName);
Assert.IsTrue(File.Exists(baseVhdLocalPath.FullName), "VHD file not exist={0}", baseVhdLocalPath);
// Get the pre-calculated MD5 hash of the fixed vhd that was converted from the original vhd.
string md5hash = Convert.ToString(TestContext.DataRow["MD5hash"]);
string md5hashBase = Convert.ToString(TestContext.DataRow["MD5hashBase"]);
// Choose the child vhd file from the local machine
var childVhdName = Convert.ToString(TestContext.DataRow["vhdName"]);
var childVhdLocalPath = new FileInfo(Directory.GetCurrentDirectory() + "\\" + childVhdName);
Assert.IsTrue(File.Exists(childVhdLocalPath.FullName), "VHD file not exist={0}", childVhdLocalPath);
int i = 0;
while (i < 16)
{
if (!isReadWritePermission(i))
{
i++; // Skip negative tests due to BUG: https://github.com/Azure/azure-sdk-tools/issues/2956
}
else
{
string destinationSasUriParent = CreateSasUriWithPermission(baseVhdName, i); // the destination of the parent vhd is a Sas Uri
// Set the destination of child vhd
string vhdBlobName = string.Format("{0}/{1}.vhd", vhdContainerName, Utilities.GetUniqueShortName(Path.GetFileNameWithoutExtension(childVhdName)));
string vhdDestUri = blobUrlRoot + vhdBlobName;
try
{
// Upload the parent vhd using Sas Uri
Console.WriteLine("uploads {0} to {1}", baseVhdName, destinationSasUriParent);
vmPowershellCmdlets.RemoveAzureSubscriptions();
var vhdUploadContext = vmPowershellCmdlets.AddAzureVhd(baseVhdLocalPath, destinationSasUriParent, true);
Console.WriteLine("uploading completed: {0}", baseVhdName);
// Verify the upload.
ReImportSubscription();
AssertUploadContextAndContentMD5UsingSaveVhd(destinationSasUriParent, baseVhdLocalPath, vhdUploadContext, md5hashBase, false);
Console.WriteLine("uploads {0} to {1} with patching from {2}", childVhdName, vhdDestUri, destinationSasUriParent);
var patchVhdUploadContext = vmPowershellCmdlets.AddAzureVhd(childVhdLocalPath, vhdDestUri, destinationSasUriParent);
Console.WriteLine("uploading the child vhd completed: {0}", childVhdName);
// Verify the upload.
AssertUploadContextAndContentMD5UsingSaveVhd(vhdDestUri, childVhdLocalPath, patchVhdUploadContext, md5hash);
Console.WriteLine("Test success with permission: {0}", i);
i++;
}
catch (Exception e)
{
continueIfNotReadWrite(e, ref i);
continue;
}
}
}
pass = true;
DateTime testEndTime = DateTime.Now;
Console.WriteLine("{0} test passed at {1}.", testName, testEndTime);
Console.WriteLine("Duration of the test pass: {0} seconds", (testEndTime - testStartTime).TotalSeconds);
System.IO.File.AppendAllLines(perfFile, new string[] { String.Format("{0},{1}", testName, (testEndTime - testStartTime).TotalSeconds) });
}
public void AzurePlatformVMImageScenarioTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string vmName = Utilities.GetUniqueShortName("pirtestvm");
string svcName = Utilities.GetUniqueShortName("pirtestservice");
try
{
SwitchToNormalUser();
try
{
vmPowershellCmdlets.GetAzureStorageAccount(storageNormalUser);
}
catch (Exception e)
{
if (e.ToString().Contains("ResourceNotFound"))
{
vmPowershellCmdlets.NewAzureStorageAccount(storageNormalUser, location1);
}
else
{
Console.WriteLine(e.ToString());
throw;
}
}
vmPowershellCmdlets.SetAzureSubscription(normaluser, normaluserSubId, storageNormalUser);
// Replicate the user image to "West US" and wait until the replication process is completed.
SwitchToPublisher();
ComputeImageConfig compCfg = new ComputeImageConfig
{
Offer = "test",
Sku = "test",
Version = "test"
};
MarketplaceImageConfig marketCfg = null;
vmPowershellCmdlets.SetAzurePlatformVMImageReplicate(image, new string[] { location1 }, compCfg, marketCfg);
// Make the replicated image public and wait until the PIR image shows up.
vmPowershellCmdlets.SetAzurePlatformVMImagePublic(image);
OSImageContext pirImage = WaitForPIRAppear(image, publisher);
// Switch to the normal User and check the PIR image.
SwitchToNormalUser();
WaitForPIRAppear(image, publisher);
// Create a VM using the PIR image
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName, svcName, pirImage.ImageName, username, password, location1);
Console.WriteLine("VM, {0}, is successfully created using the uploaded PIR image", vmPowershellCmdlets.GetAzureVM(vmName, svcName).Name);
// Remove the service and VM
vmPowershellCmdlets.RemoveAzureService(svcName);
// Switch to the publisher and remove the PIR image
SwitchToPublisher();
vmPowershellCmdlets.RemoveAzurePlatformVMImage(image);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public void TryToReserveExistingCATest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string vnet1 = VirtualNets[0];
string serviceName2 = Utilities.GetUniqueShortName(serviceNamePrefix);
string serviceName3 = Utilities.GetUniqueShortName(serviceNamePrefix);
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
string vmName2 = Utilities.GetUniqueShortName(vmNamePrefix);
string vmName3 = Utilities.GetUniqueShortName(vmNamePrefix);
try
{
string nonStaticIpAddress = string.Empty;
//Create an IaaS VM
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName1, serviceName, imageName, InstanceSize.Small.ToString(), username, password, VNetName, new string[1] {
StaticCASubnet0
}, AffinityGroup);
//Get the DIP of the VM (Get-AzureVM)
var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName);
nonStaticIpAddress = vmRoleContext.IpAddress;
//Assert that the DIP is not available (Test-AzureStaticVNetIP)
CheckAvailabilityOfIpAddressAndAssertFalse(vnet1, nonStaticIpAddress);
//Try to deploy an IaaS VM with the same static CA (CreateDeployment) and Verify that the deployment failed
//Add an IaaS VM with a static CA
Console.WriteLine("Deploying an IaaS VM with the same static CA {0} (CreateDeployment)", nonStaticIpAddress);
var vm = CreatIaasVMObject(vmName2, nonStaticIpAddress, StaticCASubnet0);
//Verify that the deployment failed.
Utilities.VerifyFailure(
() => vmPowershellCmdlets.NewAzureVM(serviceName2, new[] { vm }, vnet1, new DnsServer[1] {
DnsServers[0]
},
serviceName, "service for AddVMWithStaticCATest", string.Empty, string.Empty, null, AffinityGroup),
IPUnavaialbleExceptionMessage);
Console.WriteLine("Deployment with Static CA {0} failed as expectd", nonStaticIpAddress);
//Try to deploy an IaaS VM with the same static CA (AddRole) and verify that the deployment fails
//Add an IaaS VM with a static CA
Console.WriteLine("Deploying an IaaS VM with the same static CA {0} (AddRole)", nonStaticIpAddress);
vm = CreatIaasVMObject(vmName3, nonStaticIpAddress, StaticCASubnet0);
//Verify that the deployment failed.
Utilities.VerifyFailure(() => vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }), IPUnavaialbleExceptionMessage);
Console.WriteLine("Deployment with Static CA {0} failed as expectd", nonStaticIpAddress);
//Reserve the DIP of the VM1
vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName);
vm = vmPowershellCmdlets.SetAzureStaticVNetIP(nonStaticIpAddress, vmRoleContext.VM);
vmPowershellCmdlets.UpdateAzureVM(vmName1, serviceName, vm);
//Verify that the DIP is reserved
VerifyVmWithStaticCAIsReserved(vmName1, serviceName, nonStaticIpAddress);
//Try to deploy an IaaS VM with the same static CA (CreateDeployment)
Console.WriteLine("Deploying an IaaS VM with the same static CA {0} (CreateDeployment)", nonStaticIpAddress);
vm = CreatIaasVMObject(vmName2, nonStaticIpAddress, StaticCASubnet0);
Utilities.VerifyFailure(() => vmPowershellCmdlets.NewAzureVM(serviceName3, new[] { vm }, vnet1, new DnsServer[1] {
DnsServers[0]
},
serviceName, "service for AddVMWithStaticCATest", string.Empty, string.Empty, null, AffinityGroup), IPUnavaialbleExceptionMessage);
Console.WriteLine("Deployment with Static CA {0} failed as expectd", nonStaticIpAddress);
//Add an IaaS VM with a static CA
Console.WriteLine("Deploying an IaaS VM with the same static CA {0} (AddRole)", nonStaticIpAddress);
vm = CreatIaasVMObject(vmName3, nonStaticIpAddress, StaticCASubnet0);
Utilities.VerifyFailure(() => vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }), IPUnavaialbleExceptionMessage);
Console.WriteLine("Deployment with Static CA {0} failed as expectd", nonStaticIpAddress);
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
finally
{
CleanupService(serviceName);
CleanupService(serviceName2);
CleanupService(serviceName3);
}
}
public void CreatePaaSDeploymentAssociateAndDisassociateReservedIp()
{
try
{
string reservedIpName = Utilities.GetUniqueShortName("ResrvdIP");
string reservedIpLabel = Utilities.GetUniqueShortName("ResrvdIPLbl", 5);
string deploymentName = Utilities.GetUniqueShortName("Depl");
string deploymentLabel = Utilities.GetUniqueShortName("DepLbl", 5);
var input = new ReservedIPContext()
{
DeploymentName = string.Empty,
Label = reservedIpLabel,
InUse = false,
Location = locationName,
ReservedIPName = reservedIpName,
State = "Created"
};
// Reserve a new IP
Utilities.ExecuteAndLog(() => vmPowershellCmdlets.NewAzureReservedIP(reservedIpName, locationName, reservedIpLabel), "Reserve a new IP");
//Get the reserved ip and verify the reserved Ip properties.
VerifyReservedIpNotInUse(input);
// Create a new VM with the reserved ip.
Utilities.ExecuteAndLog(() =>
vmPowershellCmdlets.NewAzureService(serviceName, locationName),
"Create a Hosted Service");
Utilities.ExecuteAndLog(() =>
vmPowershellCmdlets.NewAzureDeployment(serviceName,
"HelloWorld_SDK20.cspkg", "ServiceConfiguration.cscfg", "Staging",
deploymentLabel, deploymentName, doNotStart: false, warning: false),
"Create a PaaS deployment");
Utilities.ExecuteAndLog(() =>
{
vmPowershellCmdlets.SetAzureReservedIPAssociation(reservedIpName,
serviceName, DeploymentSlotType.Staging);
}, "Create a new Azure Reserved IP Association");
VerifyReservedIpInUse(serviceName, input, deploymentName);
Utilities.ExecuteAndLog(() =>
{
vmPowershellCmdlets.RemoveAzureReservedIPAssociation(reservedIpName,
serviceName, true, DeploymentSlotType.Staging);
}, "Remove a new Azure Reserved IP Association");
VerifyReservedIpNotInUse(input);
Utilities.ExecuteAndLog(() =>
{
vmPowershellCmdlets.RemoveAzureDeployment(serviceName, "Staging", true);
}, "Remove a new Azure Reserved IP Association");
}
catch (Exception ex)
{
pass = false;
Console.WriteLine(ex.ToString());
throw;
}
}
public void AzureIaaSBVT()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
DateTime prevTime = DateTime.Now;
string diskLabel1 = "disk1";
int diskSize1 = 30;
int lunSlot1 = 0;
string diskLabel2 = "disk2";
int diskSize2 = 50;
int lunSlot2 = 2;
string ep1Name = "tcp1";
int ep1LocalPort = 60010;
int ep1PublicPort = 60011;
string ep1LBSetName = "lbset1";
int ep1ProbePort = 60012;
string ep1ProbePath = string.Empty;
int? ep1ProbeInterval = 7;
int? ep1ProbeTimeout = null;
NetworkAclObject ep1AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep1DirectServerReturn = false;
string ep2Name = "tcp2";
int ep2LocalPort = 60020;
int ep2PublicPort = 60021;
int ep2LocalPortChanged = 60030;
int ep2PublicPortChanged = 60031;
string ep2LBSetName = "lbset2";
int ep2ProbePort = 60022;
string ep2ProbePath = @"/";
int? ep2ProbeInterval = null;
int? ep2ProbeTimeout = 32;
NetworkAclObject ep2AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep2DirectServerReturn = false;
string cerFileName = "testcert.cer";
string thumbprintAlgorithm = "sha1";
try
{
// Create a certificate
X509Certificate2 certCreated = Utilities.CreateCertificate(password);
byte[] certData2 = certCreated.Export(X509ContentType.Cert);
File.WriteAllBytes(cerFileName, certData2);
// Install the .cer file to local machine.
StoreLocation certStoreLocation = StoreLocation.CurrentUser;
StoreName certStoreName = StoreName.My;
X509Certificate2 installedCert = Utilities.InstallCert(cerFileName, certStoreLocation, certStoreName);
PSObject certToUpload = vmPowershellCmdlets.RunPSScript(
String.Format("Get-Item cert:\\{0}\\{1}\\{2}", certStoreLocation.ToString(), certStoreName.ToString(), installedCert.Thumbprint))[0];
string certData = Convert.ToBase64String(((X509Certificate2)certToUpload.BaseObject).RawData);
string newAzureVMName = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
RecordTimeTaken(ref prevTime);
//
// New-AzureService and verify with Get-AzureService
//
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
Assert.IsTrue(Verify.AzureService(serviceName, serviceName, locationName));
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate and verify with Get-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
Assert.IsTrue(Verify.AzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm, certData));
RecordTimeTaken(ref prevTime);
//
// Remove-AzureCertificate
//
vmPowershellCmdlets.RemoveAzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm);
Assert.IsTrue(Utilities.CheckRemove(vmPowershellCmdlets.GetAzureCertificate, serviceName, certCreated.Thumbprint, thumbprintAlgorithm));
RecordTimeTaken(ref prevTime);
//
// New-AzureVMConfig
//
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
PersistentVM vm = vmPowershellCmdlets.NewAzureVMConfig(azureVMConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
//
// New-AzureCertificateSetting
//
CertificateSettingList certList = new CertificateSettingList();
certList.Add(vmPowershellCmdlets.NewAzureCertificateSetting(certStoreName.ToString(), installedCert.Thumbprint));
RecordTimeTaken(ref prevTime);
//
// Add-AzureProvisioningConfig
//
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, certList, username, password);
azureProvisioningConfig.Vm = vm;
vm = vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig);
RecordTimeTaken(ref prevTime);
//
// Add-AzureDataDisk (two disks)
//
AddAzureDataDiskConfig azureDataDiskConfigInfo1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize1, diskLabel1, lunSlot1);
azureDataDiskConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo1);
AddAzureDataDiskConfig azureDataDiskConfigInfo2 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize2, diskLabel2, lunSlot2);
azureDataDiskConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Add-AzureEndpoint (two endpoints)
//
AzureEndPointConfigInfo azureEndPointConfigInfo1 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep1LocalPort,
ep1PublicPort,
ep1Name,
ep1LBSetName,
ep1ProbePort,
ProtocolInfo.tcp,
ep1ProbePath,
ep1ProbeInterval,
ep1ProbeTimeout,
ep1AclObj,
ep1DirectServerReturn,
null,
null,
LoadBalancerDistribution.SourceIP);
azureEndPointConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo1);
AzureEndPointConfigInfo azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPort,
ep2PublicPort,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Set-AzureAvailabilitySet
//
string testAVSetName = "testAVSet1";
vm = vmPowershellCmdlets.SetAzureAvailabilitySet(testAVSetName, vm);
RecordTimeTaken(ref prevTime);
//
// New-AzureDns
//
string dnsName = "OpenDns1";
string ipAddress = "208.67.222.222";
DnsServer dns = vmPowershellCmdlets.NewAzureDns(dnsName, ipAddress);
RecordTimeTaken(ref prevTime);
//
// New-AzureVM
//
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, null, new[] { dns }, null, null, null, null);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM without any parameter (List VMs)
//
var vmlist = vmPowershellCmdlets.GetAzureVM();
Console.WriteLine("The number of VMs: {0}", vmlist.Count);
Assert.AreNotSame(0, vmlist.Count, "No VM exists!!!");
PersistentVMRoleListContext returnedVMlist =
vmlist.First(item => item.ServiceName.Equals(serviceName) && item.Name.Equals(newAzureVMName));
Assert.IsNotNull(returnedVMlist, "Created VM does not exist!!!");
Utilities.PrintContext((PersistentVMRoleContext)returnedVMlist);
//
// Get-AzureVM
//
PersistentVMRoleContext returnedVM = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName);
vm = returnedVM.VM;
RecordTimeTaken(ref prevTime);
//
// Verify AzureDataDisk
//
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.None), "Data disk is not properly added");
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel2, diskSize2, lunSlot2, HostCaching.None), "Data disk is not properly added");
Console.WriteLine("Data disk added correctly.");
RecordTimeTaken(ref prevTime);
//
// Verify AzureEndpoint
//
Assert.IsTrue(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo1, azureEndPointConfigInfo2 }));
//
// Verify RDP & PowerShell Endpoints
//
var endpoints = vmPowershellCmdlets.GetAzureEndPoint(vm);
Assert.IsTrue(endpoints.Count(e => e.Name == "PowerShell" && e.LocalPort == 5986 && e.Protocol == "tcp") == 1);
Assert.IsTrue(endpoints.Count(e => e.Name == "RemoteDesktop" && e.LocalPort == 3389 && e.Protocol == "tcp") == 1);
//
// Verify AzureDns
//
Assert.IsTrue(Verify.AzureDns(vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings, dns));
//
// Verify AzureAvailibilitySet
//
Assert.IsTrue(Verify.AzureAvailabilitySet(vm, testAVSetName));
//
// Verify AzureOsDisk
//
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadWrite));
//
// Set-AzureDataDisk
//
SetAzureDataDiskConfig setAzureDataDiskConfigInfo = new SetAzureDataDiskConfig(HostCaching.ReadOnly, lunSlot1);
setAzureDataDiskConfigInfo.Vm = vm;
vm = vmPowershellCmdlets.SetAzureDataDisk(setAzureDataDiskConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureDataDisk
//
RemoveAzureDataDiskConfig removeAzureDataDiskConfig = new RemoveAzureDataDiskConfig(lunSlot2, vm);
vm = vmPowershellCmdlets.RemoveAzureDataDisk(removeAzureDataDiskConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureEndpoint
//
azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPortChanged,
ep2PublicPortChanged,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.SetAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureEndpoint
//
vm = vmPowershellCmdlets.RemoveAzureEndPoint(azureEndPointConfigInfo1.EndpointName, vm);
RecordTimeTaken(ref prevTime);
//
// Set-AzureVMSize
//
var vmSizeConfig = new SetAzureVMSizeConfig(InstanceSize.Medium.ToString());
vmSizeConfig.Vm = vm;
vm = vmPowershellCmdlets.SetAzureVMSize(vmSizeConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureOSDisk
//
vm = vmPowershellCmdlets.SetAzureOSDisk(HostCaching.ReadOnly, vm);
//
// Update-AzureVM
//
vmPowershellCmdlets.UpdateAzureVM(newAzureVMName, serviceName, vm);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM and Verify the VM
//
vm = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName).VM;
// Verify setting data disk
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.ReadOnly), "Data disk is not properly added");
// Verify removing a data disk
Assert.AreEqual(1, vmPowershellCmdlets.GetAzureDataDisk(vm).Count, "DataDisk is not removed.");
// Verify setting an endpoint
Assert.IsTrue(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo2 }));
// Verify removing an endpoint
Assert.IsFalse(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo1 }));
// Verify os disk
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadOnly));
//
// Remove-AzureVM
//
vmPowershellCmdlets.RemoveAzureVM(newAzureVMName, serviceName);
RecordTimeTaken(ref prevTime);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public void Intialize()
{
serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
cleanupIfPassed = true;
}
public void CaptureGeneralizedLinuxVMAndDeploy()
{
string serviceName1 = Utilities.GetUniqueShortName(serviceNamePrefix);
string linuxImageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Linux" }, false);
try
{
// a. Deploy a new IaaS VM
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
PersistentVM vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, linuxImageName, false, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
Console.WriteLine("--------------------------------Deploying a new IaaS VM :{0} completed.---------------------", vmName);
//b. Stop the VM
Console.WriteLine("--------------------------------Stopping vm :{0}--------------------------------", vmName);
vmPowershellCmdlets.StopAzureVM(vmName, serviceName, force: true);
Console.WriteLine("--------------------------------Stopped vm :{0}--------------------------------", vmName);
//c. Save the VM image
Console.WriteLine("--------------------------------Save the VM image--------------------------------");
vmImageName = vmName + "Image";
vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, vmImageName, CONSTANT_GENERALIZED, vmImageName);
Console.WriteLine("--------------------------------Saved VM image with name {0}----------------------");
//d. Verify the VM image by Get-AzureVMImage
Console.WriteLine("--------------------------------Verify the VM image--------------------------------");
VerifyVMImage(vmImageName, OS.Linux, vmImageName, CONSTANT_GENERALIZED, cahcing, lunSlot1, diskSize1, 1);
Console.WriteLine("--------------------------------Verified that the VM image is saved successfully--------------------------------");
//e. Deploy a new IaaS VM with the save VM image
Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
vm = Utilities.CreateIaaSVMObject(vmName1, InstanceSize.Small, vmImageName, false, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName1, new[] { vm }, locationName);
Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName1, vmImageName);
//f. Verify the VM by Get-AzureVM
Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName1, vmImageName);
var vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName1, serviceName1);
Utilities.PrintContext(vmRoleContext);
Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName1);
//g. Add another IaaS VM with the save VM image to the existing service
string vmName2 = Utilities.GetUniqueShortName(vmNamePrefix);
Console.WriteLine("--------------------------------Deploy a new IaaS VM with the saved VM image {0}--------------------------------", vmImageName);
vmPowershellCmdlets.NewAzureQuickVM(OS.Linux, vmName2, serviceName1, vmImageName, username, password);
Console.WriteLine("--------------------------------Deployed a IaaS VM {0} with the saved VM image {1}--------------------------------", vmName2, vmImageName);
//h. Verify the VM by Get-AzureVM
Console.WriteLine("--------------------------------Verify the VM by Get-AzureVM--------------------------------", vmName2, vmImageName);
vmRoleContext = vmPowershellCmdlets.GetAzureVM(vmName2, serviceName1);
Utilities.PrintContext(vmRoleContext);
Console.WriteLine("--------------------------------Verified the VM {0} successfully--------------------------------", vmName2);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
finally
{
CleanupService(serviceName1);
//Delete the VM image
Console.WriteLine("------------------------------Delete the VM image---------------------------------");
vmPowershellCmdlets.RemoveAzureVMImage(vmImageName, true);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
}
}
public void CreateReservedIPThenPaaSVM()
{
try
{
string reservedIpName1 = Utilities.GetUniqueShortName("ResrvdIP1");;
string reservedIpName2 = Utilities.GetUniqueShortName("ResrvdIP2");;
string reservedIpLabel1 = Utilities.GetUniqueShortName("ResrvdIPLbl", 5);
string reservedIpLabel2 = Utilities.GetUniqueShortName("ResrvdIPLbl", 5);
string dnsName = Utilities.GetUniqueShortName("Dns");
string deploymentName = Utilities.GetUniqueShortName("Depl");
var input1 = new ReservedIPContext()
{
DeploymentName = string.Empty,
Label = reservedIpLabel1,
InUse = false,
Location = locationName,
ReservedIPName = reservedIpName1,
State = "Created"
};
var input2 = new ReservedIPContext()
{
DeploymentName = string.Empty,
Label = reservedIpLabel2,
InUse = false,
Location = locationName,
ReservedIPName = reservedIpName2,
State = "Created"
};
// Reserve a new IP
Utilities.ExecuteAndLog(() => vmPowershellCmdlets.NewAzureReservedIP(reservedIpName1, locationName, reservedIpLabel1), "Reserve a new IP");
//Get the reserved ip and verify the reserved Ip properties.
VerifyReservedIpNotInUse(input1);
// Reserve a new IP
Utilities.ExecuteAndLog(() => vmPowershellCmdlets.NewAzureReservedIP(reservedIpName2, locationName, reservedIpLabel2), "Reserve a new IP");
//Get the reserved ip and verify the reserved Ip properties.
VerifyReservedIpNotInUse(input2);
vmPowershellCmdlets.NewAzureService(serviceName, locationName);
var _packageName = Convert.ToString(TestContext.DataRow["packageName"]);
var _configName1 = Convert.ToString(TestContext.DataRow["configName1"]);
var _configName2 = Convert.ToString(TestContext.DataRow["configName2"]);
var _configName1update = Convert.ToString(TestContext.DataRow["updateConfig1"]);
var _configName2update = Convert.ToString(TestContext.DataRow["updateConfig2"]);
var _packagePath = new FileInfo(Directory.GetCurrentDirectory() + "\\" + _packageName);
var _configPath1 = new FileInfo(Directory.GetCurrentDirectory() + "\\" + _configName1);
var _configPath2 = new FileInfo(Directory.GetCurrentDirectory() + "\\" + _configName2);
var _configPath1update = new FileInfo(Directory.GetCurrentDirectory() + "\\" + _configName1update);
var _configPath2update = new FileInfo(Directory.GetCurrentDirectory() + "\\" + _configName2update);
vmPowershellCmdlets.NewAzureDeployment(serviceName, _packagePath.FullName, _configPath1.FullName,
DeploymentSlotType.Production, "label", deploymentName, false, false);
vmPowershellCmdlets.NewAzureDeployment(serviceName, _packagePath.FullName, _configPath2.FullName,
DeploymentSlotType.Staging, "label", deploymentName, false, false);
vmPowershellCmdlets.MoveAzureDeployment(serviceName);
vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Production);
vmPowershellCmdlets.GetAzureDeployment(serviceName, DeploymentSlotType.Staging);
vmPowershellCmdlets.SetAzureDeploymentConfig(serviceName, DeploymentSlotType.Production, _configPath1update.FullName);
vmPowershellCmdlets.SetAzureDeploymentConfig(serviceName, DeploymentSlotType.Staging, _configPath2update.FullName);
pass = true;
}
catch (Exception ex)
{
pass = false;
Console.WriteLine(ex.ToString());
throw;
}
}
public void SaveAzureVMImageNegativeTest()
{
try
{
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
// Deploy a new IaaS VM
Console.WriteLine("------------------------------Deploy a new IaaS VM---------------------------------");
var vm = CreateIaaSVMObjectWithDisk(vmName, InstanceSize.Small, imageName, true, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
Console.WriteLine("------------------------------Deploy a new IaaS VM: completed---------------------------------");
//b. Stop the VM
Console.WriteLine("------------------------------Stop the VM---------------------------------");
vmPowershellCmdlets.StopAzureVM(vm, serviceName, force: true);
Console.WriteLine("------------------------------Stop the VM: completed---------------------------------");
//c. Save the VM image
Console.WriteLine("------------------------------Save the VM image---------------------------------");
vmImageName = vmName + "Image";
vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName, vmImageName, CONSTANT_SPECIALIZED, vmImageName);
Console.WriteLine("------------------------------Save the VM image: completed---------------------------------");
//d. Deploy another new IaaS VM
Console.WriteLine("------------------------------Deploy another new IaaS VM---------------------------------");
string vmName1 = Utilities.GetUniqueShortName(vmNamePrefix);
vm = CreateIaaSVMObjectWithDisk(vmName1, InstanceSize.Small, imageName, true, username, password);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm });
Console.WriteLine("------------------------------Deploy another new IaaS VM: completed---------------------------------");
//e. Stop the VM
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
vmPowershellCmdlets.StopAzureVM(vm, serviceName, force: true);
string testImageName = Utilities.GetUniqueShortName(vmNamePrefix);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
//f. Try to save the VM image with the existing name (must fail)
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
Utilities.VerifyFailure(() => vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName1, vmImageName, CONSTANT_SPECIALIZED, vmImageName), ConflictErrorException);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
//g. Try to save the VM image with the wrong vm name (must fail)
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
Utilities.VerifyFailure(() => vmPowershellCmdlets.SaveAzureVMImage(serviceName, Utilities.GetUniqueShortName(vmNamePrefix), testImageName, CONSTANT_SPECIALIZED, testImageName), ResourceNotFoundException);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
//h. Try to save the VM image with the wrong service name (must fail)
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
string testVMIMage = Utilities.GetUniqueShortName("VMImage");
vmPowershellCmdlets.SaveAzureVMImage(Utilities.GetUniqueShortName(vmNamePrefix), vmName1, testVMIMage, CONSTANT_SPECIALIZED, testVMIMage);
Utilities.VerifyFailure(() => vmPowershellCmdlets.GetAzureVMImage(testVMIMage), ResourceNotFoundException);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
//i. Try to save the VM image with the label longer than maximum length of string (must fail)
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
string LongImageName = Utilities.GetUniqueShortName(length: 30) + Utilities.GetUniqueShortName(length: 30) + Guid.NewGuid().ToString() + Guid.NewGuid().ToString();
Console.WriteLine("Attempting to save a VMImage with name {0} of {1} characters and expecting it to fail.", LongImageName, LongImageName.Length);
Utilities.VerifyFailure(() => vmPowershellCmdlets.SaveAzureVMImage(serviceName, vmName1, testImageName, CONSTANT_SPECIALIZED, LongImageName), BadRequestException);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
finally
{
Console.WriteLine("------------------------------Delete the VM image---------------------------------");
DeleteVMImageIfExists(vmImageName);
Console.WriteLine("------------------------------Deleted the VM image---------------------------------");
}
}
public void SaveAzureVhdAllTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Choose the vhd path in your local machine
string vhdName = Convert.ToString(TestContext.DataRow["vhdLocalPath"]) + Utilities.GetUniqueShortName();
FileInfo vhdLocalPath = new FileInfo(vhdName);
// Download and verify it.
SaveVhdAndAssertContent(blobHandle, vhdLocalPath, 16, storageAccountKey.Secondary, true, false, true);
// Download with overwrite and verify it.
SaveVhdAndAssertContent(blobHandle, vhdLocalPath, 32, storageAccountKey.Primary, true, false, true);
DateTime testEndTime = DateTime.Now;
Console.WriteLine("{0} test passed at {1}.", testName, testEndTime);
//System.IO.File.AppendAllLines(perfFile, new string[] { String.Format("{0},{1}", testName, (testEndTime - testStartTime).TotalSeconds) });
}
public void HiMemVMSizeTest()
{
string serviceName = Utilities.GetUniqueShortName(serviceNamePrefix);
string vmName = Utilities.GetUniqueShortName(vmNamePrefix);
try
{
// New-AzureQuickVM test for VM size 'A5'
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName, serviceName, imageName, username, password, locationName, InstanceSize.A5.ToString());
PersistentVMRoleContext result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
RoleSizeContext returnedSize = vmPowershellCmdlets.GetAzureRoleSize(result.InstanceSize)[0];
Assert.AreEqual(InstanceSize.A5.ToString(), returnedSize.InstanceSize);
Console.WriteLine("VM size, {0}, is verified for New-AzureQuickVM", InstanceSize.A5);
vmPowershellCmdlets.RemoveAzureService(serviceName);
// New-AzureQuickVM test for VM size 'A6'
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, vmName, serviceName, imageName, username, password, locationName, InstanceSize.A6.ToString());
result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
returnedSize = vmPowershellCmdlets.GetAzureRoleSize(result.InstanceSize)[0];
Assert.AreEqual(InstanceSize.A6.ToString(), returnedSize.InstanceSize);
Console.WriteLine("VM size, {0}, is verified for New-AzureQuickVM", InstanceSize.A6);
vmPowershellCmdlets.RemoveAzureService(serviceName);
// New-AzureVMConfig test for VM size 'A7'
var azureVMConfigInfo = new AzureVMConfigInfo(vmName, InstanceSize.A7.ToString(), imageName);
var azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
var persistentVMConfigInfo = new PersistentVMConfigInfo(azureVMConfigInfo, azureProvisioningConfig, null, null);
PersistentVM vm = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo);
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, locationName);
result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
returnedSize = vmPowershellCmdlets.GetAzureRoleSize(result.InstanceSize)[0];
Assert.AreEqual(InstanceSize.A7.ToString(), returnedSize.InstanceSize);
Console.WriteLine("VM size, {0}, is verified for New-AzureVMConfig", InstanceSize.A7);
// Set-AzureVMSize test for Hi-MEM VM size (A7 to A6)
vmPowershellCmdlets.SetVMSize(vmName, serviceName, new SetAzureVMSizeConfig(InstanceSize.A6.ToString()));
result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
returnedSize = vmPowershellCmdlets.GetAzureRoleSize(result.InstanceSize)[0];
Assert.AreEqual(InstanceSize.A6.ToString(), returnedSize.InstanceSize);
Console.WriteLine("SetVMSize is verified from A7 to A6");
// Set-AzureVMSize test for Hi-MEM VM size (A6 to A5)
vmPowershellCmdlets.SetVMSize(vmName, serviceName, new SetAzureVMSizeConfig(InstanceSize.A5.ToString()));
result = vmPowershellCmdlets.GetAzureVM(vmName, serviceName);
returnedSize = vmPowershellCmdlets.GetAzureRoleSize(result.InstanceSize)[0];
Assert.AreEqual(InstanceSize.A5.ToString(), returnedSize.InstanceSize);
Console.WriteLine("SetVMSize is verified from A6 to A5");
pass = true;
}
catch (Exception e)
{
pass = false;
Console.WriteLine("Exception occurred: {0}", e.ToString());
throw;
}
finally
{
if (!Utilities.CheckRemove(vmPowershellCmdlets.GetAzureService, serviceName))
{
if ((cleanupIfFailed && !pass) || (cleanupIfPassed && pass))
{
vmPowershellCmdlets.RemoveAzureService(serviceName);
}
}
}
}
public void NewAzureVMWithResizeDiskTest()
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false, 50);
string newVMImageName = Utilities.GetUniqueShortName("vmimage");
const int newDiskSize = 100;
try
{
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, _vmName, _serviceName, imageName, username, password, locationName);
Console.WriteLine("Service Name: {0} is created. VM: {1} is created.", _serviceName, _vmName);
string diskLabel1 = "disk1";
int diskSize1 = 30;
int lunSlot1 = 0;
string diskLabel2 = "disk2";
int diskSize2 = 50;
int lunSlot2 = 2;
AddAzureDataDiskConfig dataDiskInfo1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize1, diskLabel1, lunSlot1);
AddAzureDataDiskConfig dataDiskInfo2 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize2, diskLabel2, lunSlot2);
vmPowershellCmdlets.AddDataDisk(_vmName, _serviceName, new[] { dataDiskInfo1, dataDiskInfo2 });
vmPowershellCmdlets.SaveAzureVMImage(_serviceName, _vmName, newVMImageName, "Specialized");
var newImage = vmPowershellCmdlets.GetAzureVMImageReturningVMImages(newVMImageName).FirstOrDefault();
foreach (var disk in newImage.DataDiskConfigurations)
{
Utilities.PrintContextAndItsBase(disk);
}
string disk1 = newImage.DataDiskConfigurations[0].Name;
string disk2 = newImage.DataDiskConfigurations[1].Name;
vmPowershellCmdlets.RemoveAzureService(_serviceName);
// Add-AzureProvisioningConfig with NoSSHEndpoint
var vm = vmPowershellCmdlets.NewAzureVMConfig(new AzureVMConfigInfo(_vmName, InstanceSize.Small.ToString(), newVMImageName));
vm = vmPowershellCmdlets.SetAzureDataDisk(new SetAzureDataDiskResizeConfig(disk1, newDiskSize, vm));
vm = vmPowershellCmdlets.SetAzureDataDisk(new SetAzureDataDiskResizeConfig(disk2, newDiskSize, vm));
vm = vmPowershellCmdlets.SetAzureOSDisk(null, vm, newDiskSize);
// New-AzureVM
vmPowershellCmdlets.NewAzureVM(_serviceName, new[] { vm }, locationName);
Console.WriteLine("New Azure service with name:{0} created successfully.", _serviceName);
// Validate disk sizes
var returnedVM = vmPowershellCmdlets.GetAzureVM(_vmName, _serviceName);
foreach (var disk in returnedVM.VM.DataVirtualHardDisks)
{
Utilities.PrintContextAndItsBase(disk);
}
Assert.AreEqual(newDiskSize, returnedVM.VM.DataVirtualHardDisks[0].LogicalDiskSizeInGB);
Assert.AreEqual(newDiskSize, returnedVM.VM.DataVirtualHardDisks[1].LogicalDiskSizeInGB);
pass = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Console.WriteLine(ex.InnerException);
}
throw;
}
finally
{
vmPowershellCmdlets.RemoveAzureService(_serviceName);
vmPowershellCmdlets.RemoveAzureVMImage(newVMImageName, true);
}
}
