Пример #1
0
        private void VerifyDnuInstall(
            string runtimeHomePath,
            string packageName,
            string packageVersion,
            string projectDir,
            string packagesDir,
            string workingDir)
        {
            var projectJsonPath     = Path.Combine(projectDir ?? workingDir, Runtime.Project.ProjectFileName);
            var expectedProjectJson = $@"{{
  ""dependencies"": {{
    ""{packageName}"": ""{packageVersion}""
  }}
}}";

            string stdOut, stdErr;
            var    exitCode = DnuTestUtils.ExecDnu(
                runtimeHomePath,
                subcommand: "install",
                arguments: $"{packageName} {packageVersion} {projectDir} -s {_fixture.PackageSource} --packages {packagesDir}",
                stdOut: out stdOut,
                stdErr: out stdErr,
                environment: null,
                workingDir: workingDir);

            Assert.Equal(0, exitCode);
            Assert.Empty(stdErr);
            Assert.Contains($"Installing {packageName}.{packageVersion}", stdOut);
            Assert.Equal(expectedProjectJson, File.ReadAllText(projectJsonPath));
            Assert.True(Directory.Exists(Path.Combine(packagesDir, packageName, packageVersion)));
        }
Пример #2
0
        public void DnuPack_OutPathSpecified(string flavor, string os, string architecture)
        {
            string expectedNupkg =
                @"{0} -> {1}/CustomOutput/Debug/{0}.1.0.0.nupkg".Replace('/', Path.DirectorySeparatorChar);
            string expectedSymbol =
                @"{0} -> {1}/CustomOutput/Debug/{0}.1.0.0.symbols.nupkg".Replace('/', Path.DirectorySeparatorChar);
            string stdOut;
            string stdError;
            var    runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            int    exitCode;

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir))
            {
                File.WriteAllText($"{testEnv.RootDir}/project.json",
                                  @"{
                    ""frameworks"": {
                        ""dnx451"": {
                        },
                        ""dnxcore50"": {
                            ""dependencies"": {
                                ""System.Runtime"":""4.0.20-*""
                            }
                        }
                    }
                  }");
                DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", "", out stdOut, out stdError, environment: null, workingDir: testEnv.RootDir);
                exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "pack", "--out CustomOutput", out stdOut, out stdError, environment: null, workingDir: testEnv.RootDir);

                Assert.Empty(stdError);
                Assert.Contains(string.Format(expectedNupkg, Path.GetFileName(testEnv.RootDir), testEnv.RootDir), stdOut);
                Assert.Contains(string.Format(expectedSymbol, Path.GetFileName(testEnv.RootDir), testEnv.RootDir), stdOut);
                Assert.Equal(0, exitCode);
                Assert.True(Directory.Exists($"{testEnv.RootDir}/CustomOutput"));
            }
        }
Пример #3
0
        public void DnuPack_DoesNotExecutePostBuildScriptWhenBuildFails(string flavor, string os, string architecture)
        {
            var runtimeHomeDir     = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            var projectJson        = @"{
  ""scripts"": {
    ""postbuild"": ""echo POST_BUILD_SCRIPT_OUTPUT"",
    ""postpack"": ""echo POST_PACK_SCRIPT_OUTPUT""
  },
}";
            var sourceFileContents = @"Invalid source code that makes build fail";

            using (var tempDir = new DisposableDir())
            {
                var projectJsonPath = Path.Combine(tempDir, Runtime.Project.ProjectFileName);
                var sourceFilePath  = Path.Combine(tempDir, "Program.cs");
                File.WriteAllText(projectJsonPath, projectJson);
                File.WriteAllText(sourceFilePath, sourceFileContents);

                string stdOut, stdErr;
                var    exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomeDir,
                    "pack",
                    projectJsonPath,
                    out stdOut,
                    out stdErr);

                Assert.NotEqual(0, exitCode);
                Assert.NotEmpty(stdErr);
                Assert.DoesNotContain("POST_BUILD_SCRIPT_OUTPUT", stdOut);
                Assert.DoesNotContain("POST_PACK_SCRIPT_OUTPUT", stdOut);
            }
        }
Пример #4
0
        public void DnuPack_P2PDifferentFrameworks(string flavor, string os, string architecture)
        {
            string stdOut;
            string stdError;
            var    runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir))
            {
                var p1 = Path.Combine(testEnv.RootDir, "P1");
                var p2 = Path.Combine(testEnv.RootDir, "P2");

                Directory.CreateDirectory(p1);
                Directory.CreateDirectory(p2);

                File.WriteAllText($"{p1}/project.json",
                                  @"{
                    ""dependencies"": {
                        ""System.Runtime"":""4.0.20-*""
                    },
                    ""frameworks"": {
                        ""dotnet"": {}
                    }
                  }");

                File.WriteAllText($"{p1}/BaseClass.cs", @"
public class BaseClass {
    public virtual void Test() { }
}");

                File.WriteAllText($"{p2}/project.json",
                                  @"{
                    ""dependencies"": {
                        ""P1"":""""
                    },
                    ""frameworks"": {
                        ""dnxcore50"": {}
                    }
                  }");
                File.WriteAllText($"{p2}/TestClass.cs", @"
public class TestClass : BaseClass {
    public override void Test() { }
}");

                var environment = new Dictionary <string, string> {
                    { "DNX_TRACE", "0" }
                };
                DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", "", out stdOut, out stdError, environment: null, workingDir: testEnv.RootDir);
                var exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "pack", "", out stdOut, out stdError, environment, p2);
                Assert.Equal(0, exitCode);
            }
        }
Пример #5
0
        private static void BuildPackage(string sampleDir, string runtimeHomeDir)
        {
            var projectDir    = Path.Combine(sampleDir, ProjectName);
            var buildOutpuDir = Path.Combine(sampleDir, OutputDirName);
            int exitCode      = DnuTestUtils.ExecDnu(
                runtimeHomeDir,
                "pack",
                $"{projectDir} --out {buildOutpuDir} --configuration {Configuration}",
                environment: new Dictionary <string, string> {
                { "DNX_BUILD_VERSION", null }
            });

            Assert.Equal(0, exitCode);
        }
Пример #6
0
        private static int DnuPackagesAddOutputPackage(string sampleDir, string runtimeHomeDir, out string stdOut)
        {
            var packagePath = Path.Combine(sampleDir, OutputDirName, Configuration,
                                           $"{ProjectName}.{ProjectVersion}{NuGet.Constants.PackageExtension}");
            var packagesDir = Path.Combine(sampleDir, PackagesDirName);

            string stdErr;
            var    exitCode = DnuTestUtils.ExecDnu(
                runtimeHomeDir,
                "packages",
                $"add {packagePath} {packagesDir}",
                out stdOut,
                out stdErr);

            return(exitCode);
        }
Пример #7
0
        public void DnuPack_ShowUnresolvedDependencyWhenBuildFails(string flavor, string os, string architecture)
        {
            var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            var projectJson    = @"{
  ""frameworks"": {
    ""dnx451"": {
      ""dependencies"": {
      ""NonexistentPackage"": ""1.0.0""
      }
    }
  }
}";

            using (var tempDir = new DisposableDir())
            {
                var projectPath    = Path.Combine(tempDir, "Project");
                var emptyLocalFeed = Path.Combine(tempDir, "EmptyLocalFeed");
                Directory.CreateDirectory(projectPath);
                Directory.CreateDirectory(emptyLocalFeed);
                var projectJsonPath = Path.Combine(projectPath, Runtime.Project.ProjectFileName);
                File.WriteAllText(projectJsonPath, projectJson);

                string stdOut, stdErr;
                var    exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomeDir,
                    "restore",
                    $"{projectJsonPath} -s {emptyLocalFeed}",
                    out stdOut,
                    out stdErr);
                Assert.NotEqual(0, exitCode);

                exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomeDir,
                    "pack",
                    projectJsonPath,
                    out stdOut,
                    out stdErr);

                Assert.NotEqual(0, exitCode);
                Assert.NotEmpty(stdErr);
                var unresolvedDependencyErrorCount = stdErr
                                                     .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                                                     .Where(line => line.Contains("The dependency NonexistentPackage >= 1.0.0 could not be resolved"))
                                                     .Count();
                Assert.Equal(1, unresolvedDependencyErrorCount);
            }
        }
Пример #8
0
        public void DnuPack_NoArgs(string flavor, string os, string architecture)
        {
            string expectedDNX =
                @"Building {0} for DNX,Version=v4.5.1
  Using Project dependency {0} 1.0.0
    Source: {1}/project.json".Replace('/', Path.DirectorySeparatorChar);
            string expectedDNXCore =
                @"Building {0} for DNXCore,Version=v5.0
  Using Project dependency {0} 1.0.0
    Source: {1}/project.json".Replace('/', Path.DirectorySeparatorChar);
            string expectedNupkg =
                @"{0} -> {1}/bin/Debug/{0}.1.0.0.nupkg
{0} -> {1}/bin/Debug/{0}.1.0.0.symbols.nupkg".Replace('/', Path.DirectorySeparatorChar);
            string stdOut;
            string stdError;
            var    runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            int    exitCode;

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir))
            {
                File.WriteAllText($"{testEnv.RootDir}/project.json",
                                  @"{
                    ""frameworks"": {
                        ""dnx451"": {
                        },
                        ""dnxcore50"": {
                            ""dependencies"": {
                                ""System.Runtime"":""4.0.20-*""
                            }
                        }
                    }
                  }");
                var environment = new Dictionary <string, string> {
                    { "DNX_TRACE", "0" }
                };
                DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", "", out stdOut, out stdError, environment: null, workingDir: testEnv.RootDir);
                exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "pack", "", out stdOut, out stdError, environment, testEnv.RootDir);

                Assert.Empty(stdError);
                Assert.Contains(string.Format(expectedDNX, Path.GetFileName(testEnv.RootDir), testEnv.RootDir), stdOut);
                Assert.Contains(string.Format(expectedDNXCore, Path.GetFileName(testEnv.RootDir), testEnv.RootDir), stdOut);
                Assert.Contains(string.Format(expectedNupkg, Path.GetFileName(testEnv.RootDir), testEnv.RootDir), stdOut);
                Assert.Equal(0, exitCode);
                Assert.True(Directory.Exists($"{testEnv.RootDir}/bin"));
            }
        }
Пример #9
0
        public void DnuRestore_ReinstallsPackageWithNormalizedVersion(string flavor, string os, string architecture)
        {
            var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture);

            using (var tempDir = new DisposableDir())
            {
                var projectDir  = Path.Combine(tempDir, "project");
                var packagesDir = Path.Combine(tempDir, "packages");
                var projectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName);

                Directory.CreateDirectory(projectDir);
                File.WriteAllText(projectJson, @"
{
  ""dependencies"": {
    ""alpha"": ""0.1.0""
  }
}");
                DnuTestUtils.ExecDnu(
                    runtimeHomePath,
                    subcommand: "restore",
                    arguments: $"{projectDir} -s {_fixture.PackageSource} --packages {packagesDir}");

                // rename package folder to an unnormalized string
                Directory.Move(Path.Combine(packagesDir, "alpha", "0.1.0"),
                               Path.Combine(packagesDir, "alpha", "0.1.0.0"));

                // ensure the directory is renamed
                Assert.False(Directory.Exists(Path.Combine(packagesDir, "alpha", "0.1.0")));

                string stdOut, stdErr;
                var    exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomePath,
                    subcommand: "restore",
                    arguments: $"{projectDir} -s {_fixture.PackageSource} --packages {packagesDir}",
                    stdOut: out stdOut,
                    stdErr: out stdErr);

                Assert.Equal(0, exitCode);
                Assert.Empty(stdErr);
                Assert.Contains($"Installing alpha.0.1.0", stdOut);
                Assert.True(Directory.Exists(Path.Combine(packagesDir, "alpha", "0.1.0")));
                Assert.True(File.Exists(Path.Combine(packagesDir, "alpha", "0.1.0", $"alpha{Constants.ManifestExtension}")));
            }
        }
Пример #10
0
        public void DnuPack_PortablePdbsGeneratedWhenEnvVariableSet(string flavor, string os, string architecture)
        {
            string stdOut;
            string stdError;
            var    runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            int    exitCode;

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir))
            {
                var appName = PathUtility.GetDirectoryName(testEnv.RootDir);
                File.WriteAllText($"{testEnv.RootDir}/project.json",
                                  @"{
                    ""frameworks"": {
                        ""dnx451"": {
                        }
                    }
                  }");

                var environment = new Dictionary <string, string> {
                    { "DNX_TRACE", "0" }, { "DNX_BUILD_PORTABLE_PDB", "1" }
                };
                DnuTestUtils.ExecDnu(runtimeHomeDir,
                                     "restore",
                                     "",
                                     out stdOut,
                                     out stdError,
                                     environment: null,
                                     workingDir: testEnv.RootDir);

                exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir,
                                                "pack",
                                                "",
                                                out stdOut,
                                                out stdError,
                                                environment,
                                                testEnv.RootDir);

                var outputDir = Path.Combine(testEnv.RootDir, "bin", "Debug", "dnx451");
                Assert.Equal(0, exitCode);
                Assert.True(Directory.Exists(outputDir));
                Assert.True(File.Exists(Path.Combine(outputDir, appName + ".dll")));
                Assert.True(File.Exists(Path.Combine(outputDir, appName + ".pdb")));
            }
        }
Пример #11
0
        public void DnuPack_ResourcesNoArgs_WarningAsErrorsCompilationOption(string flavor, string os, string architecture)
        {
            string stdOut;
            string stdError;
            var    runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
            int    exitCode;

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir))
            {
                using (var tempDir = new DisposableDir())
                {
                    var appPath = Path.Combine(tempDir, "ResourcesTestProjects", "ReadFromResources");
                    TestUtils.CopyFolder(Path.Combine(TestUtils.GetMiscProjectsFolder(), "ResourcesTestProjects", "ReadFromResources"), appPath);
                    var workingDir = Path.Combine(appPath, "src", "ResourcesLibrary");

                    var environment = new Dictionary <string, string> {
                        { "DNX_TRACE", "0" }
                    };
                    DnuTestUtils.ExecDnu(
                        runtimeHomeDir,
                        "restore", "",
                        out stdOut,
                        out stdError,
                        environment: null,
                        workingDir: workingDir);
                    exitCode = DnuTestUtils.ExecDnu(
                        runtimeHomeDir,
                        "pack",
                        "",
                        out stdOut,
                        out stdError,
                        environment,
                        workingDir);

                    Assert.Empty(stdError);
                    Assert.Equal(0, exitCode);
                    Assert.True(Directory.Exists(Path.Combine(workingDir, "bin")));
                    Assert.True(File.Exists(Path.Combine(workingDir, "bin", "Debug", "dnx451", "fr-FR", "ResourcesLibrary.resources.dll")));
                    Assert.True(File.Exists(Path.Combine(workingDir, "bin", "Debug", "dnxcore50", "fr-FR", "ResourcesLibrary.resources.dll")));
                }
            }
        }
Пример #12
0
        public void DnuRestore_ReinstallsCorruptedPackage(string flavor, string os, string architecture)
        {
            var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture);

            using (var tempDir = new DisposableDir())
            {
                var projectDir  = Path.Combine(tempDir, "project");
                var packagesDir = Path.Combine(tempDir, "packages");
                var projectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName);

                Directory.CreateDirectory(projectDir);
                File.WriteAllText(projectJson, @"
{
  ""dependencies"": {
    ""alpha"": ""0.1.0""
  }
}");
                DnuTestUtils.ExecDnu(
                    runtimeHomePath,
                    subcommand: "restore",
                    arguments: $"{projectDir} -s {_fixture.PackageSource} --packages {packagesDir}");

                // Corrupt the package by deleting nuspec from it
                var nuspecPath = Path.Combine(packagesDir, "alpha", "0.1.0", $"alpha{Constants.ManifestExtension}");
                File.Delete(nuspecPath);

                string stdOut, stdErr;
                var    exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomePath,
                    subcommand: "restore",
                    arguments: $"{projectDir} -s {_fixture.PackageSource} --packages {packagesDir}",
                    stdOut: out stdOut,
                    stdErr: out stdErr);

                Assert.Equal(0, exitCode);
                Assert.Empty(stdErr);
                Assert.Contains($"Installing alpha.0.1.0", stdOut);
                Assert.True(File.Exists(nuspecPath));
            }
        }
Пример #13
0
        public void DnuPack_NormalizesVersionNumberWithNoBuildNumber(string flavor, string os, string architecture)
        {
            int exitCode;
            var projectName      = "TestProject";
            var projectStructure = @"{
  '.': ['project.json']
}";
            var runtimeHomeDir   = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);

            using (var testEnv = new DnuTestEnvironment(runtimeHomeDir, projectName))
            {
                DirTree.CreateFromJson(projectStructure)
                .WithFileContents("project.json", @"{
  ""version"": ""1.0-beta"",
  ""frameworks"": {
    ""dnx451"": {}
  }
}")
                .WriteTo(testEnv.ProjectPath);

                exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomeDir,
                    subcommand: "restore",
                    arguments: string.Empty,
                    workingDir: testEnv.ProjectPath);
                Assert.Equal(0, exitCode);

                exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomeDir,
                    subcommand: "pack",
                    arguments: string.Empty,
                    workingDir: testEnv.ProjectPath);
                Assert.Equal(0, exitCode);

                Assert.True(File.Exists(Path.Combine(testEnv.ProjectPath, "bin", "Debug", $"{projectName}.1.0.0-beta.nupkg")));
                Assert.True(File.Exists(Path.Combine(testEnv.ProjectPath, "bin", "Debug", $"{projectName}.1.0.0-beta.symbols.nupkg")));
            }
        }
Пример #14
0
        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);
            }
        }
Пример #15
0
        public void DnuFeeds_ListsAllSources(string flavor, string os, string architecture)
        {
            var environment = new Dictionary <string, string>
            {
                { "DNX_TRACE", "0" },
            };

            var rootConfig =
                @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
  <packageSources>
    <clear /> <!-- Remove the effects of any machine-level config -->
    <add key=""Source1"" value=""https://source1"" />
    <add key=""Source2"" value=""https://source2"" />
  </packageSources>
</configuration>";

            var subConfig =
                @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
  <packageSources>
    <add key=""Source3"" value=""https://source3"" />
  </packageSources>
  <disabledPackageSources>
    <add key=""Source1"" value=""https://source1"" />
  </disabledPackageSources>
</configuration>";

            var projectStructure =
                @"{
    'root': {
        'NuGet.config': """",
        'sub': {
            'NuGet.config': """"
        }
    }
}";

            var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture);

            using (var testEnv = new DnuTestEnvironment(runtimeHomePath, projectName: "Project Name"))
            {
                var projectPath = testEnv.ProjectPath;
                DirTree.CreateFromJson(projectStructure)
                .WithFileContents("root/nuget.config", rootConfig)
                .WithFileContents("root/sub/nuget.config", subConfig)
                .WriteTo(projectPath);

                string output;
                string error;
                var    exitCode = DnuTestUtils.ExecDnu(
                    runtimeHomePath,
                    subcommand: "feeds",
                    arguments: "list root/sub",
                    stdOut: out output,
                    stdErr: out error,
                    environment: environment,
                    workingDir: projectPath);

                Assert.Equal(0, exitCode);
                Assert.Empty(error);

                // CI Machines and such have different sources in the user-global config
                // So we can't actually assert the exact content of the output.
                Assert.Contains($"https://source1 [Disabled]{Environment.NewLine}      Origin: {Path.Combine(projectPath, "root", "nuget.config")}", output);
                Assert.Contains($"https://source2{Environment.NewLine}      Origin: {Path.Combine(projectPath, "root", "nuget.config")}", output);
                Assert.Contains($"https://source3{Environment.NewLine}      Origin: {Path.Combine(projectPath, "root", "sub", "nuget.config")}", output);
            }
        }
Пример #16
0
        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));
            }
        }