public void DnuRestore_GeneratesDefaultRuntimeTargets(string flavor, string os, string architecture) { // TODO(anurse): Maybe this could be a condition? This is the only place we need it right now so it // didn't seem worth the refactor. // Travis has old versions of OSes and our test package doesn't work there var isTravisEnvironment = Environment.GetEnvironmentVariable("TRAVIS") ?? "false"; if (isTravisEnvironment.Equals("true")) { return; } var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture); LockFile lockFile; using (var testDir = new DisposableDir()) { var misc = TestUtils.GetMiscProjectsFolder(); DirTree.CreateFromDirectory(Path.Combine(misc, "RuntimeRestore", "TestProject")) .WriteTo(testDir); // Clean up the lock file if it ended up there during the copy var lockFilePath = Path.Combine(testDir, "project.lock.json"); if (File.Exists(lockFilePath)) { File.Delete(lockFilePath); } // Restore the project! var source = Path.Combine(misc, "RuntimeRestore", "RuntimeRestoreTestPackage", "feed"); DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", $"--source {source}", workingDir: testDir); // Check the lock file lockFile = (new LockFileFormat()).Read(Path.Combine(testDir, "project.lock.json")); } // We can use the runtime environment to determine the expected RIDs var osName = RuntimeEnvironmentHelper.RuntimeEnvironment.GetDefaultRestoreRuntimes().First(); if (osName.StartsWith("win")) { AssertLockFileTarget(lockFile, "win7-x86", "win7-x86"); AssertLockFileTarget(lockFile, "win7-x64", "win7-x64"); } else if (osName.StartsWith("ubuntu")) { // There is only ubuntu 14.04 in the package AssertLockFileTarget(lockFile, osName + "-x86", assemblyRid: null); // There is no ubuntu/osx-x86 in the test package AssertLockFileTarget(lockFile, osName + "-x64", "ubuntu.14.04-x64"); } else if (osName.StartsWith("osx")) { // There is only osx 10.10 in the package AssertLockFileTarget(lockFile, osName + "-x86", assemblyRid: null); // There is no ubuntu/osx-x86 in the test package AssertLockFileTarget(lockFile, osName + "-x64", "osx.10.10-x64"); } else { Assert.True(false, $"Unknown OS Name: {osName}"); } }
public void AppHost_ExecutesCommands( string flavor, string os, string architecture, string command, string expectedOutput) { var environment = new Dictionary <string, string> { { "DNX_TRACE", "0" }, }; var projectName = "Project Name"; var projectStructure = $@"{{ '.': ['Program.cs', '{ Project.ProjectFileName }'] }}"; var programContents = @"using System; namespace Project_Name { public class Program { public void Main(string[] arguments) { for (var i = 0; i < arguments.Length; i++) { var argument = arguments[i]; if (!string.IsNullOrWhiteSpace(argument)) { Console.WriteLine($""{ i }: '{ argument }'""); } } } } }"; var projectJsonContents = $@"{{ ""commands"": {{ ""one"": ""\""{ projectName }\"" one two"", ""two"": ""\""{ projectName }\"" ^>three &&>>^\"""", ""three"": ""\""{ projectName }\"" four \""argument five\"""" }}, ""frameworks"" : {{ ""dnx451"": {{ }} }} }}"; using (var applicationRoot = new DisposableDir()) { var projectPath = Path.Combine(applicationRoot, projectName); DirTree.CreateFromJson(projectStructure) .WithFileContents("Program.cs", programContents) .WithFileContents(Project.ProjectFileName, projectJsonContents) .WriteTo(projectPath); var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture); var exitCode = DnuTestUtils.ExecDnu( runtimeHomePath, subcommand: "restore", arguments: null, environment: environment, workingDir: projectPath); Assert.Equal(0, exitCode); // Guard string output; string error; exitCode = TestUtils.ExecBootstrapper( runtimeHomePath, arguments: $@" { command } extra", stdOut: out output, stdErr: out error, environment: environment, workingDir: projectPath); Assert.Equal(0, exitCode); Assert.Empty(error); Assert.Contains(expectedOutput, output); } }
public void DnuWrapMaintainsAllKindsOfReferences(string flavor, string os, string architecture) { var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture); if (RuntimeEnvironmentHelper.IsMono) { return; } var expectedLibGammaProjectJson = @"{ ""version"": ""1.0.0-*"", ""frameworks"": { ""net45"": { ""wrappedProject"": ""../../LibraryGamma/LibraryGamma.csproj"", ""bin"": { ""assembly"": ""../../LibraryGamma/obj/{configuration}/LibraryGamma.dll"", ""pdb"": ""../../LibraryGamma/obj/{configuration}/LibraryGamma.pdb"" }, ""dependencies"": { ""EntityFramework"": ""6.1.2-beta1"", ""LibraryEpsilon"": ""1.0.0-*"", ""LibraryDelta"": ""1.0.0-*"" } } } }"; var expectedLibEpsilonProjectJson = @"{ ""version"": ""1.0.0-*"", ""frameworks"": { ""net45"": { ""wrappedProject"": ""../../LibraryEpsilon/LibraryEpsilon.csproj"", ""bin"": { ""assembly"": ""../../LibraryEpsilon/obj/{configuration}/LibraryEpsilon.dll"", ""pdb"": ""../../LibraryEpsilon/obj/{configuration}/LibraryEpsilon.pdb"" } } } }"; var expectedLibDeltaProjectJson = @"{ ""version"": ""1.0.0-*"", ""frameworks"": { ""net45"": { ""bin"": { ""assembly"": ""../../ExternalAssemblies/LibraryDelta.dll"" } } } }"; var expectedGlobalJson = @"{ ""projects"": [ ""src"", ""test"", ""wrap"" ] }"; using (var testSolutionDir = TestUtils.GetTempTestSolution("ConsoleApp1")) { var libGammaCsprojPath = Path.Combine(testSolutionDir, "LibraryGamma", "LibraryGamma.csproj"); var globalJsonPath = Path.Combine(testSolutionDir, "global.json"); var wrapFolderPath = Path.Combine(testSolutionDir, "wrap"); var libGammaJsonPath = Path.Combine(wrapFolderPath, "LibraryGamma", "project.json"); var libEpsilonJsonPath = Path.Combine(wrapFolderPath, "LibraryEpsilon", "project.json"); var libDeltaJsonPath = Path.Combine(wrapFolderPath, "LibraryDelta", "project.json"); var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "wrap", arguments: string.Format("\"{0}\" --msbuild \"{1}\"", libGammaCsprojPath, _msbuildPath)); Assert.Equal(0, exitCode); Assert.Equal(expectedGlobalJson, File.ReadAllText(globalJsonPath)); Assert.Equal(3, Directory.EnumerateDirectories(wrapFolderPath).Count()); Assert.Equal(expectedLibGammaProjectJson, File.ReadAllText(libGammaJsonPath)); Assert.Equal(expectedLibEpsilonProjectJson, File.ReadAllText(libEpsilonJsonPath)); Assert.Equal(expectedLibDeltaProjectJson, File.ReadAllText(libDeltaJsonPath)); } }
public void DnuWrapUpdatesExistingProjectJson(string flavor, string os, string architecture) { var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture); if (RuntimeEnvironmentHelper.IsMono) { return; } var expectedProjectJson = @"{ ""version"": ""1.0.0-*"", ""dependencies"": {}, ""frameworks"": { ""net45+win+wpa81+wp80"": { ""wrappedProject"": ""../../LibraryBeta.PCL/LibraryBeta.PCL.csproj"", ""bin"": { ""assembly"": ""../../LibraryBeta.PCL/obj/{configuration}/LibraryBeta.dll"", ""pdb"": ""../../LibraryBeta.PCL/obj/{configuration}/LibraryBeta.pdb"" } }, ""net45"": { ""wrappedProject"": ""../../LibraryBeta.PCL.Desktop/LibraryBeta.PCL.Desktop.csproj"", ""bin"": { ""assembly"": ""../../LibraryBeta.PCL.Desktop/obj/{configuration}/LibraryBeta.dll"", ""pdb"": ""../../LibraryBeta.PCL.Desktop/obj/{configuration}/LibraryBeta.pdb"" } }, ""wpa81"": { ""wrappedProject"": ""../../LibraryBeta.PCL.Phone/LibraryBeta.PCL.Phone.csproj"", ""bin"": { ""assembly"": ""../../LibraryBeta.PCL.Phone/obj/{configuration}/LibraryBeta.dll"", ""pdb"": ""../../LibraryBeta.PCL.Phone/obj/{configuration}/LibraryBeta.pdb"" } } } }"; var expectedGlobalJson = @"{ ""projects"": [ ""src"", ""test"" ] }"; using (var testSolutionDir = TestUtils.GetTempTestSolution("ConsoleApp1")) { var libBetaPclCsprojPath = Path.Combine(testSolutionDir, "LibraryBeta.PCL", "LibraryBeta.PCL.csproj"); var libBetaPclDesktopCsprojPath = Path.Combine( testSolutionDir, "LibraryBeta.PCL.Desktop", "LibraryBeta.PCL.Desktop.csproj"); var libBetaPclPhoneCsprojPath = Path.Combine( testSolutionDir, "LibraryBeta.PCL.Phone", "LibraryBeta.PCL.Phone.csproj"); var libBetaJsonPath = Path.Combine(testSolutionDir, "src", "LibraryBeta", "project.json"); var globalJsonPath = Path.Combine(testSolutionDir, "global.json"); var betaPclExitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "wrap", arguments: string.Format("\"{0}\" --msbuild \"{1}\"", libBetaPclCsprojPath, _msbuildPath)); var betaDesktopExitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "wrap", arguments: string.Format("\"{0}\" --msbuild \"{1}\"", libBetaPclDesktopCsprojPath, _msbuildPath)); var betaPhoneExitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "wrap", arguments: string.Format("\"{0}\" --msbuild \"{1}\"", libBetaPclPhoneCsprojPath, _msbuildPath)); Assert.Equal(0, betaPclExitCode); Assert.Equal(0, betaDesktopExitCode); Assert.Equal(0, betaPhoneExitCode); Assert.Equal(expectedGlobalJson, File.ReadAllText(globalJsonPath)); Assert.False(Directory.Exists(Path.Combine(testSolutionDir, "wrap"))); Assert.Equal(expectedProjectJson, File.ReadAllText(libBetaJsonPath)); } }
public void GitCanInstallPackageWithSourceInformation(string flavor, string os, string architecture) { using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture)) using (var testEnv = new DnuTestEnvironment(runtimeHomeDir)) { var testPackageFolder = ScafoldEmptyProject( testEnv.RootDir, "TestPackage", _ => @"{ ""frameworks"": { ""dnx451"": { } }, ""repository"": { ""type"": ""git"", ""url"": """ + testEnv.RootDir.Replace('\\', '/') + @""" } }"); InitGitRepoAndCommitAll(testEnv.RootDir); var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, "restore", arguments: null, workingDir: testPackageFolder); Assert.Equal(0, exitCode); var outputFolder = Path.Combine(testPackageFolder, "bin"); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, $"pack --out {outputFolder}", arguments: null, workingDir: testPackageFolder); Assert.Equal(0, exitCode); outputFolder = Path.Combine(outputFolder, "Debug").Replace('\\', '/'); using (var installEnv = new DnuTestEnvironment(runtimeHomeDir)) { var testFolderName = Path.Combine(installEnv.RootDir, "project"); Directory.CreateDirectory(testFolderName); var consumerProjectFolder = ScafoldEmptyProject( testFolderName, "Client", _ => @"{ ""dependencies"": { ""TestPackage"": ""1.0.0"" }, ""frameworks"": { ""dnx451"": { } }, }"); var packagesDestinationFolder = Path.Combine(installEnv.RootDir, "packages"); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, $"restore --fallbacksource \"{ outputFolder }\" --packages \"{ packagesDestinationFolder }\"", arguments: null, workingDir: consumerProjectFolder); Assert.Equal(0, exitCode); var sourcesDestinationFolder = Path.Combine(installEnv.RootDir, "sources"); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, $"sources get TestPackage --packages \"{ packagesDestinationFolder }\" --output \"{ sourcesDestinationFolder }\"", arguments: null, workingDir: consumerProjectFolder); Assert.Equal(0, exitCode); var installProjectGlobalFile = Path.Combine(testFolderName, GlobalSettings.GlobalFileName); var globalFile = JsonConvert.DeserializeObject(File.ReadAllText(installProjectGlobalFile)) as JObject; var projects = globalFile["projects"] as JArray; Assert.Equal(2, projects.Count); var sourceFolder = projects .First(prj => prj.ToString().StartsWith(sourcesDestinationFolder, StringComparison.Ordinal)) .ToString(); Assert.True(Directory.Exists(sourceFolder)); } } }
public void DnuRestore_ExecutesScripts(string flavor, string os, string architecture) { bool isWindows = TestUtils.CurrentRuntimeEnvironment.OperatingSystem == "Windows"; var environment = new Dictionary <string, string> { { "DNX_TRACE", "0" }, }; var expectedPreContent = @"""one"" ""two"" "">three"" ""four"" "; var expectedPostContent = @"""five"" ""six"" ""argument seven"" ""argument eight"" "; string projectJsonContent; string scriptContent; string scriptName; if (isWindows) { projectJsonContent = @"{ ""frameworks"": { ""dnx451"": { } }, ""scripts"": { ""prerestore"": [ ""script.cmd one two > pre"", ""script.cmd ^>three >> pre && script.cmd ^ four >> pre"" ], ""postrestore"": [ ""\""%project:Directory%/script.cmd\"" five six > post"", ""\""%project:Directory%/script.cmd\"" \""argument seven\"" \""argument eight\"" >> post"" ] } }"; scriptContent = @"@echo off :argumentStart if ""%~1""=="""" goto argumentEnd echo ""%~1"" shift goto argumentStart :argumentEnd"; scriptName = "script.cmd"; } else { projectJsonContent = @"{ ""frameworks"": { ""dnx451"": { } }, ""scripts"": { ""prerestore"": [ ""script one two > pre"", ""script.sh \\>three >> pre; ./script.sh four >> pre"" ], ""postrestore"": [ ""\""%project:Directory%/script\"" five six > post"", ""\""%project:Directory%/script.sh\"" \""argument seven\"" \""argument eight\"" >> post"" ] } }"; scriptContent = @"#!/usr/bin/env bash set -o errexit for arg in ""$@""; do printf ""\""%s\""\n"" ""$arg"" done"; scriptName = "script.sh"; } var projectStructure = $@"{{ '.': ['project.json', '{ scriptName }'] }}"; var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture); using (var testEnv = new DnuTestEnvironment(runtimeHomePath, projectName: "Project Name")) { var projectPath = testEnv.ProjectPath; DirTree.CreateFromJson(projectStructure) .WithFileContents("project.json", projectJsonContent) .WithFileContents(scriptName, scriptContent) .WriteTo(projectPath); FileOperationUtils.MarkExecutable(Path.Combine(projectPath, scriptName)); string output; string error; var exitCode = DnuTestUtils.ExecDnu( runtimeHomePath, subcommand: "restore", arguments: null, stdOut: out output, stdErr: out error, environment: environment, workingDir: projectPath); Assert.Equal(0, exitCode); Assert.Empty(error); Assert.Contains("Executing script 'prerestore' in project.json", output); Assert.Contains("Executing script 'postrestore' in project.json", output); var preContent = File.ReadAllText(Path.Combine(projectPath, "pre")); Assert.Equal(expectedPreContent, preContent); var postContent = File.ReadAllText(Path.Combine(projectPath, "post")); Assert.Equal(expectedPostContent, postContent); } }
public void DnuPack_ExecutesScriptsForEachConfigurationAndTargetFramework(string flavor, string os, string architecture) { var projectStructure = @"{ '.': ['project.json'] }"; var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture); using (var testEnv = new DnuTestEnvironment(runtimeHomeDir, "TestProject")) { DirTree.CreateFromJson(projectStructure) .WithFileContents("project.json", @"{ ""version"": ""1.0-beta"", ""frameworks"": { ""dnx451"": {}, ""dnxcore50"": { ""dependencies"": { ""System.Runtime"":""4.0.20-*"" } } }, ""scripts"": { ""prebuild"": ""echo PREBUILD_SCRIPT_OUTPUT %build:Configuration% %build:TargetFramework%"", ""prepack"": ""echo PREPACK_SCRIPT_OUTPUT %build:Configuration% %build:TargetFramework%"", ""postbuild"": ""echo POSTBUILD_SCRIPT_OUTPUT %build:Configuration% %build:TargetFramework%"", ""postpack"": ""echo POSTPACK_SCRIPT_OUTPUT %build:Configuration% %build:TargetFramework%"" } }") .WriteTo(testEnv.ProjectPath); string stdOut, stdErr; var exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, subcommand: "restore", arguments: string.Empty, workingDir: testEnv.ProjectPath); Assert.Equal(0, exitCode); exitCode = DnuTestUtils.ExecDnu( runtimeHomeDir, "pack", testEnv.ProjectPath + " --configuration Debug --configuration Release", out stdOut, out stdErr); Assert.Equal(0, exitCode); Assert.Empty(stdErr); var idx = 0; foreach (var configuration in new[] { "Debug", "Release" }) { // note that %TargetFramework% is not defined outside build idx = stdOut.IndexOf($"PREPACK_SCRIPT_OUTPUT {configuration} %build:TargetFramework%", 0); Assert.True(idx >= 0); foreach (var framework in new[] { "dnx451", "dnxcore50" }) { idx = stdOut.IndexOf($"PREBUILD_SCRIPT_OUTPUT {configuration} {framework}", idx); Assert.True(idx >= 0); idx = stdOut.IndexOf($"POSTBUILD_SCRIPT_OUTPUT {configuration} {framework}", idx); Assert.True(idx >= 0); } idx = stdOut.IndexOf($"POSTPACK_SCRIPT_OUTPUT {configuration} %build:TargetFramework%", 0); Assert.True(idx >= 0); } Assert.Equal(-1, stdOut.IndexOf("PREPACK_SCRIPT_OUTPUT", idx + 1)); Assert.Equal(-1, stdOut.IndexOf("PREBUILD_SCRIPT_OUTPUT", idx + 1)); Assert.Equal(-1, stdOut.IndexOf("POSTBUILD_SCRIPT_OUTPUT", idx + 1)); Assert.Equal(-1, stdOut.IndexOf("POSTPACK_SCRIPT_OUTPUT", idx + 1)); } }