| public CreateNewService ( string serviceName ) : string | ||
| serviceName | string | Name of the service. |
| return | string | |
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 DisableRemoteDesktopForEmptyService()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
disableRDCmdlet.DisableRemoteDesktop();
}
}
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 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 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 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 = AzureAssert.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, AzureAssert.GetCloudRole(rootPath, workerRoleName).ConfigurationSettings);
AzureAssert.ConfigurationSettingExist(clientDiagnosticLevel, AzureAssert.GetLocalRole(rootPath, workerRoleName).ConfigurationSettings);
string workerConfigPath = string.Format(@"{0}\{1}\{2}", rootPath, workerRoleName, "web.config");
string workerCloudConfig = File.ReadAllText(workerConfigPath);
Assert.True(workerCloudConfig.Contains("configSections"));
Assert.True(workerCloudConfig.Contains("dataCacheClients"));
Assert.Equal<string>(expectedMessage, mockCommandRuntime.VerboseStream[0]);
Assert.Equal<string>(workerRoleName, (mockCommandRuntime.OutputPipeline[0] as PSObject).GetVariableValue<string>(Parameters.RoleName));
}
}
public void EnableAzureMemcacheRoleProcessOnCacheWorkerRoleFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string cacheRoleName = "WorkerRole";
string expected = string.Format(Resources.InvalidCacheRoleName, cacheRoleName);
addCacheRoleCmdlet.AddAzureCacheWorkerRoleProcess(cacheRoleName, 1, rootPath);
Testing.AssertThrows<Exception>(() => enableCacheCmdlet.EnableAzureMemcacheRoleProcess(cacheRoleName, cacheRoleName, rootPath));
}
}
public void EnableAzureMemcacheWithNoCacheWorkerRolesFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string webRoleName = "WebRole";
string expectedMessage = string.Format(Resources.NoCacheWorkerRoles);
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = webRoleName };
addNodeWebCmdlet.ExecuteCmdlet();
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WorkerRole" };
addNodeWorkerCmdlet.ExecuteCmdlet();
mockCommandRuntime.ResetPipelines();
enableCacheCmdlet.PassThru = true;
enableCacheCmdlet.CacheRuntimeVersion = "2.4.0";
Testing.AssertThrows<Exception>(() => enableCacheCmdlet.EnableAzureMemcacheRoleProcess(webRoleName, null, rootPath), expectedMessage);
}
}
public void EnableRemoteDesktopUnicode()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string rootPath = files.CreateNewService("NEW_SERVICE");
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand()
{
RootPath = rootPath,
CommandRuntime = mockCommandRuntime,
Name = "WebRole",
Instances = 1
};
addNodeWebCmdlet.ExecuteCmdlet();
EnableRemoteDesktop("㯑䲘䄂㮉", "㯑䲘䄂㮉㮉㮉㮉L");
// Verify the role has been setup with forwarding, access,
// and certs
CloudServiceProject service = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
VerifyWebRole(service.Components.Definition.WebRole[0], true);
VerifyRoleSettings(service);
}
}
public void EnableAzureMemcacheRoleProcessUsingNonCacheWorkerRole()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
string workerRoleName = "WorkerRole";
string webRoleName = "WebRole";
string expected = string.Format(Resources.NotCacheWorkerRole, workerRoleName);
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = webRoleName };
addNodeWebCmdlet.ExecuteCmdlet();
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = workerRoleName };
addNodeWorkerCmdlet.ExecuteCmdlet();
Testing.AssertThrows<Exception>(() => enableCacheCmdlet.EnableAzureMemcacheRoleProcess(webRoleName, workerRoleName, rootPath));
}
}
public void EnableRemoteDesktopBasicParameterValidation()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop(null, null));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop(string.Empty, string.Empty));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", null));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", string.Empty));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", "short"));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", "onlylower"));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", "ONLYUPPER"));
Testing.AssertThrows<ArgumentException>(
() => EnableRemoteDesktop("user", "1234567890"));
}
}
public void TestResolveRuntimePackageUrls()
{
// 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();
// Create a new service that we're going to publish
string serviceName = "TEST_SERVICE_NAME";
string rootPath = files.CreateNewService(serviceName);
// Add web and worker roles
string defaultWebRoleName = "WebRoleDefault";
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = defaultWebRoleName, Instances = 2 };
addNodeWebCmdlet.ExecuteCmdlet();
string defaultWorkerRoleName = "WorkerRoleDefault";
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = defaultWorkerRoleName, Instances = 2 };
addNodeWorkerCmdlet.ExecuteCmdlet();
AddAzureNodeWebRoleCommand matchWebRole = addNodeWebCmdlet;
string matchWebRoleName = "WebRoleExactMatch";
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = matchWebRoleName, Instances = 2 };
addNodeWebCmdlet.ExecuteCmdlet();
AddAzureNodeWorkerRoleCommand matchWorkerRole = addNodeWorkerCmdlet;
string matchWorkerRoleName = "WorkerRoleExactMatch";
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = matchWorkerRoleName, Instances = 2 };
addNodeWorkerCmdlet.ExecuteCmdlet();
AddAzureNodeWebRoleCommand overrideWebRole = addNodeWebCmdlet;
string overrideWebRoleName = "WebRoleOverride";
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = overrideWebRoleName, Instances = 2 };
addNodeWebCmdlet.ExecuteCmdlet();
AddAzureNodeWorkerRoleCommand overrideWorkerRole = addNodeWorkerCmdlet;
string overrideWorkerRoleName = "WorkerRoleOverride";
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = overrideWorkerRoleName, Instances = 2 };
addNodeWorkerCmdlet.ExecuteCmdlet();
string webRole2Name = "WebRole2";
AddAzureNodeWebRoleCommand addAzureWebRole = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = webRole2Name };
addAzureWebRole.ExecuteCmdlet();
CloudServiceProject testService = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
RuntimePackageHelper.SetRoleRuntime(testService.Components.Definition, matchWebRoleName, testService.Paths, version: "0.8.2");
RuntimePackageHelper.SetRoleRuntime(testService.Components.Definition, matchWorkerRoleName, testService.Paths, version: "0.8.2");
RuntimePackageHelper.SetRoleRuntime(testService.Components.Definition, overrideWebRoleName, testService.Paths, overrideUrl: "http://OVERRIDE");
RuntimePackageHelper.SetRoleRuntime(testService.Components.Definition, overrideWorkerRoleName, testService.Paths, overrideUrl: "http://OVERRIDE");
bool exceptionWasThrownOnSettingCacheRole = false;
try
{
string cacheRuntimeVersion = "1.7.0";
testService.AddRoleRuntime(testService.Paths, webRole2Name, Resources.CacheRuntimeValue, cacheRuntimeVersion, RuntimePackageHelper.GetTestManifest(files));
}
catch (NotSupportedException)
{
exceptionWasThrownOnSettingCacheRole = true;
}
Assert.True(exceptionWasThrownOnSettingCacheRole);
testService.Components.Save(testService.Paths);
// Get the publishing process started by creating the package
testService.ResolveRuntimePackageUrls(RuntimePackageHelper.GetTestManifest(files));
CloudServiceProject updatedService = new CloudServiceProject(testService.Paths.RootPath, null);
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, defaultWebRoleName, "http://cdn/node/default.exe;http://cdn/iisnode/default.exe", null);
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, defaultWorkerRoleName, "http://cdn/node/default.exe", null);
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, matchWorkerRoleName, "http://cdn/node/foo.exe", null);
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, matchWebRoleName, "http://cdn/node/foo.exe;http://cdn/iisnode/default.exe", null);
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, overrideWebRoleName, null, "http://OVERRIDE");
RuntimePackageHelper.ValidateRoleRuntime(updatedService.Components.Definition, overrideWorkerRoleName, null, "http://OVERRIDE");
}
}
public void TestUpgradeCloudService()
{
clientMocks.ComputeManagementClientMock.Setup(
c =>
c.HostedServices.CreateAsync(It.IsAny<HostedServiceCreateParameters>(), It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(new OperationResponse
{
RequestId = "request001",
StatusCode = HttpStatusCode.OK
}));
clientMocks.ComputeManagementClientMock.Setup(
c =>
c.Deployments.UpgradeBySlotAsync(It.IsAny<string>(), DeploymentSlot.Production,
It.IsAny<DeploymentUpgradeParameters>(),
It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(CreateComputeOperationResponse("req002")));
using (var files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Setup
string rootPath = files.CreateNewService(serviceName);
files.CreateAzureSdkDirectoryAndImportPublishSettings();
var cloudServiceProject = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath("Services"));
cloudServiceProject.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
ExecuteInTempCurrentDirectory(rootPath, () => client.PublishCloudService(location: "West US"));
clientMocks.ComputeManagementClientMock.Verify(c => c.Deployments.UpgradeBySlotAsync(serviceName, DeploymentSlot.Production, It.IsAny<DeploymentUpgradeParameters>(), It.IsAny<CancellationToken>()), Times.Once);
}
}
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 TestPublishWithDefaultLocation()
{
RemoveDeployments();
clientMocks.ComputeManagementClientMock.Setup(
c =>
c.HostedServices.CreateAsync(It.IsAny<HostedServiceCreateParameters>(), It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(new OperationResponse
{
RequestId = "request001",
StatusCode = HttpStatusCode.OK
}));
clientMocks.ManagementClientMock.Setup(c => c.Locations.ListAsync(It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(new LocationsListResponse
{
Locations =
{
new LocationsListResponse.Location {DisplayName = "East US", Name = "EastUS"}
}
}));
using (var files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Setup
string rootPath = files.CreateNewService(serviceName);
files.CreateAzureSdkDirectoryAndImportPublishSettings();
var cloudServiceProject = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath("Services"));
cloudServiceProject.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
ExecuteInTempCurrentDirectory(rootPath, () => client.PublishCloudService());
clientMocks.ManagementClientMock.Verify(c => c.Locations.ListAsync(It.IsAny<CancellationToken>()), Times.Once);
}
}
public void TestPublishWithCurrentStorageAccount()
{
RemoveDeployments();
clientMocks.ComputeManagementClientMock.Setup(
c =>
c.HostedServices.CreateAsync(It.IsAny<HostedServiceCreateParameters>(), It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(new OperationResponse
{
RequestId = "request001",
StatusCode = HttpStatusCode.OK
}));
using (var files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Setup
string rootPath = files.CreateNewService(serviceName);
files.CreateAzureSdkDirectoryAndImportPublishSettings();
var cloudServiceProject = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath("Services"));
cloudServiceProject.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
subscription.Properties[AzureSubscription.Property.StorageAccount] = storageName;
ExecuteInTempCurrentDirectory(rootPath, () => client.PublishCloudService(location: "West US"));
cloudBlobUtilityMock.Verify(f => f.UploadPackageToBlob(
clientMocks.StorageManagementClientMock.Object,
subscription.GetProperty(AzureSubscription.Property.StorageAccount),
It.IsAny<string>(),
It.IsAny<BlobRequestOptions>()), Times.Once());
}
}
public void ThrowsErrorForInvalidCacheVersion()
{
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);
string cacheRoleName = "WorkerRole1";
AddAzureCacheWorkerRoleCommand addCacheWorkerCmdlet = new AddAzureCacheWorkerRoleCommand()
{
CommandRuntime = mockCommandRuntime
};
EnableAzureMemcacheRoleCommand enableCacheCmdlet = new EnableAzureMemcacheRoleCommand()
{
CacheRuntimeVersion = "1.8.0",
CommandRuntime = mockCommandRuntime
};
CloudServiceProject service = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath("Services"));
service.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
addCacheWorkerCmdlet.AddAzureCacheWorkerRoleProcess(cacheRoleName, 1, rootPath);
enableCacheCmdlet.EnableAzureMemcacheRoleProcess("WebRole1", cacheRoleName, rootPath);
Testing.AssertThrows<Exception>(
() => cmdlet.ExecuteCmdlet(),
string.Format(Resources.CacheMismatchMessage, "WebRole1", "2.5.0"));
}
}
public void TestCreateStorageServiceWithPublish()
{
RemoveDeployments();
clientMocks.ComputeManagementClientMock.Setup(
c =>
c.HostedServices.CreateAsync(It.IsAny<HostedServiceCreateParameters>(), It.IsAny<CancellationToken>()))
.Returns(Tasks.FromResult(new AzureOperationResponse
{
RequestId = "request001",
StatusCode = HttpStatusCode.OK
}));
storageService.Clear();
using (var files = new FileSystemHelper(this) { EnableMonitoring = true })
{
// Setup
string rootPath = files.CreateNewService(serviceName);
files.CreateAzureSdkDirectoryAndImportPublishSettings();
var cloudServiceProject = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
cloudServiceProject.AddWebRole(Test.Utilities.Common.Data.NodeWebRoleScaffoldingPath);
ExecuteInTempCurrentDirectory(rootPath, () => client.PublishCloudService(location: "West US"));
clientMocks.StorageManagementClientMock.Verify(c => c.StorageAccounts.CreateAsync(It.IsAny<StorageAccountCreateParameters>(), It.IsAny<CancellationToken>()), Times.Once);
}
}
public void EnableRemoteDesktopUnicodeAndShortPasswordFails()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string rootPath = files.CreateNewService("NEW_SERVICE");
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand()
{
RootPath = rootPath,
CommandRuntime = mockCommandRuntime,
Name = "WebRole",
Instances = 1
};
addNodeWebCmdlet.ExecuteCmdlet();
Testing.AssertThrows<ArgumentException>(() => EnableRemoteDesktop("㯑䲘䄂㮉", "㯑䲘"));
}
}
public void EnableDisableEnableRemoteDesktopForWebAndWorkerRoles()
{
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();
EnableAzureRemoteDesktopCommandTest.EnableRemoteDesktop("user", "GoodPassword!");
disableRDCmdlet.DisableRemoteDesktop();
EnableAzureRemoteDesktopCommandTest.EnableRemoteDesktop("user", "GoodPassword!");
// Verify the roles have been setup with forwarding, access,
// and certs
CloudServiceProject service = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
EnableAzureRemoteDesktopCommandTest.VerifyWebRole(service.Components.Definition.WebRole[0], false);
EnableAzureRemoteDesktopCommandTest.VerifyWorkerRole(service.Components.Definition.WorkerRole[0], true);
EnableAzureRemoteDesktopCommandTest.VerifyRoleSettings(service);
}
}
public void EnableRemoteDesktopForEmptyService()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
files.CreateNewService("NEW_SERVICE");
Testing.AssertThrows<InvalidOperationException>(() =>
EnableRemoteDesktop("user", "GoodPassword!"));
}
}
public void DisableRemoteDesktopForWebRole()
{
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();
disableRDCmdlet.PassThru = true;
disableRDCmdlet.DisableRemoteDesktop();
Assert.True((bool)mockCommandRuntime.OutputPipeline[1]);
}
}
public void AddAzureWebRoleWithTemplateFolder()
{
string scaffoldingPath = "MyWebTemplateFolder";
Directory.CreateDirectory(Path.Combine(System.Environment.CurrentDirectory, 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 AddAzureWorkerRoleWithMissingScaffoldXmlFail()
{
string scaffoldingPath = "TemplateMissingScaffoldXml";
Directory.CreateDirectory(Path.Combine(System.Environment.CurrentDirectory, scaffoldingPath));
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WorkerRole1";
string serviceName = "AzureService";
string rootPath = files.CreateNewService(serviceName);
addWorkerCmdlet = new AddAzureWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = roleName, TemplateFolder = scaffoldingPath };
Testing.AssertThrows<FileNotFoundException>(() => addWorkerCmdlet.ExecuteCmdlet());
}
}
public void EnableRemoteDesktopForMultipleWebAndWorkerRolesTwice()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
files.CreateAzureSdkDirectoryAndImportPublishSettings();
string rootPath = files.CreateNewService("NEW_SERVICE");
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WebRole_1", Instances = 1 };
addNodeWebCmdlet.ExecuteCmdlet();
addNodeWebCmdlet = new AddAzureNodeWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WebRole_2", Instances = 1 };
addNodeWebCmdlet.ExecuteCmdlet();
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WorkerRole_1", Instances = 1 };
addNodeWorkerCmdlet.ExecuteCmdlet();
addNodeWorkerCmdlet = new AddAzureNodeWorkerRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = "WorkerRole_2", Instances = 1 };
addNodeWorkerCmdlet.ExecuteCmdlet();
mockCommandRuntime.ResetPipelines();
enableRDCmdlet.PassThru = true;
EnableRemoteDesktop("user", "GoodPassword!");
enableRDCmdlet.PassThru = false;
EnableRemoteDesktop("other", "OtherPassword!");
// Verify the roles have been setup with forwarding, access,
// and certs
CloudServiceProject service = new CloudServiceProject(rootPath, FileUtilities.GetContentFilePath(@"..\..\..\..\..\Package\Debug\ServiceManagement\Azure\Services"));
VerifyWebRole(service.Components.Definition.WebRole[0], false);
VerifyWebRole(service.Components.Definition.WebRole[0], false);
VerifyWorkerRole(service.Components.Definition.WorkerRole[0], true);
VerifyWorkerRole(service.Components.Definition.WorkerRole[1], false);
VerifyRoleSettings(service);
Assert.Equal<int>(1, mockCommandRuntime.OutputPipeline.Count);
Assert.True((bool)mockCommandRuntime.OutputPipeline[0]);
}
}
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 AddAzureWebRoleWithMissingScaffoldXmlFail()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string roleName = "WebRole1";
string serviceName = "AzureService";
string scaffoldingPath = "TemplateMissingScaffoldXml";
if (Directory.Exists(scaffoldingPath))
{
Directory.Delete(scaffoldingPath, true);
}
string rootPath = files.CreateNewService(serviceName);
string expectedVerboseMessage = string.Format(Resources.AddRoleMessageCreate, rootPath, roleName);
string originalDirectory = Directory.GetCurrentDirectory();
addWebCmdlet = new AddAzureWebRoleCommand() { RootPath = rootPath, CommandRuntime = mockCommandRuntime, Name = roleName, TemplateFolder = scaffoldingPath };
Assert.Throws<DirectoryNotFoundException>(() => addWebCmdlet.ExecuteCmdlet());
}
}
