public async Task CanBuildAndRun_NetCore31MvcApp_UsingPreRunCommand_WithDynamicInstall()
{
// Arrange
var runtimeVersion = "3.1";
var appName = NetCoreApp31MvcApp;
var hostDir = Path.Combine(_hostSamplesDir, "DotNetCore", appName);
var volume = DockerVolume.CreateMirror(hostDir);
var appDir = volume.ContainerDir;
var appOutputDirVolume = CreateAppOutputDirVolume();
var appOutputDir = appOutputDirVolume.ContainerDir;
var buildImageScript = new ShellScriptBuilder()
.AddDefaultTestEnvironmentVariables()
.AddCommand(
$"oryx build {appDir} -i /tmp/int " +
$"--platform dotnet --platform-version {runtimeVersion} -o {appOutputDir}")
.ToString();
// split run script to test pre-run command before running the app.
var runtimeImageScript = new ShellScriptBuilder()
.AddDefaultTestEnvironmentVariables()
.SetEnvironmentVariable(FilePaths.PreRunCommandEnvVarName,
$"\"touch {appOutputDir}/_test_file.txt\ntouch {appOutputDir}/_test_file_2.txt\"")
.AddCommand($"oryx create-script -appPath {appOutputDir} -output {RunScriptPath} -bindPort {ContainerPort}")
.AddCommand($"LINENUMBER=\"$(grep -n '# End of pre-run' {RunScriptPath} | cut -f1 -d:)\"")
.AddCommand($"eval \"head -n +${{LINENUMBER}} {RunScriptPath} > {RunScriptPreRunPath}\"")
.AddCommand($"chmod +x {RunScriptPreRunPath}")
.AddCommand($"LINENUMBERPLUSONE=\"$(expr ${{LINENUMBER}} + 1)\"")
.AddCommand($"eval \"tail -n +${{LINENUMBERPLUSONE}} {RunScriptPath} > {RunScriptTempPath}\"")
.AddCommand($"mv {RunScriptTempPath} {RunScriptPath}")
.AddCommand($"head -n +1 {RunScriptPreRunPath} | cat - {RunScriptPath} > {RunScriptTempPath}")
.AddCommand($"mv {RunScriptTempPath} {RunScriptPath}")
.AddCommand($"chmod +x {RunScriptPath}")
.AddCommand($"unset LINENUMBER")
.AddCommand($"unset LINENUMBERPLUSONE")
.AddCommand(RunScriptPreRunPath)
.AddFileExistsCheck($"{appOutputDir}/_test_file.txt")
.AddFileExistsCheck($"{appOutputDir}/_test_file_2.txt")
.AddCommand(RunScriptPath)
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
NetCoreApp31MvcApp,
_output,
new[] { volume, appOutputDirVolume },
_imageHelper.GetGitHubActionsBuildImage(),
"/bin/sh",
new[]
{
"-c",
buildImageScript
},
_imageHelper.GetRuntimeImage("dotnetcore", "3.1"),
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 void ListsPlatformsAndVersionsAvailableForDynamicInstall()
{
// Arrange
var script = new ShellScriptBuilder()
.AddDefaultTestEnvironmentVariables()
// get in json format so that it can be deserialized and verified
.AddCommand("oryx platforms --json")
.ToString();
// Act
var result = _dockerCli.Run(new DockerRunArguments
{
ImageId = _imageHelper.GetGitHubActionsBuildImage(),
CommandToExecuteOnRun = "/bin/bash",
CommandArguments = new[] { "-c", script }
});
// Assert
var actualResults = JsonConvert.DeserializeObject <List <PlatformResult> >(result.StdOut);
RunAsserts(
() =>
{
Assert.NotNull(actualResults);
var dotNetCorePlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(DotNetCoreConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(dotNetCorePlatform);
Assert.NotNull(dotNetCorePlatform.Versions);
Assert.True(dotNetCorePlatform.Versions.Any());
Assert.True(dotNetCorePlatform.Versions.Contains("1.1.13"));
Assert.True(dotNetCorePlatform.Versions.Contains("5.0.0-preview.3.20214.6"));
var nodePlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(NodeConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(nodePlatform);
Assert.NotNull(nodePlatform.Versions);
Assert.True(nodePlatform.Versions.Any());
Assert.True(nodePlatform.Versions.Contains("4.4.7"));
var pythonPlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(PythonConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(pythonPlatform);
Assert.NotNull(pythonPlatform.Versions);
Assert.True(pythonPlatform.Versions.Any());
Assert.True(pythonPlatform.Versions.Contains("2.7.17"));
Assert.True(pythonPlatform.Versions.Contains("3.8.4rc1"));
Assert.True(pythonPlatform.Versions.Contains("3.9.0b1"));
Assert.True(pythonPlatform.Versions.Contains("3.9.0"));
var phpPlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(PhpConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(phpPlatform);
Assert.NotNull(phpPlatform.Versions);
Assert.True(phpPlatform.Versions.Any());
Assert.True(phpPlatform.Versions.Contains("5.6.40"));
var hugoPlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(HugoConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(hugoPlatform);
Assert.NotNull(hugoPlatform.Versions);
Assert.True(hugoPlatform.Versions.Any());
Assert.True(hugoPlatform.Versions.Contains(HugoConstants.Version));
var rubyPlatform = actualResults
.Where(pr => pr.Name.EqualsIgnoreCase(RubyConstants.PlatformName))
.FirstOrDefault();
Assert.NotNull(rubyPlatform);
Assert.NotNull(rubyPlatform.Versions);
Assert.True(rubyPlatform.Versions.Any());
Assert.True(rubyPlatform.Versions.Contains("2.6.6"));
Assert.True(rubyPlatform.Versions.Contains("2.7.1"));
},
result.GetDebugInfo());
}
public async Task Check_If_Apache_Allows_Casing_In_PHP_File_Extension(string imageTag)
{
// Arrange
var appName = "imagick-example";
var hostDir = Path.Combine(_hostSamplesDir, "php", appName);
var volume = CreateSampleAppVolume(hostDir);
var appDir = volume.ContainerDir;
var testSiteConfigApache2 =
@"<VirtualHost *:80>
\nServerAdmin php-x@localhost
\nDocumentRoot /var/www/php-x/
\nServerName localhost
\nServerAlias www.php-x.com
\n<Directory />
\n Options FollowSymLinks
\n AllowOverride None
\n</Directory>
\n<Directory /var/www/php-x/>
Require all granted
\n</Directory>
\nErrorLog /var/www/php-x/error.log
\nCustomLog /var/www/php-x/access.log combined
</VirtualHost>";
int containerPort = 8080;
var customSiteConfig = @"echo '" + testSiteConfigApache2 + "' > /etc/apache2/sites-available/php-x.conf";
var portConfig = @"sed -i -e 's!\${APACHE_PORT}!" + containerPort + "!g' /etc/apache2/ports.conf /etc/apache2/sites-available/*.conf";
var documentRootConfig = @"sed -i -e 's!\${APACHE_DOCUMENT_ROOT}!/var/www/php-x/!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf /etc/apache2/sites-available/*.conf";
var script = new ShellScriptBuilder()
.AddCommand("mkdir -p /var/www/php-x")
.AddCommand("echo '' > /var/www/php-x/error.log")
.AddCommand("echo '' > /var/www/php-x/access.log")
.AddCommand("echo '<?php\n phpinfo();\n ?>' > /var/www/php-x/inDex.PhP")
.AddCommand("chmod -R +x /var/www/php-x")
.AddCommand(documentRootConfig)
.AddCommand(portConfig)
.AddCommand("echo 'ServerName localhost' >> /etc/apache2/apache2.conf")
.AddCommand(customSiteConfig)
.AddCommand("a2ensite php-x.conf") // load custom site
.AddCommand("service apache2 restart") // start apache with the custom site configuration
.AddCommand("tail -f /dev/null") //foreground process to keep the container alive
.ToString();
// Assert
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : $"oryxdevmcr.azurecr.io/public/oryx/php-{imageTag}",
output : _output,
volumes : new List <DockerVolume> {
volume
},
environmentVariables : null,
port : containerPort,
link : null,
runCmd : "/bin/sh",
runArgs : new[] { "-c", script },
assertAction : async(hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/inDex.PhP");
Assert.DoesNotContain("<?", data);
Assert.DoesNotContain("<?php", data);
Assert.DoesNotContain("?>", data);
},
dockerCli : _dockerCli);
}
public async Task CanBuildAndRunAngular6App_WithDevAndProdDependencies_UsingZippedNodeModules(string nodeVersion)
{
// Arrange
string compressFormat = "tar-gz";
var appOutputDirPath = Directory.CreateDirectory(Path.Combine(_tempRootDir, Guid.NewGuid().ToString("N")))
.FullName;
var appOutputDirVolume = DockerVolume.CreateMirror(appOutputDirPath);
var appOutputDir = appOutputDirVolume.ContainerDir;
var appName = "angular6app";
var volume = CreateAppVolume(appName);
var appDir = volume.ContainerDir;
var runAppScript = new ShellScriptBuilder()
.AddCommand($"export PORT=4200")
.AddCommand($"oryx -appPath {appOutputDir}")
.AddCommand(DefaultStartupFilePath)
.ToString();
var buildScript = new ShellScriptBuilder()
.AddCommand(
$"oryx build {appDir} -i /tmp/int -o {appOutputDir} --platform nodejs " +
$"--platform-version {nodeVersion} -p compress_node_modules={compressFormat}")
.ToString();
await EndToEndTestHelper.BuildRunAndAssertAppAsync(
appName,
_output,
new List <DockerVolume> {
appOutputDirVolume, volume
},
"/bin/sh",
new[]
{
"-c",
buildScript
},
_imageHelper.GetTestRuntimeImage("node", nodeVersion),
4200,
"/bin/sh",
new[]
{
"-c",
runAppScript
},
async (hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Angular6app", data);
});
// Re-run the runtime container multiple times against the same output to catch any issues.
var dockerCli = new DockerCli();
for (var i = 0; i < 5; i++)
{
await EndToEndTestHelper.RunAndAssertAppAsync(
imageName : _imageHelper.GetTestRuntimeImage("node", nodeVersion),
output : _output,
volumes : new List <DockerVolume> {
appOutputDirVolume, volume
},
environmentVariables : new List <EnvironmentVariable>(),
port : 4200,
link : null,
runCmd : "/bin/sh",
runArgs : new[]
{
"-c",
runAppScript
},
assertAction : async(hostPort) =>
{
var data = await _httpClient.GetStringAsync($"http://localhost:{hostPort}/");
Assert.Contains("Angular6app", data);
},
dockerCli);
}
}
