public void AddAzureWorkerRoleWillRecreateDeploymentSettings()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WorkerRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreate, rootPath, roleName);
string settingsFilePath = Path.Combine(rootPath, Resources.SettingsFileName);
string originalDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(rootPath);
File.Delete(settingsFilePath);
Assert.False(File.Exists(settingsFilePath));
addWorkerCmdlet = new AddAzureWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = roleName };
addWorkerCmdlet.ExecuteCmdlet();
AzureAssert.ScaffoldingExists(Path.Combine(rootPath, roleName), Path.Combine(Resources.GeneralScaffolding, Resources.WorkerRole));
Assert.Equal<string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue<string>(Parameters.RoleName));
Assert.Equal<string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
Assert.True(File.Exists(settingsFilePath));
Directory.SetCurrentDirectory(originalDirectory);
}
}
public void SetAzureServiceProjectTestsLocationValid()
{
string[] locations = { "West US", "East US", "East Asia", "North Europe" };
foreach (string item in locations)
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
PowerShellProjectPathInfo paths = new PowerShellProjectPathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
mockCommandRuntime = new MockCommandRuntime();
setServiceProjectCmdlet.CommandRuntime = mockCommandRuntime;
settings.Save(paths.Settings);
settings = setServiceProjectCmdlet.SetAzureServiceProjectProcess(item, null, null, paths.Settings);
// Assert location is changed
//
Assert.Equal<string>(item, settings.Location);
ServiceSettings actualOutput = mockCommandRuntime.OutputPipeline[0] as ServiceSettings;
Assert.Equal<string>(item, settings.Location);
}
}
}
public void PublishFromProjectFile()
{
var websiteName = "test-site";
string slot = null;
var projectFile = string.Format(@"{0}\Resources\MyWebApplication\WebApplication4.csproj", Directory.GetCurrentDirectory());
var configuration = "Debug";
var logFile = string.Format(@"{0}\build.log", Directory.GetCurrentDirectory());
var connectionStrings = new Hashtable();
connectionStrings["DefaultConnection"] = "test-connection-string";
using (FileSystemHelper files = new FileSystemHelper(this))
{
string originalDirectory = Directory.GetCurrentDirectory();
}
var publishProfile = new WebSiteGetPublishProfileResponse.PublishProfile()
{
UserName = "******",
UserPassword = "******",
PublishUrl = "test-publlish-url"
};
var package = "test-package.zip";
var published = false;
Mock<IWebsitesClient> clientMock = new Mock<IWebsitesClient>();
clientMock.Setup(c => c.GetWebDeployPublishProfile(websiteName, slot)).Returns(publishProfile);
clientMock.Setup(c => c.BuildWebProject(projectFile, configuration, logFile)).Returns(package);
clientMock.Setup(c => c.PublishWebProject(websiteName, slot, package, connectionStrings, false, false))
.Callback((string n, string s, string p, Hashtable cs, bool skipAppData, bool doNotDelete) =>
{
Assert.Equal(websiteName, n);
Assert.Equal(slot, s);
Assert.Equal(package, p);
Assert.Equal(connectionStrings, cs);
Assert.False(skipAppData);
Assert.False(doNotDelete);
published = true;
});
Mock<ICommandRuntime> powerShellMock = new Mock<ICommandRuntime>();
var command = new PublishAzureWebsiteProject()
{
CommandRuntime = powerShellMock.Object,
WebsitesClient = clientMock.Object,
Name = websiteName,
ProjectFile = projectFile,
Configuration = configuration,
ConnectionString = connectionStrings
};
command.ExecuteCmdlet();
powerShellMock.Verify(f => f.WriteVerbose(string.Format("[Complete] Publishing package {0}", package)), Times.Once());
Assert.True(published);
}
public void DisableRemoteDesktopForEmptyService()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
disableRDCmdlet.DisableRemoteDesktop();
}
}
public void NewAzureServiceWithInvalidNames()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
foreach (string name in Test.Utilities.Common.Data.InvalidServiceNames)
{
cmdlet.ServiceName = name;
Testing.AssertThrows<ArgumentException>(() => cmdlet.ExecuteCmdlet());
}
}
}
public void CreateLocalPackageWithPHPWorkerRoleTest()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
service.AddWorkerRole(Test.Utilities.Common.Data.PHPWorkerRoleScaffoldingPath);
service.CreatePackage(DevEnv.Local);
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WorkerRole1\approot"), Path.Combine(Resources.PHPScaffolding, Resources.WorkerRole));
}
}
public void NewAzureRoleTemplateWithOutputPath()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string outputPath = files.RootPath;
addTemplateCmdlet = new NewAzureRoleTemplateCommand() { Worker = true, CommandRuntime = mockCommandRuntime, Output = outputPath };
addTemplateCmdlet.ExecuteCmdlet();
Assert.Equal<string>(outputPath, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue<string>(Parameters.Path));
Testing.AssertDirectoryIdentical(Path.Combine(Resources.GeneralScaffolding, RoleType.WorkerRole.ToString()), outputPath);
}
}
public void DisableRemoteDesktopForWebAndWorkerRoles()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string rootPath = files.CreateNewService("NEW_SERVICE");
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WebRole" };
addNodeWebCmdlet.ExecuteCmdlet();
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WorkerRole" };
addNodeWorkerCmdlet.ExecuteCmdlet();
disableRDCmdlet.DisableRemoteDesktop();
}
}
public void SetAzureServiceProjectTestsLocationEmptyFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Create new empty settings file
//
PowerShellProjectPathInfo paths = new PowerShellProjectPathInfo(files.RootPath);
ServiceSettings settings = new ServiceSettings();
settings.Save(paths.Settings);
Testing.AssertThrows<ArgumentException>(() => setServiceProjectCmdlet.SetAzureServiceProjectProcess(string.Empty, null, null, paths.Settings), string.Format(Resources.InvalidOrEmptyArgumentMessage, "Location"));
}
}
public void AddAzurePythonWebRoleProcess()
{
var pyInstall = AddAzureDjangoWebRoleCommand.FindPythonInterpreterPath();
if (pyInstall == null)
{
Assert.True(false, "Python is not installed on this machine and therefore the Python tests cannot be run");
return;
}
string stdOut, stdErr;
ProcessHelper.StartAndWaitForProcess(
new ProcessStartInfo(
Path.Combine(pyInstall, "python.exe"),
string.Format("-m django.bin.django-admin")
),
out stdOut,
out stdErr
);
if (stdOut.IndexOf("django-admin.py") == -1)
{
Assert.True(false, "Django is not installed on this machine and therefore the Python tests cannot be run. Please 'pip install Django==1.5'");
return;
}
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WebRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
addPythonWebCmdlet = new AddAzureDjangoWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime };
addPythonWebCmdlet.CommandRuntime = mockCommandRuntime;
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreatePython, rootPath, roleName);
mockCommandRuntime.ResetPipelines();
addPythonWebCmdlet.ExecuteCmdlet();
AzureAssert.ScaffoldingExists(Path.Combine(rootPath, roleName), Path.Combine(Resources.PythonScaffolding, Resources.WebRole));
Assert.Equal<string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue<string>(Parameters.RoleName));
Assert.Equal<string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
Assert.True(Directory.Exists(Path.Combine(rootPath, roleName, roleName)));
Assert.True(File.Exists(Path.Combine(rootPath, roleName, roleName, "manage.py")));
Assert.True(Directory.Exists(Path.Combine(rootPath, roleName, roleName, roleName)));
Assert.True(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "__init__.py")));
Assert.True(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "settings.py")));
Assert.True(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "urls.py")));
Assert.True(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "wsgi.py")));
}
}
public void AddNewCacheWorkerRoleDoesNotHaveAnyRuntime()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string rootPath = Path.Combine(files.RootPath, "AzureService");
string roleName = "WorkerRole";
int expectedInstanceCount = 10;
newServiceCmdlet.NewAzureServiceProcess(files.RootPath, "AzureService");
WorkerRole cacheWorkerRole = addCacheRoleCmdlet.AddAzureCacheWorkerRoleProcess(roleName, expectedInstanceCount, rootPath);
Variable runtimeId = Array.Find<Variable>(cacheWorkerRole.Startup.Task[0].Environment, v => v.name.Equals(Resources.RuntimeTypeKey));
Assert.Equal<string>(string.Empty, runtimeId.value);
}
}
public void InvalidStorageAccountName()
{
// Create a temp directory that we'll use to "publish" our service
using (FileSystemHelper files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Import our default publish settings
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string serviceName = null;
Testing.AssertThrows<ArgumentException>(() =>
ServiceSettings.LoadDefault(null, null, null, null, null, "I HAVE INVALID CHARACTERS !@#$%", null, null, out serviceName));
Testing.AssertThrows<ArgumentException>(() =>
ServiceSettings.LoadDefault(null, null, null, null, null, "ihavevalidcharsbutimjustwaytooooooooooooooooooooooooooooooooooooooooolong", null, null, out serviceName));
}
}
public void SanitizeServiceNameForStorageAccountName()
{
// Create a temp directory that we'll use to "publish" our service
using (FileSystemHelper files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Import our default publish settings
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string serviceName = null;
ServiceSettings settings = ServiceSettings.LoadDefault(null, null, null, null, null, null, "My-Custom-Service!", null, out serviceName);
Assert.Equal("myx2dcustomx2dservicex21", settings.StorageServiceName);
settings = ServiceSettings.LoadDefault(null, null, null, null, null, null, "MyCustomServiceIsWayTooooooooooooooooooooooooLong", null, out serviceName);
Assert.Equal("mycustomserviceiswaytooo", settings.StorageServiceName);
}
}
public void TestGetRuntimes()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string manifest = RuntimePackageHelper.GetTestManifest(files);
CloudRuntimeCollection runtimes;
CloudRuntimeCollection.CreateCloudRuntimeCollection(out runtimes, manifest);
cmdlet.GetAzureRuntimesProcess(string.Empty, manifest);
IEnumerable<CloudRuntimePackage> actual = System.Management.Automation.LanguagePrimitives.GetEnumerable( mockCommandRuntime.OutputPipeline).Cast<CloudRuntimePackage>();
Assert.Equal<int>(runtimes.Count, actual.Count());
Assert.True(runtimes.All<CloudRuntimePackage>(p => actual.Any<CloudRuntimePackage>(p2 => p2.PackageUri.Equals(p.PackageUri))));
}
}
public void TestStartAzureService()
{
stopServiceCmdlet.ServiceName = serviceName;
stopServiceCmdlet.Slot = slot;
cloudServiceClientMock.Setup(f => f.StartCloudService(serviceName, slot));
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
stopServiceCmdlet.ExecuteCmdlet();
Assert.Equal<int>(0, mockCommandRuntime.OutputPipeline.Count);
cloudServiceClientMock.Verify(f => f.StartCloudService(serviceName, slot), Times.Once());
}
}
public void TestGetRuntimes()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string manifest = RuntimePackageHelper.GetTestManifest(files);
CloudRuntimeCollection runtimes;
CloudRuntimeCollection.CreateCloudRuntimeCollection(out runtimes, manifest);
cmdlet.GetAzureRuntimesProcess(string.Empty, manifest);
List<CloudRuntimePackage> actual = mockCommandRuntime.OutputPipeline[0] as List<CloudRuntimePackage>;
Assert.Equal<int>(runtimes.Count, actual.Count);
Assert.True(runtimes.All<CloudRuntimePackage>(p => actual.Any<CloudRuntimePackage>(p2 => p2.PackageUri.Equals(p.PackageUri))));
}
}
public void AddAzureNodeWorkerRoleProcess()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WorkerRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime };
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreateNode, rootPath, roleName);
addNodeWorkerCmdlet.ExecuteCmdlet();
AzureAssert.ScaffoldingExists(Path.Combine(rootPath, roleName), Path.Combine(Resources.NodeScaffolding, Resources.WorkerRole));
Assert.Equal<string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue<string>(Parameters.RoleName));
Assert.Equal<string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
}
}
public void TestCreatePackageWithEmptyServiceSuccessfull()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
string rootPath = Path.Combine(files.RootPath, "NEW_SERVICE");
string packagePath = Path.Combine(rootPath, Resources.CloudPackageFileName);
cmdlet.ExecuteCmdlet();
PSObject obj = mockCommandRuntime.OutputPipeline[0] as PSObject;
Assert.Equal<string>(string.Format(Resources.PackageCreated, packagePath), mockCommandRuntime.VerboseStream[0]);
Assert.Equal<string>(packagePath, obj.GetVariableValue<string>(Parameters.PackagePath));
Assert.True(File.Exists(packagePath));
}
}
public void CreateLocalPackageWithOnePHPWebRoleTest()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
RoleInfo webRoleInfo = service.AddWebRole(Test.Utilities.Common.Data.PHPWebRoleScaffoldingPath);
string logsDir = Path.Combine(service.Paths.RootPath, webRoleInfo.Name, "server.js.logs");
string logFile = Path.Combine(logsDir, "0.txt");
string targetLogsFile = Path.Combine(service.Paths.LocalPackage, "roles", webRoleInfo.Name, @"approot\server.js.logs\0.txt");
files.CreateDirectory(logsDir);
files.CreateEmptyFile(logFile);
service.CreatePackage(DevEnv.Local);
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WebRole1\approot"), Path.Combine(Resources.PHPScaffolding, Resources.WebRole));
Assert.True(File.Exists(targetLogsFile));
}
}
public void CreateCloudPackageWithMultipleRoles()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
service.AddWorkerRole(Test.Utilities.Common.Data.NodeWorkerRoleScaffoldingPath);
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
service.AddWorkerRole(Test.Utilities.Common.Data.PHPWorkerRoleScaffoldingPath);
service.AddWebRole(Test.Utilities.Common.Data.PHPWebRoleScaffoldingPath);
service.CreatePackage(DevEnv.Cloud);
using (Package package = Package.Open(service.Paths.CloudPackage))
{
Assert.Equal(9, package.GetParts().Count());
}
}
}
public void SetAzureVMSizeProcessTestsNode()
{
string newRoleVMSize = "Large";
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
string roleName = "WebRole1";
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
cmdlet.PassThru = false;
RoleSettings roleSettings = cmdlet.SetAzureVMSizeProcess("WebRole1", newRoleVMSize, service.Paths.RootPath);
service = new CloudServiceProject(service.Paths.RootPath, null);
Assert.Equal<string>(newRoleVMSize, service.Components.Definition.WebRole[0].vmsize.ToString());
Assert.Equal<int>(0, mockCommandRuntime.OutputPipeline.Count);
Assert.Equal<string>(roleName, roleSettings.name);
}
}
public void TestSetAzureRuntimeValidRuntimeVersions()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
string roleName = "WebRole1";
cmdlet.PassThru = false;
RoleSettings roleSettings1 = cmdlet.SetAzureRuntimesProcess(roleName, "node", "0.8.2", service.Paths.RootPath, RuntimePackageHelper.GetTestManifest(files));
RoleSettings roleSettings2 = cmdlet.SetAzureRuntimesProcess(roleName, "iisnode", "0.1.21", service.Paths.RootPath, RuntimePackageHelper.GetTestManifest(files));
VerifyPackageJsonVersion(service.Paths.RootPath, roleName, "node", "0.8.2");
VerifyPackageJsonVersion(service.Paths.RootPath, roleName, "iisnode", "0.1.21");
Assert.Equal<int>(0, mockCommandRuntime.OutputPipeline.Count);
Assert.Equal<string>(roleName, roleSettings1.name);
Assert.Equal<string>(roleName, roleSettings2.name);
}
}
public void SetAzureVMSizeProcessTestsPHP()
{
string newRoleVMSize = "Medium";
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
string roleName = "WebRole1";
service.AddWebRole(Test.Utilities.Common.Data.PHPWebRoleScaffoldingPath);
RoleSettings roleSettings = cmdlet.SetAzureVMSizeProcess("WebRole1", newRoleVMSize, service.Paths.RootPath);
service = new CloudServiceProject(service.Paths.RootPath, null);
Assert.Equal<string>(newRoleVMSize, service.Components.Definition.WebRole[0].vmsize.ToString());
Assert.Equal<string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).Members[Parameters.RoleName].Value.ToString());
Assert.True(((PSObject)mockCommandRuntime.OutputPipeline[0]).TypeNames.Contains(typeof(RoleSettings).FullName));
Assert.Equal<string>(roleName, roleSettings.name);
}
}
public void TestCreatePackageSuccessfull()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
string rootPath = Path.Combine(files.RootPath, "NEW_SERVICE");
string packagePath = Path.Combine(rootPath, Resources.CloudPackageFileName);
CloudServiceProject service = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
cmdlet.ExecuteCmdlet();
PSObject obj = mockCommandRuntime.OutputPipeline[0] as PSObject;
Assert.Equal<string>(string.Format(Resources.PackageCreated, packagePath), mockCommandRuntime.VerboseStream[0]);
Assert.Equal<string>(packagePath, obj.GetVariableValue<string>(Parameters.PackagePath));
Assert.True(File.Exists(packagePath));
}
}
public void EnableAzureMemcacheRoleProcess()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string cacheRoleName = "WorkerRole";
string webRoleName = "WebRole";
string expectedMessage = string.Format(Resources.EnableMemcacheMessage, webRoleName, cacheRoleName, Resources.MemcacheEndpointPort);
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = webRoleName };
addNodeWebCmdlet.ExecuteCmdlet();
addCacheRoleCmdlet.AddAzureCacheWorkerRoleProcess(cacheRoleName, 1, rootPath);
mockCommandRuntime.ResetPipelines();
enableCacheCmdlet.PassThru = true;
enableCacheCmdlet.CacheRuntimeVersion = "2.4.0";
enableCacheCmdlet.EnableAzureMemcacheRoleProcess(webRoleName, cacheRoleName, rootPath);
AssertCachingEnabled(files, serviceName, rootPath, webRoleName, expectedMessage);
}
}
public void SetAzureInstancesProcessTestsNode()
{
int newRoleInstances = 10;
using (FileSystemHelper files = new FileSystemHelper(this))
{
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
string roleName = "WebRole1";
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
cmdlet.PassThru = false;
RoleSettings roleSettings = cmdlet.SetAzureInstancesProcess("WebRole1", newRoleInstances, service.Paths.RootPath);
service = new CloudServiceProject(service.Paths.RootPath, null);
Assert.Equal<int>(newRoleInstances, service.Components.CloudConfig.Role[0].Instances.count);
Assert.Equal<int>(newRoleInstances, service.Components.LocalConfig.Role[0].Instances.count);
Assert.Equal<int>(0, mockCommandRuntime.OutputPipeline.Count);
Assert.Equal<int>(newRoleInstances, roleSettings.Instances.count);
Assert.Equal<string>(roleName, roleSettings.name);
}
}
public CacheTests()
{
helper = new FileSystemHelper(this);
helper.CreateAzureSdkDirectoryAndImportPublishSettings();
WebSpacesFile = Path.Combine(AzurePowerShell.ProfileDirectory,
string.Format("spaces.{0}.json", SubscriptionName));
SitesFile = Path.Combine(AzurePowerShell.ProfileDirectory,
string.Format("sites.{0}.json", SubscriptionName));
if (File.Exists(WebSpacesFile))
{
File.Delete(WebSpacesFile);
}
if (File.Exists(SitesFile))
{
File.Delete(SitesFile);
}
}
public void ParseTests()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string path = files.CreateEmptyFile("Scaffold.xml");
FileUtilities.DataStore.WriteFile(path, Resources.ValidScaffoldXml);
Scaffold scaffold = Scaffold.Parse(path);
Assert.Equal(scaffold.Files.Count, 6);
Assert.Equal(scaffold.Files[0].PathExpression, "modules\\.*");
Assert.Equal(scaffold.Files[1].Path, @"bin/node123dfx65.exe");
Assert.Equal(scaffold.Files[1].TargetPath, @"/bin/node.exe");
Assert.Equal(scaffold.Files[2].Path, @"bin/iisnode.dll");
Assert.Equal(scaffold.Files[3].Path, @"bin/setup.cmd");
Assert.Equal(scaffold.Files[4].Path, "Web.config");
Assert.Equal(scaffold.Files[4].Rules.Count, 1);
Assert.Equal(scaffold.Files[5].Path, "WebRole.xml");
Assert.Equal(scaffold.Files[5].Copy, false);
Assert.Equal(scaffold.Files[5].Rules.Count, 1);
}
}
public void NewAzureServiceSuccessfull()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
// Setup
string expectedName = "test";
string expectedRootPath = Path.Combine(files.RootPath, expectedName);
string expectedServiceCreatedMessage = string.Format(Resources.NewServiceCreatedMessage, expectedRootPath);
cmdlet.ServiceName = expectedName;
// Test
cmdlet.NewAzureServiceProcess(files.RootPath, expectedName);
// Assert
PSObject actualPSObject = mockCommandRuntime.OutputPipeline[0] as PSObject;
string actualServiceCreatedMessage = mockCommandRuntime.VerboseStream[0];
Assert.Equal<string>(expectedName, actualPSObject.Members[Parameters.ServiceName].Value.ToString());
Assert.Equal<string>(expectedRootPath, actualPSObject.Members[Parameters.RootPath].Value.ToString());
Assert.Equal<string>(expectedServiceCreatedMessage, actualServiceCreatedMessage);
AzureAssert.AzureServiceExists(expectedRootPath, Resources.GeneralScaffolding, expectedName);
}
}
public void AddAzureWorkerRoleWithTemplateFolder()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WorkerRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreate, rootPath, roleName);
string scaffoldingPath = "MyWorkerTemplateFolder";
using (new DirStack(rootPath))
{
addWorkerCmdlet = new AddAzureWorkerRoleCommand()
{
RootPath = rootPath,
CommandRuntime = mockCommandRuntime,
Name = roleName,
TemplateFolder = scaffoldingPath
};
addWorkerCmdlet.ExecuteCmdlet();
AzureAssert.ScaffoldingExists(Path.Combine(rootPath, roleName), scaffoldingPath);
Assert.Equal<string>(roleName,
((PSObject) mockCommandRuntime.OutputPipeline[0]).GetVariableValue<string>(Parameters.RoleName));
Assert.Equal<string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
}
}
}