public static string GetTestFolder <T>(DnxSdk sdk, [CallerMemberName] string testName = null)
{
var tempFolderPath = Path.Combine(RootTestFolder, $"{typeof(T).Name}.{testName}", sdk.FullName);
Directory.CreateDirectory(tempFolderPath);
return(tempFolderPath);
}
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 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 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 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 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 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 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 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.NotEqual(0, result.ExitCode);
Assert.Contains("System.Exception: foo", result.StandardError);
}
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 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.NotEqual(0, result.ExitCode);
Assert.Equal($"Error: Unable to load application or execute command '{unknownCommand}'. Available commands: {testerCommand}.{Environment.NewLine}", result.StandardError);
}
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);
}
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);
}
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 CompileModuleWithDeps(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests2>(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);
}
public void ApplicationWithEcmaEntryPoint(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests2>(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($"EntryPoint: Main", result.StandardOutput);
}
public void RunP2PDifferentFrameworks(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests2>(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);
}
private static void CreateDisposableTestProject(DnxSdk sdk, string targetDir, string sourceDir)
{
// Find the misc project to copy
var targetProjectDir = Path.Combine(targetDir, Path.GetFileName(sourceDir));
Testing.TestUtils.CopyFolder(sourceDir, targetProjectDir);
// Make sure package restore can be successful
var currentDnxSolutionRootDir = ProjectRootResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
File.Copy(
Path.Combine(currentDnxSolutionRootDir, "NuGet.config"),
Path.Combine(targetProjectDir, "NuGet.config"));
// Use the newly built runtime to generate lock files for samples
sdk.Dnu.Restore(targetProjectDir);
}
public void LibraryExporterGetExports(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<AppHostTests2>(sdk, "AppHostServicesProjects");
var project = solution.GetProject("GetExports");
sdk.Dnu.Restore(project.ProjectDirectory).EnsureSuccess();
// Act
var result = sdk.Dnx.Execute(project);
// Assert
Assert.Equal(0, result.ExitCode);
Assert.Contains($"Project: {project.Name}", result.StandardOutput);
Assert.Contains($"Package: Microsoft.Dnx.Compilation.Abstractions", result.StandardOutput);
}
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 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 static DthTestServer Create(DnxSdk sdk, TimeSpan timeout)
{
var bootstraperExe = Path.Combine(sdk.Location, "bin", Constants.BootstrapperExeName);
var dthPath = Path.Combine(sdk.Location, "bin", "lib", DthName, $"{DthName}.dll");
if (!File.Exists(dthPath))
{
throw new InvalidOperationException($"Can't find {DthName} at {dthPath}.");
}
var port = FindFreePort();
var hostId = Guid.NewGuid().ToString();
var processStartInfo = new ProcessStartInfo()
{
UseShellExecute = false,
WorkingDirectory = sdk.Location,
FileName = bootstraperExe,
Arguments = $"--appbase \"{sdk.Location}\" \"{dthPath}\" {port} {Process.GetCurrentProcess().Id} {hostId}",
RedirectStandardOutput = true,
RedirectStandardError = true
};
var wait = new ManualResetEvent(false);
var success = false;
var successOuput = $"Listening on port {port}";
var process = Process.Start(processStartInfo);
process.EnableRaisingEvents = true;
var stdout = new StringBuilder();
process.OutputDataReceived += (sender, args) =>
{
if (args.Data != null)
{
stdout.AppendLine(Exec.RemoveAnsiColorCodes(args.Data));
if (string.Equals(args.Data, successOuput, StringComparison.Ordinal))
{
success = true;
wait.Set();
}
}
};
var stderr = new StringBuilder();
process.ErrorDataReceived += (sender, args) =>
{
if (args.Data != null)
{
stderr.AppendLine(Exec.RemoveAnsiColorCodes(args.Data));
}
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
if (wait.WaitOne(timeout))
{
if (!success)
{
Console.WriteLine(stdout);
Console.WriteLine(stderr);
throw new InvalidOperationException($"Failed to start DesignTime host.");
}
else
{
return new DthTestServer(process, port, hostId);
}
}
else
{
throw new InvalidOperationException($"Timeout after {timeout.TotalSeconds}. Expected message {successOuput} from STDOUT to indicate that DTH is started successfully.");
}
}
public static DthTestServer Create(DnxSdk sdk)
{
return Create(sdk, TimeSpan.FromSeconds(10));
}
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 GlobalJsonInProjectDir(DnxSdk sdk)
{
const string solutionName = "GlobalJsonInProjectDir";
var solution = TestUtils.GetSolution<DnuPublishTests>(sdk, solutionName);
var projectPath = Path.Combine(solution.RootPath, "Project");
var outputPath = Path.Combine(solution.RootPath, "Output");
var expectedOutputProjectJson = new JObject
{
["dependencies"] = new JObject { },
["frameworks"] = new JObject
{
["dnx451"] = new JObject { },
["dnxcore50"] = new JObject { }
}
};
var expectedOutputGlobalJson = new JObject
{
["sdk"] = new JObject
{
["version"] = "1.0.0-beta7"
},
["projects"] = new JArray("src"),
["packages"] = "packages"
};
var expectedOutputLockFile = new JObject
{
["locked"] = false,
["version"] = Constants.LockFileVersion,
["targets"] = new JObject
{
["DNX,Version=v4.5.1"] = new JObject { },
["DNXCore,Version=v5.0"] = new JObject { },
},
["libraries"] = new JObject { },
["projectFileDependencyGroups"] = new JObject
{
[""] = new JArray(),
["DNX,Version=v4.5.1"] = new JArray(),
["DNXCore,Version=v5.0"] = new JArray()
}
};
var expectedOutputStructure = new Dir
{
["approot"] = new Dir
{
[$"src/Project"] = new Dir
{
["project.json"] = expectedOutputProjectJson,
["project.lock.json"] = expectedOutputLockFile
},
[$"global.json"] = expectedOutputGlobalJson
}
};
var result = sdk.Dnu.Publish(
projectPath,
outputPath);
result.EnsureSuccess();
var actualOutputStructure = new Dir(outputPath);
DirAssert.Equal(expectedOutputStructure, actualOutputStructure);
}
public static string GetTempTestFolder <T>(DnxSdk sdk, [CallerMemberName] string testName = null)
{
return(GetTestFolder <T>(sdk, Path.Combine(testName, Path.GetRandomFileName())));
}
public void DthStartup_ProtocolNegotiation_ZeroIsNoAllowed(DnxSdk sdk)
{
var projectName = "EmptyConsoleApp";
var testProject = _fixture.GetTestProjectPath(projectName);
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
client.SetProtocolVersion(0);
Assert.Throws<TimeoutException>(() =>
{
client.DrainTillFirst(ProtocolManager.NegotiationMessageTypeName);
});
}
}
public void DthStartup_ProtocolNegotiation(DnxSdk sdk, int requestVersion, int expectVersion)
{
var projectName = "EmptyConsoleApp";
var testProject = _fixture.GetTestProjectPath(projectName);
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
client.SetProtocolVersion(requestVersion);
var response = client.DrainTillFirst(ProtocolManager.NegotiationMessageTypeName);
response.EnsureSource(server, client);
Assert.Equal(expectVersion, response.Payload["Version"]?.Value<int>());
}
}
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 DthDependencies_UpdateGlobalJson_RefreshDependencies(DnxSdk sdk)
{
using (var disposableDir = new DisposableDir())
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
Testing.TestUtils.CopyFolder(
_fixture.GetTestProjectPath("UpdateSearchPathSample"),
Path.Combine(disposableDir, "UpdateSearchPathSample"));
var root = Path.Combine(disposableDir, "UpdateSearchPathSample", "home");
sdk.Dnu.Restore(root).EnsureSuccess();
var testProject = Path.Combine(root, "src", "MainProject");
client.Initialize(testProject, protocolVersion: 2);
var messages = client.DrainAllMessages();
messages.RetrieveSingleMessage("ProjectInformation")
.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("ProjectSearchPaths")
.AssertJArrayCount(2);
messages.RetrieveSingleMessage("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", "Project")
.AssertProperty("Resolved", true)
.AssertProperty<JArray>("Errors", array => array.Count == 0, _ => "Dependency shouldn't contain any error.");
messages.RetrieveSingleMessage("DependencyDiagnostics")
.RetrievePayloadAs<JObject>()
.AssertProperty<JArray>("Errors", array => array.Count == 0)
.AssertProperty<JArray>("Warnings", array => array.Count == 0);
// 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");
messages = client.DrainAllMessages();
messages.RetrieveSingleMessage("ProjectInformation")
.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("ProjectSearchPaths")
.AssertJArrayCount(1)
.AssertJArrayElement(0, Path.Combine(root, "src"));
messages.RetrieveSingleMessage("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", LibraryTypes.Unresolved)
.AssertProperty("Resolved", false)
.RetrievePropertyAs<JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
messages.RetrieveSingleMessage("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt<JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
}
}
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_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 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 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 AddDepsReturnsReferences(DnxSdk sdk)
{
// Arrange
var solution = TestUtils.GetSolution<DthStartupTests>(sdk, "HelloWorld");
var project = solution.GetProject("HelloWorld");
using (var server = DthTestServer.Create(sdk))
using (var client = server.CreateClient())
{
sdk.Dnu.Restore(solution.RootPath).EnsureSuccess();
client.SetProtocolVersion(3);
client.Initialize(project.ProjectDirectory);
var messages = client.DrainAllMessages();
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.DrainAllMessages();
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");
messages = client.DrainAllMessages();
var diagnosticsPerFramework = messages.RetrieveSingleMessage("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"));
}
}
}
public void PublishedAppWithWebRootDefaults(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();
sdk.Dnu.Publish(project.ProjectDirectory, outputPath).EnsureSuccess();
var config = File.ReadAllText(Path.Combine(outputPath, project.WebRoot, "web.config"));
var expected = @"<configuration>
<system.webServer>
<handlers>
<add name=""httpplatformhandler"" path=""*"" verb=""*"" modules=""httpPlatformHandler"" resourceType=""Unspecified"" />
</handlers>
<httpPlatform processPath=""..\approot\HelloWorld.cmd"" arguments="""" stdoutLogEnabled=""true"" stdoutLogFile=""..\logs\stdout.log""></httpPlatform>
</system.webServer>
</configuration>";
Assert.Equal(RemoveWhitespace(expected), RemoveWhitespace(config));
}