public void DthNegative_BrokenProjectPathInLockFile()
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
// After restore the project is copied to another place so that
// the relative path in project lock file is invalid.
var movedProjectPath = _testAssetsManager.CreateTestInstance("BrokenProjectPathSample")
.WithLockFiles()
.TestRoot;
client.Initialize(movedProjectPath);
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);
}
}
public void DthCompilation_Initialize_UnresolvedDependency(string referenceType,
string testProjectName,
string expectedUnresolvedDependency,
string expectedUnresolvedType)
{
var projectPath = _testHelper.FindSampleProject(testProjectName);
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_testHelper.LoggerFactory))
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
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(projectPath),
expectedUnresolvedDependency,
Project.FileName));
}
else
{
Assert.False(unresolveDependency["Path"].HasValues);
}
var referencesMessage = client.DrainTillFirst("References", TimeSpan.FromDays(1))
.EnsureSource(server, client);
if (referenceType == "Project")
{
var expectedUnresolvedProjectPath = Path.Combine(Path.GetDirectoryName(projectPath),
expectedUnresolvedDependency,
Project.FileName);
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()
{
var projectPath = _testHelper.FindSampleProject("EmptyConsoleApp");
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_testHelper.LoggerFactory))
using (var client = new DthTestClient(server))
{
// Drain the inital messages
client.Initialize(projectPath);
client.SendPayLoad(projectPath, "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 RefreshDependenciesResultsAreConsistent(string messageType, bool?clearCache)
{
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, "EmptyNetCoreApp");
Assert.True(Directory.Exists(projectPath));
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
var originalDependencies = client.DrainMessage(7).Single(m => m.MessageType == MessageTypes.Dependencies)
.RetrievePayloadAs <JObject>();
if (clearCache.HasValue)
{
client.SendPayload(projectPath, messageType, new { Reset = clearCache.Value });
}
else
{
client.SendPayload(projectPath, messageType);
}
var refreshedDependencies = client.DrainTillFirst(MessageTypes.Dependencies).Payload.ToString();
Assert.Equal(originalDependencies.ToString(), refreshedDependencies.ToString());
}
}
public void DthStartup_GetProjectInformation()
{
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, "EmptyConsoleApp");
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.Initialize(projectPath);
var projectInformation = client.DrainTillFirst(MessageTypes.ProjectInformation)
.EnsureSource(server, client)
.RetrievePayloadAs <JObject>()
.AssertProperty("Name", "EmptyConsoleApp");
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("netstandardapp1.5", frameworkShortNames);
Assert.Contains("dnx451", frameworkShortNames);
}
}
public void DthStartup_GetProjectInformation()
{
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, "EmptyConsoleApp");
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.Initialize(projectPath);
var projectInformation = client.DrainTillFirst(MessageTypes.ProjectInformation)
.EnsureSource(server, client)
.RetrievePayloadAs<JObject>()
.AssertProperty("Name", "EmptyConsoleApp");
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("netstandardapp1.5", frameworkShortNames);
Assert.Contains("dnx451", frameworkShortNames);
}
}
public void RefreshDependenciesResultsAreConsistent(string messageType, bool? clearCache)
{
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, "EmptyNetCoreApp");
Assert.True(Directory.Exists(projectPath));
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
var originalDependencies = client.DrainMessage(7).Single(m => m.MessageType == MessageTypes.Dependencies)
.RetrievePayloadAs<JObject>();
if (clearCache.HasValue)
{
client.SendPayload(projectPath, messageType, new { Reset = clearCache.Value });
}
else
{
client.SendPayload(projectPath, messageType);
}
var refreshedDependencies = client.DrainTillFirst(MessageTypes.Dependencies).Payload.ToString();
Assert.Equal(originalDependencies.ToString(), refreshedDependencies.ToString());
}
}
public void InvalidProjectJson()
{
var testAssetsPath = Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer");
var assetsManager = new TestAssetsManager(testAssetsPath);
var testSource = assetsManager.CreateTestInstance("IncorrectProjectJson").TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(Path.Combine(_testAssetsManager.AssetsRoot, "EmptyLibrary"));
client.Initialize(testSource);
// Error for invalid project.json
var messages = client.DrainMessage(8);
messages.Single(msg => msg.MessageType == MessageTypes.Error)
.Payload.AsJObject()
.AssertProperty <string>("Path", v => v.Contains("IncorrectProjectJson"));
// Successfully initialize the other project
messages.Single(msg => msg.MessageType == MessageTypes.ProjectInformation)
.Payload.AsJObject()
.AssertProperty <string>("Name", v => string.Equals(v, "EmptyLibrary", StringComparison.Ordinal));
// Successfully initialize another project afterwards
client.Initialize(Path.Combine(_testAssetsManager.AssetsRoot, "EmptyConsoleApp"));
client.DrainTillFirst(MessageTypes.ProjectInformation)
.Payload.AsJObject()
.AssertProperty <string>("Name", v => string.Equals(v, "EmptyConsoleApp", StringComparison.Ordinal));
}
}
public void DthStartup_ProtocolNegotiation_ZeroIsNoAllowed()
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.SetProtocolVersion(0);
Assert.Throws <TimeoutException>(() =>
{
client.DrainTillFirst(MessageTypes.ProtocolVersion, timeout: TimeSpan.FromSeconds(1));
});
}
}
public void DthStartup_ProtocolNegotiation(int requestVersion, int expectVersion)
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.SetProtocolVersion(requestVersion);
var response = client.DrainTillFirst(MessageTypes.ProtocolVersion, TimeSpan.FromDays(1));
response.EnsureSource(server, client);
Assert.Equal(expectVersion, response.Payload["Version"]?.Value <int>());
}
}
public void DthDependencies_UpdateGlobalJson_RefreshDependencies()
{
var assets = new TestAssetsManager(Path.Combine(AppContext.BaseDirectory, "TestAssets", "ProjectModelServer"));
var projectPath = assets.CreateTestInstance("DthUpdateSearchPathSample").WithLockFiles().TestRoot;
Assert.True(Directory.Exists(projectPath));
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
var testProject = Path.Combine(projectPath, "home", "src", "MainProject");
client.Initialize(testProject);
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(projectPath, "home", GlobalSettings.FileName),
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(projectPath, "home", "src"));
client.DrainTillFirst("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt <JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
client.DrainTillFirst("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", "")
.AssertProperty("Resolved", false)
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
}
}
public void RecoverFromGlobalError()
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyConsoleApp")
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
var projectFile = Path.Combine(testProject, Project.FileName);
var content = File.ReadAllText(projectFile);
File.WriteAllText(projectFile, content + "}");
client.Initialize(testProject);
client.DrainTillFirst(MessageTypes.Error);
File.WriteAllText(projectFile, content);
client.SendPayload(testProject, MessageTypes.FilesChanged);
client.DrainTillFirst(MessageTypes.Error)
.Payload.AsJObject()
.AssertProperty("Message", null as string);
}
}
public void RemoveMSBuildDependencyFromProjectJson()
{
// Remove a msbuild project dependency from project.json and then request refreshing dependency before
// restore.
var tam = new TestAssetsManager(
Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer", "MSBuildReferencesProjects"));
// var appName = "EmptyNetCoreApp";
var projectPath = tam.CreateTestInstance("ValidCase01").WithLockFiles().TestRoot;
projectPath = Path.Combine(projectPath, "src", "MainApp");
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
client.DrainAllMessages()
.AssertDoesNotContain(MessageTypes.Error)
.RetrieveSingleMessage(MessageTypes.Dependencies)
.RetrieveDependency("MainApp")
.RetrievePropertyAs <JArray>("Dependencies")
.AssertJArrayContains <JObject>(dep => dep["Name"].Value <string>() == "ClassLibrary1")
.AssertJArrayContains <JObject>(dep => dep["Name"].Value <string>() == "ClassLibrary2")
.AssertJArrayContains <JObject>(dep => dep["Name"].Value <string>() == "ClassLibrary3");
var projectFilePath = Path.Combine(projectPath, Project.FileName);
var projectJson = JsonConvert.DeserializeObject <JObject>(File.ReadAllText(projectFilePath));
// Remove ClassLibrary2 and ClassLibrary3 dependency
var dependencies = projectJson["frameworks"]["net46"]["dependencies"] as JObject;
dependencies.Remove("ClassLibrary2");
dependencies.Remove("ClassLibrary3");
File.WriteAllText(projectFilePath, JsonConvert.SerializeObject(projectJson));
client.SendPayload(projectPath, MessageTypes.RefreshDependencies);
var afterDependencies = client.DrainTillFirst(MessageTypes.Dependencies);
afterDependencies.RetrieveDependency("MainApp")
.RetrievePropertyAs <JArray>("Dependencies")
.AssertJArrayNotContains <JObject>(dep => dep["Name"].Value <string>() == "ClassLibrary2")
.AssertJArrayNotContains <JObject>(dep => dep["Name"].Value <string>() == "ClassLibrary3");
afterDependencies.RetrieveDependency("ClassLibrary2");
afterDependencies.RetrieveDependency("ClassLibrary3");
}
}
public void InvalidGlobalJson()
{
var testAssetsPath = Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer");
var assetsManager = new TestAssetsManager(testAssetsPath);
var testSource = assetsManager.CreateTestInstance("IncorrectGlobalJson");
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(Path.Combine(testSource.TestRoot, "src", "Project1"));
client.DrainTillFirst(MessageTypes.Error)
.Payload.AsJObject()
.AssertProperty <string>("Path", v => v.Contains("InvalidGlobalJson"));
}
}
public void RemovePackageDependencyFromProjectJson()
{
// Remove a package dependency from project.json and then request refreshing dependency before
// restore.
var appName = "EmptyNetCoreApp";
var projectPath = _testAssetsManager.CreateTestInstance(appName)
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
client.DrainAllMessages()
.AssertDoesNotContain(MessageTypes.Error)
.RetrieveSingleMessage(MessageTypes.Dependencies)
.RetrieveDependency(appName)
.RetrievePropertyAs <JArray>("Dependencies")
.AssertJArrayCount(2);
var projectFilePath = Path.Combine(projectPath, Project.FileName);
var projectJson = JsonConvert.DeserializeObject <JObject>(File.ReadAllText(projectFilePath));
// Remove newtonsoft.json dependency
var dependencies = projectJson["frameworks"]["netcoreapp1.0"]["dependencies"] as JObject;
dependencies.Remove("Newtonsoft.Json");
File.WriteAllText(projectFilePath, JsonConvert.SerializeObject(projectJson));
client.SendPayload(projectPath, MessageTypes.RefreshDependencies);
var afterDependencies = client.DrainTillFirst(MessageTypes.Dependencies);
afterDependencies.RetrieveDependency(appName)
.RetrievePropertyAs <JArray>("Dependencies")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("Name", "Microsoft.NETCore.App");
afterDependencies.RetrieveDependency("Newtonsoft.Json");
}
}
public void WaitForLockFileReleased(int occupyFileFor, bool expectSuccess)
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyConsoleApp")
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
var lockFilePath = Path.Combine(testProject, LockFile.FileName);
var lockFileContent = File.ReadAllText(lockFilePath);
var fs = new FileStream(lockFilePath, FileMode.Create, FileAccess.Write, FileShare.None);
// Test the platform
// A sharing violation is expected in following code. Otherwise the FileSteam is not implemented correctly.
Assert.ThrowsAny <IOException>(() =>
{
new FileStream(lockFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
});
var task = Task.Run(() =>
{
// WorkspaceContext will try to open the lock file for 3 times with 500 ms interval in between.
Thread.Sleep(occupyFileFor);
fs.Dispose();
});
client.Initialize(testProject);
if (expectSuccess)
{
client.DrainMessage(12).AssertDoesNotContain(MessageTypes.Error);
}
else
{
client.DrainTillFirst(MessageTypes.Error);
}
}
}
public void DthStartup_ProtocolNegotiation(int requestVersion, int expectVersion)
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server))
{
client.SetProtocolVersion(requestVersion);
var response = client.DrainTillFirst(MessageTypes.ProtocolVersion, TimeSpan.FromDays(1));
response.EnsureSource(server, client);
Assert.Equal(expectVersion, response.Payload["Version"]?.Value<int>());
}
}
public void DthDependencies_UpdateGlobalJson_RefreshDependencies()
{
var assets = new TestAssetsManager(Path.Combine(AppContext.BaseDirectory, "TestAssets", "ProjectModelServer"));
var projectPath = assets.CreateTestInstance("DthUpdateSearchPathSample").WithLockFiles().TestRoot;
Assert.True(Directory.Exists(projectPath));
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server))
{
var testProject = Path.Combine(projectPath, "home", "src", "MainProject");
client.Initialize(testProject);
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(projectPath, "home", GlobalSettings.FileName),
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(projectPath, "home", "src"));
client.DrainTillFirst("DependencyDiagnostics")
.RetrieveDependencyDiagnosticsCollection()
.RetrieveDependencyDiagnosticsErrorAt<JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
client.DrainTillFirst("Dependencies")
.RetrieveDependency("Newtonsoft.Json")
.AssertProperty("Type", "")
.AssertProperty("Resolved", false)
.RetrievePropertyAs<JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("ErrorCode", "NU1010");
}
}
public void DthNegative_BrokenProjectPathInLockFile()
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server))
{
// After restore the project is copied to another place so that
// the relative path in project lock file is invalid.
var movedProjectPath = _testAssetsManager.CreateTestInstance("BrokenProjectPathSample")
.WithLockFiles()
.TestRoot;
client.Initialize(movedProjectPath);
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);
}
}
public void WaitForLockFileReleased(int occupyFileFor, bool expectSuccess)
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyConsoleApp")
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
var lockFilePath = Path.Combine(testProject, LockFile.FileName);
var lockFileContent = File.ReadAllText(lockFilePath);
var fs = new FileStream(lockFilePath, FileMode.Create, FileAccess.Write, FileShare.None);
// Test the platform
// A sharing violation is expected in following code. Otherwise the FileSteam is not implemented correctly.
Assert.ThrowsAny<IOException>(() =>
{
new FileStream(lockFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
});
var task = Task.Run(() =>
{
// WorkspaceContext will try to open the lock file for 3 times with 500 ms interval in between.
Thread.Sleep(occupyFileFor);
fs.Dispose();
});
client.Initialize(testProject);
if (expectSuccess)
{
client.DrainMessage(12).AssertDoesNotContain(MessageTypes.Error);
}
else
{
client.DrainTillFirst(MessageTypes.Error);
}
}
}
public void RemoveMSBuildDependencyFromProjectJson()
{
// Remove a msbuild project dependency from project.json and then request refreshing dependency before
// restore.
var tam = new TestAssetsManager(
Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer", "MSBuildReferencesProjects"));
// var appName = "EmptyNetCoreApp";
var projectPath = tam.CreateTestInstance("ValidCase01").WithLockFiles().TestRoot;
projectPath = Path.Combine(projectPath, "src", "MainApp");
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.Initialize(projectPath);
client.DrainAllMessages()
.AssertDoesNotContain(MessageTypes.Error)
.RetrieveSingleMessage(MessageTypes.Dependencies)
.RetrieveDependency("MainApp")
.RetrievePropertyAs<JArray>("Dependencies")
.AssertJArrayContains<JObject>(dep => dep["Name"].Value<string>() == "ClassLibrary1")
.AssertJArrayContains<JObject>(dep => dep["Name"].Value<string>() == "ClassLibrary2")
.AssertJArrayContains<JObject>(dep => dep["Name"].Value<string>() == "ClassLibrary3");
var projectFilePath = Path.Combine(projectPath, Project.FileName);
var projectJson = JsonConvert.DeserializeObject<JObject>(File.ReadAllText(projectFilePath));
// Remove ClassLibrary2 and ClassLibrary3 dependency
var dependencies = projectJson["frameworks"]["net46"]["dependencies"] as JObject;
dependencies.Remove("ClassLibrary2");
dependencies.Remove("ClassLibrary3");
File.WriteAllText(projectFilePath, JsonConvert.SerializeObject(projectJson));
client.SendPayLoad(projectPath, MessageTypes.RefreshDependencies);
var afterDependencies = client.DrainTillFirst(MessageTypes.Dependencies);
afterDependencies.RetrieveDependency("MainApp")
.RetrievePropertyAs<JArray>("Dependencies")
.AssertJArrayNotContains<JObject>(dep => dep["Name"].Value<string>() == "ClassLibrary2")
.AssertJArrayNotContains<JObject>(dep => dep["Name"].Value<string>() == "ClassLibrary3");
afterDependencies.RetrieveDependency("ClassLibrary2");
afterDependencies.RetrieveDependency("ClassLibrary3");
}
}
public void RecoverFromGlobalError()
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyConsoleApp")
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
var projectFile = Path.Combine(testProject, Project.FileName);
var content = File.ReadAllText(projectFile);
File.WriteAllText(projectFile, content + "}");
client.Initialize(testProject);
var messages = client.DrainAllMessages();
messages.ContainsMessage(MessageTypes.Error);
File.WriteAllText(projectFile, content);
client.SendPayLoad(testProject, MessageTypes.FilesChanged);
var clearError = client.DrainTillFirst(MessageTypes.Error);
clearError.Payload.AsJObject().AssertProperty("Message", null as string);
}
}
public void RemovePackageDependencyFromProjectJson()
{
// Remove a package dependency from project.json and then request refreshing dependency before
// restore.
var appName = "EmptyNetCoreApp";
var projectPath = _testAssetsManager.CreateTestInstance(appName)
.WithLockFiles()
.TestRoot;
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.Initialize(projectPath);
client.DrainAllMessages()
.AssertDoesNotContain(MessageTypes.Error)
.RetrieveSingleMessage(MessageTypes.Dependencies)
.RetrieveDependency(appName)
.RetrievePropertyAs<JArray>("Dependencies")
.AssertJArrayCount(2);
var projectFilePath = Path.Combine(projectPath, Project.FileName);
var projectJson = JsonConvert.DeserializeObject<JObject>(File.ReadAllText(projectFilePath));
// Remove newtonsoft.json dependency
var dependencies = projectJson["frameworks"]["netcoreapp1.0"]["dependencies"] as JObject;
dependencies.Remove("Newtonsoft.Json");
File.WriteAllText(projectFilePath, JsonConvert.SerializeObject(projectJson));
client.SendPayLoad(projectPath, MessageTypes.RefreshDependencies);
var afterDependencies = client.DrainTillFirst(MessageTypes.Dependencies);
afterDependencies.RetrieveDependency(appName)
.RetrievePropertyAs<JArray>("Dependencies")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("Name", "Microsoft.NETCore.App");
afterDependencies.RetrieveDependency("Newtonsoft.Json");
}
}
public void TestTargetFrameworkChange()
{
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyLibrary")
.WithLockFiles()
.TestRoot;
// initialize the project and drain all messages (7 message for project with one framework)
client.Initialize(testProject);
client.DrainAllMessages();
// update the target framework from netstandard1.3 to netstandard 1.5 so as to invalidate all
// dependencies
var projectJsonPath = Path.Combine(testProject, "project.json");
File.WriteAllText(projectJsonPath,
File.ReadAllText(projectJsonPath).Replace("netstandard1.3", "netstandard1.5"));
// send files change request to server to prompt update
client.SendPayload(testProject, MessageTypes.FilesChanged);
// assert project information is updated
client.DrainTillFirst(MessageTypes.ProjectInformation)
.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("Frameworks")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("ShortName", "netstandard1.5");
// the NETStandard.Library dependency should turn unresolved
var dependencies = client.DrainTillFirst(MessageTypes.Dependencies);
dependencies.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JObject>("Framework")
.AssertProperty("ShortName", "netstandard1.5");
dependencies.RetrieveDependency("NETStandard.Library")
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("ErrorCode", "NU1001");
// warning for project.json and project.lock.json out of sync
var diagnostics = client.DrainTillFirst(MessageTypes.DependencyDiagnostics);
diagnostics.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JObject>("Framework")
.AssertProperty("ShortName", "netstandard1.5");
diagnostics.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("Warnings")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("ErrorCode", "NU1006");
// restore again
var restoreCommand = new RestoreCommand();
restoreCommand.WorkingDirectory = testProject;
restoreCommand.Execute().Should().Pass();
client.SendPayload(testProject, MessageTypes.RefreshDependencies);
client.DrainTillFirst(MessageTypes.Dependencies)
.RetrieveDependency("NETStandard.Library")
.RetrievePropertyAs <JArray>("Errors")
.AssertJArrayCount(0);
client.DrainTillFirst(MessageTypes.DependencyDiagnostics)
.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("Warnings")
.AssertJArrayCount(0);
}
}
public void InvalidGlobalJson()
{
var testAssetsPath = Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer");
var assetsManager = new TestAssetsManager(testAssetsPath);
var testSource = assetsManager.CreateTestInstance("IncorrectGlobalJson");
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(Path.Combine(testSource.TestRoot, "src", "Project1"));
client.DrainTillFirst(MessageTypes.Error)
.Payload.AsJObject()
.AssertProperty<string>("Path", v => v.Contains("InvalidGlobalJson"));
}
}
public void DthStartup_ProtocolNegotiation_ZeroIsNoAllowed()
{
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server))
{
client.SetProtocolVersion(0);
Assert.Throws<TimeoutException>(() =>
{
client.DrainTillFirst(MessageTypes.ProtocolVersion, timeout: TimeSpan.FromSeconds(1));
});
}
}
public void TestTargetFrameworkChange()
{
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
var testProject = _testAssetsManager.CreateTestInstance("EmptyLibrary")
.WithLockFiles()
.TestRoot;
// initialize the project and drain all messages (7 message for project with one framework)
client.Initialize(testProject);
client.DrainMessage(7);
// update the target framework from netstandard1.3 to netstandard 1.5 so as to invalidate all
// dependencies
var projectJsonPath = Path.Combine(testProject, "project.json");
File.WriteAllText(projectJsonPath,
File.ReadAllText(projectJsonPath).Replace("netstandard1.3", "netstandard1.5"));
// send files change request to server to prompt update
client.SendPayload(testProject, MessageTypes.FilesChanged);
// assert project information is updated
client.DrainTillFirst(MessageTypes.ProjectInformation)
.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("Frameworks")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("ShortName", "netstandard1.5");
// the NETStandard.Library dependency should turn unresolved
var dependencies = client.DrainTillFirst(MessageTypes.Dependencies);
dependencies.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JObject>("Framework")
.AssertProperty("ShortName", "netstandard1.5");
dependencies.RetrieveDependency("NETStandard.Library")
.RetrievePropertyAs<JArray>("Errors")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("ErrorCode", "NU1001");
// warning for project.json and project.lock.json out of sync
var diagnostics = client.DrainTillFirst(MessageTypes.DependencyDiagnostics);
diagnostics.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JObject>("Framework")
.AssertProperty("ShortName", "netstandard1.5");
diagnostics.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("Warnings")
.AssertJArrayCount(1)
.RetrieveArraryElementAs<JObject>(0)
.AssertProperty("ErrorCode", "NU1006");
// restore again
var restoreCommand = new RestoreCommand();
restoreCommand.WorkingDirectory = testProject;
restoreCommand.Execute().Should().Pass();
client.SendPayload(testProject, MessageTypes.RefreshDependencies);
client.DrainTillFirst(MessageTypes.Dependencies)
.RetrieveDependency("NETStandard.Library")
.RetrievePropertyAs<JArray>("Errors")
.AssertJArrayCount(0);
client.DrainTillFirst(MessageTypes.DependencyDiagnostics)
.RetrievePayloadAs<JObject>()
.RetrievePropertyAs<JArray>("Warnings")
.AssertJArrayCount(0);
}
}
public void DthCompilation_Initialize_UnresolvedDependency(string referenceType,
string testProjectName,
string expectedUnresolvedDependency,
string expectedUnresolvedType)
{
if (PlatformServices.Default.Runtime.OperatingSystemPlatform == Platform.Linux)
{
Console.WriteLine("Test is skipped on Linux");
return;
}
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, testProjectName);
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server, _loggerFactory))
{
client.Initialize(projectPath);
var referencesMessage = client.DrainTillFirst(MessageTypes.References, TimeSpan.FromDays(1))
.EnsureSource(server, client);
if (referenceType == "Project")
{
var expectedUnresolvedProjectPath = Path.Combine(Path.GetDirectoryName(projectPath),
expectedUnresolvedDependency,
Project.FileName);
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(1)
.RetrieveArraryElementAs <JObject>(0)
.AssertProperty("Name", expectedUnresolvedDependency)
.AssertProperty("Path", expectedUnresolvedProjectPath);
}
else if (referenceType == "Package")
{
referencesMessage.RetrievePayloadAs <JObject>()
.RetrievePropertyAs <JArray>("ProjectReferences")
.AssertJArrayCount(0);
}
var unresolveDependency = client.DrainTillFirst(MessageTypes.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(projectPath),
expectedUnresolvedDependency,
Project.FileName));
}
else
{
Assert.False(unresolveDependency["Path"].HasValues);
}
}
}
public void DthCompilation_Initialize_UnresolvedDependency(string referenceType,
string testProjectName,
string expectedUnresolvedDependency,
string expectedUnresolvedType)
{
if (PlatformServices.Default.Runtime.OperatingSystemPlatform == Platform.Linux)
{
Console.WriteLine("Test is skipped on Linux");
return;
}
var projectPath = Path.Combine(_testAssetsManager.AssetsRoot, testProjectName);
Assert.NotNull(projectPath);
using (var server = new DthTestServer(_loggerFactory))
using (var client = new DthTestClient(server))
{
client.Initialize(projectPath);
var referencesMessage = client.DrainTillFirst(MessageTypes.References, TimeSpan.FromDays(1))
.EnsureSource(server, client);
if (referenceType == "Project")
{
var expectedUnresolvedProjectPath = Path.Combine(Path.GetDirectoryName(projectPath),
expectedUnresolvedDependency,
Project.FileName);
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);
}
var unresolveDependency = client.DrainTillFirst(MessageTypes.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(projectPath),
expectedUnresolvedDependency,
Project.FileName));
}
else
{
Assert.False(unresolveDependency["Path"].HasValues);
}
}
}
public void InvalidProjectJson()
{
var testAssetsPath = Path.Combine(RepoRoot, "TestAssets", "ProjectModelServer");
var assetsManager = new TestAssetsManager(testAssetsPath);
var testSource = assetsManager.CreateTestInstance("IncorrectProjectJson").TestRoot;
using (var server = new DthTestServer())
using (var client = new DthTestClient(server))
{
client.Initialize(Path.Combine(_testAssetsManager.AssetsRoot, "EmptyLibrary"));
client.Initialize(testSource);
// Error for invalid project.json
var messages = client.DrainMessage(8);
messages.Single(msg => msg.MessageType == MessageTypes.Error)
.Payload.AsJObject()
.AssertProperty<string>("Path", v => v.Contains("IncorrectProjectJson"));
// Successfully initialize the other project
messages.Single(msg => msg.MessageType == MessageTypes.ProjectInformation)
.Payload.AsJObject()
.AssertProperty<string>("Name", v => string.Equals(v, "EmptyLibrary", StringComparison.Ordinal));
// Successfully initialize another project afterwards
client.Initialize(Path.Combine(_testAssetsManager.AssetsRoot, "EmptyConsoleApp"));
client.DrainTillFirst(MessageTypes.ProjectInformation)
.Payload.AsJObject()
.AssertProperty<string>("Name", v => string.Equals(v, "EmptyConsoleApp", StringComparison.Ordinal));
}
}