public void CanSpecifyProjectDirectoryInGlobalJson()
{
var solutionStructure = @"{
'global.json': '',
'src': {
'ProjectA': {
'project.json': '{}'
}
},
'ProjectB': {
'project.json': '{}'
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src"", ""ProjectB""]
}")
.WriteTo(solutionPath);
var resolutionRoot = Path.Combine(solutionPath, "src", "ProjectA");
Runtime.Project project;
Assert.True(new ProjectResolver(resolutionRoot).TryResolveProject("ProjectB", out project));
Assert.NotNull(project);
}
}
public void ProjectResolverWorksWithMultipleNonProjectFoldersThatHaveSameName()
{
const string projectName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src1': {
'ProjectA': {
'file.txt': 'Not a project.json'
}
},
'src2': {
'ProjectA': {
'file.txt': 'Not a project.json'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src1"", ""src2""]
}")
.WriteTo(solutionPath);
var projectPath = Path.Combine(solutionPath, "src1", projectName);
Runtime.Project project;
Assert.False(new ProjectResolver(projectPath).TryResolveProject(projectName, out project));
Assert.Null(project);
}
}
public void ProjectResolverDoesNotThrowWhenThereAreDuplicatedEntriesInGlobalJson()
{
const string unambiguousName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src': {
'ProjectA': {
'project.json': '{}'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src"", ""src/../src"", ""somedir\\somesubdir\\..\\..\\src""]
}")
.WriteTo(solutionPath);
var unambiguousProjectPath = Path.Combine(solutionPath, "src", unambiguousName);
Runtime.Project project;
Assert.True(new ProjectResolver(unambiguousProjectPath).TryResolveProject(unambiguousName, out project));
Assert.NotNull(project);
}
}
public DnuTestEnvironment(string runtimePath, string projectName = null, string outputDirName = null)
{
_projectName = projectName ?? "ProjectName";
_outputDirName = outputDirName ?? "OutputDirName";
_runtimePath = runtimePath;
RootDir = new DisposableDir();
}
public void ReadResourcesFromProjectNugetPackageAndClassLibrary(string flavor, string os, string architecture)
{
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempDir = new DisposableDir())
{
var appPath = Path.Combine(tempDir, "ResourcesTestProjects", "ReadFromResources");
TestUtils.CreateDisposableTestProject(runtimeHomeDir, Path.Combine(tempDir, "ResourcesTestProjects"), Path.Combine(TestUtils.GetMiscProjectsFolder(), "ResourcesTestProjects", "ReadFromResources"));
string stdOut;
string stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: "-p . run",
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
{ EnvironmentNames.Trace, null }
},
workingDir: Path.Combine(appPath, "src", "ReadFromResources"));
Assert.Equal(0, exitCode);
Assert.Contains(@"Hello World!
Bonjour Monde!
Hallo Welt
Bienvenue
The name '{0}' is ambiguous.
Le nom '{0}' est ambigu.
", stdOut);
}
}
public void DnuRestore_UsesProjectAndCommandLineProvidedRuntimes(string flavor, string os, string architecture)
{
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);
}
// Modify the project
AddRuntimeToProject(testDir, "win10-x86");
// Restore the project!
var source = Path.Combine(misc, "RuntimeRestore", "RuntimeRestoreTestPackage", "feed");
DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", $"--source {source} --runtime ubuntu.14.04-x64 --runtime osx.10.10-x64", workingDir: testDir);
// Check the lock file
lockFile = (new LockFileFormat()).Read(Path.Combine(testDir, "project.lock.json"));
}
AssertLockFileTarget(lockFile, "win10-x86", "win8-x86");
AssertLockFileTarget(lockFile, "osx.10.10-x64", "osx.10.10-x64");
AssertLockFileTarget(lockFile, "ubuntu.14.04-x64", "ubuntu.14.04-x64");
}
public void DthNegative_BrokenProjectPathInLockFile_V2(DnxSdk sdk)
{
var testProject = _fixture.GetTestProjectPath("BrokenProjectPathSample");
using (var disposableDir = new DisposableDir())
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
// copy the project to difference location so that the project path in its lock file is invalid
var targetPath = Path.Combine(disposableDir, "BrokenProjectPathSample");
Testing.TestUtils.CopyFolder(testProject, targetPath);
client.Initialize(targetPath, protocolVersion: 2);
var messages = client.DrainAllMessages()
.AssertDoesNotContain("Error");
messages.RetrieveSingleMessage("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt(0)
.AssertProperty <string>("FormattedMessage", message => message.Contains("error NU1001: The dependency EmptyLibrary could not be resolved."))
.RetrievePropertyAs <JObject>("Source")
.AssertProperty("Name", "EmptyLibrary");
messages.RetrieveSingleMessage("Dependencies")
.RetrieveDependency("EmptyLibrary")
.AssertProperty <JArray>("Errors", errorsArray => errorsArray.Count == 1)
.AssertProperty <JArray>("Warnings", warningsArray => warningsArray.Count == 0)
.AssertProperty("Name", "EmptyLibrary")
.AssertProperty("Resolved", false);
}
}
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);
}
}
public void KCommandShowsErrorWhenGivenSubcommandWasNotFoundInProjectJson(DisposableDir runtimeHomeDir)
{
var projectStructure = @"{
'project.json': '{ }'
}";
using (runtimeHomeDir)
using (var projectPath = TestUtils.CreateTempDir())
{
DirTree.CreateFromJson(projectStructure).WriteTo(projectPath);
string stdOut, stdErr;
var exitCode = KCommandTestUtils.ExecKCommand(
runtimeHomeDir,
subcommand: "invalid",
arguments: string.Empty,
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
{ EnvironmentNames.AppBase, projectPath }
});
Assert.NotEqual(0, exitCode);
Assert.Contains("Unable to load application or execute command 'invalid'.", stdErr);
}
}
public void DnuInstall_OverwriteOldVersion(string flavor, string os, string architecture)
{
var runtimeHomePath = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempDir = new DisposableDir())
{
var packagesDir = Path.Combine(tempDir, "packages");
var projectDir = Path.Combine(tempDir, "project");
Directory.CreateDirectory(projectDir);
var projectJsonPath = Path.Combine(projectDir, Runtime.Project.ProjectFileName);
File.WriteAllText(projectJsonPath, @"{
""dependencies"": {
""alpha"": ""0.0.0""
}
}");
VerifyDnuInstall(
runtimeHomePath,
packageName: "alpha",
packageVersion: "0.1.0",
projectDir: projectDir,
packagesDir: packagesDir,
workingDir: projectDir);
}
}
private void CreateNewPackage(string name, string version)
{
var runtimeForPacking = TestUtils.GetClrRuntimeComponents().FirstOrDefault();
if (runtimeForPacking == null)
{
throw new InvalidOperationException("Can't find a CLR runtime to pack test packages.");
}
var runtimeHomePath = base.GetRuntimeHomeDir((string)runtimeForPacking[0],
(string)runtimeForPacking[1],
(string)runtimeForPacking[2]);
using (var tempdir = new DisposableDir())
{
var dir = new DirectoryInfo(tempdir);
var projectDir = dir.CreateSubdirectory(name);
var outputDir = dir.CreateSubdirectory("output");
var projectJson = Path.Combine(projectDir.FullName, "project.json");
File.WriteAllText(projectJson, $@"{{
""version"": ""{version}"",
""frameworks"": {{
""dnx451"": {{ }}
}}
}}");
DnuTestUtils.ExecDnu(runtimeHomePath, "restore", projectJson);
DnuTestUtils.ExecDnu(runtimeHomePath, "pack", projectJson + " --out " + outputDir.FullName, environment: null, workingDir: null);
var packageName = string.Format("{0}.{1}.nupkg", name, version);
var packageFile = Path.Combine(outputDir.FullName, "Debug", packageName);
File.Copy(packageFile, Path.Combine(PackageSource, packageName), overwrite: true);
}
}
public void AppHostShowsErrorWhenGivenSubcommandWasNotFoundInProjectJson(string flavor, string os, string architecture)
{
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
var projectStructure = @"{
""project.json"": ""{ }""
}";
using (var projectPath = new DisposableDir())
{
DirTree.CreateFromJson(projectStructure)
.WithFileContents("project.json", @"
{
""frameworks"": {
""dnx451"": { },
""dnxcore50"": { }
}
}").WriteTo(projectPath);
string stdOut, stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: "invalid",
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
},
workingDir: projectPath);
Assert.Equal(1, exitCode);
Assert.Contains("Unable to load application or execute command 'invalid'.", stdErr);
}
}
public void ProjectResolverChecksProjectFileForDisambiguation()
{
const string projectName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src1': {
'ProjectA': {
'project.json': '{}'
}
},
'src2': {
'ProjectA': {
'file.txt': 'Not a project.json'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src1"", ""src2""]
}")
.WriteTo(solutionPath);
var projectPath = Path.Combine(solutionPath, "src1", projectName);
Runtime.Project project;
Assert.True(new ProjectResolver(projectPath).TryResolveProject(projectName, out project));
Assert.NotNull(project);
}
}
public void ReadEmbeddedResourcesFromProject(string flavor, string os, string architecture)
{
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempDir = new DisposableDir())
{
var appPath = Path.Combine(tempDir, "ResourcesTestProjects", "EmbeddedResources");
TestUtils.CreateDisposableTestProject(runtimeHomeDir, Path.Combine(tempDir, "ResourcesTestProjects"), Path.Combine(TestUtils.GetMiscProjectsFolder(), "ResourcesTestProjects", "EmbeddedResources"));
string stdOut;
string stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: "-p . run",
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
{ EnvironmentNames.Trace, null }
},
workingDir: appPath);
Assert.Equal(0, exitCode);
Assert.Contains(@"Hello
<html>
Basic Test
</html>
", stdOut);
}
}
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var projectSrcDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
const string configuration = "Debug";
var components = TestUtils.GetRuntimeComponentsCombinations().First();
var flavor = (string)components[0];
var os = (string)components[1];
var architecture = (string)components[2];
using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture))
using (var tempDir = new DisposableDir())
{
var projectDir = Path.Combine(tempDir, projectName);
var buildOutpuDir = Path.Combine(tempDir, "output");
TestUtils.CopyFolder(projectSrcDir, projectDir);
var exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", projectDir);
Assert.Equal(0, exitCode);
exitCode = DnuTestUtils.ExecDnu(
runtimeHomeDir,
"pack",
$"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
Assert.Equal(0, exitCode);
var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
}
}
public void BootstrapperLaunchesRequestedFramworkVersionIfOptionProvided(string flavor, string os, string architecture, string requestedFramework, string expectedOutput)
{
const string projectStructure = @"{
""project.json"": {},
""project.lock.json"": {},
""Program.cs"": {}
}";
const string projectJson = @"{
""dependencies"": {
},
""frameworks"": {
""dnx46"": {},
""dnx452"": {},
""dnx451"": {}
}
}";
const string lockFile = @"{
""locked"": false,
""version"": 2,
""targets"": {
""DNX,Version=v4.5.1"": {},
""DNX,Version=v4.5.2"": {},
""DNX,Version=v4.6"": {}
},
""libraries"": {},
""projectFileDependencyGroups"": {
"""": [],
""DNX,Version=v4.5.1"": [],
""DNX,Version=v4.5.2"": [],
""DNX,Version=v4.6"": []
}
}";
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempDir = new DisposableDir())
{
DirTree.CreateFromJson(projectStructure)
.WithFileContents("project.json", projectJson)
.WithFileContents("project.lock.json", lockFile)
.WithFileContents("Program.cs", ClrVersionTestProgram)
.WriteTo(tempDir);
string stdOut;
string stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: $"--framework {requestedFramework} run",
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
{ EnvironmentNames.Trace, null }
},
workingDir: tempDir);
Assert.Equal(0, exitCode);
Assert.Contains(expectedOutput, stdOut.Trim());
}
}
public void Dispose()
{
if (Root != null)
{
Root.Dispose();
Root = null;
}
}
public void KpmBundleConsoleApp(DisposableDir runtimeHomeDir)
{
var projectStructure = @"{
'.': ['project.json', 'Config.json', 'Program.cs'],
'Data': {
'Input': ['data1.dat', 'data2.dat'],
'Backup': ['backup1.dat', 'backup2.dat']
},
'packages': {}
}";
var expectedOutputStructure = @"{
'approot': {
'global.json': '',
'src': {
'PROJECT_NAME': {
'.': ['project.json', 'Config.json', 'Program.cs'],
'Data': {
'Input': ['data1.dat', 'data2.dat']
}
}
}
}
}".Replace("PROJECT_NAME", _projectName);
using (var testEnv = new KpmTestEnvironment(runtimeHomeDir, _projectName, _outputDirName))
{
DirTree.CreateFromJson(projectStructure)
.WithFileContents("project.json", @"{
""bundleExclude"": ""Data/Backup/**""
}")
.WriteTo(testEnv.ProjectPath);
var environment = new Dictionary <string, string>()
{
{ EnvironmentNames.Packages, Path.Combine(testEnv.ProjectPath, "packages") }
};
var exitCode = KpmTestUtils.ExecKpm(
runtimeHomeDir,
subcommand: "bundle",
arguments: string.Format("--out {0}",
testEnv.BundleOutputDirPath),
environment: environment,
workingDir: testEnv.ProjectPath);
Assert.Equal(0, exitCode);
var expectedOutputDir = DirTree.CreateFromJson(expectedOutputStructure)
.WithFileContents(Path.Combine("approot", "src", testEnv.ProjectName, "project.json"), @"{
""bundleExclude"": ""Data/Backup/**""
}")
.WithFileContents(Path.Combine("approot", "global.json"), @"{
""dependencies"": {},
""packages"": ""packages""
}");
Assert.True(expectedOutputDir.MatchDirectoryOnDisk(testEnv.BundleOutputDirPath,
compareFileContents: true));
}
}
public PackageManagerFunctionalTestFixture() : base()
{
_contextDir = new DisposableDir();
PackageSource = Path.Combine(_contextDir.DirPath, "packages");
Directory.CreateDirectory(PackageSource);
CreateNewPackage("alpha", "0.1.0");
PackPackage(Path.Combine(TestUtils.GetMiscProjectsFolder(), "XreTestApps/CommandsProject"), PackageSource);
}
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.
if (RuntimeEnvironmentHelper.RuntimeEnvironment.OperatingSystem.Equals("Darwin"))
{
var ver = Version.Parse(RuntimeEnvironmentHelper.RuntimeEnvironment.OperatingSystemVersion);
if (ver < new Version(10, 10))
{
// Not supported on this!
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 because by default it only uses the current OSes RIDs
if (RuntimeEnvironmentHelper.IsWindows)
{
AssertLockFileTarget(lockFile, "win7-x86", "win7-x86");
AssertLockFileTarget(lockFile, "win7-x64", "win7-x64");
}
else
{
var osName = RuntimeEnvironmentHelper.RuntimeEnvironment.GetDefaultRestoreRuntimes().First();
osName = osName.Substring(0, osName.Length - 4); // Remove the -x86 suffix
AssertLockFileTarget(lockFile, osName + "-x86", assemblyRid: null); // There is no ubuntu/osx-x86 in the test package
AssertLockFileTarget(lockFile, osName + "-x64", osName + "-x64");
}
}
public void BootstrapperConfiguresAppConfigFile(string flavor, string os, string architecture)
{
const string projectStructure = @"{
""project.json"": {},
""project.lock.json"": {},
""app.config"": {},
""Program.cs"": {}
}";
const string projectJson = @" {
""frameworks"": {
""dnx451"": {
""frameworkAssemblies"": {
""System.Configuration"": """"
}
}
}
}";
const string appConfig = @"<configuration>
<appSettings>
<add key=""TheSetting"" value=""TheValue"" />
</appSettings>
</configuration>";
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var tempDir = new DisposableDir())
{
DirTree.CreateFromJson(projectStructure)
.WithFileContents("project.json", projectJson)
.WithFileContents("app.config", appConfig)
.WithFileContents("Program.cs", AppSettingTestProgram)
.WriteTo(tempDir);
string stdOut;
string stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: $"run",
stdOut: out stdOut,
stdErr: out stdErr,
environment: new Dictionary <string, string> {
{ EnvironmentNames.Trace, null }
},
workingDir: tempDir);
Assert.Equal(0, exitCode);
Assert.Contains("TheSetting=TheValue", stdOut.Trim());
}
}
public void KCommandReturnsNonZeroExitCodeWhenNoArgumentWasGiven(DisposableDir kreHomeDir)
{
using (kreHomeDir)
{
string stdOut, stdErr;
var exitCode = KCommandTestUtils.ExecKCommand(
kreHomeDir,
subcommand: string.Empty,
arguments: string.Empty,
stdOut: out stdOut,
stdErr: out stdErr);
Assert.NotEqual(0, exitCode);
}
}
public void KCommandReturnsZeroExitCodeWhenHelpOptionWasGiven(DisposableDir runtimeHomeDir)
{
using (runtimeHomeDir)
{
string stdOut, stdErr;
var exitCode = KCommandTestUtils.ExecKCommand(
runtimeHomeDir,
subcommand: string.Empty,
arguments: "--help",
stdOut: out stdOut,
stdErr: out stdErr);
Assert.Equal(0, exitCode);
}
}
public IDisposable CreateDisposableTestProject(string projectName, DnxSdk sdk, out string testProjectDir)
{
var source = Path.Combine(TestUtils.GetTestSolutionsDirectory(), "DthTestProjects", projectName);
if (!Directory.Exists(source))
{
throw new ArgumentException($"Test project {source} doesn't exist.", nameof(projectName));
}
var disposableDir = new DisposableDir();
CreateDisposableTestProject(sdk, disposableDir, source);
testProjectDir = Path.Combine(disposableDir, projectName);
return(disposableDir);
}
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);
}
}
public void AppHostShowsErrorWhenNoProjectJsonWasFound(string flavor, string os, string architecture)
{
var runtimeHomeDir = _fixture.GetRuntimeHomeDir(flavor, os, architecture);
using (var emptyFolder = new DisposableDir())
{
string stdOut, stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: "run",
stdOut: out stdOut,
stdErr: out stdErr,
workingDir: emptyFolder);
Assert.Equal(1, exitCode);
Assert.Contains("Unable to resolve project", stdErr);
}
}
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}")));
}
}
public void ProjectResolverThrowsWhenResolvingAmbiguousName()
{
const string ambiguousName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src1': {
'ProjectA': {
'project.json': '{}'
}
},
'src2': {
'ProjectA': {
'project.json': '{}'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src1"", ""src2""]
}")
.WriteTo(solutionPath);
var src1ProjectPath = Path.Combine(solutionPath, "src1", ambiguousName);
var src2ProjectPath = Path.Combine(solutionPath, "src2", ambiguousName);
var expectedMessage = $@"The project name '{ambiguousName}' is ambiguous between the following projects:
{src1ProjectPath}
{src2ProjectPath}";
Runtime.Project project = null;
var resolver1 = new ProjectResolver(src1ProjectPath);
var exception = Assert.Throws <InvalidOperationException>(() => resolver1.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
var resolver2 = new ProjectResolver(src2ProjectPath);
exception = Assert.Throws <InvalidOperationException>(() => resolver2.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
}
}
public void AppHostShowsErrorWhenCurrentTargetFrameworkWasNotFoundInProjectJson(string flavor, string os, string architecture)
{
var runtimeTargetFrameworkString = flavor == "coreclr" ? FrameworkNames.LongNames.DnxCore50 : FrameworkNames.LongNames.Dnx451;
var runtimeTargetFramework = new FrameworkName(runtimeTargetFrameworkString);
var runtimeTargetFrameworkShortName = VersionUtility.GetShortFrameworkName(runtimeTargetFramework);
var runtimeType = flavor == "coreclr" ? "CoreCLR" : "CLR";
runtimeType = RuntimeEnvironmentHelper.IsMono ? "Mono" : runtimeType;
var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
var projectJsonContents = @"{
""frameworks"": {
""FRAMEWORK_NAME"": { }
}
}".Replace("FRAMEWORK_NAME", flavor == "coreclr" ? "dnx451" : "dnxcore50");
using (runtimeHomeDir)
using (var projectPath = new DisposableDir())
{
var projectName = new DirectoryInfo(projectPath).Name;
var projectJsonPath = Path.Combine(projectPath, Project.ProjectFileName);
File.WriteAllText(projectJsonPath, projectJsonContents);
string stdOut, stdErr;
var exitCode = BootstrapperTestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: $"{projectPath} run",
stdOut: out stdOut,
stdErr: out stdErr);
var expectedErrorMsg = $@"The current runtime target framework is not compatible with '{projectName}'.
Current runtime Target Framework: '{runtimeTargetFramework} ({runtimeTargetFrameworkShortName})'
Type: {runtimeType}
Architecture: {architecture ?? TestUtils.CurrentRuntimeEnvironment.RuntimeArchitecture}
Version: {TestUtils.GetRuntimeVersion()}
Please make sure the runtime matches a framework specified in {Project.ProjectFileName}";
Assert.NotEqual(0, exitCode);
Assert.Contains(expectedErrorMsg, stdErr);
}
}
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")));
}
}
}
