public async Task CustomGeneratorArgs()
{
await ApplicationManager.RunAsync("UpdatedTargetPathShouldChangeDeploymentDestination", async appManager =>
{
// Even though it's a WAP, use custom script generator arguments to treat it as a web site,
// deploying only its content folder
await appManager.SettingsManager.SetValue(SettingsKeys.ScriptGeneratorArgs, "--basic -p MvcApplication14/content");
using (TestRepository testRepository = Git.Clone("Mvc3AppWithTestProject"))
{
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 + "themes/base/jquery.ui.accordion.css", ".ui-accordion-header");
});
}
public void TestPositiveMatch()
{
// Arrange
string appName = "VersionPinnedNodeJsApp";
using (var repo = Git.Clone("VersionPinnedNodeJsApp"))
{
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, "v0.8.2");
});
}
}
public void PushingNonMasterBranchToMasterBranchShouldDeploy()
{
string repositoryName = "PushingNonMasterBranchToMasterBranchShouldDeploy";
string appName = KuduUtils.GetRandomWebsiteName("PushNonMasterToMaster");
string cloneUrl = "https://github.com/KuduApps/RepoWithMultipleBranches.git";
using (var repo = Git.Clone(repositoryName, cloneUrl))
{
Git.CheckOut(repo.PhysicalPath, "test");
ApplicationManager.Run(appName, appManager =>
{
// Act
appManager.GitDeploy(repo.PhysicalPath, "test", "master");
var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
// Assert
Assert.Equal(1, results.Count);
KuduAssert.VerifyUrl(appManager.SiteUrl, "Test branch");
});
}
}
public void GoingBackInTimeDeploysOldFiles()
{
string repositoryName = "Bakery10";
string appName = KuduUtils.GetRandomWebsiteName("GoBackDeployOld");
using (var repo = Git.CreateLocalRepository(repositoryName))
{
string originalCommitId = repo.CurrentId;
ApplicationManager.Run(appName, appManager =>
{
// Deploy the app
appManager.GitDeploy(repo.PhysicalPath);
var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(1, results.Count);
KuduAssert.VerifyUrl(appManager.SiteUrl);
// Add a file
File.WriteAllText(Path.Combine(repo.PhysicalPath, "hello.txt"), "Wow");
Git.Commit(repo.PhysicalPath, "Added hello.txt");
string helloUrl = appManager.SiteUrl + "/hello.txt";
// Deploy those changes
appManager.GitDeploy(repo.PhysicalPath);
results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(2, results.Count);
Assert.Equal(DeployStatus.Success, results[1].Status);
KuduAssert.VerifyUrl(helloUrl, "Wow");
// Go back to the first deployment
appManager.DeploymentManager.DeployAsync(originalCommitId).Wait();
results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
KuduAssert.VerifyUrl(helloUrl, statusCode: HttpStatusCode.NotFound);
Assert.Equal(2, results.Count);
});
}
}
private static void PushAndDeployApps(string name, string repoName, string repoCloneUrl, string defaultBranchName,
string verificationText, HttpStatusCode expectedResponseCode, string verificationLogText)
{
TestRepository testRepository = null;
string localRepo = KuduUtils.GetCachedRepositoryPath(repoName);
string randomTestName = KuduUtils.GetRandomWebsiteName(repoName);
if (localRepo == null)
{
testRepository = Git.Clone(randomTestName, repoCloneUrl);
localRepo = testRepository.PhysicalPath;
}
try
{
ApplicationManager.Run(randomTestName, appManager =>
{
// Act
appManager.GitDeploy(localRepo, 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());
}
});
}
finally
{
if (testRepository != null)
{
testRepository.Dispose();
}
}
}
public void PushRepoWithProjectAndNoSolutionShouldDeploy()
{
// Arrange
string repositoryName = "Mvc3Application_NoSolution";
string appName = KuduUtils.GetRandomWebsiteName("PushRepoWithProjNoSln");
string verificationText = "Kudu Deployment Testing: Mvc3Application_NoSolution";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
// 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, verificationText);
});
}
}
public void PushShouldOverwriteModifiedFilesInRepo()
{
// Arrange
string repositoryName = "Mvc3Application";
string appName = KuduUtils.GetRandomWebsiteName("PushOverwriteModified");
string verificationText = "Welcome to ASP.NET MVC!";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
// Act
appManager.GitDeploy(repo.PhysicalPath);
KuduAssert.VerifyUrl(appManager.SiteUrl, verificationText);
appManager.ProjectSystem.WriteAllText("Views/Home/Index.cshtml", "Hello world!");
// Sleep a little since it's a remote call
Thread.Sleep(500);
KuduAssert.VerifyUrl(appManager.SiteUrl, "Hello world!");
// Make an unrelated change (newline to the end of web.config)
repo.AppendFile(@"Mvc3Application\Web.config", "\n");
Git.Commit(repo.PhysicalPath, "This is a test");
appManager.GitDeploy(repo.PhysicalPath);
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);
});
}
}
public void AppNameWithSignalRWorks()
{
// Arrange
string repositoryName = "Mvc3Application";
string appName = KuduUtils.GetRandomWebsiteName("signalroverflow");
string verificationText = "Welcome to ASP.NET MVC!";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
// 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, verificationText);
});
}
}
public void PushSimpleRepoShouldDeploy()
{
// Arrange
string repositoryName = "Bakery10";
string appName = KuduUtils.GetRandomWebsiteName("PushSimpleRepo");
string verificationText = "Welcome to Fourth Coffee!";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
// 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, verificationText);
});
}
}
public void WapBuildsReleaseMode()
{
// Arrange
string repositoryName = "WapBuildsReleaseMode";
string appName = KuduUtils.GetRandomWebsiteName("WapBuildsRelease");
string cloneUrl = "https://github.com/KuduApps/ConditionalCompilation.git";
using (var repo = Git.Clone(repositoryName, cloneUrl))
{
ApplicationManager.Run(appName, appManager =>
{
// 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, null, "RELEASE MODE", "Context.IsDebuggingEnabled: False");
});
}
}
public void WebsiteWithIISExpressWorks()
{
// Arrange
string repositoryName = "WebsiteWithIISExpressWorks";
string appName = KuduUtils.GetRandomWebsiteName("WebsiteWithIISExpressWorks");
string cloneUrl = "https://github.com/KuduApps/waws.git";
using (var repo = Git.Clone(repositoryName, cloneUrl))
{
ApplicationManager.Run(appName, appManager =>
{
// 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, "Home");
});
}
}
//Common code
private static void PushAndDeployApps(string repoCloneUrl, string defaultBranchName,
string verificationText, HttpStatusCode expectedResponseCode, string verificationLogText,
string resourcePath = "", string httpMethod = "GET", string jsonPayload = "")
{
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(DeployStatus.Success, results[0].Status);
var url = new Uri(new Uri(appManager.SiteUrl), resourcePath);
KuduAssert.VerifyUrl(url.ToString(), verificationText, expectedResponseCode, httpMethod, jsonPayload);
if (!String.IsNullOrEmpty(verificationLogText))
{
KuduAssert.VerifyLogOutput(appManager, results[0].Id, verificationLogText.Trim());
}
});
}
}
public void PushRepoWithMultipleProjectsShouldDeploy()
{
// Arrange
string repositoryName = "Mvc3Application";
string appName = KuduUtils.GetRandomWebsiteName("PushMultiProjects");
string verificationText = "Welcome to ASP.NET MVC! - Change1";
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
// 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);
Assert.NotNull(results[0].LastSuccessEndTime);
KuduAssert.VerifyUrl(appManager.SiteUrl, verificationText);
});
}
}
public void NSimpleDeployments()
{
string repositoryName = "HelloKudu";
using (var repo = Git.Clone("HelloKudu"))
{
for (int i = 0; i < 5; i++)
{
string applicationName = repositoryName + i;
ApplicationManager.Run(applicationName, appManager =>
{
// 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, "Hello Kudu");
});
}
}
}
public void NSimpleDeployments()
{
string repositoryName = "HelloKudu";
string cloneUrl = "https://github.com/KuduApps/HelloKudu.git";
using (Git.Clone(repositoryName, cloneUrl))
{
for (int i = 0; i < 5; i++)
{
string applicationName = KuduUtils.GetRandomWebsiteName(repositoryName + i);
ApplicationManager.Run(applicationName, appManager =>
{
// Act
appManager.GitDeploy(repositoryName);
var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
// Assert
Assert.Equal(1, results.Count);
Assert.Equal(DeployStatus.Success, results[0].Status);
KuduAssert.VerifyUrl(appManager.SiteUrl, "Hello Kudu");
});
}
}
}
public void CloneFromEmptyRepoAndPushShouldDeploy()
{
string repositoryName = "CloneFromEmptyRepoAndPushShouldDeploy";
string appName = KuduUtils.GetRandomWebsiteName("CloneEmptyAndPush");
ApplicationManager.Run(appName, appManager =>
{
// Act
using (var repo = Git.Clone(repositoryName, appManager.GitUrl, createDirectory: true))
{
// Add a file
repo.WriteFile("hello.txt", "Wow");
Git.Commit(repo.PhysicalPath, "Added hello.txt");
string helloUrl = appManager.SiteUrl + "/hello.txt";
appManager.GitDeploy(repo.PhysicalPath);
var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
// Assert
Assert.Equal(1, results.Count);
KuduAssert.VerifyUrl(helloUrl, "Wow");
}
});
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Hello, new world");
}
private static void WriteLogText(string siteUrl, string filePath, string content)
{
string url = String.Format("{0}?path={1}&content={2}", siteUrl, filePath, content);
KuduAssert.VerifyUrl(url);
}
public void DeploymentApis()
{
// Arrange
string repositoryName = "Mvc3Application";
string appName = KuduUtils.GetRandomWebsiteName("DeploymentApis");
using (var repo = Git.CreateLocalRepository(repositoryName))
{
ApplicationManager.Run(appName, appManager =>
{
appManager.GitDeploy(repo.PhysicalPath);
var results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(1, results.Count);
var result = results[0];
Assert.Equal("Raquel Almeida", result.Author);
Assert.Equal("*****@*****.**", result.AuthorEmail);
Assert.True(result.Current);
Assert.Equal(DeployStatus.Success, result.Status);
Assert.NotNull(result.Url);
Assert.NotNull(result.LogUrl);
Assert.True(String.IsNullOrEmpty(result.Deployer));
ICredentials cred = appManager.DeploymentManager.Credentials;
KuduAssert.VerifyUrl(result.Url, cred);
KuduAssert.VerifyUrl(result.LogUrl, cred);
var resultAgain = appManager.DeploymentManager.GetResultAsync(result.Id).Result;
Assert.Equal("Raquel Almeida", resultAgain.Author);
Assert.Equal("*****@*****.**", resultAgain.AuthorEmail);
Assert.True(resultAgain.Current);
Assert.Equal(DeployStatus.Success, resultAgain.Status);
Assert.NotNull(resultAgain.Url);
Assert.NotNull(resultAgain.LogUrl);
KuduAssert.VerifyUrl(resultAgain.Url, cred);
KuduAssert.VerifyUrl(resultAgain.LogUrl, cred);
repo.WriteFile("HelloWorld.txt", "This is a test");
Git.Commit(repo.PhysicalPath, "Another commit");
appManager.GitDeploy(repo.PhysicalPath);
results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(2, results.Count);
string oldId = results[1].Id;
// Delete one
appManager.DeploymentManager.DeleteAsync(oldId).Wait();
results = appManager.DeploymentManager.GetResultsAsync().Result.ToList();
Assert.Equal(1, results.Count);
Assert.NotEqual(oldId, results[0].Id);
result = results[0];
// Redeploy
appManager.DeploymentManager.DeployAsync(result.Id).Wait();
// Clean deploy
appManager.DeploymentManager.DeployAsync(result.Id, clean: true).Wait();
var entries = appManager.DeploymentManager.GetLogEntriesAsync(result.Id).Result.ToList();
Assert.True(entries.Count > 0);
// First entry is always null
Assert.Null(entries[0].DetailsUrl);
var entryWithDetails = entries.First(e => e.DetailsUrl != null);
var nested = appManager.DeploymentManager.GetLogEntryDetailsAsync(result.Id, entryWithDetails.Id).Result.ToList();
Assert.True(nested.Count > 0);
KuduAssert.VerifyLogOutput(appManager, result.Id, "Cleaning git repository");
// Can't delete the active one
var ex = KuduAssert.ThrowsUnwrapped <HttpRequestException>(() => appManager.DeploymentManager.DeleteAsync(result.Id).Wait());
Assert.Equal("Response status code does not indicate success: 409 (Conflict).", ex.Message);
});
}
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Choose a NEW language");
}
public virtual void VerifyUrl(ApplicationManager appManager, string documentRoot)
{
KuduAssert.VerifyUrl(appManager.SiteUrl + documentRoot + @"/" + DefaultDocument, Content);
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Welcome to Fifth Coffee");
}
public void DeployVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl + "install.php", "Choose a language");
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Modify this new template to jump-start");
}
public void DeployVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Welcome to Fourth Coffee");
}
public void DeployVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Modify this template to jump-start");
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "To learn even more about");
}
public void DeployVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "To learn more about");
}
public void ChangeVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl + "index.html", "Hello New Kudu");
}
public void DeployVerify(string siteUrl)
{
KuduAssert.VerifyUrl(siteUrl, "Hello, world");
}