public async Task TestDiscovery(DnxSdk sdk)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects");
var project = solution.GetProject("EmptyConsoleApp");
client.Initialize(project.ProjectDirectory);
client.DrainMessage(7);
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, server.Port));
var stream = new NetworkStream(socket);
var compiler = new DesignTimeHostCompiler(stream);
client.SendPayLoad(1, DthMessageTypes.EnumerateProjectContexts);
var target = new CompilationTarget("EmptyConsoleApp",
VersionUtility.ParseFrameworkName("dnx451"),
"Debug",
aspect: null);
var response = await compiler.Compile(project.ProjectDirectory, target);
Assert.NotNull(response);
Assert.Empty(response.Diagnostics);
Assert.NotEmpty(response.AssemblyBytes);
}
}
public void DnuRestoreInstallsIndirectDependency(DnxSdk sdk)
{
// SimpleChain -> DependencyA -> DependencyB
const string feedSolutionName = "DependencyGraphsFeed";
const string projectSolutionName = "DependencyGraphsProject";
const string projectName = "SimpleChain";
var feedSolution = TestUtils.GetSolution <DnuRestoreTests>(sdk, feedSolutionName, appendSolutionNameToTestFolder: true);
var localFeed = TestUtils.CreateLocalFeed <DnuRestoreTests>(sdk, feedSolution);
var projectSolution = TestUtils.GetSolution <DnuRestoreTests>(sdk, projectSolutionName, appendSolutionNameToTestFolder: true);
var project = projectSolution.GetProject(projectName);
var packagesDir = Path.Combine(project.ProjectDirectory, "packages");
var result = sdk.Dnu.Restore(
project.ProjectDirectory,
packagesDir,
feeds: new [] { localFeed });
result.EnsureSuccess();
Assert.Empty(result.StandardError);
Assert.Contains($"Installing DependencyA.1.0.0", result.StandardOutput);
Assert.Contains($"Installing DependencyB.2.0.0", result.StandardOutput);
Assert.True(Directory.Exists(Path.Combine(packagesDir, "DependencyA", "1.0.0")));
Assert.True(Directory.Exists(Path.Combine(packagesDir, "DependencyB", "2.0.0")));
TestUtils.CleanUpTestDir <DnuRestoreTests>(sdk);
}
public void CompileModuleWithDeps(DnxSdk sdk)
{
// Arrange
var solution = TestProjectsRepository.EnsureRestoredSolution("CompileModuleWithDependencies");
var project = solution.GetProject("A");
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
client.Initialize(project.ProjectDirectory);
client.SendPayLoad(project, "GetDiagnostics");
// Assert
var diagnosticsPerFramework = client.DrainTillFirst("AllDiagnostics")
.RetrievePayloadAs <JArray>()
.AssertJArrayCount(3);
foreach (var frameworkDiagnostics in diagnosticsPerFramework)
{
var errors = frameworkDiagnostics.Value <JArray>("Errors");
var warnings = frameworkDiagnostics.Value <JArray>("Warnings");
Assert.Equal(0, errors.Count);
Assert.Equal(0, warnings.Count);
}
}
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
public void DnuPublishWebApp_SubdirAsPublicDir_DirPlusFlatList(DnxSdk sdk)
{
const string projectName = "ProjectForTesting";
FrameworkName[] frameworkCandidates =
{
FrameworkNameHelper.ParseFrameworkName("dnx451"),
FrameworkNameHelper.ParseFrameworkName("dnxcore50")
};
var targetFramework = DependencyContext.SelectFrameworkNameForRuntime(
frameworkCandidates, sdk.FullName).FullName;
var projectJson = new JObject
{
["publishExclude"] = "**.useless",
["webroot"] = "public",
["frameworks"] = new JObject
{
["dnx451"] = new JObject {
},
["dnxcore50"] = new JObject {
}
}
};
var projectStructure = new Dir
{
public void DthStartup_GetProjectInformation(DnxSdk sdk)
{
using (var server = sdk.Dth.CreateServer())
using (var client = new DthTestClient(server))
{
var solution = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects");
var project = solution.GetProject("EmptyConsoleApp");
sdk.Dnu.Restore(project).EnsureSuccess();
client.Initialize(project.ProjectDirectory);
var projectInformation = client.DrainTillFirst("ProjectInformation")
.EnsureSource(server, client)
.RetrievePayloadAs <JObject>()
.AssertProperty("Name", project.Name);
projectInformation.RetrievePropertyAs <JArray>("Configurations")
.AssertJArrayCount(2)
.AssertJArrayContains("Debug")
.AssertJArrayContains("Release");
var frameworkShortNames = projectInformation.RetrievePropertyAs <JArray>("Frameworks")
.AssertJArrayCount(2)
.Select(f => f["ShortName"].Value <string>());
Assert.Contains("dnxcore50", frameworkShortNames);
Assert.Contains("dnx451", frameworkShortNames);
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void DnuPack_ClientProfile(DnxSdk sdk)
{
const string ProjectName = "ClientProfileProject";
var projectStructure = new Dir
{
[ProjectName] = new Dir
{
["project.json"] = new JObject
{
["frameworks"] = new JObject
{
["net40-client"] = new JObject(),
["net35-client"] = new JObject()
}
}
},
["Output"] = new Dir()
};
var baseDir = TestUtils.GetTestFolder <DnuPackTests>(sdk);
var projectDir = Path.Combine(baseDir, ProjectName);
var outputDir = Path.Combine(baseDir, "Output");
projectStructure.Save(baseDir);
sdk.Dnu.Restore(projectDir).EnsureSuccess();
var result = sdk.Dnu.Pack(projectDir, outputDir);
Assert.Equal(0, result.ExitCode);
}
public void ComparisonTest(DnxSdk sdk)
{
var file1a = new JObject
{
["info"] = "foo"
};
var file1b = new JObject
{
["info"] = "bar1"
};
var project1 = new Dir
{
["file1"] = file1a,
["file2"] = file1b
};
var file2a = new JObject
{
["info"] = "foo"
};
var file2b = new JObject
{
["info"] = "bar2"
};
var project2 = new Dir
{
["file1"] = file2a,
["file2"] = file2b
};
var project3 = new Dir
{
["file1"] = file2a,
["file2"] = new DirItem(Dir.EmptyFile, skipComparison: true)
};
var project4 = new Dir
{
["subdir1"] = project1,
["subdir2"] = project1
};
var project5 = new Dir
{
["subdir1"] = new DirItem(project2, skipComparison: true),
["subdir2"] = project2
};
DirAssert.Equal(project1, project2, compareContents: false);
DirAssert.Equal(project1, project3, compareContents: false);
DirAssert.Equal(project1, project3);
DirAssert.Equal(project2, project3);
//DirAssert.Equal(project4, project5); // this should fail, but only subdir2 should be different
TestUtils.CleanUpTestDir <DnuPublishTests>(sdk);
}
public void CompileModuleWithDeps(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution <DthStartupTests>(sdk, "CompileModuleWithDependencies");
var project = solution.GetProject("A");
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
client.Initialize(project.ProjectDirectory);
client.SendPayLoad(project, "GetDiagnostics");
var messages = client.DrainAllMessages();
// Assert
messages.AssertDoesNotContain("Error");
var diagnosticsPerFramework = messages.RetrieveSingleMessage("AllDiagnostics")
.RetrievePayloadAs <JArray>()
.AssertJArrayCount(3);
foreach (var frameworkDiagnostics in diagnosticsPerFramework)
{
var errors = frameworkDiagnostics.Value <JArray>("Errors");
var warnings = frameworkDiagnostics.Value <JArray>("Warnings");
Assert.Equal(0, errors.Count);
Assert.Equal(0, warnings.Count);
}
}
}
public void DthStartup_EnumerateProjectContexts(DnxSdk sdk)
{
// arrange
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects");
var projects = new Project[]
{
solution.GetProject("EmptyLibrary"),
solution.GetProject("UnresolvedPackageSample"),
solution.GetProject("EmptyConsoleApp")
};
var contexts = projects.ToDictionary(proj => proj.ProjectDirectory,
proj => client.Initialize(proj.ProjectDirectory));
// 7 response for each project initalization
client.DrainMessage(21);
// the context id here doesn't matter, this request is processed before it reaches
// ApplicationContext
client.SendPayLoad(1, DthMessageTypes.EnumerateProjectContexts, new { Version = 1 });
var message = client.DrainTillFirst(DthMessageTypes.ProjectContexts);
Assert.Equal(contexts.Count, message.Projects.Count);
Assert.True(Enumerable.SequenceEqual(contexts, message.Projects));
}
}
public void DthNegative_BrokenProjectPathInLockFile_V2(DnxSdk sdk)
{
var projectName = "BrokenProjectPathSample";
var project = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects")
.GetProject(projectName);
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
// After restore the project is copied to another place so that
// the relative path in project lock file is invalid.
var movedProjectPath = Path.Combine(TestUtils.GetTempTestFolder <DthStartupTests>(sdk), projectName);
TestUtils.CopyFolder(project.ProjectDirectory, movedProjectPath);
client.Initialize(movedProjectPath, protocolVersion: 2);
client.DrainTillFirst("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt(0)
.AssertProperty <string>("FormattedMessage", message => message.Contains("error NU1002"))
.RetrievePropertyAs <JObject>("Source")
.AssertProperty("Name", "EmptyLibrary");
client.DrainTillFirst("Dependencies")
.RetrieveDependency("EmptyLibrary")
.AssertProperty <JArray>("Errors", errorsArray => errorsArray.Count == 1)
.AssertProperty <JArray>("Warnings", warningsArray => warningsArray.Count == 0)
.AssertProperty("Name", "EmptyLibrary")
.AssertProperty("Resolved", false);
}
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
public void DthDependencies_UpdateGlobalJson_RefreshDependencies(DnxSdk sdk)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestUtils.GetSolution <DthStartupTests>(sdk, "DthUpdateSearchPathSample");
var root = Path.Combine(solution.RootPath, "home");
sdk.Dnu.Restore(root).EnsureSuccess();
var testProject = Path.Combine(root, "src", "MainProject");
client.Initialize(testProject, protocolVersion: 2);
client.DrainTillFirst("ProjectInformation")
.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectSearchPaths")
.AssertJArrayCount(2);
client.DrainTillFirst("DependencyDiagnostics")
.RetrievePayloadAs <JObject>()
.AssertProperty <JArray>("Errors", array => array.Count == 0)
.AssertProperty <JArray>("Warnings", array => array.Count == 0);
client.DrainTillFirst("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", "Project")
.AssertProperty("Resolved", true)
.AssertProperty <JArray>("Errors", array => array.Count == 0, _ => "Dependency shouldn't contain any error.");
// Overwrite the global.json to remove search path to ext
File.WriteAllText(
Path.Combine(root, GlobalSettings.GlobalFileName),
JsonConvert.SerializeObject(new { project = new string[] { "src" } }));
client.SendPayLoad(testProject, "RefreshDependencies");
client.DrainTillFirst("ProjectInformation")
.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectSearchPaths")
.AssertJArrayCount(1)
.AssertJArrayElement(0, Path.Combine(root, "src"));
client.DrainTillFirst("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt <JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
client.DrainTillFirst("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", LibraryTypes.Unresolved)
.AssertProperty("Resolved", false)
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void Restore_PackageOverProjectTarget(DnxSdk sdk)
{
var solution = TestUtils.GetSolution <DnuRestoreTests2>(sdk, "DependencyTargets");
var bOutputPath = Path.Combine(solution.ArtifactsPath, "B");
// Build a package for B
sdk.Dnu.Restore(solution.GetProject("A")).EnsureSuccess();
sdk.Dnu.Restore(solution.GetProject("B")).EnsureSuccess();
sdk.Dnu.Pack(
solution.GetProject("B").ProjectDirectory,
bOutputPath,
configuration: "package").EnsureSuccess();
sdk.Dnu.PackagesAdd(
Path.Combine(bOutputPath, "package", "B.1.0.0.nupkg"),
solution.LocalPackagesDir).EnsureSuccess();
// Restore the app, it'll work but it will choose the package over the project
sdk.Dnu.Restore(solution.GetProject("App")).EnsureSuccess();
// Run the app
var result = sdk.Dnx.Execute(solution.GetProject("App"));
Assert.Equal(@"A: This is Project A
B: This is Package B
", result.StandardOutput);
}
public void DthNegative_BrokenProjectPathInLockFile_V1(DnxSdk sdk)
{
var projectName = "BrokenProjectPathSample";
var project = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects")
.GetProject(projectName);
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
// After restore the project is copied to another place so that
// the relative path in project lock file is invalid.
var movedProjectPath = Path.Combine(TestUtils.GetTempTestFolder <DthStartupTests>(sdk), projectName);
TestUtils.CopyFolder(project.ProjectDirectory, movedProjectPath);
client.Initialize(movedProjectPath, protocolVersion: 1);
var error = client.DrainTillFirst("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt <JValue>(0);
Assert.Contains("error NU1002", error.Value <string>());
client.DrainTillFirst("Dependencies")
.RetrieveDependency("EmptyLibrary")
.AssertProperty("Name", "EmptyLibrary")
.AssertProperty("Resolved", false);
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void DthCompilation_RestoreComplete_OnEmptyLibrary(DnxSdk sdk, int protocolVersion)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestUtils.GetSolution <DthStartupTests>(sdk, "DthTestProjects");
var project = solution.GetProject("EmptyLibrary");
sdk.Dnu.Restore(project).EnsureSuccess();
// Drain the inital messages
client.Initialize(project.ProjectDirectory, protocolVersion);
client.DrainTillFirst("Dependencies")
.EnsureSource(server, client)
.EnsureNotContainDependency("System.Console");
File.Copy(Path.Combine(project.ProjectDirectory, "project-update.json"),
Path.Combine(project.ProjectDirectory, "project.json"),
overwrite: true);
sdk.Dnu.Restore(project).EnsureSuccess();
client.SendPayLoad(project, "RestoreComplete");
client.DrainTillFirst("Dependencies")
.EnsureSource(server, client)
.RetrieveDependency("System.Console");
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void DthCompilation_GetDiagnostics_OnEmptyConsoleApp(DnxSdk sdk, int protocolVersion)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects");
var project = solution.GetProject("EmptyConsoleApp");
// Drain the inital messages
client.Initialize(project.ProjectDirectory, protocolVersion);
client.SendPayLoad(project, "GetDiagnostics");
var diagnosticsGroup = client.DrainTillFirst("AllDiagnostics")
.EnsureSource(server, client)
.RetrievePayloadAs <JArray>()
.AssertJArrayCount(3);
foreach (var group in diagnosticsGroup)
{
group.AsJObject()
.AssertProperty <JArray>("Errors", errorsArray => !errorsArray.Any())
.AssertProperty <JArray>("Warnings", warningsArray => !warningsArray.Any());
}
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void Restore_ProjectOverPackageTarget(DnxSdk sdk)
{
var solution = TestUtils.GetSolution <DnuRestoreTests2>(sdk, "DependencyTargets");
var aOutputPath = Path.Combine(solution.ArtifactsPath, "A");
sdk.Dnu.Restore(solution.GetProject("B")).EnsureSuccess();
// Build a package for A
sdk.Dnu.Restore(solution.GetProject("A")).EnsureSuccess();
sdk.Dnu.Pack(
solution.GetProject("A").ProjectDirectory,
aOutputPath,
configuration: "package").EnsureSuccess();
sdk.Dnu.PackagesAdd(
Path.Combine(aOutputPath, "package", "A.1.0.0.nupkg"),
solution.LocalPackagesDir).EnsureSuccess();
// Delete the project A
CommonTestUtils.TestUtils.DeleteFolder(solution.GetProject("A").ProjectDirectory);
// Restore the app, it should fail because the project is gone!
var result = sdk.Dnu.Restore(solution.GetProject("App"));
Assert.NotEqual(0, result.ExitCode);
Assert.Contains("Unable to locate Project A", result.StandardError);
}
public void DnuRestoreInstallsIndirectDependency(DnxSdk sdk)
{
// SimpleChain -> DependencyA -> DependencyB
const string feedSolutionName = "DependencyGraphsFeed";
const string projectSolutionName = "DependencyGraphsProject";
const string projectName = "SimpleChain";
var feedSolution = TestUtils.GetSolution<DnuRestoreTests>(sdk, feedSolutionName, appendSolutionNameToTestFolder: true);
var localFeed = TestUtils.CreateLocalFeed<DnuRestoreTests>(sdk, feedSolution);
var projectSolution = TestUtils.GetSolution<DnuRestoreTests>(sdk, projectSolutionName, appendSolutionNameToTestFolder: true);
var project = projectSolution.GetProject(projectName);
var packagesDir = Path.Combine(project.ProjectDirectory, "packages");
var result = sdk.Dnu.Restore(
project.ProjectDirectory,
packagesDir,
feeds: new [] { localFeed });
result.EnsureSuccess();
Assert.Empty(result.StandardError);
Assert.Contains($"Installing DependencyA.1.0.0", result.StandardOutput);
Assert.Contains($"Installing DependencyB.2.0.0", result.StandardOutput);
Assert.True(Directory.Exists(Path.Combine(packagesDir, "DependencyA", "1.0.0")));
Assert.True(Directory.Exists(Path.Combine(packagesDir, "DependencyB", "2.0.0")));
TestUtils.CleanUpTestDir<DnuRestoreTests>(sdk);
}
public void DthCompilation_ChangeConfiguration(DnxSdk sdk)
{
// arrange
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var project = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects")
.GetProject("FailReleaseProject");
var contextId = client.Initialize(project.ProjectDirectory);
client.SendPayLoad(contextId, DthMessageTypes.GetDiagnostics);
// the default configuration must be debug. therefore the sample project
// can be compiled successfully
client.DrainTillFirst(DthMessageTypes.AllDiagnostics)
.RetrieveCompilationDiagnostics("dnxcore50")
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayEmpty();
client.SendPayLoad(contextId, DthMessageTypes.ChangeConfiguration, new
{
Configuration = "Release"
});
client.SendPayLoad(contextId, DthMessageTypes.GetDiagnostics);
client.DrainTillFirst(DthMessageTypes.AllDiagnostics)
.RetrieveCompilationDiagnostics("dnxcore50")
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayNotEmpty();
}
}
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 ComparisonTest(DnxSdk sdk)
{
var file1a = new JObject
{
["info"] = "foo"
};
var file1b = new JObject
{
["info"] = "bar1"
};
var project1 = new Dir
{
["file1"] = file1a,
["file2"] = file1b
};
var file2a = new JObject
{
["info"] = "foo"
};
var file2b = new JObject
{
["info"] = "bar2"
};
var project2 = new Dir
{
["file1"] = file2a,
["file2"] = file2b
};
var project3 = new Dir
{
["file1"] = file2a,
["file2"] = new DirItem(Dir.EmptyFile, skipComparison: true)
};
var project4 = new Dir
{
["subdir1"] = project1,
["subdir2"] = project1
};
var project5 = new Dir
{
["subdir1"] = new DirItem(project2, skipComparison: true),
["subdir2"] = project2
};
DirAssert.Equal(project1, project2, compareContents: false);
DirAssert.Equal(project1, project3, compareContents: false);
DirAssert.Equal(project1, project3);
DirAssert.Equal(project2, project3);
//DirAssert.Equal(project4, project5); // this should fail, but only subdir2 should be different
TestUtils.CleanUpTestDir<DnuPublishTests>(sdk);
}
public void DthStartup_GetProjectInformation(DnxSdk sdk)
{
var projectName = "EmptyConsoleApp";
var testProject = _fixture.GetTestProjectPath(projectName);
using (var server = DthTestServer.Create(sdk))
using (var client = new DthTestClient(server))
{
client.Initialize(testProject);
var projectInformation = client.DrainAllMessages()
.RetrieveSingleMessage("ProjectInformation")
.EnsureSource(server, client)
.RetrievePayloadAs <JObject>()
.AssertProperty("Name", projectName);
projectInformation.RetrievePropertyAs <JArray>("Configurations")
.AssertJArrayCount(2)
.AssertJArrayContains("Debug")
.AssertJArrayContains("Release");
var frameworkShortNames = projectInformation.RetrievePropertyAs <JArray>("Frameworks")
.AssertJArrayCount(2)
.Select(f => f["ShortName"].Value <string>());
Assert.Contains("dnxcore50", frameworkShortNames);
Assert.Contains("dnx451", frameworkShortNames);
}
}
public void DthCompilation_RestoreComplete_OnEmptyLibrary(DnxSdk sdk, int protocolVersion)
{
var projectName = "EmptyLibrary";
string testProject;
using (_fixture.CreateDisposableTestProject(projectName, sdk, out testProject))
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
// Drain the inital messages
client.Initialize(testProject, protocolVersion);
client.DrainTillFirst("Dependencies")
.EnsureSource(server, client)
.EnsureNotContainDependency("System.Console");
File.Copy(Path.Combine(testProject, "project-update.json"),
Path.Combine(testProject, "project.json"),
overwrite: true);
sdk.Dnu.Restore(testProject).EnsureSuccess();
client.SendPayLoad(testProject, "RestoreComplete");
client.DrainTillFirst("Dependencies")
.EnsureSource(server, client)
.RetrieveDependency("System.Console");
}
}
public void DthCompilation_GetDiagnostics_OnEmptyConsoleApp(DnxSdk sdk, int protocolVersion)
{
var projectName = "EmptyConsoleApp";
var testProject = _fixture.GetTestProjectPath(projectName);
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
// Drain the inital messages
client.Initialize(testProject, protocolVersion);
client.SendPayLoad(testProject, "GetDiagnostics");
var diagnosticsGroup = client.DrainTillFirst("AllDiagnostics")
.EnsureSource(server, client)
.RetrievePayloadAs <JArray>()
.AssertJArrayCount(3);
foreach (var group in diagnosticsGroup)
{
group.AsJObject()
.AssertProperty <JArray>("Errors", errorsArray => !errorsArray.Any())
.AssertProperty <JArray>("Warnings", warningsArray => !warningsArray.Any());
}
}
}
public void PublishWrappedProjectForSpecificFramework(DnxSdk sdk)
{
var solutionName = Path.Combine("DnuWrapTestSolutions", "WrapAndPublish");
var solution = TestUtils.GetSolution <DnuPublishTests2>(sdk, solutionName);
// Restore the wrapper project
sdk.Dnu.Restore(solution.GetWrapperProjectPath("ClassLibrary")).EnsureSuccess();
sdk.Dnu.Restore(solution.GetProject("DnxConsoleApp")).EnsureSuccess();
// Build the console app in Debug mode (we specify the config explicitly since dnx here defaults to a Debug
// build but on the CI we might have the Configuration environment variable set so that MSBuild builds as Release by default).
var msbuild = CommonTestUtils.TestUtils.ResolveMSBuildPath();
Exec.Run(msbuild, "/p:Configuration=Debug", workingDir: Path.Combine(solution.SourcePath, "ClassLibrary")).EnsureSuccess();;
// Publish the console app
sdk.Dnu.Publish(solution.GetProject("DnxConsoleApp").ProjectFilePath, solution.ArtifactsPath, "--framework dnx451").EnsureSuccess();
// Get an SDK we can use the RUN the wrapped project (it has to be CLR because the project only supports dnx451)
var clrSdk = GetRuntime("clr", "win", "x86");
// Run it
var outputPath = Path.Combine(solution.ArtifactsPath, "approot", "src", "DnxConsoleApp");
var result = clrSdk.Dnx.Execute(
commandLine: $"--project \"{outputPath}\" --configuration Debug DnxConsoleApp run")
.EnsureSuccess();
Assert.Contains($"Hello from the wrapped project{Environment.NewLine}", result.StandardOutput);
}
public void Restore_NormalizesVersionCasing(DnxSdk sdk)
{
var solution = TestUtils.GetSolution <DnuRestoreTests>(sdk, "MismatchedVersionCasing");
var result = sdk.Dnu.Restore(solution.GetProject("A"));
Assert.Equal(0, result.ExitCode);
}
public void FailTest(DnxSdk sdk)
{
var feedSolution = TestUtils.GetSolution<DnuCommonUtilTests>(sdk, "DependencyGraphsProject");
//Assert.True(false);
TestUtils.CleanUpTestDir<DnuCommonUtilTests>(sdk);
}
public void FailTest(DnxSdk sdk)
{
var feedSolution = TestUtils.GetSolution <DnuCommonUtilTests>(sdk, "DependencyGraphsProject");
//Assert.True(false);
TestUtils.CleanUpTestDir <DnuCommonUtilTests>(sdk);
}
public void DthCompilation_Initialize_UnresolvedDependency(DnxSdk sdk, int protocolVersion, string referenceType, string testProjectName,
string expectedUnresolvedDependency, string expectedUnresolvedType)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
var solution = TestProjectsRepository.EnsureRestoredSolution("DthTestProjects");
var project = solution.GetProject(testProjectName);
client.Initialize(project.ProjectDirectory, protocolVersion);
var unresolveDependency = client.DrainTillFirst("Dependencies")
.EnsureSource(server, client)
.RetrieveDependency(expectedUnresolvedDependency);
unresolveDependency.AssertProperty("Name", expectedUnresolvedDependency)
.AssertProperty("DisplayName", expectedUnresolvedDependency)
.AssertProperty("Resolved", false)
.AssertProperty("Type", expectedUnresolvedType);
if (expectedUnresolvedType == "Project")
{
unresolveDependency.AssertProperty("Path", Path.Combine(Path.GetDirectoryName(project.ProjectDirectory),
expectedUnresolvedDependency,
Project.ProjectFileName));
}
else
{
Assert.False(unresolveDependency["Path"].HasValues);
}
var referencesMessage = client.DrainTillFirst("References")
.EnsureSource(server, client);
if (referenceType == "Project")
{
var expectedUnresolvedProjectPath = Path.Combine(Path.GetDirectoryName(project.ProjectDirectory),
expectedUnresolvedDependency,
Project.ProjectFileName);
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("Name", expectedUnresolvedDependency)
.AssertProperty("Path", expectedUnresolvedProjectPath)
.AssertProperty <JToken>("WrappedProjectPath", prop => !prop.HasValues);
}
else if (referenceType == "Package")
{
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(0);
}
TestUtils.CleanUpTestDir <DthStartupTests>(sdk);
}
}
public void UnresolvedProjectDoesNotThrow(DnxSdk sdk)
{
const string solutionName = "BootstrapperSolution";
var solution = TestUtils.GetSolution <BootstrapperTests>(sdk, solutionName);
var result = sdk.Dnx.Execute($"--project {solution.RootPath} run");
Assert.NotEqual(0, result.ExitCode);
Assert.Equal($"Error: Unable to resolve project from {solution.RootPath}{Environment.NewLine}", result.StandardError);
}
public void DthCompilation_Initialize_UnresolvedDependency(DnxSdk sdk, int protocolVersion, string referenceType, string testProjectName,
string expectedUnresolvedDependency, string expectedUnresolvedType)
{
var testProject = _fixture.GetTestProjectPath(testProjectName);
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
client.Initialize(testProject, protocolVersion);
var messages = client.DrainAllMessages();
var unresolveDependency = messages.RetrieveSingleMessage("Dependencies")
.EnsureSource(server, client)
.RetrieveDependency(expectedUnresolvedDependency);
unresolveDependency.AssertProperty("Name", expectedUnresolvedDependency)
.AssertProperty("DisplayName", expectedUnresolvedDependency)
.AssertProperty("Resolved", false)
.AssertProperty("Type", expectedUnresolvedType);
if (expectedUnresolvedType == "Project")
{
unresolveDependency.AssertProperty(
"Path",
Path.Combine(Path.GetDirectoryName(testProject), expectedUnresolvedDependency, Project.ProjectFileName));
}
else
{
Assert.False(unresolveDependency["Path"].HasValues);
}
var referencesMessage = messages.RetrieveSingleMessage("References")
.EnsureSource(server, client);
if (referenceType == "Project")
{
var expectedUnresolvedProjectPath = Path.Combine(Path.GetDirectoryName(testProject), expectedUnresolvedDependency, Project.ProjectFileName);
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("Name", expectedUnresolvedDependency)
.AssertProperty("Path", expectedUnresolvedProjectPath)
.AssertProperty <JToken>("WrappedProjectPath", prop => !prop.HasValues);
}
else if (referenceType == "Package")
{
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(0);
}
}
}
public BootstrapperTestFixture()
{
Console.WriteLine($@"
Environment information:
DNX_HOME: {Environment.GetEnvironmentVariable("DNX_HOME")}
DNX_SDK_VERSION_FOR_TESTING: {Environment.GetEnvironmentVariable("DNX_SDK_VERSION_FOR_TESTING")}
Information of DNX under testing:
DNX Home: {DnxSdk.GetRuntimeHome()}
DNX Version: {DnxSdkFunctionalTestBase.SdkVersionForTesting}
");
}
public void DthStartup_ProtocolNegotiation_ZeroIsNoAllowed(DnxSdk sdk)
{
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
client.SetProtocolVersion(0);
Assert.Throws <TimeoutException>(() =>
{
client.DrainTillFirst(ProtocolManager.NegotiationMessageTypeName, timeout: TimeSpan.FromSeconds(1));
});
}
}
public void PublishedAppWithWebRootFailsIfIISCommandInvalid(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution <DnuPublishTests2>(sdk, "HelloWorldWithWebRoot");
var outputPath = Path.Combine(solution.RootPath, "Output");
var project = solution.GetProject("HelloWorldWithWebRoot");
// Act
sdk.Dnu.Restore(project).EnsureSuccess();
var result = sdk.Dnu.Publish(project.ProjectDirectory, outputPath, $"--iis-command SomethingRandom");
Assert.NotEqual(0, result.ExitCode);
}
public void DnuPublishWebApp_SubdirAsPublicDir_DirPlusFlatList(DnxSdk sdk)
{
const string projectName = "ProjectForTesting";
FrameworkName[] frameworkCandidates = {
FrameworkNameHelper.ParseFrameworkName("dnx451"),
FrameworkNameHelper.ParseFrameworkName("dnxcore50")
};
var targetFramework = DependencyContext.SelectFrameworkNameForRuntime(
frameworkCandidates, sdk.FullName).FullName;
var projectJson = new JObject
{
["publishExclude"] = "**.useless",
["webroot"] = "public",
["frameworks"] = new JObject
{
["dnx451"] = new JObject { },
["dnxcore50"] = new JObject { }
}
};
var projectStructure = new Dir
{
