public void RemoveDocument_RemovesDocumentFromOwnerProject()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var ownerProject = TestProjectSnapshot.Create("/C:/path/to/project.csproj", new[] { documentFilePath });
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>
{
[documentFilePath] = ownerProject
},
TestProjectSnapshot.Create("/__MISC_PROJECT__"));
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentRemoved(It.IsAny <HostProject>(), It.IsAny <HostDocument>()))
.Callback <HostProject, HostDocument>((hostProject, hostDocument) =>
{
Assert.Same(ownerProject.HostProject, hostProject);
Assert.Equal(documentFilePath, hostDocument.FilePath);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.RemoveDocument(documentFilePath);
// Assert
projectSnapshotManager.VerifyAll();
}
public void CloseDocument_ClosesDocumentInMiscellaneousProject()
{
// Arrange
var expectedDocumentFilePath = "/C:/path/to/document.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>(),
miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentClosed(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TextLoader>()))
.Callback <string, string, TextLoader>((projectFilePath, documentFilePath, text) =>
{
Assert.Equal(miscellaneousProject.FilePath, projectFilePath);
Assert.Equal(expectedDocumentFilePath, documentFilePath);
Assert.NotNull(text);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.CloseDocument(expectedDocumentFilePath);
// Assert
projectSnapshotManager.VerifyAll();
}
public void UpdateDocument_TracksKnownDocumentVersion()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var ownerProject = TestProjectSnapshot.Create("/C:/path/to/project.csproj", new[] { documentFilePath });
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>
{
[documentFilePath] = ownerProject
},
TestProjectSnapshot.Create("/__MISC_PROJECT__"));
DocumentSnapshot documentSnapshot = TestDocumentSnapshot.Create(documentFilePath);
var documentResolver = Mock.Of <DocumentResolver>(resolver => resolver.TryResolveDocument(It.IsAny <string>(), out documentSnapshot) == true);
var documentVersionCache = new Mock <DocumentVersionCache>(MockBehavior.Strict);
documentVersionCache.Setup(cache => cache.TrackDocumentVersion(documentSnapshot, It.IsAny <long>()))
.Callback <DocumentSnapshot, long>((snapshot, version) =>
{
Assert.Same(documentSnapshot, snapshot);
Assert.Equal(1337, version);
});
var newText = SourceText.From("Something New");
var projectService = CreateProjectService(
projectResolver,
Mock.Of <ProjectSnapshotManagerBase>(),
documentResolver,
documentVersionCache.Object);
// Act
projectService.UpdateDocument(documentFilePath, newText, 1337);
// Assert
documentVersionCache.VerifyAll();
}
public void UpdateDocument_ChangesDocumentInMiscProject()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__", new[] { documentFilePath });
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>(),
TestProjectSnapshot.Create("/__MISC_PROJECT__"));
var newText = SourceText.From("Something New");
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentChanged(miscellaneousProject.FilePath, documentFilePath, newText))
.Callback <string, string, SourceText>((projectPath, documentPath, sourceText) =>
{
Assert.Equal(miscellaneousProject.FilePath, projectPath);
Assert.Equal(documentFilePath, documentPath);
Assert.Same(newText, sourceText);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.UpdateDocument(documentFilePath, newText, 1337);
// Assert
projectSnapshotManager.VerifyAll();
}
public void AddDocument_AddsDocumentToOwnerProject()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var ownerProject = TestProjectSnapshot.Create("/C:/path/to/project.sproj");
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>
{
[documentFilePath] = ownerProject
},
TestProjectSnapshot.Create("__MISC_PROJECT__"));
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentAdded(It.IsAny <HostProject>(), It.IsAny <HostDocument>(), It.IsAny <TextLoader>()))
.Callback <HostProject, HostDocument, TextLoader>((hostProject, hostDocument, loader) =>
{
Assert.Same(ownerProject.HostProject, hostProject);
Assert.Equal(documentFilePath, hostDocument.FilePath);
Assert.NotNull(loader);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
var textLoader = CreateTextLoader("Hello World");
// Act
projectService.AddDocument(documentFilePath, textLoader);
// Assert
projectSnapshotManager.VerifyAll();
}
public void TryMigrateDocumentsFromRemovedProject_MigratesDocumentsToMiscProject()
{
// Arrange
var documentFilePath1 = "/C:/path/to/some/document1.cshtml";
var documentFilePath2 = "/C:/path/to/some/document2.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var removedProject = TestProjectSnapshot.Create("/C:/path/to/some/project.csproj", new[] { documentFilePath1, documentFilePath2 });
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var migratedDocuments = new List <HostDocument>();
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentAdded(It.IsAny <HostProject>(), It.IsAny <HostDocument>(), It.IsAny <TextLoader>()))
.Callback <HostProject, HostDocument, TextLoader>((hostProject, hostDocument, textLoader) =>
{
Assert.Same(miscellaneousProject.HostProject, hostProject);
Assert.NotNull(textLoader);
migratedDocuments.Add(hostDocument);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.TryMigrateDocumentsFromRemovedProject(removedProject);
// Assert
Assert.Collection(migratedDocuments.OrderBy(doc => doc.FilePath),
document => Assert.Equal(documentFilePath1, document.FilePath),
document => Assert.Equal(documentFilePath2, document.FilePath));
}
public void ProjectSnapshot_CanKindOfRoundTrip()
{
// Arrange
var projectSnapshot = TestProjectSnapshot.Create(
"/path/to/project.csproj",
new[]
{
"/path/to/component.razor",
"/path/to/file.cshtml",
},
Configuration,
ProjectWorkspaceState);
var serializedHandle = JsonConvert.SerializeObject(projectSnapshot, Converters);
// Act
var deserializedHandle = JsonConvert.DeserializeObject <FullProjectSnapshotHandle>(serializedHandle, Converters);
// Assert
Assert.Equal(projectSnapshot.FilePath, deserializedHandle.FilePath);
Assert.Equal(projectSnapshot.Configuration, deserializedHandle.Configuration);
Assert.Equal(projectSnapshot.ProjectWorkspaceState, deserializedHandle.ProjectWorkspaceState);
Assert.Collection(deserializedHandle.Documents.OrderBy(doc => doc.FilePath),
document => Assert.Equal("/path/to/component.razor", document.FilePath),
document => Assert.Equal("/path/to/file.cshtml", document.FilePath));
}
public void OpenDocument_OpensAlreadyAddedDocumentInMiscellaneousProject()
{
// Arrange
var expectedDocumentFilePath = "/C:/path/to/document.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>(),
miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentAdded(It.IsAny <HostProject>(), It.IsAny <HostDocument>(), It.IsAny <TextLoader>()))
.Throws(new InvalidOperationException("This shouldn't have been called."));
projectSnapshotManager.Setup(manager => manager.DocumentOpened(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <SourceText>()))
.Callback <string, string, SourceText>((projectFilePath, documentFilePath, text) =>
{
Assert.Equal(miscellaneousProject.FilePath, projectFilePath);
Assert.Equal(expectedDocumentFilePath, documentFilePath);
Assert.NotNull(text);
});
var documentSnapshot = Mock.Of <DocumentSnapshot>();
var documentResolver = Mock.Of <DocumentResolver>(resolver => resolver.TryResolveDocument(It.IsAny <string>(), out documentSnapshot) == true);
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object, documentResolver);
var sourceText = SourceText.From("Hello World");
// Act
projectService.OpenDocument(expectedDocumentFilePath, sourceText, 1);
// Assert
projectSnapshotManager.Verify(manager => manager.DocumentOpened(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <SourceText>()));
}
public void TryUpdateViewImportDependencies_OnlyUpdatesOpenDocuments()
{
// Arrange
var importFilePath = "/C:/path/to/_ViewImports.cshtml";
var documentFilePath = "/C:/path/to/Index.cshtml";
var closedDocumentFilePath = "/C:/path/to/About.cshtml";
var ownerProject = TestProjectSnapshot.Create(
"/C:/path/to/project.sproj",
new[]
{
importFilePath,
documentFilePath,
closedDocumentFilePath,
});
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentChanged(ownerProject.FilePath, documentFilePath, It.IsAny <TextLoader>()));
projectSnapshotManager.Setup(manager => manager.IsDocumentOpen(documentFilePath)).Returns(true);
projectSnapshotManager.Setup(manager => manager.IsDocumentOpen(closedDocumentFilePath)).Returns(false);
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectSnapshotManager.Object);
// Act
projectService.TryUpdateViewImportDependencies(importFilePath, ownerProject);
// Assert
projectSnapshotManager.VerifyAll();
}
internal static ProjectSnapshot CreateProjectSnapshot(string projectFilePath, ProjectWorkspaceState projectWorkspaceState = null, string[] documentFilePaths = null)
{
if (documentFilePaths is null)
{
documentFilePaths = Array.Empty <string>();
}
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath, documentFilePaths, projectWorkspaceState);
return(testProjectSnapshot);
}
public void TryUpdateViewImportDependencies_NoopsForNonViewImportFiles()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var ownerProject = TestProjectSnapshot.Create("/C:/path/to/project.sproj");
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentChanged(ownerProject.FilePath, documentFilePath, It.IsAny <TextLoader>()))
.Throws(new XunitException("Should not have been called."));
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectSnapshotManager.Object);
// Act & Assert
projectService.TryUpdateViewImportDependencies(documentFilePath, ownerProject);
}
public void RemoveProject_NoopsIfProjectIsNotLoaded()
{
// Arrange
var projectFilePath = "C:/path/to/project.csproj";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>();
projectSnapshotManager.Setup(manager => manager.ProjectRemoved(It.IsAny <HostProject>()))
.Throws(new InvalidOperationException("Should not have been called."));
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act & Assert
projectService.RemoveProject(projectFilePath);
}
public void TryMigrateMiscellaneousDocumentsToProject_DoesNotMigrateDocumentsIfNoOwnerProject()
{
// Arrange
var documentFilePath1 = "/C:/path/to/document1.cshtml";
var documentFilePath2 = "/C:/path/to/document2.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__", new[] { documentFilePath1, documentFilePath2 });
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>();
projectSnapshotManager.Setup(manager => manager.DocumentAdded(It.IsAny <HostProject>(), It.IsAny <HostDocument>(), It.IsAny <TextLoader>()))
.Throws(new InvalidOperationException("Should not have been called."));
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act & Assert
projectService.TryMigrateMiscellaneousDocumentsToProject();
}
public void RemoveDocument_NoopsIfMiscellaneousProjectDoesNotContainDocument()
{
// Arrange
var documentFilePath = "C:/path/to/document.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__", new string[0]);
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>(),
miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>();
projectSnapshotManager.Setup(manager => manager.DocumentRemoved(It.IsAny <HostProject>(), It.IsAny <HostDocument>()))
.Throws(new InvalidOperationException("Should not have been called."));
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act & Assert
projectService.RemoveDocument(documentFilePath);
}
public void ProjectSnapshotManager_Changed_DocumentChanged_ClosedDoc_EvictsCache()
{
// Arrange
var documentFilePath = "/C:/path/to/file.cshtml";
var projectFilePath = "/C:/path/to/project.csproj";
var container = Store.Get(documentFilePath);
var oldProject = TestProjectSnapshot.Create(projectFilePath, new[] { documentFilePath });
var newProjet = TestProjectSnapshot.Create(projectFilePath, new[] { documentFilePath });
var args = new ProjectChangeEventArgs(oldProject, newProjet, documentFilePath, ProjectChangeKind.DocumentChanged);
// Act
Store.ProjectSnapshotManager_Changed(null, args);
var newContainer = Store.Get(documentFilePath);
// Assert
Assert.NotSame(container, newContainer);
}
public void UpdateProject_SameConfigurationAndRootNamespaceNoops()
{
// Arrange
var projectFilePath = "/C:/path/to/project.csproj";
var ownerProject = TestProjectSnapshot.Create(projectFilePath);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.GetLoadedProject(projectFilePath))
.Returns(ownerProject);
projectSnapshotManager.Setup(manager => manager.ProjectWorkspaceStateChanged(It.IsAny <string>(), It.IsAny <ProjectWorkspaceState>()));
projectSnapshotManager.Setup(manager => manager.ProjectConfigurationChanged(It.IsAny <HostProject>()))
.Throws(new XunitException("Should not have been called."));
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectSnapshotManager.Object);
// Act & Assert
projectService.UpdateProject(projectFilePath, ownerProject.Configuration, "TestRootNamespace", ProjectWorkspaceState.Default, EmptyDocuments);
}
public void TryMigrateMiscellaneousDocumentsToProject_MigratesDocumentsToNewOwnerProject()
{
// Arrange
var documentFilePath1 = "C:/path/to/document1.cshtml";
var documentFilePath2 = "C:/path/to/document2.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("__MISC_PROJECT__", new[] { documentFilePath1, documentFilePath2 });
var projectToBeMigratedTo = TestProjectSnapshot.Create("C:/path/to/project.csproj");
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>
{
[documentFilePath1] = projectToBeMigratedTo,
[documentFilePath2] = projectToBeMigratedTo,
},
miscellaneousProject);
var migratedDocuments = new List <HostDocument>();
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.DocumentAdded(It.IsAny <HostProject>(), It.IsAny <HostDocument>(), It.IsAny <TextLoader>()))
.Callback <HostProject, HostDocument, TextLoader>((hostProject, hostDocument, textLoader) =>
{
Assert.Same(projectToBeMigratedTo.HostProject, hostProject);
Assert.NotNull(textLoader);
migratedDocuments.Add(hostDocument);
});
projectSnapshotManager.Setup(manager => manager.DocumentRemoved(It.IsAny <HostProject>(), It.IsAny <HostDocument>()))
.Callback <HostProject, HostDocument>((hostProject, hostDocument) =>
{
Assert.Same(miscellaneousProject.HostProject, hostProject);
Assert.DoesNotContain(hostDocument, migratedDocuments);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.TryMigrateMiscellaneousDocumentsToProject();
// Assert
Assert.Collection(migratedDocuments,
document => Assert.Equal(documentFilePath1, document.FilePath),
document => Assert.Equal(documentFilePath2, document.FilePath));
}
public void AddProject_AddsProjectWithDefaultConfiguration()
{
// Arrange
var projectFilePath = "/C:/path/to/project.csproj";
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.ProjectAdded(It.IsAny <HostProject>()))
.Callback <HostProject>((hostProject) =>
{
Assert.Equal(projectFilePath, hostProject.FilePath);
Assert.Same(RazorDefaults.Configuration, hostProject.Configuration);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.AddProject(projectFilePath);
// Assert
projectSnapshotManager.VerifyAll();
}
public void AddProject_AddsProjectWithProvidedConfiguration()
{
// Arrange
var projectConfiguration = RazorConfiguration.Create(RazorLanguageVersion.Version_1_0, "Test", Array.Empty <RazorExtension>());
var projectFilePath = "/C:/path/to/document.cshtml";
var miscellaneousProject = TestProjectSnapshot.Create("__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.HostProjectAdded(It.IsAny <HostProject>()))
.Callback <HostProject>((hostProject) =>
{
Assert.Equal(projectFilePath, hostProject.FilePath);
Assert.Same(projectConfiguration, hostProject.Configuration);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.AddProject(projectFilePath, projectConfiguration);
// Assert
projectSnapshotManager.VerifyAll();
}
private DocumentSnapshot CreateRazorDocumentSnapshot(RazorProjectEngine projectEngine, TestRazorProjectItem item, string rootNamespaceName, IReadOnlyList <TagHelperDescriptor> tagHelpers)
{
var codeDocument = projectEngine.ProcessDesignTime(item);
var namespaceNode = (NamespaceDeclarationIntermediateNode)codeDocument
.GetDocumentIntermediateNode()
.FindDescendantNodes <IntermediateNode>()
.FirstOrDefault(n => n is NamespaceDeclarationIntermediateNode);
namespaceNode.Content = rootNamespaceName;
var sourceText = SourceText.From(new string(item.Content));
var projectWorkspaceState = new ProjectWorkspaceState(tagHelpers, LanguageVersion.Default);
var projectSnapshot = TestProjectSnapshot.Create("C:/project.csproj", projectWorkspaceState);
var documentSnapshot = Mock.Of <DocumentSnapshot>(d =>
d.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
d.FilePath == item.FilePath &&
d.FileKind == FileKinds.Component &&
d.GetTextAsync() == Task.FromResult(sourceText) &&
d.Project == projectSnapshot, MockBehavior.Strict);
return(documentSnapshot);
}
public void RemoveProject_RemovesProject()
{
// Arrange
var projectFilePath = "/C:/path/to/project.csproj";
var ownerProject = TestProjectSnapshot.Create(projectFilePath);
var miscellaneousProject = TestProjectSnapshot.Create("/__MISC_PROJECT__");
var projectResolver = new TestProjectResolver(new Dictionary <string, ProjectSnapshot>(), miscellaneousProject);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.GetLoadedProject(projectFilePath))
.Returns(ownerProject);
projectSnapshotManager.Setup(manager => manager.ProjectRemoved(ownerProject.HostProject))
.Callback <HostProject>((hostProject) =>
{
Assert.Equal(projectFilePath, hostProject.FilePath);
});
var projectService = CreateProjectService(projectResolver, projectSnapshotManager.Object);
// Act
projectService.RemoveProject(projectFilePath);
// Assert
projectSnapshotManager.VerifyAll();
}
public void UpdateProject_SameConfigurationDifferentRootNamespace_UpdatesRootNamespace()
{
// Arrange
var projectFilePath = "/C:/path/to/project.csproj";
var ownerProject = TestProjectSnapshot.Create(projectFilePath);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
var expectedRootNamespace = "NewRootNamespace";
projectSnapshotManager.Setup(manager => manager.GetLoadedProject(projectFilePath))
.Returns(ownerProject);
projectSnapshotManager.Setup(manager => manager.ProjectWorkspaceStateChanged(It.IsAny <string>(), It.IsAny <ProjectWorkspaceState>()));
projectSnapshotManager.Setup(manager => manager.ProjectConfigurationChanged(It.IsAny <HostProject>()))
.Callback <HostProject>((hostProject) =>
{
Assert.Equal(expectedRootNamespace, hostProject.RootNamespace);
});
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectSnapshotManager.Object);
// Act
projectService.UpdateProject(projectFilePath, ownerProject.Configuration, expectedRootNamespace, ProjectWorkspaceState.Default, EmptyDocuments);
// Assert
projectSnapshotManager.VerifyAll();
}
public void UpdateProject_ChangesProjectToUseProvidedConfiguration()
{
// Arrange
var projectFilePath = "/C:/path/to/project.csproj";
var ownerProject = TestProjectSnapshot.Create(projectFilePath);
var projectSnapshotManager = new Mock <ProjectSnapshotManagerBase>(MockBehavior.Strict);
projectSnapshotManager.Setup(manager => manager.GetLoadedProject(projectFilePath))
.Returns(ownerProject);
projectSnapshotManager.Setup(manager => manager.ProjectWorkspaceStateChanged(It.IsAny <string>(), It.IsAny <ProjectWorkspaceState>()));
projectSnapshotManager.Setup(manager => manager.ProjectConfigurationChanged(It.IsAny <HostProject>()))
.Callback <HostProject>((hostProject) =>
{
Assert.Same(FallbackRazorConfiguration.MVC_1_1, hostProject.Configuration);
Assert.Equal(projectFilePath, hostProject.FilePath);
});
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectSnapshotManager.Object);
// Act
projectService.UpdateProject(projectFilePath, FallbackRazorConfiguration.MVC_1_1, "TestRootNamespace", ProjectWorkspaceState.Default, EmptyDocuments);
// Assert
projectSnapshotManager.VerifyAll();
}
public void ProjectSnapshotManager_Changed_DocumentChanged_OpenDoc_DoesNotEvictCache()
{
// Arrange
var documentFilePath = "/C:/path/to/file.cshtml";
var projectFilePath = "/C:/path/to/project.csproj";
var container = Store.Get(documentFilePath);
var project = new HostProject(projectFilePath, RazorConfiguration.Default, "TestRootNamespace");
ProjectManager.ProjectAdded(project);
var document = new HostDocument(documentFilePath, "file.cshtml");
ProjectManager.DocumentAdded(project, document, null);
ProjectManager.DocumentOpened(projectFilePath, documentFilePath, SourceText.From(string.Empty));
var oldProject = TestProjectSnapshot.Create(projectFilePath, new[] { documentFilePath });
var newProjet = TestProjectSnapshot.Create(projectFilePath, new[] { documentFilePath });
var args = new ProjectChangeEventArgs(oldProject, newProjet, documentFilePath, ProjectChangeKind.DocumentChanged);
// Act
Store.ProjectSnapshotManager_Changed(null, args);
var newContainer = Store.Get(documentFilePath);
// Assert
Assert.Same(container, newContainer);
}
public void UpdateDocument_IgnoresUnknownDocumentVersions()
{
// Arrange
var documentFilePath = "/C:/path/to/document.cshtml";
var ownerProject = TestProjectSnapshot.Create("/C:/path/to/project.csproj", new[] { documentFilePath });
var projectResolver = new TestProjectResolver(
new Dictionary <string, ProjectSnapshot>
{
[documentFilePath] = ownerProject
},
TestProjectSnapshot.Create("/__MISC_PROJECT__"));
var documentVersionCache = new Mock <DocumentVersionCache>();
documentVersionCache.Setup(cache => cache.TrackDocumentVersion(It.IsAny <DocumentSnapshot>(), It.IsAny <long>()))
.Throws <XunitException>();
var newText = SourceText.From("Something New");
var projectService = CreateProjectService(
projectResolver,
Mock.Of <ProjectSnapshotManagerBase>(),
documentVersionCache: documentVersionCache.Object);
// Act & Assert
projectService.UpdateDocument(documentFilePath, newText, 1337);
}
internal ProjectSnapshot CreateProjectSnapshot(string projectFilePath, string[] documentFilePaths)
{
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath, documentFilePaths);
return(testProjectSnapshot);
}
internal ProjectSnapshot CreateProjectSnapshot(string projectFilePath)
{
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath);
return(testProjectSnapshot);
}
internal ProjectSnapshot CreateProjectSnapshot(string projectFilePath, ProjectWorkspaceState projectWorkspaceState = null)
{
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath, projectWorkspaceState);
return(testProjectSnapshot);
}