public void WhenTargetingNetCore3_0AspNetCoreAllPackageReferenceErrors(bool useWebSdk, string packageVersion)
{
var testProject = new TestProject()
{
Name = "AspNetCoreAll_On3_0",
TargetFrameworks = "netcoreapp3.0",
ProjectSdk = useWebSdk ? "Microsoft.NET.Sdk.Web" : null,
IsExe = true
};
// Add PackageReference
testProject.PackageReferences.Add(new TestPackageReference("Microsoft.AspNetCore.All", packageVersion));
var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: $"{useWebSdk}_{packageVersion}");
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand.Execute()
.Should()
.Fail()
.And
.HaveStdOutContaining("NETSDK1079");
var buildCommand = new BuildCommand(testAsset);
buildCommand.Execute()
.Should()
.Fail()
.And
.HaveStdOutContaining("NETSDK1079");
}
public void MultipleWarningsAreGeneratedForMultipleExplicitReferences()
{
var testProject = new TestProject()
{
Name = "MultipleExplicitReferences",
TargetFrameworks = "netcoreapp2.1",
IsExe = true
};
testProject.PackageReferences.Add(new TestPackageReference("Microsoft.NETCore.App", "2.1.0"));
testProject.PackageReferences.Add(new TestPackageReference("Microsoft.AspNetCore.App", "2.1.0"));
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand
.Execute()
.Should()
.Pass()
.And
.NotHaveStdOutContaining("NETSDK1071");
var buildCommand = new BuildCommand(testAsset);
buildCommand
.Execute()
.Should()
.Pass()
.And
.HaveStdOutContaining("NETSDK1071")
.And
.HaveStdOutContaining("NETSDK1023");
}
private async Task <bool> Restore(PublishRoot root, PublishProject publishProject, string restoreDirectory, IEnumerable <FrameworkName> targetFrameworks)
{
var appEnv = PlatformServices.Default.Application;
var feedOptions = new FeedOptions();
feedOptions.IgnoreFailedSources = true;
feedOptions.Sources.Add(root.TargetPackagesPath);
feedOptions.TargetPackagesFolder = root.TargetPackagesPath;
var restoreCommand = new RestoreCommand(appEnv);
restoreCommand.TargetFrameworks.AddRange(targetFrameworks);
restoreCommand.RequestedRuntimes = root.RuntimeIdentifiers;
restoreCommand.SkipRestoreEvents = true;
restoreCommand.SkipInstall = true;
// This is a workaround for #1322. Since we use restore to generate the lock file
// after publish, it's possible to fail restore after copying the closure
// if framework assemblies and packages have the same name. This is more likely now
// since dependencies may exist in the top level
restoreCommand.IgnoreMissingDependencies = true;
restoreCommand.CheckHashFile = false;
restoreCommand.RestoreDirectories.Add(restoreDirectory);
restoreCommand.FeedOptions = feedOptions;
// Mute "dnu restore" subcommand
restoreCommand.Reports = Reports.Constants.NullReports;
var success = await restoreCommand.Execute();
return(success);
}
private void Restore(string projectDirectory, string projectName = null)
{
var command = new RestoreCommand()
.WithWorkingDirectory(projectDirectory);
if (projectName != null)
{
command.Execute($"{projectName}.csproj /p:SkipInvalidConfigurations=true;_InvalidConfigurationWarning=false")
.Should().Pass();
}
else
{
command.Execute("/p:SkipInvalidConfigurations=true;_InvalidConfigurationWarning=false")
.Should().Pass();
}
}
public void It_does_not_fail_publishing_a_self_twice()
{
var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
var testAsset = _testAssetsManager
.CopyTestAsset(TestProjectName)
.WithSource();
var msbuildArgs = new string[] { "/p:SelfContained=true",
$"/p:TargetFramework={TargetFramework}",
$"/p:RuntimeIdentifier={runtimeIdentifier}" };
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand.Execute(msbuildArgs);
var publishCommand = new PublishCommand(Log, testAsset.TestRoot);
publishCommand
.Execute(msbuildArgs)
.Should().Pass();
publishCommand
.Execute(msbuildArgs)
.Should().Pass().And.NotHaveStdOutContaining("HelloWorld.exe' already exists");
}
private void PublishAppWithLibraryAndRid(bool selfContained, out DirectoryInfo publishDirectory, out string runtimeIdentifier)
{
runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", $"PublishAppWithLibraryAndRid{selfContained}")
.WithSource();
var projectPath = Path.Combine(testAsset.TestRoot, "App");
var msbuildArgs = new[]
{
$"/p:RuntimeIdentifier={runtimeIdentifier}",
$"/p:TestRuntimeIdentifier={runtimeIdentifier}",
$"/p:SelfContained={selfContained}"
};
var restoreCommand = new RestoreCommand(Log, projectPath, "App.csproj");
restoreCommand
.Execute(msbuildArgs)
.Should()
.Pass();
var publishCommand = new PublishCommand(Log, projectPath);
publishCommand
.Execute(msbuildArgs)
.Should().Pass();
publishDirectory = publishCommand.GetOutputDirectory("netcoreapp1.1", runtimeIdentifier: runtimeIdentifier);
}
public void TestRestore()
{
var command = new RestoreCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [ ""jquery.min.js"", ""core.js"" ]
}
]
}";
File.WriteAllText(Path.Combine(WorkingDir, "libman.json"), contents);
int result = command.Execute();
Assert.AreEqual(0, result);
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "core.js")));
}
private static void SetupStaticTestProject()
{
AssetsRoot = Path.Combine(AppContext.BaseDirectory, "bin");
RestoredTestProjectDirectory = Path.Combine(AssetsRoot, s_testdirName);
// Ignore Delete Failure
try
{
Directory.Delete(RestoredTestProjectDirectory, true);
}
catch (Exception) { }
Directory.CreateDirectory(RestoredTestProjectDirectory);
// Todo: this is a hack until corefx is on nuget.org remove this After RC 2 Release
NuGetConfig.Write(RestoredTestProjectDirectory);
var newCommand = new NewCommand();
newCommand.WorkingDirectory = RestoredTestProjectDirectory;
newCommand.Execute().Should().Pass();
var restoreCommand = new RestoreCommand();
restoreCommand.WorkingDirectory = RestoredTestProjectDirectory;
restoreCommand.Execute("/p:SkipInvalidConfigurations=true")
.Should().Pass();
}
private async Task <bool> Restore(PublishRoot root, PublishProject publishProject, string restoreDirectory)
{
var appEnv = (IApplicationEnvironment)root.HostServices.GetService(typeof(IApplicationEnvironment));
var feedOptions = new FeedOptions();
feedOptions.IgnoreFailedSources = true;
feedOptions.Sources.Add(root.TargetPackagesPath);
feedOptions.TargetPackagesFolder = root.TargetPackagesPath;
var restoreCommand = new RestoreCommand(appEnv);
foreach (var runtime in root.Runtimes)
{
restoreCommand.TargetFrameworks.Add(publishProject.SelectFrameworkForRuntime(runtime));
}
restoreCommand.SkipRestoreEvents = true;
restoreCommand.SkipInstall = true;
// This is a workaround for #1322. Since we use restore to generate the lock file
// after publish, it's possible to fail restore after copying the closure
// if framework assemblies and packages have the same name. This is more likely now
// since dependencies may exist in the top level
restoreCommand.IgnoreMissingDependencies = true;
restoreCommand.CheckHashFile = false;
restoreCommand.RestoreDirectories.Add(restoreDirectory);
restoreCommand.FeedOptions = feedOptions;
// Mute "dnu restore" subcommand
restoreCommand.Reports = Reports.Constants.NullReports;
var success = await restoreCommand.Execute();
return(success);
}
public void TestRestoreErrors()
{
var command = new RestoreCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [ ""jquery.min.js"", ""core123.js"" ]
}
]
}";
File.WriteAllText(Path.Combine(WorkingDir, "libman.json"), contents);
int result = command.Execute();
Assert.AreEqual(0, result);
Assert.IsFalse(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsFalse(File.Exists(Path.Combine(WorkingDir, "wwwroot", "core.js")));
var logger = HostEnvironment.Logger as TestLogger;
Assert.IsTrue(logger.Messages.Any(m => m.Key == LibraryManager.Contracts.LogLevel.Error));
}
public void GroupNotPopulatedWithoutRid()
{
var testProject = this.SetupProject();
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, testAsset.Path, testProject.Name);
restoreCommand
.Execute()
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, testAsset.Path, testProject.Name);
buildCommand
.Execute("/t:PublishItemsOutputGroup")
.Should()
.Pass();
var testOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput"));
Log.WriteLine("Contents of PublishItemsOutputGroup dumped to '{0}'.", testOutputDir.FullName);
// Since no RID was specified the output group should only contain framework dependent output
testOutputDir.Should().HaveFile($"{testProject.Name}{Constants.ExeSuffix}");
testOutputDir.Should().HaveFile($"{testProject.Name}.deps.json");
testOutputDir.Should().NotHaveFiles(FrameworkAssemblies);
}
public void GroupPopulatedWithRid()
{
var testProject = this.SetupProject();
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, testAsset.Path, testProject.Name);
restoreCommand
.Execute()
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, testAsset.Path, testProject.Name);
buildCommand
.Execute("/p:RuntimeIdentifier=win-x86", "/t:PublishItemsOutputGroup")
.Should()
.Pass();
var testOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput"));
Log.WriteLine("Contents of PublishItemsOutputGroup dumped to '{0}'.", testOutputDir.FullName);
// Check for the existence of a few specific files that should be in the directory where the
// contents of PublishItemsOutputGroup were dumped to make sure it's getting populated.
testOutputDir.Should().HaveFile($"{testProject.Name}.exe");
testOutputDir.Should().HaveFile($"{testProject.Name}.deps.json");
testOutputDir.Should().HaveFiles(FrameworkAssemblies);
}
public void WhenTargetingNetCore3_0AspNetCoreAppPackageReferenceWarns(bool useWebSdk, string packageVersion)
{
var testProject = new TestProject()
{
Name = "AspNetCoreApp_On3_0",
TargetFrameworks = "netcoreapp3.0",
IsSdkProject = true,
ProjectSdk = useWebSdk ? "Microsoft.NET.Sdk.Web" : null,
IsExe = true
};
// Add PackageReference
testProject.PackageReferences.Add(new TestPackageReference("Microsoft.AspNetCore.App", packageVersion));
var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: $"{useWebSdk}_{packageVersion}");
var restoreCommand = new RestoreCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
restoreCommand.Execute()
.Should()
.Pass()
.And
.HaveStdOutContaining("NETSDK1080");
var buildCommand = new BuildCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
buildCommand.Execute()
.Should()
.Pass()
.And
.HaveStdOutContaining("NETSDK1080");
}
public void DuplicateFrameworkReferencesCauseError()
{
var testProject = new TestProject()
{
Name = "DuplicateFrameworkReference",
TargetFrameworks = "netcoreapp3.0",
};
var testAsset = _testAssetsManager.CreateTestProject(testProject)
.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
project.Root.Element(ns + "PropertyGroup").Add(
new XElement(ns + "DisableImplicitFrameworkReferences", "true"));
var itemGroup = new XElement(ns + "ItemGroup");
project.Root.Add(itemGroup);
itemGroup.Add(new XElement(ns + "FrameworkReference",
new XAttribute("Include", "Microsoft.NETCore.App")));
itemGroup.Add(new XElement(ns + "FrameworkReference",
new XAttribute("Include", "Microsoft.NETCore.App")));
});
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand
.Execute()
.Should()
.Fail()
.And.HaveStdOutContaining("NETSDK1087");
}
public void BuildFailsIfInvalidRuntimeIdentifierIsSpecified()
{
var testProject = new TestProject()
{
Name = "RuntimePackNotAvailable",
TargetFrameworks = "netcoreapp3.0",
IsSdkProject = true,
IsExe = true,
RuntimeIdentifier = "invalid-rid"
};
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
restoreCommand
// Pass "/clp:summary" so that we can check output for string "1 Error(s)"
.Execute("/clp:summary")
.Should()
.Fail()
.And
.HaveStdOutContaining("NETSDK1083")
.And
.HaveStdOutContaining("1 Error(s)");
}
public void GroupBuildsWithoutPublish()
{
var testProject = this.SetupProject();
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand
.Execute()
.Should()
.Pass();
var buildCommand = new BuildCommand(testAsset);
buildCommand
.Execute("/p:RuntimeIdentifier=win-x86;DesignTimeBuild=true", "/t:PublishItemsOutputGroup")
.Should()
.Pass();
// Confirm we were able to build the output group without the publish actually happening
var publishDir = new DirectoryInfo(Path.Combine(buildCommand.GetOutputDirectory(testProject.TargetFrameworks).FullName, "win-x86", "publish"));
publishDir
.Should()
.NotExist();
}
public void It_builds_a_framework_dependent_RID_specific_runnable_output()
{
var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", "BuildFrameworkDependentRIDSpecific")
.WithSource();
if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
{
// .NET Core 2.1.0 packages don't support latest versions of OS X, so roll forward to the
// latest patch which does
testAsset = testAsset.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var propertyGroup = project.Root.Elements(ns + "PropertyGroup").First();
propertyGroup.Add(new XElement("TargetLatestRuntimePatch", true));
});
}
var restoreCommand = new RestoreCommand(testAsset, "App");
restoreCommand
.Execute($"/p:TestRuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
var buildCommand = new BuildCommand(testAsset, "App");
buildCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}", $"/p:TestRuntimeIdentifier={runtimeIdentifier}", "/p:SelfContained=false")
.Should().Pass();
var outputDirectory = buildCommand.GetOutputDirectory(ToolsetInfo.CurrentTargetFramework, runtimeIdentifier: runtimeIdentifier);
outputDirectory.Should().NotHaveSubDirectories();
string[] expectedFiles = new[] {
$"App{Constants.ExeSuffix}",
"App.dll",
"App.pdb",
"App.deps.json",
"App.runtimeconfig.json",
"LibraryWithoutRid.dll",
"LibraryWithoutRid.pdb",
"LibraryWithRid.dll",
"LibraryWithRid.pdb",
"LibraryWithRids.dll",
"LibraryWithRids.pdb",
$"{FileConstants.DynamicLibPrefix}sqlite3{FileConstants.DynamicLibSuffix}"
};
outputDirectory.Should().OnlyHaveFiles(expectedFiles.Where(x => !String.IsNullOrEmpty(x)).ToList());
new DotnetCommand(Log, Path.Combine(outputDirectory.FullName, "App.dll"))
.Execute()
.Should().Pass()
.And.HaveStdOutContaining($"3.13.0 '{runtimeIdentifier}' 3.13.0 '{runtimeIdentifier}' Hello World");
}
public void It_builds_a_framework_dependent_RID_specific_runnable_output()
{
var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", "BuildFrameworkDependentRIDSpecific")
.WithSource();
if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
{
// .NET Core 2.1.0 packages don't support latest versions of OS X, so roll forward to the
// latest patch which does
testAsset = testAsset.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var propertyGroup = project.Root.Elements(ns + "PropertyGroup").First();
propertyGroup.Add(new XElement("TargetLatestRuntimePatch", true));
});
}
var projectPath = Path.Combine(testAsset.TestRoot, "App");
var restoreCommand = new RestoreCommand(Log, projectPath, "App.csproj");
restoreCommand
.Execute($"/p:TestRuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, projectPath);
buildCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}", $"/p:TestRuntimeIdentifier={runtimeIdentifier}", "/p:SelfContained=false")
.Should().Pass();
var outputDirectory = buildCommand.GetOutputDirectory("netcoreapp2.1", runtimeIdentifier: runtimeIdentifier);
outputDirectory.Should().NotHaveSubDirectories();
outputDirectory.Should().OnlyHaveFiles(new[] {
$"App{Constants.ExeSuffix}",
"App.dll",
"App.pdb",
"App.deps.json",
"App.runtimeconfig.json",
"App.runtimeconfig.dev.json",
"LibraryWithoutRid.dll",
"LibraryWithoutRid.pdb",
"LibraryWithRid.dll",
"LibraryWithRid.pdb",
"LibraryWithRids.dll",
"LibraryWithRids.pdb",
});
Command.Create(TestContext.Current.ToolsetUnderTest.DotNetHostPath, new[] { Path.Combine(outputDirectory.FullName, "App.dll") })
.CaptureStdOut()
.Execute()
.Should().Pass()
.And.HaveStdOutContaining($"3.13.0 '{runtimeIdentifier}' 3.13.0 '{runtimeIdentifier}' Hello World");
}
public void It_can_restore_with_netcoreapp2_2()
{
TestProject toolProject = new TestProject()
{
Name = "TestTool" + nameof(It_can_restore_with_netcoreapp2_2),
IsSdkProject = true,
TargetFrameworks = "netcoreapp1.0",
IsExe = true
};
toolProject.AdditionalProperties.Add("PackageType", "DotnetCliTool");
var toolProjectInstance = _testAssetsManager.CreateTestProject(toolProject, identifier: toolProject.Name);
var packCommand = new PackCommand(Log, Path.Combine(toolProjectInstance.TestRoot, toolProject.Name));
packCommand.Execute().Should().Pass();
string nupkgPath = Path.Combine(packCommand.ProjectRootPath, "bin", "Debug");
TestProject toolReferenceProject = new TestProject()
{
Name = "DotNetCliToolReferenceProject",
IsSdkProject = true,
IsExe = true,
TargetFrameworks = "netcoreapp1.0",
};
toolReferenceProject.DotNetCliToolReferences.Add(
new TestPackageReference(id: toolProject.Name,
version: ProjectToolVersion,
nupkgPath: null));
TestAsset toolReferenceProjectInstance = _testAssetsManager.CreateTestProject(toolReferenceProject, identifier: toolReferenceProject.Name);
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, toolProject.Name.ToLowerInvariant()));
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, ".tools", toolProject.Name.ToLowerInvariant()));
NuGetConfigWriter.Write(toolReferenceProjectInstance.TestRoot, NuGetConfigWriter.DotnetCoreBlobFeed, nupkgPath);
RestoreCommand restoreCommand =
toolReferenceProjectInstance.GetRestoreCommand(log: Log, relativePath: toolReferenceProject.Name);
var restoreResult = restoreCommand
.Execute("/v:n");
var assetsJsonPath = Path.Combine(TestContext.Current.NuGetCachePath,
".tools",
toolProject.Name.ToLowerInvariant(),
ProjectToolVersion,
ExpectedProjectToolRestoreTargetFrameworkMoniker,
"project.assets.json");
LockFile lockFile = LockFileUtilities.GetLockFile(assetsJsonPath, NullLogger.Instance);
lockFile.Targets.Single().TargetFramework
.Should().Be(NuGetFramework.Parse(ExpectedProjectToolRestoreTargetFrameworkMoniker),
"Restore target framework should be capped at netcoreapp2.2 due to moving away from project tools." +
"Even when SDK's TFM is higher and the project's TFM is netcoreapp1.0");
}
public void BuildWithRuntimeIdentifier()
{
var testProject = new TestProject()
{
Name = "BuildWithRid",
TargetFrameworks = "netcoreapp3.0",
IsSdkProject = true,
IsExe = true
};
var compatibleRid = EnvironmentInfo.GetCompatibleRid(testProject.TargetFrameworks);
var runtimeIdentifiers = new[]
{
"win-x64",
"linux-x64",
compatibleRid
};
testProject.AdditionalProperties["RuntimeIdentifiers"] = string.Join(';', runtimeIdentifiers);
// Use a test-specific packages folder
testProject.AdditionalProperties["RestorePackagesPath"] = @"$(MSBuildProjectDirectory)\..\pkg";
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, testAsset.Path, testProject.Name);
restoreCommand
.Execute()
.Should()
.Pass();
foreach (var runtimeIdentifier in runtimeIdentifiers)
{
var buildCommand = new BuildCommand(Log, testAsset.Path, testProject.Name);
buildCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
if (runtimeIdentifier == compatibleRid)
{
var outputDirectory = buildCommand.GetOutputDirectory(testProject.TargetFrameworks, runtimeIdentifier: runtimeIdentifier);
var selfContainedExecutable = $"{testProject.Name}{Constants.ExeSuffix}";
string selfContainedExecutableFullPath = Path.Combine(outputDirectory.FullName, selfContainedExecutable);
Command.Create(selfContainedExecutableFullPath, new string[] { })
.CaptureStdOut()
.Execute()
.Should()
.Pass()
.And
.HaveStdOutContaining("Hello World!");
}
}
}
public void It_publishes_and_runs_self_contained_wpf_app()
{
var testDir = _testAssetsManager.CreateTestDirectory();
var newCommand = new DotnetCommand(Log);
newCommand.WorkingDirectory = testDir.Path;
newCommand.Execute("new", "wpf").Should().Pass();
var project = XDocument.Load(Path.Combine(testDir.Path, Path.GetFileName(testDir.Path) + ".csproj"));
var ns = project.Root.Name.Namespace;
string targetFramework = project.Root.Elements(ns + "PropertyGroup")
.Elements(ns + "TargetFramework")
.Single().Value;
var rid = EnvironmentInfo.GetCompatibleRid(targetFramework);
string mainWindowXamlCsPath = Path.Combine(testDir.Path, "MainWindow.xaml.cs");
string csContents = File.ReadAllText(mainWindowXamlCsPath);
csContents = csContents.Replace("InitializeComponent();", @"InitializeComponent();
this.Loaded += delegate { Application.Current.Shutdown(42); };");
File.WriteAllText(mainWindowXamlCsPath, csContents);
var restoreCommand = new RestoreCommand(Log, testDir.Path);
restoreCommand.Execute($"/p:RuntimeIdentifier={rid}")
.Should()
.Pass();
var publishCommand = new PublishCommand(Log, testDir.Path);
publishCommand.Execute($"/p:RuntimeIdentifier={rid}")
.Should()
.Pass();
var publishDirectory = publishCommand.GetOutputDirectory(
targetFramework: targetFramework,
runtimeIdentifier: rid);
var runAppCommand = new SdkCommandSpec()
{
FileName = Path.Combine(publishDirectory.FullName, Path.GetFileName(testDir.Path) + ".exe")
};
runAppCommand.Environment["DOTNET_ROOT"] = Path.GetDirectoryName(TestContext.Current.ToolsetUnderTest.DotNetHostPath);
var result = runAppCommand.ToCommand()
.CaptureStdErr()
.CaptureStdOut()
.Execute();
result.ExitCode.Should().Be(42);
}
public void TestUpdateCommand()
{
var command = new UpdateCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [ ""jquery.min.js"", ""jquery.js"" ]
}
]
}";
string libmanjsonPath = Path.Combine(WorkingDir, "libman.json");
File.WriteAllText(libmanjsonPath, contents);
var restoreCommand = new RestoreCommand(HostEnvironment);
restoreCommand.Configure(null);
restoreCommand.Execute();
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
int result = command.Execute("jquery");
Assert.AreEqual(0, result);
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
string actualText = File.ReadAllText(libmanjsonPath);
string expectedText = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [
""jquery.min.js"",
""jquery.js""
]
}
]
}";
Assert.AreEqual(StringHelper.NormalizeNewLines(expectedText), StringHelper.NormalizeNewLines(actualText));
}
private void Restore(DirectoryInfo projectDirectory, string projectName = null, string runtime = null)
{
var command = new RestoreCommand()
.WithWorkingDirectory(projectDirectory)
.WithRuntime(runtime);
if (projectName != null)
{
if (!Path.HasExtension(projectName))
{
projectName += ".csproj";
}
command.Execute($"{projectName} /p:SkipInvalidConfigurations=true;_InvalidConfigurationWarning=false")
.Should().Pass();
}
else
{
command.Execute("/p:SkipInvalidConfigurations=true;_InvalidConfigurationWarning=false")
.Should().Pass();
}
}
public void It_builds_a_framework_dependent_RID_specific_runnable_output()
{
if (UsingFullFrameworkMSBuild)
{
// Disable this test on full framework, as the current build won't have access to
// https://github.com/Microsoft/msbuild/pull/1674
// See https://github.com/dotnet/sdk/issues/877
return;
}
var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", "BuildFrameworkDependentRIDSpecific")
.WithSource();
var projectPath = Path.Combine(testAsset.TestRoot, "App");
var restoreCommand = new RestoreCommand(Stage0MSBuild, projectPath, "App.csproj");
restoreCommand
.Execute($"/p:TestRuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
var buildCommand = new BuildCommand(Stage0MSBuild, projectPath);
buildCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}", $"/p:TestRuntimeIdentifier={runtimeIdentifier}", "/p:SelfContained=false")
.Should().Pass();
var outputDirectory = buildCommand.GetOutputDirectory("netcoreapp1.1", runtimeIdentifier: runtimeIdentifier);
outputDirectory.Should().NotHaveSubDirectories();
outputDirectory.Should().OnlyHaveFiles(new[] {
"App.dll",
"App.pdb",
"App.deps.json",
"App.runtimeconfig.json",
"App.runtimeconfig.dev.json",
"LibraryWithoutRid.dll",
"LibraryWithoutRid.pdb",
"LibraryWithRid.dll",
"LibraryWithRid.pdb",
"LibraryWithRids.dll",
"LibraryWithRids.pdb",
});
Command.Create(RepoInfo.DotNetHostPath, new[] { Path.Combine(outputDirectory.FullName, "App.dll") })
.CaptureStdOut()
.Execute()
.Should().Pass()
.And.HaveStdOutContaining($"3.13.0 '{runtimeIdentifier}' 3.13.0 '{runtimeIdentifier}' Hello World");
}
public void TestUninstall_NoLibraryToUninstall()
{
var command = new UninstallCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""provider"": ""cdnjs"",
""library"": ""[email protected]"",
""destination"": ""wwwroot"",
""files"": [
""jquery.min.js"",
""core.js""
]
}
]
}";
string libmanjsonPath = Path.Combine(WorkingDir, "libman.json");
File.WriteAllText(libmanjsonPath, contents);
var restoreCommand = new RestoreCommand(HostEnvironment);
restoreCommand.Configure(null);
restoreCommand.Execute();
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "core.js")));
int result = command.Execute("[email protected]");
Assert.AreEqual(0, result);
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "core.js")));
var logger = HostEnvironment.Logger as TestLogger;
Assert.AreEqual("Library \"[email protected]\" is not installed. Nothing to uninstall", logger.Messages[logger.Messages.Count - 1].Value);
string actualText = File.ReadAllText(libmanjsonPath);
Assert.AreEqual(StringHelper.NormalizeNewLines(contents), StringHelper.NormalizeNewLines(actualText));
}
public void TestUpdateCommand_InvalidLibraryName()
{
var command = new UpdateCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [
""jquery.min.js"",
""jquery.js""
]
}
]
}";
string libmanjsonPath = Path.Combine(WorkingDir, "libman.json");
File.WriteAllText(libmanjsonPath, contents);
var restoreCommand = new RestoreCommand(HostEnvironment);
restoreCommand.Configure(null);
restoreCommand.Execute();
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
int result = command.Execute("[email protected]");
Assert.AreEqual(0, result);
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
var logger = HostEnvironment.Logger as TestLogger;
string message = "No library found with name \"[email protected]\" to update.\r\nPlease specify a library name without the version information to update.";
Assert.AreEqual(StringHelper.NormalizeNewLines(message), StringHelper.NormalizeNewLines(logger.Messages.Last().Value));
string actualText = File.ReadAllText(libmanjsonPath);
Assert.AreEqual(StringHelper.NormalizeNewLines(contents), StringHelper.NormalizeNewLines(actualText));
}
public void GroupPopulatedCorrectlyWithSingleFile()
{
var testProject = this.SetupProject();
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, testAsset.Path, testProject.Name);
restoreCommand
.Execute()
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, testAsset.Path, testProject.Name);
buildCommand
.Execute("/p:RuntimeIdentifier=win-x86;DesignTimeBuild=true;PublishSingleFile=true", "/t:PublishItemsOutputGroup")
.Should()
.Pass();
var testOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput"));
Log.WriteLine("Contents of PublishItemsOutputGroup dumped to '{0}'.", testOutputDir.FullName);
if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
{
testOutputDir.Should().HaveFile($"{testProject.Name}{Constants.ExeSuffix}");
}
// In the single file case there shouldn't be a deps.json file
testOutputDir.Should().NotHaveFile($"{testProject.Name}.deps.json");
// The framework assemblies should also get bundled with the main exe
testOutputDir.Should().NotHaveFiles(FrameworkAssemblies);
var testKeyOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput_Key"));
Log.WriteLine("PublishItemsOutputGroup key items dumped to '{0}'.", testKeyOutputDir.FullName);
if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
{
// Verify the only key item is the exe
testKeyOutputDir.Should()
.OnlyHaveFiles(new List <string>()
{
$"{testProject.Name}{Constants.ExeSuffix}"
});
}
}
public void TestUpdateCommand_InvalidUpdatedLibrary()
{
var command = new UpdateCommand(HostEnvironment);
command.Configure(null);
string contents = @"{
""version"": ""1.0"",
""defaultProvider"": ""cdnjs"",
""defaultDestination"": ""wwwroot"",
""libraries"": [
{
""library"": ""[email protected]"",
""files"": [ ""jquery.min.js"", ""jquery.js"" ]
}
]
}";
string libmanjsonPath = Path.Combine(WorkingDir, "libman.json");
File.WriteAllText(libmanjsonPath, contents);
var restoreCommand = new RestoreCommand(HostEnvironment);
restoreCommand.Configure(null);
restoreCommand.Execute();
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsTrue(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
int result = command.Execute("jquery", "--to", "[email protected]");
Assert.IsFalse(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.min.js")));
Assert.IsFalse(File.Exists(Path.Combine(WorkingDir, "wwwroot", "jquery.js")));
string actualText = File.ReadAllText(libmanjsonPath);
Assert.AreEqual(StringHelper.NormalizeNewLines(contents), StringHelper.NormalizeNewLines(actualText));
var logger = HostEnvironment.Logger as TestLogger;
Assert.AreEqual(LogLevel.Error, logger.Messages.Last().Key);
string expectedMessage = "Failed to update \"jquery\" to \"[email protected]\"";
Assert.IsTrue(logger.Messages.Any(m => m.Value == expectedMessage));
}
public static void Register(CommandLineApplication cmdApp, ReportsFactory reportsFactory, IApplicationEnvironment applicationEnvironment, IRuntimeEnvironment runtimeEnvironment)
{
cmdApp.Command("restore", c =>
{
c.Description = "Restore packages";
var argRoot = c.Argument("[root]",
"List of projects and project folders to restore. Each value can be: a path to a project.json or global.json file, or a folder to recursively search for project.json files.",
multipleValues: true);
var feedCommandLineOptions = FeedCommandLineOptions.Add(c);
var optLock = c.Option("--lock",
"Creates dependencies file with locked property set to true. Overwrites file if it exists.",
CommandOptionType.NoValue);
var optUnlock = c.Option("--unlock",
"Creates dependencies file with locked property set to false. Overwrites file if it exists.",
CommandOptionType.NoValue);
var optRuntimes = c.Option("--runtime <RID>",
"List of runtime identifiers to restore for",
CommandOptionType.MultipleValue);
c.HelpOption("-?|-h|--help");
c.OnExecute(async () =>
{
c.ShowRootCommandFullNameAndVersion();
var feedOptions = feedCommandLineOptions.GetOptions();
var command = new RestoreCommand(applicationEnvironment);
command.Reports = reportsFactory.CreateReports(feedOptions.Quiet);
command.RestoreDirectories.AddRange(argRoot.Values);
command.FeedOptions = feedOptions;
command.Lock = optLock.HasValue();
command.Unlock = optUnlock.HasValue();
command.RequestedRuntimes = optRuntimes.Values;
command.FallbackRuntimes = runtimeEnvironment.GetDefaultRestoreRuntimes();
if (!string.IsNullOrEmpty(feedOptions.Proxy))
{
Environment.SetEnvironmentVariable("http_proxy", feedOptions.Proxy);
}
var success = await command.Execute();
return success ? 0 : 1;
});
});
}
public void GroupNotPopulatedWithoutRid()
{
var testProject = this.SetupProject();
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(Log, testAsset.Path, testProject.Name);
restoreCommand
.Execute()
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, testAsset.Path, testProject.Name);
buildCommand
.Execute("/p:DesignTimeBuild=true", "/t:PublishItemsOutputGroup")
.Should()
.Pass();
var testOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput"));
Log.WriteLine("Contents of PublishItemsOutputGroup dumped to '{0}'.", testOutputDir.FullName);
if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
{
testOutputDir.Should().HaveFile($"{testProject.Name}{Constants.ExeSuffix}");
}
testOutputDir.Should().HaveFile($"{testProject.Name}.deps.json");
// Since no RID was specified the output group should not contain framework assemblies
testOutputDir.Should().NotHaveFiles(FrameworkAssemblies);
var testKeyOutputDir = new DirectoryInfo(Path.Combine(testAsset.Path, testProject.Name, "TestOutput_Key"));
Log.WriteLine("PublishItemsOutputGroup key items dumped to '{0}'.", testKeyOutputDir.FullName);
if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
{
// Verify the only key item is the exe
testKeyOutputDir.Should()
.OnlyHaveFiles(new List <string>()
{
$"{testProject.Name}{Constants.ExeSuffix}"
});
}
}
public void PublishDepsFilePathIsEmptyForSingleFileApps()
{
var testProject = SetupProject(singleFile: true);
var testAsset = _testAssetsManager.CreateTestProject(testProject);
var restoreCommand = new RestoreCommand(testAsset);
restoreCommand
.Execute()
.Should()
.Pass();
var projectPath = Path.Combine(testAsset.Path, testProject.Name);
var targetFramework = testProject.TargetFrameworks;
var publishDepsFilePath = GetPropertyValue(projectPath, targetFramework, "PublishDepsFilePath");
String.IsNullOrEmpty(publishDepsFilePath).Should().BeTrue();
}
private async Task<bool> Restore(PublishRoot root, PublishProject publishProject, string restoreDirectory, IEnumerable<FrameworkName> targetFrameworks)
{
var appEnv = PlatformServices.Default.Application;
var feedOptions = new FeedOptions();
feedOptions.IgnoreFailedSources = true;
feedOptions.Sources.Add(root.TargetPackagesPath);
feedOptions.TargetPackagesFolder = root.TargetPackagesPath;
var restoreCommand = new RestoreCommand(appEnv);
restoreCommand.TargetFrameworks.AddRange(targetFrameworks);
restoreCommand.RequestedRuntimes = root.RuntimeIdentifiers;
restoreCommand.SkipRestoreEvents = true;
restoreCommand.SkipInstall = true;
// This is a workaround for #1322. Since we use restore to generate the lock file
// after publish, it's possible to fail restore after copying the closure
// if framework assemblies and packages have the same name. This is more likely now
// since dependencies may exist in the top level
restoreCommand.IgnoreMissingDependencies = true;
restoreCommand.CheckHashFile = false;
restoreCommand.RestoreDirectories.Add(restoreDirectory);
restoreCommand.FeedOptions = feedOptions;
// Mute "dnu restore" subcommand
restoreCommand.Reports = Reports.Constants.NullReports;
var success = await restoreCommand.Execute();
return success;
}
private bool UpdateLockFile(PublishRoot root)
{
var appEnv = (IApplicationEnvironment)root.HostServices.GetService(typeof(IApplicationEnvironment));
var feedOptions = new FeedOptions();
feedOptions.IgnoreFailedSources = true;
feedOptions.Sources.Add(root.TargetPackagesPath);
feedOptions.TargetPackagesFolder = root.TargetPackagesPath;
var tasks = new Task<bool>[root.Projects.Count];
for (int i = 0; i < root.Projects.Count; i++)
{
var project = root.Projects[i];
var restoreCommand = new RestoreCommand(appEnv);
foreach (var runtime in root.Runtimes)
{
restoreCommand.TargetFrameworks.Add(project.SelectFrameworkForRuntime(runtime));
}
var restoreDirectory = project.IsPackage ? Path.Combine(project.TargetPath, "root") : project.TargetPath;
restoreCommand.SkipRestoreEvents = true;
restoreCommand.SkipInstall = true;
// This is a workaround for #1322. Since we use restore to generate the lock file
// after publish, it's possible to fail restore after copying the closure
// if framework assemblies and packages have the same name. This is more likely now
// since dependencies may exist in the top level
restoreCommand.IgnoreMissingDependencies = true;
restoreCommand.CheckHashFile = false;
restoreCommand.RestoreDirectories.Add(restoreDirectory);
restoreCommand.FeedOptions = feedOptions;
restoreCommand.Reports = root.Reports.ShallowCopy();
// Mute "dnu restore" completely if it is invoked by "dnu publish --quiet"
restoreCommand.Reports.Information = root.Reports.Quiet;
tasks[i] = restoreCommand.Execute();
}
Task.WaitAll(tasks);
return tasks.All(t => t.Result);
}
private async Task<bool> Restore(PublishRoot root, PublishProject publishProject, string restoreDirectory)
{
var appEnv = (IApplicationEnvironment)root.HostServices.GetService(typeof(IApplicationEnvironment));
var feedOptions = new FeedOptions();
feedOptions.IgnoreFailedSources = true;
feedOptions.Sources.Add(root.TargetPackagesPath);
feedOptions.TargetPackagesFolder = root.TargetPackagesPath;
var restoreCommand = new RestoreCommand(appEnv);
foreach (var framework in root.Frameworks)
{
restoreCommand.TargetFrameworks.Add(framework.Key);
}
restoreCommand.SkipRestoreEvents = true;
restoreCommand.SkipInstall = true;
// This is a workaround for #1322. Since we use restore to generate the lock file
// after publish, it's possible to fail restore after copying the closure
// if framework assemblies and packages have the same name. This is more likely now
// since dependencies may exist in the top level
restoreCommand.IgnoreMissingDependencies = true;
restoreCommand.CheckHashFile = false;
restoreCommand.RestoreDirectories.Add(restoreDirectory);
restoreCommand.FeedOptions = feedOptions;
// Mute "dnu restore" subcommand
restoreCommand.Reports = Reports.Constants.NullReports;
var success = await restoreCommand.Execute();
return success;
}
