public void AddAzurePythonWebRoleWillRecreateDeploymentSettings()
{
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);
string settingsFilePath = Path.Combine(rootPath, Resources.SettingsFileName);
File.Delete(settingsFilePath);
Assert.IsFalse(File.Exists(settingsFilePath));
addPythonWebCmdlet.ExecuteCmdlet();
AzureAssert.ScaffoldingExists(Path.Combine(rootPath, roleName), Path.Combine(Resources.PythonScaffolding, Resources.WebRole));
Assert.AreEqual <string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue <string>(Parameters.RoleName));
Assert.AreEqual <string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
Assert.IsTrue(File.Exists(settingsFilePath));
}
}
public void AddNewCacheWorkerRoleSuccessful()
{
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);
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, "AzureService", "WorkerRole"), Path.Combine(Resources.GeneralScaffolding, Resources.WorkerRole));
AzureAssert.WorkerRoleImportsExists(new Import {
moduleName = Resources.CachingModuleName
}, cacheWorkerRole);
AzureAssert.LocalResourcesLocalStoreExists(new LocalStore {
name = Resources.CacheDiagnosticStoreName, cleanOnRoleRecycle = false
},
cacheWorkerRole.LocalResources);
Assert.IsNull(cacheWorkerRole.Endpoints.InputEndpoint);
AssertConfigExists(Testing.GetCloudRole(rootPath, roleName));
AssertConfigExists(Testing.GetLocalRole(rootPath, roleName), Resources.EmulatorConnectionString);
PSObject actualOutput = mockCommandRuntime.OutputPipeline[1] as PSObject;
Assert.AreEqual <string>(roleName, actualOutput.Members[Parameters.CacheWorkerRoleName].Value.ToString());
Assert.AreEqual <int>(expectedInstanceCount, int.Parse(actualOutput.Members[Parameters.Instances].Value.ToString()));
}
}
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]);
}
}
}
public void EnableAzureMemcacheRoleProcessOnWorkerRoleSuccess()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string cacheRoleName = "CacheWorkerRole";
string workerRoleName = "WorkerRole";
string expectedMessage = string.Format(Resources.EnableMemcacheMessage, workerRoleName, cacheRoleName, Resources.MemcacheEndpointPort);
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand()
{
RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = workerRoleName
};
addNodeWorkerCmdlet.ExecuteCmdlet();
addCacheRoleCmdlet.AddAzureCacheWorkerRoleProcess(cacheRoleName, 1, rootPath);
mockCommandRuntime.ResetPipelines();
enableCacheCmdlet.PassThru = true;
enableCacheCmdlet.EnableAzureMemcacheRoleProcess(workerRoleName, cacheRoleName, rootPath);
WorkerRole workerRole = Testing.GetWorkerRole(rootPath, workerRoleName);
AzureAssert.RuntimeUrlAndIdExists(workerRole.Startup.Task, Resources.CacheRuntimeValue);
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, serviceName, workerRoleName), Path.Combine(Resources.CacheScaffolding, Resources.WorkerRole));
AzureAssert.StartupTaskExists(workerRole.Startup.Task, Resources.CacheStartupCommand);
AzureAssert.InternalEndpointExists(workerRole.Endpoints.InternalEndpoint,
new InternalEndpoint {
name = Resources.MemcacheEndpointName, protocol = InternalProtocol.tcp, port = Resources.MemcacheEndpointPort
});
LocalStore localStore = new LocalStore
{
name = Resources.CacheDiagnosticStoreName,
cleanOnRoleRecycle = false
};
AzureAssert.LocalResourcesLocalStoreExists(localStore, workerRole.LocalResources);
DefinitionConfigurationSetting diagnosticLevel = new DefinitionConfigurationSetting {
name = Resources.CacheClientDiagnosticLevelAssemblyName
};
AzureAssert.ConfigurationSettingExist(diagnosticLevel, workerRole.ConfigurationSettings);
ConfigConfigurationSetting clientDiagnosticLevel = new ConfigConfigurationSetting {
name = Resources.ClientDiagnosticLevelName, value = Resources.ClientDiagnosticLevelValue
};
AzureAssert.ConfigurationSettingExist(clientDiagnosticLevel, Testing.GetCloudRole(rootPath, workerRoleName).ConfigurationSettings);
AzureAssert.ConfigurationSettingExist(clientDiagnosticLevel, Testing.GetLocalRole(rootPath, workerRoleName).ConfigurationSettings);
string workerConfigPath = string.Format(@"{0}\{1}\{2}", rootPath, workerRoleName, "web.config");
string workerCloudConfig = File.ReadAllText(workerConfigPath);
Assert.IsTrue(workerCloudConfig.Contains("configSections"));
Assert.IsTrue(workerCloudConfig.Contains("dataCacheClients"));
Assert.AreEqual <string>(expectedMessage, mockCommandRuntime.VerboseStream[0]);
Assert.AreEqual <string>(workerRoleName, (mockCommandRuntime.OutputPipeline[0] as PSObject).GetVariableValue <string>(Parameters.RoleName));
}
}
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 AddAzureWebRoleWithTemplateFolder()
{
string scaffoldingPath = "MyWebTemplateFolder";
Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, scaffoldingPath));
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WebRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreate, rootPath, roleName);
string originalDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(rootPath);
addWebCmdlet = new AddAzureWebRoleCommand()
{
RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = roleName, TemplateFolder = scaffoldingPath
};
addWebCmdlet.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]);
Directory.SetCurrentDirectory(originalDirectory);
}
}
public void SavePackageWithOneNodeWebRoleTest()
{
//Create a temp directory for monitoring and cleaning up the output of our test
using (FileSystemHelper files = new FileSystemHelper(this)
{
EnableMonitoring = true
})
{
//Create a new service that we're going to pack locally
string serviceName = "TEST_SERVICE_NAME";
NewAzureServiceCommand newService = new NewAzureServiceCommand();
newService.NewAzureServiceProcess(files.RootPath, serviceName);
string servicePath = files.CreateDirectory(serviceName);
//Add a Node web role to the solution
string roleName = "TEST_WEB_ROLE";
int instanceCount = 2;
AddAzureNodeWebRoleCommand addAzureNodeWebRole = new AddAzureNodeWebRoleCommand();
addAzureNodeWebRole.AddAzureNodeWebRoleProcess(roleName, instanceCount, servicePath);
//Run our packaging command
SaveAzureServicePackageCommand saveServicePackage = new SaveAzureServicePackageCommand();
saveServicePackage.CreatePackage(servicePath);
//Assert that the service structure is as expected
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, serviceName, roleName), Path.Combine(Resources.NodeScaffolding, Resources.WebRole));
// Verify the generated files
files.AssertFiles(new Dictionary <string, Action <string> >()
{
{
serviceName + @"\deploymentSettings.json",
null
},
{
serviceName + @"\ServiceDefinition.csdef",
p => File.ReadAllText(p).Contains(serviceName)
},
{
serviceName + @"\ServiceConfiguration.Cloud.cscfg",
p => File.ReadAllText(p).Contains(serviceName)
},
{
serviceName + @"\ServiceConfiguration.Local.cscfg",
p => File.ReadAllText(p).Contains(serviceName)
},
{
serviceName + @"\cloud_package.cspkg",
p =>
{
using (Package package = Package.Open(p))
{
Assert.AreEqual(6, package.GetParts().Count());
}
}
}
});
}
}
private void AssertCachingEnabled(
FileSystemHelper files,
string serviceName,
string rootPath,
string webRoleName,
string expectedMessage)
{
WebRole webRole = Testing.GetWebRole(rootPath, webRoleName);
RoleSettings roleSettings = Testing.GetCloudRole(rootPath, webRoleName);
AzureAssert.RuntimeUrlAndIdExists(webRole.Startup.Task, Resources.CacheRuntimeValue);
Assert.AreEqual <string>(Resources.CacheRuntimeVersionKey, webRole.Startup.Task[0].Environment[0].name);
Assert.AreEqual <string>(enableCacheCmdlet.CacheRuntimeVersion, webRole.Startup.Task[0].Environment[0].value);
Assert.AreEqual <string>(Resources.EmulatedKey, webRole.Startup.Task[2].Environment[0].name);
Assert.AreEqual <string>("/RoleEnvironment/Deployment/@emulated", webRole.Startup.Task[2].Environment[0].RoleInstanceValue.xpath);
Assert.AreEqual <string>(Resources.CacheRuntimeUrl, webRole.Startup.Task[2].Environment[1].name);
Assert.AreEqual <string>(TestResources.CacheRuntimeUrl, webRole.Startup.Task[2].Environment[1].value);
Assert.AreEqual(1, webRole.Startup.Task.Count(t => t.commandLine.Equals(Resources.CacheStartupCommand)));
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, serviceName, webRoleName), Path.Combine(Resources.CacheScaffolding, Resources.WebRole));
AzureAssert.StartupTaskExists(webRole.Startup.Task, Resources.CacheStartupCommand);
AzureAssert.InternalEndpointExists(webRole.Endpoints.InternalEndpoint,
new InternalEndpoint {
name = Resources.MemcacheEndpointName, protocol = InternalProtocol.tcp, port = Resources.MemcacheEndpointPort
});
LocalStore localStore = new LocalStore
{
name = Resources.CacheDiagnosticStoreName,
cleanOnRoleRecycle = false
};
AzureAssert.LocalResourcesLocalStoreExists(localStore, webRole.LocalResources);
DefinitionConfigurationSetting diagnosticLevel = new DefinitionConfigurationSetting {
name = Resources.CacheClientDiagnosticLevelAssemblyName
};
AzureAssert.ConfigurationSettingExist(diagnosticLevel, webRole.ConfigurationSettings);
ConfigConfigurationSetting clientDiagnosticLevel = new ConfigConfigurationSetting {
name = Resources.ClientDiagnosticLevelName, value = Resources.ClientDiagnosticLevelValue
};
AzureAssert.ConfigurationSettingExist(clientDiagnosticLevel, roleSettings.ConfigurationSettings);
AssertWebConfig(string.Format(@"{0}\{1}\{2}", rootPath, webRoleName, Resources.WebCloudConfig));
AssertWebConfig(string.Format(@"{0}\{1}\{2}", rootPath, webRoleName, Resources.WebConfigTemplateFileName));
Assert.AreEqual <string>(expectedMessage, mockCommandRuntime.VerboseStream[0]);
Assert.AreEqual <string>(webRoleName, (mockCommandRuntime.OutputPipeline[0] as PSObject).GetVariableValue <string>(Parameters.RoleName));
}
public void AddAzureNodeWorkerRoleProcess()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
new NewAzureServiceProjectCommand().NewAzureServiceProcess(files.RootPath, "AzureService");
new AddAzureNodeWorkerRoleCommand().AddAzureNodeWorkerRoleProcess("WorkerRole", 1, Path.Combine(files.RootPath, "AzureService"));
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, "AzureService", "WorkerRole"), Path.Combine(Resources.NodeScaffolding, Resources.WorkerRole));
}
}
public void AddAzurePythonWebRoleProcess()
{
var pyInstall = AddAzureDjangoWebRoleCommand.FindPythonInterpreterPath();
if (pyInstall == null)
{
Assert.Inconclusive("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.Inconclusive("Django is not installed on this machine and therefore the Python tests cannot be run");
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.AreEqual <string>(roleName, ((PSObject)mockCommandRuntime.OutputPipeline[0]).GetVariableValue <string>(Parameters.RoleName));
Assert.AreEqual <string>(expectedVerboseMessage, mockCommandRuntime.VerboseStream[0]);
Assert.IsTrue(Directory.Exists(Path.Combine(rootPath, roleName, roleName)));
Assert.IsTrue(File.Exists(Path.Combine(rootPath, roleName, roleName, "manage.py")));
Assert.IsTrue(Directory.Exists(Path.Combine(rootPath, roleName, roleName, roleName)));
Assert.IsTrue(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "__init__.py")));
Assert.IsTrue(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "settings.py")));
Assert.IsTrue(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "urls.py")));
Assert.IsTrue(File.Exists(Path.Combine(rootPath, roleName, roleName, roleName, "wsgi.py")));
}
}
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 CreateLocalPackageWithWorkerRoleTest()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string standardOutput;
string standardError;
AzureService service = new AzureService(files.RootPath, serviceName, null);
service.AddWorkerRole();
service.CreatePackage(DevEnv.Local, out standardOutput, out standardError);
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WorkerRole1\approot"), Path.Combine(Resources.NodeScaffolding, Resources.WorkerRole));
}
}
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 AddAzureWorkerRoleProcess()
{
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);
TestMockSupport.TestExecutionFolder = rootPath;
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]);
}
}
public void AddAzureNodeWebRoleProcess()
{
var pyInstall = AddAzureDjangoWebRoleCommand.FindPythonInterpreterPath();
if (pyInstall == null)
{
Assert.Inconclusive("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.Inconclusive("Django is not installed on this machine and therefore the Python tests cannot be run");
return;
}
using (FileSystemHelper files = new FileSystemHelper(this))
{
var curDir = Environment.CurrentDirectory;
try
{
new NewAzureServiceProjectCommand().NewAzureServiceProcess(files.RootPath, "AzureService");
new AddAzureDjangoWebRoleCommand().AddAzureDjangoWebRoleProcess("WebRole", 1, Path.Combine(files.RootPath, "AzureService"));
}
finally
{
Environment.CurrentDirectory = curDir;
}
AzureAssert.ScaffoldingExists(Path.Combine(files.RootPath, "AzureService", "WebRole"), Path.Combine(Resources.PythonScaffolding, Resources.WebRole));
}
}
public void CreateLocalPackageWithOneWebRoleTest()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string standardOutput;
string standardError;
AzureService service = new AzureService(files.RootPath, serviceName, null);
RoleInfo webRoleInfo = service.AddWebRole();
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, out standardOutput, out standardError);
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WebRole1\approot"), Path.Combine(Resources.NodeScaffolding, Resources.WebRole));
Assert.IsTrue(File.Exists(targetLogsFile));
}
}
public void CreateLocalPackageWithMultipleRoles()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string standardOutput;
string standardError;
CloudServiceProject service = new CloudServiceProject(files.RootPath, serviceName, null);
service.AddWorkerRole(Data.NodeWorkerRoleScaffoldingPath);
service.AddWebRole(Data.NodeWebRoleScaffoldingPath);
service.AddWorkerRole(Data.PHPWorkerRoleScaffoldingPath);
service.AddWebRole(Data.PHPWebRoleScaffoldingPath);
service.CreatePackage(DevEnv.Local, out standardOutput, out standardError);
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WorkerRole1\approot"), Path.Combine(Resources.NodeScaffolding, Resources.WorkerRole));
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WebRole1\approot"), Path.Combine(Resources.NodeScaffolding, Resources.WebRole));
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WorkerRole2\approot"), Path.Combine(Resources.PHPScaffolding, Resources.WorkerRole));
AzureAssert.ScaffoldingExists(Path.Combine(service.Paths.LocalPackage, @"roles\WebRole2\approot"), Path.Combine(Resources.PHPScaffolding, Resources.WebRole));
}
}