public void PullApiTestBitbucketFormat() { string bitbucketPayload = @"{ ""canon_url"": ""https://github.com"", ""commits"": [ { ""author"": ""davidebbo"", ""branch"": ""master"", ""files"": [ { ""file"": ""Mvc3Application/Views/Home/Index.cshtml"", ""type"": ""modified"" } ], ""message"": ""Blah2\n"", ""node"": ""e550351c5188"", ""parents"": [ ""297fcc65308c"" ], ""raw_author"": ""davidebbo <*****@*****.**>"", ""raw_node"": ""e550351c5188681a9ed889e07bc1fbc0bd51a0f2"", ""revision"": null, ""size"": -1, ""timestamp"": ""2012-09-20 03:11:20"", ""utctimestamp"": ""2012-09-20 01:11:20+00:00"" } ], ""repository"": { ""absolute_url"": ""/KuduApps/SimpleWebApplication"", ""fork"": false, ""is_private"": false, ""name"": ""Mvc3Application"", ""owner"": ""davidebbo"", ""scm"": ""git"", ""slug"": ""mvc3application"", ""website"": """" }, ""user"": ""davidebbo"" }"; string appName = KuduUtils.GetRandomWebsiteName("PullApiTestBitbucketFormat"); ApplicationManager.Run(appName, appManager => { var handler = new HttpClientHandler { Credentials = appManager.DeploymentManager.Credentials }; var client = new HttpClient(handler) { BaseAddress = new Uri(appManager.ServiceUrl), Timeout = TimeSpan.FromMinutes(5) }; client.DefaultRequestHeaders.Add("User-Agent", "Bitbucket.org"); var post = new Dictionary <string, string> { { "payload", bitbucketPayload } }; client.PostAsync("deploy", new FormUrlEncodedContent(post)).Wait(); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "Welcome to ASP.NET!"); }); }
public void PullApiTestGenericFormat() { string payload = @"{ ""oldRef"": ""0000000000000000000"", ""newRef"": ""7e2a599e2d28665047ec347ab36731c905c95e8b"", ""url"": ""https://github.com/KuduApps/SimpleWebApplication.git"", ""deployer"" : ""me!"" }"; string appName = KuduUtils.GetRandomWebsiteName("PullApiTestGenericFormat"); ApplicationManager.Run(appName, appManager => { var handler = new HttpClientHandler { Credentials = appManager.DeploymentManager.Credentials }; var client = new HttpClient(handler) { BaseAddress = new Uri(appManager.ServiceUrl), Timeout = TimeSpan.FromMinutes(5) }; var post = new Dictionary <string, string> { { "payload", payload } }; client.PostAsync("deploy", new FormUrlEncodedContent(post)).Wait(); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "Welcome to ASP.NET!"); Assert.Equal("me!", results[0].Deployer); }); }
public void PullApiTestGitHubFormat() { string githubPayload = @"{ ""after"": ""7e2a599e2d28665047ec347ab36731c905c95e8b"", ""before"": ""7e2a599e2d28665047ec347ab36731c905c95e8b"", ""commits"": [], ""compare"": ""https://github.com/KuduApps/GitHookTest/compare/7e2a599e2d28...7e2a599e2d28"", ""created"": false, ""deleted"": false, ""forced"": false, ""head_commit"": { ""added"": [ "".gitignore"", ""SimpleWebApplication.sln"", ""SimpleWebApplication/About.aspx"", ""SimpleWebApplication/About.aspx.cs"", ""SimpleWebApplication/About.aspx.designer.cs"", ""SimpleWebApplication/Account/ChangePassword.aspx"", ""SimpleWebApplication/Account/ChangePassword.aspx.cs"", ""SimpleWebApplication/Account/ChangePassword.aspx.designer.cs"", ""SimpleWebApplication/Account/ChangePasswordSuccess.aspx"", ""SimpleWebApplication/Account/ChangePasswordSuccess.aspx.cs"", ""SimpleWebApplication/Account/ChangePasswordSuccess.aspx.designer.cs"", ""SimpleWebApplication/Account/Login.aspx"", ""SimpleWebApplication/Account/Login.aspx.cs"", ""SimpleWebApplication/Account/Login.aspx.designer.cs"", ""SimpleWebApplication/Account/Register.aspx"", ""SimpleWebApplication/Account/Register.aspx.cs"", ""SimpleWebApplication/Account/Register.aspx.designer.cs"", ""SimpleWebApplication/Account/Web.config"", ""SimpleWebApplication/Default.aspx"", ""SimpleWebApplication/Default.aspx.cs"", ""SimpleWebApplication/Default.aspx.designer.cs"", ""SimpleWebApplication/Global.asax"", ""SimpleWebApplication/Global.asax.cs"", ""SimpleWebApplication/Properties/AssemblyInfo.cs"", ""SimpleWebApplication/Scripts/jquery-1.4.1-vsdoc.js"", ""SimpleWebApplication/Scripts/jquery-1.4.1.js"", ""SimpleWebApplication/Scripts/jquery-1.4.1.min.js"", ""SimpleWebApplication/SimpleWebApplication.csproj"", ""SimpleWebApplication/Site.Master"", ""SimpleWebApplication/Site.Master.cs"", ""SimpleWebApplication/Site.Master.designer.cs"", ""SimpleWebApplication/Styles/Site.css"", ""SimpleWebApplication/Web.Debug.config"", ""SimpleWebApplication/Web.Release.config"", ""SimpleWebApplication/Web.config"" ], ""author"": { ""email"": ""*****@*****.**"", ""name"": ""davidebbo"", ""username"": ""davidebbo"" }, ""committer"": { ""email"": ""*****@*****.**"", ""name"": ""davidebbo"", ""username"": ""davidebbo"" }, ""distinct"": false, ""id"": ""7e2a599e2d28665047ec347ab36731c905c95e8b"", ""message"": ""Initial"", ""modified"": [], ""removed"": [], ""timestamp"": ""2011-11-21T23:07:42-08:00"", ""url"": ""https://github.com/KuduApps/GitHookTest/commit/7e2a599e2d28665047ec347ab36731c905c95e8b"" }, ""pusher"": { ""name"": ""none"" }, ""ref"": ""refs/heads/master"", ""repository"": { ""created_at"": ""2012-06-28T00:07:55-07:00"", ""description"": """", ""fork"": false, ""forks"": 1, ""has_downloads"": true, ""has_issues"": true, ""has_wiki"": true, ""language"": ""ASP"", ""name"": ""GitHookTest"", ""open_issues"": 0, ""organization"": ""KuduApps"", ""owner"": { ""email"": ""*****@*****.**"", ""name"": ""KuduApps"" }, ""private"": false, ""pushed_at"": ""2012-06-28T00:11:48-07:00"", ""size"": 188, ""url"": ""https://github.com/KuduApps/SimpleWebApplication"", ""watchers"": 1 } }"; string appName = KuduUtils.GetRandomWebsiteName("PullApiTestGitHubFormat"); ApplicationManager.Run(appName, appManager => { var handler = new HttpClientHandler { Credentials = appManager.DeploymentManager.Credentials }; var client = new HttpClient(handler) { BaseAddress = new Uri(appManager.ServiceUrl), Timeout = TimeSpan.FromMinutes(5) }; var post = new Dictionary <string, string> { { "payload", githubPayload } }; client.PostAsync("deploy", new FormUrlEncodedContent(post)).Wait(); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "Welcome to ASP.NET!"); }); }
public void PushSimpleWapWithCustomDeploymentScript() { // Arrange string repositoryName = "WapWithCustomDeploymentScript"; string appName = KuduUtils.GetRandomWebsiteName("WapWithCustomDeploymentScript"); string cloneUrl = "https://github.com/KuduApps/CustomBuildScript.git"; using (var repo = Git.Clone(repositoryName, cloneUrl)) { repo.WriteFile(".deployment", @" [config] command = deploy.cmd"); Git.Commit(repo.PhysicalPath, "Custom build script added"); ApplicationManager.Run(appName, appManager => { // Act GitDeploymentResult deployResult = appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "DEBUG"); }); } }
public void PushSimpleWapWithInlineCommand() { // Arrange string repositoryName = "PushSimpleWapWithInlineCommand"; string appName = KuduUtils.GetRandomWebsiteName("PushSimpleWapWithInlineCommand"); string cloneUrl = "https://github.com/KuduApps/CustomBuildScript.git"; using (var repo = Git.Clone(repositoryName, cloneUrl)) { repo.WriteFile(".deployment", @" [config] command = msbuild SimpleWebApplication/SimpleWebApplication.csproj /t:pipelinePreDeployCopyAllFilesToOneFolder /p:_PackageTempDir=""%DEPLOYMENT_TARGET%"";AutoParameterizationWebConfigConnectionStrings=false;Configuration=Debug;SolutionDir=""%DEPLOYMENT_SOURCE%"""); Git.Commit(repo.PhysicalPath, "Custom build command added"); ApplicationManager.Run(appName, appManager => { // Act GitDeploymentResult deployResult = appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "DEBUG"); }); } }
public void DeployingBranchThatExists() { string payload = @"{ ""oldRef"": ""0000000000000000000"", ""newRef"": ""ad21595c668f3de813463df17c04a3b23065fedc"", ""url"": ""https://github.com/KuduApps/RepoWithMultipleBranches.git"", ""deployer"" : ""me!"", branch: ""test"" }"; string appName = KuduUtils.GetRandomWebsiteName("DeployingBranchThatExists"); ApplicationManager.Run(appName, appManager => { var handler = new HttpClientHandler { Credentials = appManager.DeploymentManager.Credentials }; var client = new HttpClient(handler) { BaseAddress = new Uri(appManager.ServiceUrl), Timeout = TimeSpan.FromMinutes(5) }; var post = new Dictionary <string, string> { { "payload", payload } }; client.PostAsync("deploy", new FormUrlEncodedContent(post)).Wait(); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, "Master branch"); Assert.Equal("me!", results[0].Deployer); }); }
public void DeletesToRepositoryArePropagatedForNonWaps() { string repositoryName = "Bakery10"; string appName = KuduUtils.GetRandomWebsiteName("DeleteForNonWaps"); using (var repo = Git.CreateLocalRepository(repositoryName)) { ApplicationManager.Run(appName, appManager => { string deletePath = Path.Combine(repo.PhysicalPath, @"Styles"); // Act appManager.GitDeploy(repo.PhysicalPath); // Assert var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl + "Styles/Site.css", statusCode: HttpStatusCode.OK); Directory.Delete(deletePath, recursive: true); Git.Commit(repo.PhysicalPath, "Deleted all styles"); appManager.GitDeploy(repo.PhysicalPath); results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(2, results.Count); Assert.Equal(DeployStatus.Success, results[1].Status); KuduAssert.VerifyUrl(appManager.SiteUrl + "Styles/Site.css", statusCode: HttpStatusCode.NotFound); }); } }
public void SetGetDeleteValue() { // Arrange string repositoryName = "Mvc3Application"; string appName = KuduUtils.GetRandomWebsiteName("SetValue"); using (var repo = Git.CreateLocalRepository(repositoryName)) { ApplicationManager.Run(appName, appManager => { // Act appManager.SettingsManager.SetValue("x", "1").Wait(); // Assert string result = appManager.SettingsManager.GetValue("x").Result; Assert.Equal("1", result); appManager.SettingsManager.Delete("x").Wait(); // Act var ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.SettingsManager.GetValue("x").Wait()); // Assert Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); }); } }
public async Task TestDropboxBasic() { OAuthInfo oauth = GetOAuthInfo(); if (oauth == null) { // only run in private kudu return; } AccountInfo account = GetAccountInfo(oauth); DropboxDeployInfo deploy = GetDeployInfo("/BasicTest", oauth, account); string appName = "DropboxTest"; await ApplicationManager.RunAsync(appName, async appManager => { HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials); var result = await client.PostAsJsonAsync("deploy?scmType=Dropbox", deploy); result.EnsureSuccessful(); await Task.WhenAll( KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/default.html", "Hello Default!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/temp/temp.html", "Hello Temp!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/New Folder/New File.html", "Hello New File!") ); }); }
public void PushAndDeployApps(string name, string repoName, string repoUrl, string repoCloneUrl, string defaultBranchName, string verificationText, HttpStatusCode expectedResponseCode, bool skip, string verificationLogText = null) { if (!skip) { string randomTestName = KuduUtils.GetRandomWebsiteName(repoName); using (var repo = Git.Clone(randomTestName, repoCloneUrl)) { ApplicationManager.Run(randomTestName, appManager => { // Act appManager.GitDeploy(repo.PhysicalPath, defaultBranchName); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, verificationText, expectedResponseCode); if (!String.IsNullOrEmpty(verificationLogText.Trim())) { KuduAssert.VerifyLogOutput(appManager, results[0].Id, verificationLogText.Trim()); } }); } Debug.Write(String.Format("Test completed: {0}\n", name)); } else { Debug.Write(String.Format("Test skipped: {0}\n", name)); } }
private void VerifyDeploymentConfiguration(string siteName, string targetProject, string expectedText, DeployStatus expectedStatus = DeployStatus.Success, string expectedLog = null) { string name = KuduUtils.GetRandomWebsiteName(siteName); string cloneUrl = "https://github.com/KuduApps/SpecificDeploymentConfiguration.git"; using (var repo = Git.Clone(name, cloneUrl)) { ApplicationManager.Run(name, appManager => { string deploymentFile = Path.Combine(repo.PhysicalPath, @".deployment"); File.WriteAllText(deploymentFile, String.Format(@"[config] project = {0}", targetProject)); Git.Commit(name, "Updated configuration"); // Act appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(expectedStatus, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, expectedText); if (!String.IsNullOrEmpty(expectedLog)) { KuduAssert.VerifyLogOutput(appManager, results[0].Id, expectedLog); } }); } }
public void PushSimpleWapWithFailingCustomDeploymentScript() { // Arrange string repositoryName = "WapWithFailingCustomDeploymentScript"; string appName = KuduUtils.GetRandomWebsiteName("WapWithFailingCustomDeploymentScript"); string cloneUrl = "https://github.com/KuduApps/CustomBuildScript.git"; using (var repo = Git.Clone(repositoryName, cloneUrl)) { repo.WriteFile(".deployment", @" [config] command = deploy.cmd"); repo.WriteFile("deploy.cmd", "bogus"); Git.Commit(repo.PhysicalPath, "Updated the deploy file."); ApplicationManager.Run(appName, appManager => { // Act GitDeploymentResult deployResult = appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Failed, results[0].Status); KuduAssert.VerifyLogOutput(appManager, results[0].Id, ">bogus"); KuduAssert.VerifyLogOutput(appManager, results[0].Id, "'bogus' is not recognized as an internal or external command"); }); } }
public void FirstPushDeletesPriorContent() { string repositoryName = "Bakery10"; string appName = KuduUtils.GetRandomWebsiteName("FirstPushDelPrior"); using (var repo = Git.CreateLocalRepository(repositoryName)) { ApplicationManager.Run(appName, appManager => { appManager.ProjectSystem.WriteAllText("foo.txt", "This is a test file"); string url = appManager.SiteUrl + "/foo.txt"; Thread.Sleep(500); KuduAssert.VerifyUrl(url, "This is a test file"); // Act appManager.GitDeploy(repo.PhysicalPath); // Assert var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl); KuduAssert.VerifyUrl(url, statusCode: HttpStatusCode.NotFound); }); } }
public void DeletesToRepositoryArePropagatedForWaps() { string repositoryName = "Mvc3Application"; string appName = KuduUtils.GetRandomWebsiteName("DeletesToRepoForWaps"); using (var repo = Git.CreateLocalRepository(repositoryName)) { ApplicationManager.Run(appName, appManager => { string deletePath = Path.Combine(repo.PhysicalPath, @"Mvc3Application\Controllers\AccountController.cs"); string projectPath = Path.Combine(repo.PhysicalPath, @"Mvc3Application\Mvc3Application.csproj"); // Act appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl + "Account/LogOn", statusCode: HttpStatusCode.OK); File.Delete(deletePath); File.WriteAllText(projectPath, File.ReadAllText(projectPath).Replace(@"<Compile Include=""Controllers\AccountController.cs"" />", "")); Git.Commit(repo.PhysicalPath, "Deleted the filez"); appManager.GitDeploy(repo.PhysicalPath); results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(2, results.Count); Assert.Equal(DeployStatus.Success, results[1].Status); KuduAssert.VerifyUrl(appManager.SiteUrl + "Account/LogOn", statusCode: HttpStatusCode.NotFound); }); } }
public async Task TestDropboxBasicForBasicScenarioWithOAuthV2() { if (String.IsNullOrEmpty(OAuth20Token)) { // only run in private kudu return; } object payload = new { scmType = "DropboxV2", dropbox_token = OAuth20Token, dropbox_path = "/Basictest" }; await ApplicationManager.RunAsync("TestDropboxBasicForBasicScenarioWithOAuthV2", async appManager => { HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials); var result = await client.PostAsJsonAsync("deploy?scmType=Dropbox", payload); result.EnsureSuccessful(); await Task.WhenAll( KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/default.html", "Hello Default!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/temp/temp.html", "Hello Temp!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/New Folder/New File.html", "Hello New File!") ); }); }
public void TestNodeCustomStartScriptFromPackageJson() { // Arrange string appName = "TestCustomStartScriptFromPackageJson"; using (var repo = Git.Clone("NodeWithCustomStartScript")) { ApplicationManager.Run(appName, appManager => { // Act GitDeploymentResult deployResult = appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert deployment success Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); // Verify log output Assert.Contains("Using start-up script app/app.js", deployResult.GitTrace); Assert.Contains("Updating iisnode.yml", deployResult.GitTrace); // Verify app works. KuduAssert.VerifyUrl(appManager.SiteUrl, "Hello Main App!"); // Verify that node-inspector works KuduAssert.VerifyUrl(appManager.SiteUrl + "/app/app.js/debug", "node-inspector"); }); } }
public void DeploymentApisReturn404IfDeploymentIdDoesntExist() { string appName = KuduUtils.GetRandomWebsiteName("Rtn404IfDeployIdNotExist"); ApplicationManager.Run(appName, appManager => { string id = "foo"; var ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.DeleteAsync(id).Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.DeployAsync(id).Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.DeployAsync(id, clean: true).Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.GetLogEntriesAsync(id).Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.GetResultAsync(id).Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.GetLogEntryDetailsAsync(id, "fakeId").Wait()); Assert.Equal("Response status code does not indicate success: 404 (Not Found).", ex.Message); }); }
public void SetGetDeleteValue() { // Arrange string repositoryName = "Mvc3Application"; string appName = "SetValue"; using (var repo = Git.Clone(repositoryName)) { ApplicationManager.Run(appName, appManager => { // Act appManager.SettingsManager.SetValue("x", "1").Wait(); // Assert string result = appManager.SettingsManager.GetValue("x").Result; Assert.Equal("1", result); appManager.SettingsManager.Delete("x").Wait(); // Act var ex = KuduAssert.ThrowsUnwrapped <HttpUnsuccessfulRequestException>(() => appManager.SettingsManager.GetValue("x").Wait()); // Assert Assert.Equal(HttpStatusCode.NotFound, ex.ResponseMessage.StatusCode); }); } }
public void WarningsAsErrors() { // Arrange string repositoryName = "WarningsAsErrors"; string appName = KuduUtils.GetRandomWebsiteName("WarningsAsErrors"); string cloneUrl = "https://github.com/KuduApps/WarningsAsErrors.git"; using (var repo = Git.Clone(repositoryName, cloneUrl)) { ApplicationManager.Run(appName, appManager => { // Act GitDeploymentResult deployResult = appManager.GitDeploy(repo.PhysicalPath); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Failed, results[0].Status); Assert.Null(results[0].LastSuccessEndTime); KuduAssert.VerifyLogOutput(appManager, results[0].Id, "Warning as Error: The variable 'x' is declared but never used"); Assert.True(deployResult.GitTrace.Contains("Warning as Error: The variable 'x' is declared but never used")); Assert.True(deployResult.GitTrace.Contains("Error - Changes committed to remote repository but your website not updated.")); }); } }
public void PostDeploymentActionWhichFailsShouldFailDeployment() { string testName = "PostDeploymentActionsShouldBeCalledOnSuccessfulPublish"; string testLine1 = "test script 1 is running"; string testLine2 = "test script 2 is running too"; string failScriptCommand = "\n exit /b 1"; using (new LatencyLogger(testName)) { ApplicationManager.Run(testName, appManager => { using (var appRepository = Git.Clone("HelloKudu")) { TestTracer.Trace("Add action scripts, first script should fail, second script shouldn't run"); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_1.cmd", @"@echo off echo " + testLine1 + failScriptCommand); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_2.bat", @"@echo off echo " + testLine2); TestTracer.Trace("Deploy test app"); appManager.GitDeploy(appRepository.PhysicalPath); TestTracer.Trace("Verify results"); var deploymentResults = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, deploymentResults.Count); Assert.Equal(DeployStatus.Failed, deploymentResults[0].Status); KuduAssert.VerifyLogOutput(appManager, deploymentResults[0].Id, testLine1); KuduAssert.VerifyLogOutputWithUnexpected(appManager, deploymentResults[0].Id, testLine2); TestTracer.Trace("Update action scripts, first script should succeed, second script should fail"); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_1.cmd", @"@echo off echo " + testLine1); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_2.bat", @"@echo off echo " + testLine2 + failScriptCommand); TestTracer.Trace("Deploy test app"); appManager.DeploymentManager.DeployAsync(null).Wait(); TestTracer.Trace("Verify results"); deploymentResults = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, deploymentResults.Count); Assert.Equal(DeployStatus.Failed, deploymentResults[0].Status); KuduAssert.VerifyLogOutput(appManager, deploymentResults[0].Id, testLine1, testLine2); } }); } }
public async Task TestDropboxBasicForBasicScenario(Scenario scenario) { OAuthInfo oauth = GetOAuthInfo(); if (oauth == null) { // only run in private kudu return; } AccountInfo account = GetAccountInfo(oauth); Assert.Equal(oauth.Account, account.email); var deploy = GetDeployInfo("/BasicTest", oauth, account); string appName = "DropboxTest"; await ApplicationManager.RunAsync(appName, async appManager => { if (scenario == Scenario.NoRepository) { await appManager.SettingsManager.SetValue(SettingsKeys.NoRepository, "1"); } else if (scenario == Scenario.InPlace) { await appManager.SettingsManager.SetValue(SettingsKeys.RepositoryPath, "wwwroot"); } HttpClient client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials); var result = await client.PostAsJsonAsync("deploy?scmType=Dropbox", deploy); result.EnsureSuccessful(); await Task.WhenAll( KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/default.html", "Hello Default!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/temp/temp.html", "Hello Temp!"), KuduAssert.VerifyUrlAsync(appManager.SiteUrl + "/New Folder/New File.html", "Hello New File!") ); var repositoryGit = appManager.VfsManager.Exists(@"site\repository\.git"); var wwwrootGit = appManager.VfsManager.Exists(@"site\wwwroot\.git"); if (scenario == Scenario.NoRepository) { Assert.False(repositoryGit, @"site\repository\.git should not exist for " + scenario); Assert.False(wwwrootGit, @"site\wwwroot\.git should not exist for " + scenario); } else if (scenario == Scenario.InPlace) { Assert.False(repositoryGit, @"site\repository\.git should not exist for " + scenario); Assert.True(wwwrootGit, @"site\wwwroot\.git should exist for " + scenario); } else if (scenario == Scenario.Default) { Assert.True(repositoryGit, @"site\repository\.git should exist for " + scenario); Assert.False(wwwrootGit, @"site\wwwroot\.git should not exist for " + scenario); } }); }
public void DeployLargeRepoFromDropbox(string repoPath, string appName, string verificationText, string resourcePath) { if (!shouldRunLargeRepoTests) { return; } using (new LatencyLogger("PushAndDeployApps - " + appName)) { var db = new DropboxTests(); { DropboxTests.OAuthInfo oauth = db.GetOAuthInfo(appName); if (oauth == null) { // only run in private kudu return; } JObject deploy; DropboxTests.AccountInfo account = db.GetAccountInfo(oauth); using (new LatencyLogger("DropboxGetDeployInfo - " + appName)) { deploy = db.GetDeployInfo(repoPath, oauth, account); } ApplicationManager.Run(appName, appManager => { const int timeoutInMinutes = 100; DateTime stopTime = DateTime.Now.AddMinutes(timeoutInMinutes); var client = HttpClientHelper.CreateClient(appManager.ServiceUrl, appManager.DeploymentManager.Credentials); using (new LatencyLogger("DropboxDeploy - " + appName)) { client.PostAsJsonAsync("deploy?scmType=Dropbox", deploy); List <DeployResult> results; do { Thread.Sleep(5000); if (DateTime.Now > stopTime) { throw new TimeoutException("Terminating test. Current test took too long."); } results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); TestTracer.Trace(results[0].Progress); } while ((results[0]).Status != DeployStatus.Success && (results[0]).Status != DeployStatus.Failed); } KuduAssert.VerifyUrl(appManager.SiteUrl + resourcePath, verificationText); using (new LatencyLogger("DropboxScmDelete - " + appName)) { appManager.RepositoryManager.Delete(deleteWebRoot: false, ignoreErrors: false).Wait(); } }); } } }
private static void CreateLogDirectory(string siteUrl, string directory) { if (!directory.EndsWith("\\")) { directory += "\\"; } string url = String.Format("{0}?path={1}", siteUrl, directory); KuduAssert.VerifyUrl(url); }
public virtual void VerifyUrl(ApplicationManager appManager, Setting setting) { if (setting.TargetPath == ".") { KuduAssert.VerifyUrl(appManager.SiteUrl + DefaultDocument, Content); } else { VerifyUrl(appManager, setting.TargetPath); } }
public void TestLogStreamNotFound() { string appName = "TestLogStreamNotFound"; ApplicationManager.Run(appName, appManager => { RemoteLogStreamManager manager = new RemoteLogStreamManager(appManager.ServiceUrl + "/logstream/notfound"); var ex = KuduAssert.ThrowsUnwrapped <WebException>(() => manager.GetStream().Wait()); Assert.Equal(((HttpWebResponse)ex.Response).StatusCode, HttpStatusCode.NotFound); }); }
public void PostDeploymentActionsShouldBeCalledOnSuccessfulDeployment() { string testName = "PostDeploymentActionsShouldBeCalledOnSuccessfulDeployment"; string testLine1 = "test script 1 is running"; string testLine2 = "test script 2 is running too"; const string testCommitIdPrefix = @"SCM_COMMIT_ID = "; const string testCommitIdVariable = @"%SCM_COMMIT_ID%"; using (new LatencyLogger(testName)) { ApplicationManager.Run(testName, appManager => { using (var appRepository = Git.Clone("HelloKudu")) { TestTracer.Trace("Add action scripts"); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_1.cmd", @"@echo off echo " + testLine1); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_2.bat", @"@echo off echo " + testLine2); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_3.sh", @"@echo off echo fail if we try to run this exit /b 1"); appManager.VfsManager.WriteAllText( @"site\deployments\tools\PostDeploymentActions\test_script_4.cmd", @"@echo off echo " + testCommitIdPrefix + testCommitIdVariable); TestTracer.Trace("Deploy test app"); appManager.GitDeploy(appRepository.PhysicalPath); TestTracer.Trace("Verify results"); var deploymentResults = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, deploymentResults.Count); Assert.Equal(DeployStatus.Success, deploymentResults[0].Status); KuduAssert.VerifyLogOutput(appManager, deploymentResults[0].Id, testLine1, testLine2); KuduAssert.VerifyLogOutput(appManager, deploymentResults[0].Id, testCommitIdPrefix + deploymentResults[0].Id); } }); } }
//Common code internal static void PushAndDeployApps(string repoCloneUrl, string defaultBranchName, string verificationText, HttpStatusCode expectedResponseCode, string verificationLogText, DeployStatus expectedStatus = DeployStatus.Success, string resourcePath = "", string httpMethod = "GET", string jsonPayload = "", bool deleteSCM = false) { using (new LatencyLogger("PushAndDeployApps - " + repoCloneUrl)) { Uri uri; if (!Uri.TryCreate(repoCloneUrl, UriKind.Absolute, out uri)) { uri = null; } string randomTestName = uri != null?Path.GetFileNameWithoutExtension(repoCloneUrl) : repoCloneUrl; ApplicationManager.Run(randomTestName, appManager => { // Act using (TestRepository testRepository = Git.Clone(randomTestName, uri != null ? repoCloneUrl : null)) { using (new LatencyLogger("GitDeploy")) { appManager.GitDeploy(testRepository.PhysicalPath, defaultBranchName); } } var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(1, results.Count); Assert.Equal(expectedStatus, results[0].Status); var url = new Uri(new Uri(appManager.SiteUrl), resourcePath); if (!String.IsNullOrEmpty(verificationText)) { KuduAssert.VerifyUrl(url.ToString(), verificationText, expectedResponseCode, httpMethod, jsonPayload); } if (!String.IsNullOrEmpty(verificationLogText)) { KuduAssert.VerifyLogOutput(appManager, results[0].Id, verificationLogText.Trim()); } if (deleteSCM) { using (new LatencyLogger("SCMAndWebDelete")) { appManager.RepositoryManager.Delete(deleteWebRoot: false, ignoreErrors: false).Wait(); } } }); } }
public void UpdatedTargetPathShouldChangeDeploymentDestination() { ApplicationManager.Run("UpdatedTargetPathShouldChangeDeploymentDestination", appManager => { using (TestRepository testRepository = Git.Clone("TargetPathTest")) { appManager.GitDeploy(testRepository.PhysicalPath, "master"); } var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); Assert.Equal(1, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl + "myTarget/index.html", "Target Path Test"); }); }
public async Task ProcessApiTests() { string appName = "ProcessApiTests"; await ApplicationManager.RunAsync(appName, async appManager => { // Test current process var process = await appManager.ProcessManager.GetCurrentProcessAsync(); int currentId = process.Id; DateTime startTime = process.StartTime; Assert.NotNull(process); Assert.Contains("w3wp", process.Name); Assert.Contains("/diagnostics/processes/" + currentId, process.Href.AbsoluteUri); // Test get process by id process = await appManager.ProcessManager.GetProcessAsync(currentId); Assert.NotNull(process); Assert.Contains("w3wp", process.Name); Assert.Contains("/diagnostics/processes/" + currentId, process.Href.AbsoluteUri); // Test get not running process id var notfound = await KuduAssert.ThrowsUnwrappedAsync <HttpUnsuccessfulRequestException>(() => appManager.ProcessManager.GetProcessAsync(99999)); Assert.Equal(HttpStatusCode.NotFound, notfound.ResponseMessage.StatusCode); Assert.Contains("is not running", notfound.ResponseMessage.ExceptionMessage); // Test process list var processes = await appManager.ProcessManager.GetProcessesAsync(); Assert.True(processes.Count() >= 1); Assert.True(processes.Any(p => p.Id == currentId)); // Test minidump var stream = new MemoryStream(); using (var minidump = await appManager.ProcessManager.MiniDump()) { Assert.NotNull(minidump); await minidump.CopyToAsync(stream); } Assert.True(stream.Length > 0); // Test kill process await KuduAssert.ThrowsUnwrappedAsync <HttpRequestException>(() => appManager.ProcessManager.KillProcessAsync(currentId)); HttpUtils.WaitForSite(appManager.SiteUrl, delayBeforeRetry: 10000); process = await appManager.ProcessManager.GetCurrentProcessAsync(); Assert.NotEqual(startTime, process.StartTime); }); }
public void GoingBackInTimeShouldOverwriteModifiedFilesInRepo() { // Arrange string repositoryName = "Mvc3Application"; string appName = KuduUtils.GetRandomWebsiteName("GoBackOverwriteModified"); string verificationText = "Welcome to ASP.NET MVC!"; using (var repo = Git.CreateLocalRepository(repositoryName)) { string id = repo.CurrentId; ApplicationManager.Run(appName, appManager => { // Act appManager.GitDeploy(repositoryName); KuduAssert.VerifyUrl(appManager.SiteUrl, verificationText); repo.AppendFile(@"Mvc3Application\Views\Home\Index.cshtml", "Say Whattttt!"); // Make a small changes and commit them to the local repo Git.Commit(repositoryName, "This is a small changes"); // Push those changes appManager.GitDeploy(repositoryName); // Make a server site change and verify it shows up appManager.ProjectSystem.WriteAllText("Views/Home/Index.cshtml", "Hello world!"); Thread.Sleep(500); KuduAssert.VerifyUrl(appManager.SiteUrl, "Hello world!"); // Now go back in time appManager.DeploymentManager.DeployAsync(id).Wait(); var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList(); // Assert Assert.Equal(2, results.Count); Assert.Equal(DeployStatus.Success, results[0].Status); KuduAssert.VerifyUrl(appManager.SiteUrl, verificationText); }); } }