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);
TestUtils.CleanUpTestDir<DnuPackTests>(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",
["frameworks"] = new JObject
{
["dnx451"] = new JObject { },
["dnxcore50"] = new JObject { }
}
};
var hostingJson = new JObject
{
["webroot"] = "public"
};
var projectStructure = new Dir
{
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 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 static string GetTestFolder <T>(DnxSdk sdk, [CallerMemberName] string testName = null)
{
var tempFolderPath = Path.Combine(RootTestFolder, $"{typeof(T).Name}.{testName}", sdk.ShortName);
Directory.CreateDirectory(tempFolderPath);
return(tempFolderPath);
}
public static DnxSdk GetRuntime(string flavor, string os, string arch)
{
var dnxSolutionRoot = ProjectRootResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var runtimeHome = Path.Combine(dnxSolutionRoot, "artifacts", "test", DnxSdk.GetRuntimeName(flavor, os, arch));
var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
var sdkVersionForTesting = Environment.GetEnvironmentVariable(TestEnvironmentNames.TestSdkVersion);
DnxSdk sdk = null;
if (string.IsNullOrEmpty(sdkVersionForTesting) &&
Directory.Exists(runtimeHome) &&
!string.IsNullOrEmpty(buildVersion))
{
sdk = DnxSdk.GetRuntime(runtimeHome, $"1.0.0-{buildVersion}", flavor, os, arch);
}
else
{
sdk = DnxSdk.GetRuntime(SdkVersionForTesting, flavor, os, arch);
}
if (!Directory.Exists(sdk.Location))
{
throw new InvalidOperationException($"Unable to locate DNX at ${sdk.Location}");
}
return(sdk);
}
public void Restore_PackageOverProjectTarget(DnxSdk sdk)
{
var solution = TestUtils.GetSolution<DnuRestoreTests>(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.Contains(@"A: This is Project A
B: This is Package B
", result.StandardOutput);
TestUtils.CleanUpTestDir<DnuPublishTests>(sdk);
}
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 Restore_ProjectOverPackageTarget(DnxSdk sdk)
{
var solution = TestUtils.GetSolution<DnuRestoreTests>(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.Equal(1, result.ExitCode);
Assert.Contains("Unable to locate Project A", result.StandardError);
TestUtils.CleanUpTestDir<DnuPublishTests>(sdk);
}
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);
}
}
private static void DoPublish(DnxSdk sdk, string arguments = null)
{
var solutionName = Path.Combine("DnuWrapTestSolutions", "WrapAndPublish");
var solution = TestUtils.GetSolution<DnuPublishWrappedTests>(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
var publishResult = sdk.Dnu.Publish(solution.GetProject("DnxConsoleApp").ProjectFilePath, solution.ArtifactsPath, arguments);
publishResult.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);
TestUtils.CleanUpTestDir<DnuPublishWrappedTests>(sdk);
}
public void FailTest(DnxSdk sdk)
{
var feedSolution = TestUtils.GetSolution<DnuCommonUtilTests>(sdk, "DependencyGraphsProject");
//Assert.True(false);
TestUtils.CleanUpTestDir<DnuCommonUtilTests>(sdk);
}
public static Solution GetSolution <TTest>(
DnxSdk sdk,
string solutionName,
[CallerMemberName] string testName = null,
bool appendSolutionNameToTestFolder = false)
{
var originalSolutionPath = Path.Combine(GetTestSolutionsDirectory(), solutionName);
var tempSolutionPath = GetTestFolder <TTest>(sdk, Path.Combine(testName, appendSolutionNameToTestFolder ? solutionName : string.Empty));
CopyFolder(originalSolutionPath, tempSolutionPath);
return(new Solution(tempSolutionPath));
}
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.Equal(1, result.ExitCode);
Assert.Equal($"Error: Unable to resolve project from {solution.RootPath}{Environment.NewLine}", result.StandardError);
TestUtils.CleanUpTestDir<BootstrapperTests>(sdk);
}
public DnxSdkFunctionalTestFixtureBase()
{
Console.WriteLine($@"
Environment information:
DNX_HOME: {Environment.GetEnvironmentVariable(EnvironmentNames.Home)}
DNX_TEST_SDK_VERSION: {Environment.GetEnvironmentVariable(TestEnvironmentNames.TestSdkVersion)}
Information of DNX under testing:
DNX Home: {DnxSdk.GetRuntimeHome()}
DNX Version: {DnxSdkFunctionalTestBase.SdkVersionForTesting}
");
}
public static void CleanUpTestDir <T>(DnxSdk sdk, [CallerMemberName] string testName = null)
{
var saveFilesBehaviour = Environment.GetEnvironmentVariable(TestEnvironmentNames.SaveFiles);
if (string.IsNullOrEmpty(saveFilesBehaviour) || !saveFilesBehaviour.Equals(TestConstants.SaveFilesAll, StringComparison.OrdinalIgnoreCase))
{
var testFolder = GetTestFolder <T>(sdk, testName);
if (Directory.Exists(testFolder))
{
Directory.Delete(testFolder, recursive: true);
}
}
}
public void Restore_DoNotRestoreNestProjects(DnxSdk sdk)
{
var solution = TestUtils.GetSolution<DnuRestoreTests>(sdk, "NestProjectRestoreModel");
// ensure there is no lock file before restore
Assert.Empty(Directory.GetFiles(solution.RootPath, "project.lock.json", SearchOption.AllDirectories));
sdk.Dnu.Restore(solution.GetProject("Main")).EnsureSuccess();
// only the project.json under Main folder is expected to be restored
var lockFiles = Directory.GetFiles(solution.RootPath, "project.lock.json", SearchOption.AllDirectories);
Assert.Equal(1, lockFiles.Length);
Assert.Equal("Main", Path.GetFileName(Path.GetDirectoryName(lockFiles[0])));
}
public void VerifyDllImportWithPackageReference(DnxSdk sdk)
{
if (ShouldSkipTest)
{
return;
}
var solution = TestUtils.GetSolution<DllImportTests>(sdk, "DllImportTestProjects");
var project = solution.GetProject("PackageReferenceTest");
var artifactsPath = Path.Combine(solution.ArtifactsPath, "NativeLib");
sdk.Dnu.Restore(solution.GetProject("NativeLib")).EnsureSuccess();
sdk.Dnu.Pack(
solution.GetProject("NativeLib").ProjectDirectory,
artifactsPath,
configuration: "package").EnsureSuccess();
sdk.Dnu.Restore(solution.RootPath, packagesDir: null, feeds: null, additionalArguments: "-f " + Path.Combine(artifactsPath, "package"))
.EnsureSuccess();
var result = sdk.Dnx.Execute(project, dnxTraceOn: true);
Assert.Equal(0, result.ExitCode);
Assert.Contains("The answer is 42", result.StandardOutput);
if (sdk.Flavor == "coreclr")
{
Assert.Contains("Information: [PackageAssemblyLoader]: Loaded unmanaged library=nativelib", result.StandardOutput);
}
else
{
var lines = result.StandardOutput.Split('\n');
if (sdk.Flavor == "clr")
{
Assert.True(lines.Any(l =>
l.StartsWith("Information: [PackageDependencyProvider]: Enabling loading native libraries from packages by extendig %PATH% with")
&& l.Contains("NativeLib")));
}
else
{
Assert.True(lines.Any(l =>
l.StartsWith("Information: [PackageDependencyProvider]: Preloading:")
&& l.Contains("nativelib")
&& l.Contains("succeeded")));
}
}
TestUtils.CleanUpTestDir<DllImportTests>(sdk);
}
public static string CreateLocalFeed <TTest>(DnxSdk sdk, Solution solution, [CallerMemberName] string testName = null)
{
var feed = GetTestFolder <TTest>(sdk, Path.Combine(testName, Path.GetRandomFileName()));
var packOutput = GetTestFolder <TTest>(sdk, Path.Combine(testName, Path.GetRandomFileName()));
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
foreach (var project in solution.Projects)
{
var output = sdk.Dnu.Pack(project.ProjectDirectory, packOutput);
output.EnsureSuccess();
sdk.Dnu.PackagesAdd(output.PackagePath, feed).EnsureSuccess();
}
return(feed);
}
public void UserExceptionsThrows(DnxSdk sdk)
{
const string solutionName = "BootstrapperSolution";
const string projectName = "TesterProgram";
var solution = TestUtils.GetSolution<BootstrapperTests>(sdk, solutionName);
var project = solution.GetProject(projectName);
sdk.Dnu.Restore(project).EnsureSuccess();
var result = sdk.Dnx.Execute($"--project {project.ProjectDirectory} run");
Assert.Equal(1, result.ExitCode);
Assert.Contains("System.Exception: foo", result.StandardError);
TestUtils.CleanUpTestDir<BootstrapperTests>(sdk);
}
public void CompileModuleWithDeps(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<DnuPackTests>(sdk, "CompileModuleWithDependencies");
var project = solution.GetProject("A");
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
// Act
var result = sdk.Dnu.Pack(project.ProjectDirectory);
// Assert
Assert.Equal(0, result.ExitCode);
TestUtils.CleanUpTestDir<DnuPackTests>(sdk);
}
public void P2PDifferentFrameworks(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<DnuPackTests>(sdk, "ProjectToProject");
var project = solution.GetProject("P1");
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
// Act
var result = sdk.Dnu.Pack(project.ProjectDirectory);
// Assert
Assert.Equal(0, result.ExitCode);
TestUtils.CleanUpTestDir<DnuPackTests>(sdk);
}
public void UnknownCommandDoesNotThrow(DnxSdk sdk)
{
const string solutionName = "BootstrapperSolution";
const string projectName = "TesterProgram";
const string unknownCommand = "unknownCommand";
const string testerCommand = "TesterProgram";
var solution = TestUtils.GetSolution<BootstrapperTests>(sdk, solutionName);
var project = solution.GetProject(projectName);
var result = sdk.Dnx.Execute($"--project {project.ProjectDirectory} {unknownCommand}");
Assert.Equal(1, result.ExitCode);
Assert.Equal($"Error: Unable to load application or execute command '{unknownCommand}'. Available commands: {testerCommand}.{Environment.NewLine}", result.StandardError);
TestUtils.CleanUpTestDir<BootstrapperTests>(sdk);
}
public void ApplicationWithEcmaEntryPoint(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests>(sdk, "EcmaEntryPoint");
var project = solution.GetProject("EcmaEntryPoint");
sdk.Dnu.Restore(project.ProjectDirectory).EnsureSuccess();
// Act
var result = sdk.Dnx.Execute(project);
// Assert
Assert.Equal(0, result.ExitCode);
Assert.Contains("ECMA EntryPoint Ran", result.StandardOutput);
TestUtils.CleanUpTestDir<AppHostTests>(sdk);
}
public void LibraryExporterGetExports(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests>(sdk, "AppHostServicesProjects");
var project = solution.GetProject("GetExports");
sdk.Dnu.Restore(project.ProjectDirectory).EnsureSuccess();
// Act
var result = sdk.Dnx.Execute(project).EnsureSuccess();
// Assert
Assert.Contains($"Project: {project.Name}", result.StandardOutput);
Assert.Contains($"Package: Microsoft.Extensions.CompilationAbstractions", result.StandardOutput);
TestUtils.CleanUpTestDir<AppHostTests>(sdk);
}
public void CompileModuleWithDeps(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests>(sdk, "CompileModuleWithDependencies");
var project = solution.GetProject("A");
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
// Act
var result = sdk.Dnx.Execute(project);
// Assert
Assert.Equal(0, result.ExitCode);
Assert.Contains($"Hello from generated code", result.StandardOutput);
TestUtils.CleanUpTestDir<AppHostTests>(sdk);
}
public void RunP2PDifferentFrameworks(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests>(sdk, "ProjectToProject");
var project = solution.GetProject("P1");
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
// Act
var result = sdk.Dnx.Execute(project);
// Assert
Assert.Equal(0, result.ExitCode);
Assert.Contains("BaseClass.Test()", result.StandardOutput);
Assert.Contains("Derived.Test", result.StandardOutput);
TestUtils.CleanUpTestDir<AppHostTests>(sdk);
}
public void VerifyDllImportWithProjectReference(DnxSdk sdk)
{
if (ShouldSkipTest)
{
return;
}
var solution = TestUtils.GetSolution<DllImportTests>(sdk, "DllImportTestProjects");
var project = solution.GetProject("ProjectReferenceTest");
sdk.Dnu.Restore(project).EnsureSuccess();
var result = sdk.Dnx.Execute(project, dnxTraceOn: true);
Assert.Equal(0, result.ExitCode);
Assert.Contains($"The answer is 42", result.StandardOutput);
if (sdk.Flavor == "coreclr")
{
Assert.Contains("Information: [ProjectAssemblyLoader]: Loaded unmanaged library=nativelib", result.StandardOutput);
}
else
{
var lines = result.StandardOutput.Split('\n');
if (sdk.Flavor == "clr")
{
Assert.True(lines.Any(l =>
l.StartsWith("Information: [PackageDependencyProvider]: Enabling loading native libraries from projects by extendig %PATH% with")
&& l.Contains("NativeLib")));
}
else
{
Assert.True(lines.Any(l =>
l.StartsWith("Information: [PackageDependencyProvider]: Preloading:")
&& l.Contains("nativelib")
&& l.Contains("succeeded")));
}
}
TestUtils.CleanUpTestDir<DllImportTests>(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_NormalizesVersionCasing(DnxSdk sdk)
{
var solution = TestUtils.GetSolution<DnuRestoreTests>(sdk, "MismatchedVersionCasing");
var result = sdk.Dnu.Restore(solution.GetProject("A"));
Assert.Equal(0, result.ExitCode);
}
public static string GetTempTestFolder <T>(DnxSdk sdk, [CallerMemberName] string testName = null)
{
return(GetTestFolder <T>(sdk, Path.Combine(testName, Path.GetRandomFileName())));
}
public void AddDepsReturnsReferences(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<DthStartupTests>(sdk, "HelloWorld");
var project = solution.GetProject("HelloWorld");
using (var server = sdk.Dth.CreateServer())
using (var client = server.CreateClient())
{
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
client.SetProtocolVersion(3);
client.Initialize(project.ProjectDirectory);
// for a project supports two frameworks, 13 responses will be sent.
// one ProjectInformation, and Depenedencies, DependencyDiagnostics,
// References, Source, Diagnostics, CompilerOptions for each framework
var messages = client.DrainMessage(13);
foreach (var frameworkInfo in project.GetTargetFrameworks())
{
var messagesByFramework = messages.GetMessagesByFramework(frameworkInfo.FrameworkName);
messagesByFramework.RetrieveSingleMessage("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", LibraryTypes.Package);
var references = messagesByFramework.RetrieveSingleMessage("References")
.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("FileReferences");
Assert.NotEmpty(references);
Assert.Contains("Newtonsoft.Json", references.Select(r => Path.GetFileNameWithoutExtension(r.Value<string>())));
}
// Update dependencies
project = project.UpdateProjectFile(json =>
{
json["dependencies"]["DoesNotExist"] = "1.0.0";
});
client.SendPayLoad(project, "FilesChanged");
messages = client.DrainMessage(4);
foreach (var frameworkInfo in project.GetTargetFrameworks())
{
var messagesByFramework = messages.GetMessagesByFramework(frameworkInfo.FrameworkName);
var dependencies = messagesByFramework.RetrieveSingleMessage("Dependencies");
dependencies.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", LibraryTypes.Package);
dependencies.RetrieveDependency("DoesNotExist")
.AssertProperty("Type", LibraryTypes.Unresolved);
// The references should not have changed
messagesByFramework.AssertDoesNotContain("References");
}
client.SendPayLoad(project, "GetDiagnostics");
var diagnosticsPerFramework = client.DrainTillFirst("AllDiagnostics")
.RetrievePayloadAs<JArray>()
.AssertJArrayCount(3);
foreach (var frameworkDiagnostics in diagnosticsPerFramework)
{
if (!frameworkDiagnostics["Framework"].HasValues)
{
continue;
}
var errors = frameworkDiagnostics.Value<JArray>("Errors");
var warnings = frameworkDiagnostics.Value<JArray>("Warnings");
Assert.Equal(2, errors.Count);
Assert.Equal(0, warnings.Count);
var error1 = errors[0];
var error2 = errors[1];
Assert.Equal("NU1006", error1.Value<string>("ErrorCode"));
Assert.Equal("NU1001", error2.Value<string>("ErrorCode"));
Assert.Equal("DoesNotExist", error2["Source"].Value<string>("Name"));
}
}
TestUtils.CleanUpTestDir<DthStartupTests>(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 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 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 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 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);
}
}
