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]); } } }