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 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 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 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 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 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 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 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 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();
}
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 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);
}
