public void ProjectConfigurationFileChanged_Added_AddAndUpdatesProject()
{
// Arrange
var handle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Default,
rootNamespace: "TestRootNamespace",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp5),
Array.Empty <DocumentSnapshotHandle>());
var projectService = new Mock <RazorProjectService>(MockBehavior.Strict);
projectService.Setup(service => service.AddProject(handle.FilePath)).Verifiable();
projectService.Setup(service => service.UpdateProject(
handle.FilePath,
handle.Configuration,
handle.RootNamespace,
handle.ProjectWorkspaceState,
handle.Documents)).Verifiable();
var synchronizer = GetSynchronizer(projectService.Object);
var jsonFileDeserializer = CreateJsonFileDeserializer(handle);
var args = new ProjectConfigurationFileChangeEventArgs("/path/to/project.razor.json", RazorFileChangeKind.Added, jsonFileDeserializer);
// Act
synchronizer.ProjectConfigurationFileChanged(args);
WaitForEnqueueAsync(synchronizer).Wait();
// Assert
projectService.VerifyAll();
}
public bool TryDeserialize(out FullProjectSnapshotHandle handle)
{
if (Kind == RazorFileChangeKind.Removed)
{
// There's no file to represent the snapshot handle.
handle = null;
return(false);
}
lock (_projectSnapshotHandleLock)
{
if (!_deserialized)
{
// We use a deserialized flag instead of checking if _projectSnapshotHandle is null because if we're reading an old snapshot
// handle that doesn't deserialize properly it could be expected that it would be null.
_deserialized = true;
_projectSnapshotHandle = _jsonFileDeserializer.Deserialize <FullProjectSnapshotHandle>(ConfigurationFilePath);
}
}
handle = _projectSnapshotHandle;
if (handle == null)
{
// Deserialization failed
return(false);
}
return(true);
}
public void FullProjectSnapshotHandle_CanRoundTrip()
{
// Arrange
var legacyDocument = new DocumentSnapshotHandle("/path/to/file.cshtml", "file.cshtml", FileKinds.Legacy);
var componentDocument = new DocumentSnapshotHandle("/path/to/otherfile.razor", "otherfile.razor", FileKinds.Component);
var handle = new FullProjectSnapshotHandle(
"/path/to/project.csproj",
Configuration,
rootNamespace: "TestProject",
ProjectWorkspaceState,
new[] { legacyDocument, componentDocument });
var serializedHandle = JsonConvert.SerializeObject(handle, Converters);
// Act
var deserializedHandle = JsonConvert.DeserializeObject <FullProjectSnapshotHandle>(serializedHandle, Converters);
// Assert
Assert.Equal(handle.FilePath, deserializedHandle.FilePath);
Assert.Equal(handle.Configuration, deserializedHandle.Configuration);
Assert.Equal(handle.RootNamespace, deserializedHandle.RootNamespace);
Assert.Equal(handle.ProjectWorkspaceState, deserializedHandle.ProjectWorkspaceState);
Assert.Collection(handle.Documents.OrderBy(doc => doc.FilePath),
document =>
{
Assert.Equal(legacyDocument.FilePath, document.FilePath);
Assert.Equal(legacyDocument.TargetPath, document.TargetPath);
Assert.Equal(legacyDocument.FileKind, document.FileKind);
},
document =>
{
Assert.Equal(componentDocument.FilePath, document.FilePath);
Assert.Equal(componentDocument.TargetPath, document.TargetPath);
Assert.Equal(componentDocument.FileKind, document.FileKind);
});
}
private static JsonFileDeserializer CreateJsonFileDeserializer(FullProjectSnapshotHandle deserializedHandle)
{
var deserializer = new Mock <JsonFileDeserializer>(MockBehavior.Strict);
deserializer.Setup(deserializer => deserializer.Deserialize <FullProjectSnapshotHandle>(It.IsAny <string>()))
.Returns(deserializedHandle);
return(deserializer.Object);
}
public void ProjectConfigurationFileChanged_Changed_UpdatesProject()
{
// Arrange
var initialHandle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Default,
rootNamespace: "TestRootNamespace",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp5),
Array.Empty <DocumentSnapshotHandle>());
var projectService = new Mock <RazorProjectService>(MockBehavior.Strict);
projectService.Setup(service => service.AddProject(initialHandle.FilePath)).Verifiable();
projectService.Setup(service => service.UpdateProject(
initialHandle.FilePath,
initialHandle.Configuration,
initialHandle.RootNamespace,
initialHandle.ProjectWorkspaceState,
initialHandle.Documents)).Verifiable();
var changedHandle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Create(
RazorLanguageVersion.Experimental,
"TestConfiguration",
Array.Empty <RazorExtension>()),
rootNamespace: "TestRootNamespace2",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp6),
Array.Empty <DocumentSnapshotHandle>());
projectService.Setup(service => service.UpdateProject(
changedHandle.FilePath,
changedHandle.Configuration,
changedHandle.RootNamespace,
changedHandle.ProjectWorkspaceState,
changedHandle.Documents)).Verifiable();
var synchronizer = GetSynchronizer(projectService.Object);
var addDeserializer = CreateJsonFileDeserializer(initialHandle);
var addArgs = new ProjectConfigurationFileChangeEventArgs("path/to/project.razor.json", RazorFileChangeKind.Added, addDeserializer);
synchronizer.ProjectConfigurationFileChanged(addArgs);
WaitForEnqueue(synchronizer).Wait();
var changedDeserializer = CreateJsonFileDeserializer(changedHandle);
var changedArgs = new ProjectConfigurationFileChangeEventArgs("path/to/project.razor.json", RazorFileChangeKind.Changed, changedDeserializer);
// Act
synchronizer.ProjectConfigurationFileChanged(changedArgs);
WaitForEnqueue(synchronizer).Wait();
// Assert
projectService.VerifyAll();
}
public void ProjectConfigurationFileChanged_Changed_CantDeserialize_ResetsProject()
{
// Arrange
var initialHandle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Default,
rootNamespace: "TestRootNamespace",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp5),
Array.Empty <DocumentSnapshotHandle>());
var projectService = new Mock <RazorProjectService>(MockBehavior.Strict);
projectService.Setup(service => service.AddProject(initialHandle.FilePath)).Verifiable();
projectService.Setup(service => service.UpdateProject(
initialHandle.FilePath,
initialHandle.Configuration,
initialHandle.RootNamespace,
initialHandle.ProjectWorkspaceState,
initialHandle.Documents)).Verifiable();
var changedHandle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Create(
RazorLanguageVersion.Experimental,
"TestConfiguration",
Array.Empty <RazorExtension>()),
rootNamespace: "TestRootNamespace2",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp6),
Array.Empty <DocumentSnapshotHandle>());
// This is the request that happens when the server is reset
projectService.Setup(service => service.UpdateProject(
initialHandle.FilePath,
null,
null,
ProjectWorkspaceState.Default,
Array.Empty <DocumentSnapshotHandle>())).Verifiable();
var synchronizer = new ProjectConfigurationStateSynchronizer(Dispatcher, projectService.Object, FilePathNormalizer);
var addDeserializer = CreateJsonFileDeserializer(initialHandle);
var addArgs = new ProjectConfigurationFileChangeEventArgs("/path/to/project.razor.json", RazorFileChangeKind.Added, addDeserializer);
synchronizer.ProjectConfigurationFileChanged(addArgs);
var changedDeserializer = Mock.Of <JsonFileDeserializer>();
var changedArgs = new ProjectConfigurationFileChangeEventArgs("/path/to/project.razor.json", RazorFileChangeKind.Changed, changedDeserializer);
// Act
synchronizer.ProjectConfigurationFileChanged(changedArgs);
// Assert
projectService.VerifyAll();
}
public void ProjectConfigurationFileChanged_RemoveThenAdd_OnlyAdds()
{
// Arrange
var handle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Default,
rootNamespace: "TestRootNamespace",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp5),
Array.Empty <DocumentSnapshotHandle>());
var filePath = "path/to/project.csproj";
var projectService = new Mock <RazorProjectService>(MockBehavior.Strict);
projectService.Setup(service => service.AddProject(handle.FilePath)).Verifiable();
projectService.Setup(p => p.UpdateProject(
filePath,
It.IsAny <RazorConfiguration>(),
It.IsAny <string>(),
It.IsAny <ProjectWorkspaceState>(),
It.IsAny <IReadOnlyList <DocumentSnapshotHandle> >()));
var synchronizer = GetSynchronizer(projectService.Object);
var changedDeserializer = CreateJsonFileDeserializer(handle);
var removedArgs = new ProjectConfigurationFileChangeEventArgs(filePath, RazorFileChangeKind.Removed, changedDeserializer);
var addedArgs = new ProjectConfigurationFileChangeEventArgs(filePath, RazorFileChangeKind.Added, changedDeserializer);
var changedArgs = new ProjectConfigurationFileChangeEventArgs(filePath, RazorFileChangeKind.Changed, changedDeserializer);
// Act
synchronizer.ProjectConfigurationFileChanged(addedArgs);
synchronizer.ProjectConfigurationFileChanged(changedArgs);
WaitForEnqueueAsync(synchronizer).Wait();
// Assert
projectService.Verify(p => p.UpdateProject(
filePath,
It.IsAny <RazorConfiguration>(),
It.IsAny <string>(),
It.IsAny <ProjectWorkspaceState>(),
It.IsAny <IReadOnlyList <DocumentSnapshotHandle> >()), Times.Once);
projectService.VerifyAll();
}
public void TryDeserialize_MemoizesResults()
{
// Arrange
var jsonFileDeserializer = new Mock <JsonFileDeserializer>(MockBehavior.Strict);
var projectSnapshotHandle = new FullProjectSnapshotHandle("c:/path/to/project.csproj", configuration: null, rootNamespace: null, projectWorkspaceState: null, documents: Array.Empty <DocumentSnapshotHandle>());
jsonFileDeserializer.Setup(deserializer => deserializer.Deserialize <FullProjectSnapshotHandle>(It.IsAny <string>()))
.Returns(projectSnapshotHandle);
var args = new ProjectConfigurationFileChangeEventArgs("c:/some/path", RazorFileChangeKind.Added, jsonFileDeserializer.Object);
// Act
var result1 = args.TryDeserialize(out var handle1);
var result2 = args.TryDeserialize(out var handle2);
// Assert
Assert.True(result1);
Assert.True(result2);
Assert.Same(projectSnapshotHandle, handle1);
Assert.Same(projectSnapshotHandle, handle2);
}
public void FullProjectSnapshotHandle_MissingSerializationFormat_SerializesToNull()
{
// Arrange
var handle = new FullProjectSnapshotHandle(
"/path/to/project.csproj",
Configuration,
rootNamespace: "TestProject",
ProjectWorkspaceState,
Array.Empty<DocumentSnapshotHandle>());
var serializedHandle = JsonConvert.SerializeObject(handle, Converters);
var serializedJObject = JObject.Parse(serializedHandle);
serializedJObject.Remove("SerializationFormat");
var reserializedHandle = JsonConvert.SerializeObject(serializedJObject);
// Act
var deserializedHandle = JsonConvert.DeserializeObject<FullProjectSnapshotHandle>(reserializedHandle, Converters);
// Assert
Assert.Null(deserializedHandle);
}
public void ProjectConfigurationFileChanged_Removed_NonNormalizedPaths()
{
// Arrange
var handle = new FullProjectSnapshotHandle(
"path/to/project.csproj",
RazorConfiguration.Default,
rootNamespace: "TestRootNamespace",
new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp5),
Array.Empty <DocumentSnapshotHandle>());
var projectService = new Mock <RazorProjectService>(MockBehavior.Strict);
projectService.Setup(service => service.AddProject(handle.FilePath)).Verifiable();
projectService.Setup(service => service.UpdateProject(
handle.FilePath,
handle.Configuration,
handle.RootNamespace,
handle.ProjectWorkspaceState,
handle.Documents)).Verifiable();
projectService.Setup(service => service.UpdateProject(
handle.FilePath,
null,
null,
ProjectWorkspaceState.Default,
Array.Empty <DocumentSnapshotHandle>())).Verifiable();
var synchronizer = new ProjectConfigurationStateSynchronizer(Dispatcher, projectService.Object, FilePathNormalizer);
var jsonFileDeserializer = CreateJsonFileDeserializer(handle);
var addArgs = new ProjectConfigurationFileChangeEventArgs("/path/to\\project.razor.json", RazorFileChangeKind.Added, jsonFileDeserializer);
synchronizer.ProjectConfigurationFileChanged(addArgs);
var removeArgs = new ProjectConfigurationFileChangeEventArgs("/path/to/project.razor.json", RazorFileChangeKind.Removed, Mock.Of <JsonFileDeserializer>());
// Act
synchronizer.ProjectConfigurationFileChanged(removeArgs);
// Assert
projectService.VerifyAll();
}
