public async Task BuildsAndRunsNodeApp_WhenPruneDevDependenciesIsTrue_AndNodeModulesAreCompressed()
{
// Arrange
// Use a separate volume for output due to rsync errors
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var nodeVersion = "10";
var appOutputDirVolume = DockerVolume.CreateMirror(appOutputDirPath);
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_NetCore31WebApp()
{
// Arrange
var dotnetcoreVersion = "3.1";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", NetCoreApp31MvcApp);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform dotnet --language-version {dotnetcoreVersion} -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp30WebApp,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
_imageHelper.GetTestRuntimeImage("dotnetcore", dotnetcoreVersion),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Welcome to ASP.NET Core MVC!", data);
});
}
public async Task CanBuildAndRun_NetCoreApp10WebApp()
{
// Arrange
var dotNetCoreVersion = "1.0";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", "aspnetcore10");
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} --platform dotnet --language-version {dotNetCoreVersion} -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"oryx -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp11WebApp,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
$"oryxdevmcr.azurecr.io/public/oryx/dotnetcore-{dotNetCoreVersion}",
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", data);
});
}
public void CanBuildVuePressSampleAppWithPruneDevDependencies()
{
// Arrange
var appName = "vuepress";
var volume = DockerVolume.CreateMirror(Path.Combine(_hostSamplesDir, "nodejs", appName));
// Make sure 'vuepress' package is in 'dependencies' node because that is what triggered the original issue
var packageJsonContent = File.ReadAllText(Path.Combine(volume.OriginalHostDir, "package.json"));
dynamic packageJson = JsonConvert.DeserializeObject(packageJsonContent);
Assert.NotNull(packageJson);
Assert.NotNull(packageJson.dependencies);
Assert.NotNull(packageJson.dependencies.vuepress);
Assert.Null(packageJson.devDependencies);
var appDir = volume.ContainerDir;
var appOutputDir = "/tmp/vuepress-output";
var script = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {appOutputDir} -p {NodePlatform.PruneDevDependenciesPropertyKey}")
.AddDirectoryExistsCheck($"{appOutputDir}/node_modules/vuepress")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = Settings.LtsVersionsBuildImageName,
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", script }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
},
result.GetDebugInfo());
}
public async Task CanBuildAndRun_NetCore21WebApp_HavingMultipleProjects()
{
// Arrange
var appName = "NetCoreApp22MultiProjectApp";
var dotnetcoreVersion = "2.2";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var repoDir = volume.ContainerDir;
var appOutputDir = $"{repoDir}/myoutputdir";
var buildImageScript = new ShellScriptBuilder()
.AddCommand($"oryx build {repoDir} -o {appOutputDir}")
.ToString();
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
_imageHelper.GetRuntimeImage("dotnetcore", dotnetcoreVersion),
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 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 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 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 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);
});
}
public async Task CanBuildAndRun_FSharpNetCoreApp21WebApp_WithoutSpecifyingLanguageExplicitly()
{
// 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 -appPath {appOutputDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp22WebApp,
_output,
volume,
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
_imageHelper.GetTestRuntimeImage("dotnetcore", "2.1"),
ContainerPort,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!", 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 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);
});
}
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 void BuildsAppAfterInstallingAllRequiredPlatforms()
{
// Arrange
var appName = "dotNetCoreReactApp";
var hostDir = Path.Combine(_hostSamplesDir, "multilanguage", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildScript = new ShellScriptBuilder()
.AddBuildCommand(
$"{appDir} -o {appOutputDir} --platform {DotNetCoreConstants.PlatformName} --platform-version 3.1")
.AddFileExistsCheck($"{appOutputDir}/dotNetCoreReactApp.dll")
.AddDirectoryExistsCheck($"{appOutputDir}/ClientApp/build")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = _imageHelper.GetGitHubActionsBuildImage(),
EnvironmentVariables = new List <EnvironmentVariable> {
CreateAppNameEnvVar(appName)
},
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", buildScript }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.Contains("Using .NET Core SDK Version: ", result.StdOut);
Assert.Contains("react-scripts build", result.StdOut);
},
result.GetDebugInfo());
}
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);
});
}
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 CanBuildAndRunApp(string phpVersion)
{
// Arrange
var exifImageTypePng = "3";
var appName = "exif-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddDefaultTestEnvironmentVariables()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {appOutputDir} " +
$"--platform {PhpConstants.PlatformName} --platform-version {phpVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appOutputDir} -output {RunScriptPath}")
.AddCommand(RunScriptPath)
.ToString();
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new[] { volume, appOutputDirVolume },
_imageHelper.GetGitHubActionsBuildImage(),
"/bin/sh", new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("php", phpVersion),
ContainerPort,
"/bin/sh", new[] { "-c", runScript },
async (hostPort) =>
{
string exifOutput = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
// The test app: `echo exif_imagetype('64x64.png')`
Assert.Equal(exifImageTypePng, exifOutput);
});
}
public async Task CanBuildAndRun_NetCore11WebApp_HavingExplicitAssemblyName()
{
// Arrange
var appName = "NetCoreApp11WithExplicitAssemblyName";
var dotnetcoreVersion = "1.1";
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var containerPort = "9095";
var portMapping = $"{HostPort}:{containerPort}";
var startupFilePath = "/tmp/run.sh";
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand($"oryx -sourcePath {appDir} -output {startupFilePath}")
.AddCommand($"export ASPNETCORE_URLS=http://*:{containerPort}")
.AddCommand(startupFilePath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "dotnet", "--language-version", dotnetcoreVersion },
$"oryxdevms/dotnetcore-{dotnetcoreVersion}",
portMapping,
"/bin/sh",
new[]
{
"-c",
runtimeImageScript
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello World!", data);
});
}
public async Task CanRunApp_WithoutBuildManifestFile()
{
// Arrange
var golangVersion = "1.17";
var hostDir = Path.Combine(_hostSamplesDir, "golang", GolangHelloWorldWebApp);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var runtimeImageScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {appOutputDir} " +
$"--platform {GolangConstants.PlatformName} --platform-version {golangVersion}")
.AddCommand(
$"oryx run-script {appOutputDir} --output {DefaultStartupFilePath} --debug")
.AddCommand(DefaultStartupFilePath)
.ToString();
// Assert
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : "oryxdevmcr.azurecr.io/public/oryx/build:full",
output : _output,
volumes : new List <DockerVolume> {
appOutputDirVolume, volume
},
environmentVariables : null,
port : ContainerPort,
link : null,
runCmd : "/bin/sh",
runArgs : new[] { "-c", runtimeImageScript },
assertAction : async(hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World!!!", data);
},
dockerCli : new DockerCli());
}
public void CanBuildAppHavingAppDynamicsNpmPackage()
{
// Arrange
// Create an app folder with a package.json having the 'appdynamics' package
var packageJsonContent = "{\"dependencies\": { \"appdynamics\": \"20.10.1\" }}";
var sampleAppPath = Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(sampleAppPath);
File.WriteAllText(Path.Combine(sampleAppPath, NodeConstants.PackageJsonFileName), packageJsonContent);
var volume = DockerVolume.CreateMirror(sampleAppPath);
var appDir = volume.ContainerDir;
var appOutputDir = "/tmp/output";
var script = new ShellScriptBuilder()
.AddBuildCommand($"{appDir} -i /tmp/int -o {appOutputDir}")
.AddDirectoryExistsCheck($"{appOutputDir}/node_modules")
.AddDirectoryExistsCheck($"{appOutputDir}/node_modules/appdynamics")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = Settings.LtsVersionsBuildImageName,
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", script }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
},
result.GetDebugInfo());
}
public async Task Node_CreateReactAppSample_singleImage()
{
// Arrange
var appName = "create-react-app-sample";
var nodeVersion = "10";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:3000";
var startupFile = "/tmp/startup.sh";
var runScript = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx run-script --appPath {appDir} --output {startupFile} --platform nodejs --platform-version {nodeVersion}")
.AddCommand($"chmod +x {startupFile}")
.AddCommand(startupFile)
.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.Contains("<title>React App</title>", data);
});
}
public async Task PhpFpmGreetingsAppTest(string phpVersion)
{
// Arrange
var appName = "greetings";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -i /tmp/int -o {appOutputDir} " +
$"--platform php --platform-version {phpVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appOutputDir} -output {RunScriptPath} -bindPort {ContainerPort}")
.AddCommand("mkdir -p /home/site/wwwroot")
.AddCommand($"cp -rf {appOutputDir}/* /home/site/wwwroot")
.AddCommand(RunScriptPath)
.ToString();
var phpimageVersion = string.Concat(phpVersion, "-", "fpm");
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName, _output, new[] { volume, appOutputDirVolume },
"/bin/sh", new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("php", phpimageVersion),
ContainerPort,
"/bin/sh", new[] { "-c", runScript },
async (hostPort) =>
{
var output = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Hello World", output);
Assert.Contains("oryx oryx oryx", output);
});
}
public void MultiPlatformBuild_IsDisabled()
{
// Arrange
var appName = "dotnetreact";
var hostDir = Path.Combine(_hostSamplesDir, "multilanguage", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildScript = new ShellScriptBuilder()
.AddCommand("export ENABLE_MULTIPLATFORM_BUILD=true")
.AddBuildCommand($"{appDir} -o {appOutputDir} -l dotnet --language-version 2.2")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = Settings.BuildImageName,
EnvironmentVariables = new List <EnvironmentVariable> {
CreateAppNameEnvVar(appName)
},
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", buildScript }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.DoesNotContain(@"npm install", result.StdOut);
},
result.GetDebugInfo());
}
public async Task CanBuildAndRun_ShapelyFlaskApp_PackageDir(string pythonVersion)
{
// Arrange
const string packageDir = "orx_packages";
var appName = "shapely-flask-app";
var hostDir = Path.Combine(_hostSamplesDir, "python", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort} -packagedir {packageDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var imageVersion = "oryxdevms/python-" + pythonVersion;
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
volume,
"oryx",
new[] { "build", appDir, "-l", "python", "--language-version", pythonVersion, "-p", $"packagedir={packageDir}" },
imageVersion,
portMapping,
"/bin/bash",
new[]
{
"-c",
script
},
async() =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Hello Shapely, Area is: 314", data);
});
}
public void CanUseDotNetCoreAsPartOfMultiPlatformBuild()
{
// Arrange
var appName = "dotnetreact";
var hostDir = Path.Combine(_hostSamplesDir, "multilanguage", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDir = $"{appDir}/myoutputdir";
var buildScript = new ShellScriptBuilder()
.AddCommand($"export {BuildScriptGeneratorCli.SettingsKeys.EnableMultiPlatformBuild}=true")
.AddBuildCommand($"{appDir} -o {appOutputDir} --platform {DotNetCoreConstants.PlatformName} --platform-version 2.2")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = Settings.BuildImageName,
EnvironmentVariables = new List <EnvironmentVariable> {
CreateAppNameEnvVar(appName)
},
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", buildScript }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
Assert.Contains(@"npm install", result.StdOut);
},
result.GetDebugInfo());
}
public async Task PhpFpmGdExample(string phpVersion)
{
// Arrange
var appName = "gd-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var buildScript = new ShellScriptBuilder()
.AddCommand($"oryx build {appDir} -i /tmp/int -o {appOutputDir} " +
$"--platform {PhpConstants.PlatformName} --platform-version {phpVersion}")
.ToString();
var runScript = new ShellScriptBuilder()
.AddCommand($"oryx create-script -appPath {appOutputDir} -output {RunScriptPath}")
.AddCommand("mkdir -p /home/site/wwwroot")
.AddCommand($"cp -rf {appOutputDir}/* /home/site/wwwroot")
.AddCommand(RunScriptPath)
.ToString();
var phpimageVersion = string.Concat(phpVersion, "-", "fpm");
// Act & Assert
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName, _output, new[] { volume, appOutputDirVolume },
"/bin/sh", new[] { "-c", buildScript },
_imageHelper.GetRuntimeImage("php", phpimageVersion),
ContainerPort,
"/bin/sh", new[] { "-c", runScript },
async (hostPort) =>
{
string gdInfoOutput = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
// The test app: `echo $info['JPEG Support'] . ',' . $info['PNG Support']`
Assert.Equal("1,1", gdInfoOutput);
});
}
public async Task NodeStartupScript_UsesSuppliedBindingPort_EvenIfPortEnvironmentVariableValue_IsPresent()
{
// Arrange
var nodeVersion = "10.14";
var appName = "webfrontend";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:{ContainerPort}";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"export PORT=9095")
.AddCommand($"oryx -appPath {appDir} -bindPort {ContainerPort}")
.AddCommand(DefaultStartupFilePath)
.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 data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Say It Again", data);
});
}
public void GeneratesScript_AndBuilds_UsingSuppliedPackageDir_WhenPackageDirAndSourceDirAreSame()
{
// Arrange
var volume = DockerVolume.CreateMirror(
Path.Combine(_hostSamplesDir, "nodejs", "monorepo-lerna-yarn"));
var appDir = volume.ContainerDir;
var script = new ShellScriptBuilder()
.SetEnvironmentVariable(
SdkStorageConstants.SdkStorageBaseUrlKeyName,
SdkStorageConstants.DevSdkStorageBaseUrl)
.SetEnvironmentVariable(
SettingsKeys.EnableNodeMonorepoBuild,
true.ToString())
.AddBuildCommand($"{appDir} --package -p {NodePlatform.PackageDirectoryPropertyKey}=''")
.AddFileExistsCheck($"{appDir}/lerna-monorepo-post-1.0.0.tgz")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = Settings.BuildImageName,
Volumes = new List <DockerVolume> {
volume
},
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", script }
});
// Assert
RunAsserts(
() =>
{
Assert.True(result.IsSuccess);
},
result.GetDebugInfo());
}
public async Task NodeApp_WithYarnLock()
{
// Arrange
var appName = "webfrontend-yarnlock";
var nodeVersion = "10.14";
var hostDir = Path.Combine(_hostSamplesDir, "nodejs", appName);
var volume = DockerVolume.Create(hostDir);
var appDir = volume.ContainerDir;
var portMapping = $"{HostPort}:80";
var startupFile = "/tmp/startup.sh";
var script = new ShellScriptBuilder()
.AddCommand($"cd {appDir}")
.AddCommand($"oryx -appPath {appDir} -output {startupFile}")
.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 data = await _httpClient.GetStringAsync($"http://localhost:{HostPort}/");
Assert.Contains("Say It Again", data);
});
}
