public async Task WordPress51(string phpVersion)
{
// Arrange
string hostDir = Path.Combine(_hostTempDir, "wordpress");
if (!Directory.Exists(hostDir))
{
using (var webClient = new WebClient())
{
var wpZipPath = Path.Combine(_hostTempDir, "wp.zip");
webClient.DownloadFile("https://wordpress.org/wordpress-5.1.zip", wpZipPath);
// The ZIP already contains a `wordpress` folder
ZipFile.ExtractToDirectory(wpZipPath, _hostTempDir);
}
}
var appName = "wordpress";
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -l php --language-version {phpVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -output {RunScriptPath}")
.AddCommand(RunScriptPath)
.ToString();
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName, _output, volume,
"/bin/sh", new[] { "-c", buildScript },
$"oryxdevms/php-{phpVersion}",
ContainerPort,
"/bin/sh", new[] { "-c", runScript },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<title>WordPress › Setup Configuration File</title>", data);
});
}
// pdo_sqlsrv only supports PHP >= 7.1
public async Task PhpApp_UsingPdo(string phpVersion)
{
// Arrange
var appName = "sqlsrv-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
volume
},
Settings.BuildImageName,
"oryx",
new[] { "build", appDir, "-l", "php", "--language-version", phpVersion },
_imageHelper.GetRuntimeImage("php", phpVersion),
GetEnvironmentVariables(),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal(
DbContainerFixtureBase.GetSampleDataAsJson(),
data.Trim(),
ignoreLineEndingDifferences: true,
ignoreWhiteSpaceDifferences: true);
});
}
public async Task CanBuildAndRunPythonApp(string pythonVersion)
{
// Arrange
var appName = "flask-app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand(GetSnippetToCleanUpExistingInstallation())
.SetEnvironmentVariable(SettingsKeys.EnableDynamicInstall, true.ToString())
.SetEnvironmentVariable(
SdkStorageConstants.SdkStorageBaseUrlKeyName,
SdkStorageConstants.DevSdkStorageBaseUrl)
.AddCommand(
$"oryx build {appDir} --platform {PythonConstants.PlatformName} --platform-version {pythonVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.SetEnvironmentVariable(
SdkStorageConstants.SdkStorageBaseUrlKeyName,
SdkStorageConstants.DevSdkStorageBaseUrl)
.AddCommand($"oryx setupEnv -appPath {appDir}")
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new[] { volume },
_imageHelper.GetLtsVersionsBuildImage(),
"/bin/bash", new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("python", "dynamic"),
ContainerPort,
"/bin/bash",
new[] { "-c", runScript },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanBuildAndRunPythonApp_UsingPython37_AndVirtualEnv()
{
// Arrange
var appName = "flask-app";
var virtualEnvName = "antenv";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -p virtualenv_name={virtualEnvName} --platform {PythonConstants.PlatformName} --platform-version 3.7")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
_imageHelper.GetRuntimeImage("python", "3.7"),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanRunApp_UsingPreRunCommand_FromBuildEnvFile()
{
// Arrange
var phpVersion = "7.3";
var appName = "twig-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var expectedFileInOutputDir = Guid.NewGuid().ToString("N");
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform {PhpConstants.PlatformName} --platform-version {phpVersion}")
// Create a 'build.env' file
.AddCommand(
$"echo '{FilePaths.PreRunCommandEnvVarName}=\"echo > {expectedFileInOutputDir}\"' > " +
$"{appDir}/{BuildScriptGeneratorCli.Constants.BuildEnvironmentFileName}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -output {RunScriptPath}")
.AddCommand(RunScriptPath)
.ToString();
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh", new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("php", phpVersion),
ContainerPort,
"/bin/sh", new[] { "-c", runScript },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<h1>Hello World!</h1>", data);
// Verify that the file created using the pre-run command is
// in fact present in the output directory.
Assert.True(File.Exists(Path.Combine(volume.MountedHostDir, expectedFileInOutputDir)));
});
}
public async Task CanBuildAndRun_NodeExpressApp_UsingSingleImage_AndCustomStartupCommandOnly()
{
// Arrange
var appName = "linxnodeexpress";
var nodeVersion = "10";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
// Create a custom startup command
const string customRunCommand = "'npm start'";
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform {NodeConstants.PlatformName} --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx run-script {appDir} --debug --platform {NodeConstants.PlatformName} --platform-version {nodeVersion} " +
$"--output {DefaultStartupFilePath} -- -bindPort {ContainerPort} " +
$"-userStartupCommand {customRunCommand}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName : appName,
output : _output,
volume : volume,
buildCmd : "/bin/sh",
buildArgs : new[] { "-c", buildScript },
runtimeImageName : _imageHelper.GetBuildImage(),
ContainerPort,
runCmd : "/bin/sh",
runArgs : new[]
{
"-c",
runScript
},
assertAction : async(hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal("Hello World from express!", data);
});
}
public async Task Python37App_MicrosoftSqlServerDB(string imageTag)
{
// Arrange
var appName = "mssqlserver-sample";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
volume
},
_imageHelper.GetBuildImage(imageTag),
"oryx",
new[] { "build", appDir, "--platform", "python", "--platform-version", "3.7" },
_imageHelper.GetRuntimeImage("python", "3.7"),
SqlServerDbTestHelper.GetEnvironmentVariables(),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal(
DbContainerFixtureBase.GetSampleDataAsJson(),
data.Trim(),
ignoreLineEndingDifferences: true,
ignoreWhiteSpaceDifferences: true);
});
}
public async Task NodeStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var nodeVersion = NodeVersion;
var appName = "webfrontend";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform {NodeConstants.PlatformName} --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT=9095")
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task CanBuildAndRun_NodeWebFrontEndApp_WhenPruneDevDependenciesIsTrue(string appName)
{
// Arrange
var nodeVersion = "10";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} --platform {NodeConstants.PlatformName} --platform-version {nodeVersion} " +
$"-p {NodePlatform.PruneDevDependenciesPropertyKey}=true")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task Node_CreateReactAppSample_zippedNodeModules(string nodeVersion)
{
// Arrange
// Use a separate volume for output due to rsync errors
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var appOutputDirVolume = DockerVolume.CreateMirror(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var appName = "create-react-app-sample";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o /tmp/out --platform nodejs " +
$"--platform-version {nodeVersion} -p compress_node_modules=zip")
.AddCommand($"cp -rf /tmp/out/* {appOutputDir}")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/bash",
new[] { "-c", buildScript },
$"oryxdevmcr.azurecr.io/public/oryx/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[] { "-c", runAppScript },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<title>React App</title>", data);
});
}
public async Task CanBuildAndRun_NodeExpressApp_UsingSingleImage_AndCustomStartupCommandOnly()
{
// Arrange
var appName = "linxnodeexpress";
var nodeVersion = "10";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
const int localPort = 8080;
var portMapping = $"{HostPort}:{localPort}";
// Create a custom startup command
const string customStartupScriptCommand = "'npm start'";
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx run-script --appPath {appDir} --platform nodejs --platform-version {nodeVersion} --userStartupCommand {customStartupScriptCommand} --debug")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName : appName,
output : _output,
volume : volume,
buildCmd : "oryx",
buildArgs : new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
runtimeImageName : $"oryxdevms/build",
portMapping : portMapping,
runCmd : "/bin/sh",
runArgs : new[]
{
"-c",
runScript
},
assertAction : async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Equal("Hello World from express!", data);
});
}
public async Task CanBuildAndRun_FSharpNetCoreApp21WebApp_WithoutSpecifyingPlatformExplicitly()
{
// Arrange
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", "FSharpNetCoreApp21.WebApp");
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"oryx create-script -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp22WebApp,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
_imageHelper.GetRuntimeImage("dotnetcore", "2.1"),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task NodeApp_MicrosoftSqlServerDB()
{
// Arrange
var appName = "node-mssql";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
volume
},
Settings.BuildImageName,
"oryx",
new[] { "build", appDir, "-l", "nodejs", "--language-version", "10.14" },
"oryxdevms/node-10.14",
GetEnvironmentVariables(),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
script
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Equal(
DbContainerFixtureBase.GetSampleDataAsJson(),
data.Trim(),
ignoreLineEndingDifferences: true,
ignoreWhiteSpaceDifferences: true);
});
}
public async Task NodeStartupScript_UsesPortEnvironmentVariableValue()
{
// Arrange
var nodeVersion = "10.14";
var appName = "webfrontend";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -l nodejs --language-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT={ContainerPort}")
.AddCommand($"oryx -appPath {appDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task CanBuildNodeAppUsingScriptsNodeInPackageJson()
{
// Arrange
var appName = "NodeAndTypeScriptHelloWorld";
var nodeVersion = NodeVersion;
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform {NodeConstants.PlatformName} --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("{\"message\":\"Hello World!\"}", data);
});
}
public async Task CanBuildAndRunPythonApp_UsingPython27_AndExplicitOutputStartupFile()
{
// Arrange
var appName = "python2-flask-app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var startupFile = "/tmp/startup.sh";
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform python --language-version 2.7")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -output {startupFile} -bindPort {ContainerPort}")
.AddCommand(startupFile)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
_imageHelper.GetTestRuntimeImage("python", "2.7"),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanBuildAndRun_Angular6NodeApp_WithoutZippingNodeModules(string nodeVersion)
{
// Arrange
var appName = "angular6app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform nodejs --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT=4200")
.AddCommand($"oryx -appPath {appDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevmcr.azurecr.io/public/oryx/node-{nodeVersion}",
4200,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Angular6app", data);
});
}
public async Task PythonStartupScript_UsesPortEnvironmentVariableValue()
{
// Arrange
var appName = "flask-app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT={ContainerPort}")
.AddCommand($"oryx -appPath {appDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
"oryxdevmcr.azurecr.io/public/oryx/python-3.7",
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task Node_CreateReactAppSample()
{
// Arrange
var appName = "create-react-app-sample";
var nodeVersion = "10.14";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -l nodejs --language-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevms/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<title>React App</title>", data);
});
}
public async Task PythonStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var appName = "flask-app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT=9095")
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
_imageHelper.GetTestRuntimeImage("python", "3.7"),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task Node_CreateReactAppSample()
{
// Arrange
var appName = "create-react-app-sample";
var nodeVersion = NodeVersion;
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform {NodeConstants.PlatformName} --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("<title>React App</title>", data);
});
}
protected async Task RunTestAsync(string language, string languageVersion, string samplePath,
int containerPort = 8000, bool specifyBindPortFlag = true)
{
var volume = DockerVolume.Create(samplePath);
var appDir = volume.ContainerDir;
var portMapping = $"{_appPort}:{containerPort}";
var entrypointScript = "./run.sh";
var bindPortFlag = specifyBindPortFlag ? $"-bindPort {containerPort}" : string.Empty;
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} {bindPortFlag}")
.AddCommand(entrypointScript)
.ToString();
var runtimeImageName = $"oryxdevms/{language}-{languageVersion}";
if (string.Equals(language, "nodejs", StringComparison.OrdinalIgnoreCase))
{
runtimeImageName = $"oryxdevms/node-{languageVersion}";
}
string link = $"{_dbFixture.DbServerContainerName}:{Constants.InternalDbLinkName}";
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
_output,
new List <DockerVolume> {
volume
},
"oryx", new[] { "build", appDir, "-l", language, "--language-version", languageVersion },
runtimeImageName,
_dbFixture.GetCredentialsAsEnvVars(),
portMapping, link,
"/bin/sh", new[] { "-c", script },
async() =>
{
var data = await HttpClient.GetStringAsync($"http://localhost:{_appPort}/");
Assert.Equal(_dbFixture.GetSampleDataAsJson(), data.Trim(), ignoreLineEndingDifferences: true, ignoreWhiteSpaceDifferences: true);
});
}
public async Task BuildsAndRunsNodeApp_WhenPruneDevDependenciesIsTrue_AndNodeModulesAreCompressed()
{
// Arrange
// Use a separate volume for output due to rsync errors
var nodeVersion = "10";
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var appName = "webfrontend";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {appOutputDir} --platform {NodeConstants.PlatformName} " +
$"--platform-version {nodeVersion} -p {NodePlatform.CompressNodeModulesPropertyKey}=zip" +
$" -p {NodePlatform.PruneDevDependenciesPropertyKey}=true")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
}, Settings.LtsVersionsBuildImageName,
"/bin/bash",
new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[] { "-c", runAppScript },
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Say It Again", data);
});
}
public async Task CanBuildAndRun_ShapelyFlaskApp_UsingVirtualEnv(string pythonVersion)
{
// Arrange
var appName = "shapely-flask-app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform python --language-version {pythonVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var imageVersion = "oryxdevmcr.azurecr.io/public/oryx/python-" + pythonVersion;
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
imageVersion,
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello Shapely, Area is: 314", data);
});
}
public async Task CanBuildAndRun_Tweeter3App()
{
// Arrange
var appName = "tweeter3";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.SetEnvironmentVariable(EnvironmentSettingsKeys.PostBuildCommand, "scripts/postbuild.sh")
.AddCommand($"oryx build {appDir} --platform python --platform-version 3.7")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/bash",
new[]
{
"-c",
buildScript
},
_imageHelper.GetTestRuntimeImage("python", "3.7"),
ContainerPort,
"/bin/bash",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("logged in as: bob", data);
});
}
public async Task Node_Lab2AppServiceApp()
{
// Arrange
var appName = "lab2-appservice";
var nodeVersion = "10.14";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform nodejs --language-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetTestRuntimeImage("node", nodeVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Welcome to Express", data);
});
}
public async Task Node_SoundCloudNgrxApp()
{
// Arrange
var appName = "soundcloud-ngrx";
var nodeVersion = "8.11";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:3000";
var startupFile = "./run.sh";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir}")
.AddCommand($"npm rebuild node-sass") //remove this once workitem 762584 is done
.AddCommand(startupFile)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "nodejs", "--language-version", nodeVersion },
$"oryxdevms/node-{nodeVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
script
},
async() =>
{
var response = await _httpClient.GetAsync($"http://localhost:{HostPort}/");
Assert.True(response.IsSuccessStatusCode);
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("<title>SoundCloud • Angular2 NgRx</title>", data);
});
}
public async Task CanBuildNodeAppUsingScriptsNodeInPackageJson()
{
// Arrange
var appName = "NodeAndTypeScriptHelloWorld";
var nodeVersion = "10.14";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform nodejs --language-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevmcr.azurecr.io/public/oryx/node-{nodeVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("{\"message\":\"Hello World!\"}", data);
});
}
public async Task CanBuildAndRun_BlogStarterNextJsApp_WithoutZippingNodeModules()
{
// Arrange
var nodeVersion = "10";
var volume = CreateAppVolume(AppName);
var appDir = volume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform nodejs --platform-version {nodeVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"export PORT={ContainerAppPort}")
.AddCommand($"oryx -appPath {appDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
AppName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildScript
},
$"oryxdevmcr.azurecr.io/public/oryx/node-{nodeVersion}",
ContainerAppPort,
"/bin/sh",
new[]
{
"-c",
runScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Welcome to your new blog built with Next.js", data);
});
}
public async Task Python27App_virtualEnv()
{
// Arrange
var appName = "python2-flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
const string virtualEnvName = "antenv2.7";
var startupFile = "/tmp/startup.sh";
var portMapping = $"{HostPort}:5000";
var script = new ShellScriptBuilder()
// Mimic the commands ran by app service in their derived image.
.AddCommand("pip install gunicorn")
.AddCommand("pip install flask")
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFile} -hostBind=\":5000\" -virtualEnvName={virtualEnvName}")
.AddCommand(startupFile)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "python", "--language-version", "2.7", "-p", $"virtualenv_name={virtualEnvName}" },
"oryxdevms/python-2.7",
portMapping,
"/bin/bash",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
