public void UpdateProject_KnownDocuments()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
var hostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
projectManager.ProjectAdded(hostProject);
var document = new HostDocument("/path/to/file.cshtml", "file.cshtml", FileKinds.Legacy);
projectManager.DocumentAdded(hostProject, document, Mock.Of <TextLoader>());
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectManager);
var newDocument = new DocumentSnapshotHandle(document.FilePath, document.TargetPath, document.FileKind);
projectManager.AllowNotifyListeners = true;
projectManager.Changed += (sender, args) =>
{
if (args.Kind == ProjectChangeKind.DocumentRemoved ||
args.Kind == ProjectChangeKind.DocumentChanged ||
args.Kind == ProjectChangeKind.DocumentAdded)
{
throw new XunitException("Should have nooped");
}
};
// Act & Assert
projectService.UpdateProject(hostProject.FilePath, hostProject.Configuration, hostProject.RootNamespace, ProjectWorkspaceState.Default, new[] { newDocument });
}
public void ProjectSnapshotManager_WorkspacePopulated_SetsUIContext()
{
// Arrange
var responseRouterReturns = new Mock <IResponseRouterReturns>(MockBehavior.Strict);
responseRouterReturns.Setup(r => r.ReturningVoid(It.IsAny <CancellationToken>()))
.Returns(() => Task.CompletedTask);
var clientNotifierService = new Mock <ClientNotifierServiceBase>(MockBehavior.Strict);
clientNotifierService.Setup(l => l.SendRequestAsync(_razorServerReadyEndpoint))
.Returns(Task.FromResult(responseRouterReturns.Object));
var razorServerReadyPublisher = new RazorServerReadyPublisher(Dispatcher, clientNotifierService.Object);
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.AllowNotifyListeners = true;
razorServerReadyPublisher.Initialize(projectManager);
var document = TestDocumentSnapshot.Create("C:/file.cshtml");
document.TryGetText(out var text);
document.TryGetTextVersion(out var textVersion);
var textAndVersion = TextAndVersion.Create(text, textVersion);
// Act
projectManager.ProjectAdded(document.ProjectInternal.HostProject);
projectManager.ProjectWorkspaceStateChanged(document.ProjectInternal.HostProject.FilePath, CreateProjectWorkspace());
// Assert
clientNotifierService.VerifyAll();
responseRouterReturns.VerifyAll();
}
public DefaultVisualStudioDocumentTrackerTest()
{
RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) == true);
TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType);
FilePath = TestProjectData.SomeProjectFile1.FilePath;
ProjectPath = TestProjectData.SomeProject.FilePath;
ImportDocumentManager = Mock.Of <ImportDocumentManager>();
WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(Mock.Of <ForegroundDispatcher>(), Mock.Of <EditorSettingsManager>());
SomeTagHelpers = new List <TagHelperDescriptor>()
{
TagHelperDescriptorBuilder.Create("test", "test").Build(),
};
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace)
{
AllowNotifyListeners = true
};
HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1);
UpdatedHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0);
OtherHostProject = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_2_0);
DocumentTracker = new DefaultVisualStudioDocumentTracker(
Dispatcher,
FilePath,
ProjectPath,
ProjectManager,
WorkspaceEditorSettings,
Workspace,
TextBuffer,
ImportDocumentManager);
}
public async Task SolutionClosing_CancelsActiveWork()
{
// Arrange
var projectManager = new TestProjectSnapshotManager(Workspace)
{
AllowNotifyListeners = true,
};
var expectedProjectPath = SomeProject.FilePath;
var expectedProjectSnapshot = await Dispatcher.RunOnDispatcherThreadAsync(() =>
{
projectManager.ProjectAdded(SomeProject);
projectManager.ProjectAdded(SomeOtherProject);
return(projectManager.GetLoadedProject(SomeProject.FilePath));
}, CancellationToken.None);
var projectService = new Mock <TextBufferProjectService>(MockBehavior.Strict);
projectService.Setup(p => p.GetProjectPath(It.IsAny <IVsHierarchy>())).Returns(expectedProjectPath);
var workspaceStateGenerator = new TestProjectWorkspaceStateGenerator();
var trigger = new VsSolutionUpdatesProjectSnapshotChangeTrigger(TestServiceProvider.Instance, projectService.Object, workspaceStateGenerator, Dispatcher, JoinableTaskFactory.Context);
trigger.Initialize(projectManager);
trigger.UpdateProjectCfg_Done(Mock.Of <IVsHierarchy>(MockBehavior.Strict), pCfgProj: default, pCfgSln: default, dwAction: default, fSuccess: default, fCancel: default);
public void ProjectSnapshotManager_WorkspaceNull_DoesNothing()
{
// Arrange
var clientNotifierService = new Mock <ClientNotifierServiceBase>(MockBehavior.Strict);
var razorServerReadyPublisher = new RazorServerReadyPublisher(Dispatcher, clientNotifierService.Object);
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.AllowNotifyListeners = true;
razorServerReadyPublisher.Initialize(projectManager);
var document = TestDocumentSnapshot.Create("C:/file.cshtml");
document.TryGetText(out var text);
document.TryGetTextVersion(out var textVersion);
var textAndVersion = TextAndVersion.Create(text, textVersion);
// Act
projectManager.ProjectAdded(document.ProjectInternal.HostProject);
projectManager.DocumentAdded(document.ProjectInternal.HostProject, document.State.HostDocument, TextLoader.From(textAndVersion));
// Assert
// Should not have been called
clientNotifierService.Verify();
}
public async Task Changed_TriggersOnSnapshotManagerChanged()
{
// Arrange
var projectSnapshotManager = new TestProjectSnapshotManager(ProjectSnapshot1);
using var proxy = new DefaultProjectSnapshotManagerProxy(
new TestCollaborationSession(true),
Dispatcher,
projectSnapshotManager,
JoinableTaskFactory);
var changedArgs = new ProjectChangeEventArgs(ProjectSnapshot1, ProjectSnapshot1, ProjectChangeKind.ProjectChanged);
var called = false;
proxy.Changed += (sender, args) =>
{
called = true;
Assert.Equal($"vsls:/path/to/project1.csproj", args.ProjectFilePath.ToString());
Assert.Equal(ProjectProxyChangeKind.ProjectChanged, args.Kind);
Assert.Equal("vsls:/path/to/project1.csproj", args.Newer.FilePath.ToString());
};
// Act
projectSnapshotManager.TriggerChanged(changedArgs);
await proxy._processingChangedEventTestTask.JoinAsync();
// Assert
Assert.True(called);
}
public void Create_CreatesTemplateEngine_ForVersion1_1()
{
// Arrange
var projectManager = new TestProjectSnapshotManager(Workspace);
projectManager.ProjectAdded(Project);
projectManager.ProjectUpdated(new ProjectSnapshotUpdateContext(Project)
{
Configuration = new MvcExtensibilityConfiguration(
RazorLanguageVersion.Version_1_1,
ProjectExtensibilityConfigurationKind.ApproximateMatch,
new ProjectExtensibilityAssembly(new AssemblyIdentity("Microsoft.AspNetCore.Mvc.Razor", new Version("1.1.3.0"))),
new ProjectExtensibilityAssembly(new AssemblyIdentity("Microsoft.AspNetCore.Razor", new Version("1.1.3.0")))),
});
var factoryService = new DefaultProjectEngineFactoryService(projectManager);
// Act
var engine = factoryService.Create("/TestPath/SomePath/", b =>
{
b.Features.Add(new MyCoolNewFeature());
});
// Assert
Assert.Single(engine.Engine.Features.OfType <MyCoolNewFeature>());
Assert.Single(engine.Engine.Features.OfType <Mvc1_X.MvcViewDocumentClassifierPass>());
Assert.Single(engine.Engine.Features.OfType <Mvc1_X.ViewComponentTagHelperPass>());
}
public DefaultRazorDynamicFileInfoProviderTest()
{
DocumentServiceFactory = new DefaultRazorDocumentServiceProviderFactory();
EditorFeatureDetector = Mock.Of <LSPEditorFeatureDetector>(MockBehavior.Strict);
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace)
{
AllowNotifyListeners = true
};
var hostProject = new HostProject("C:\\project.csproj", RazorConfiguration.Default, rootNamespace: "TestNamespace");
ProjectSnapshotManager.ProjectAdded(hostProject);
var hostDocument1 = new HostDocument("C:\\document1.razor", "document1.razor", FileKinds.Component);
ProjectSnapshotManager.DocumentAdded(hostProject, hostDocument1, new EmptyTextLoader(hostDocument1.FilePath));
var hostDocument2 = new HostDocument("C:\\document2.razor", "document2.razor", FileKinds.Component);
ProjectSnapshotManager.DocumentAdded(hostProject, hostDocument2, new EmptyTextLoader(hostDocument2.FilePath));
Project = ProjectSnapshotManager.GetSnapshot(hostProject);
Document1 = (DefaultDocumentSnapshot)Project.GetDocument(hostDocument1.FilePath);
Document2 = (DefaultDocumentSnapshot)Project.GetDocument(hostDocument2.FilePath);
Provider = new DefaultRazorDynamicFileInfoProvider(DocumentServiceFactory, EditorFeatureDetector);
TestAccessor = Provider.GetTestAccessor();
Provider.Initialize(ProjectSnapshotManager);
var lspDocumentContainer = new Mock <DynamicDocumentContainer>(MockBehavior.Strict);
lspDocumentContainer.SetupSet(c => c.SupportsDiagnostics = true).Verifiable();
lspDocumentContainer.Setup(container => container.GetTextLoader(It.IsAny <string>())).Returns(new EmptyTextLoader(string.Empty));
LSPDocumentContainer = lspDocumentContainer.Object;
}
public OOPTagHelperResolverTest()
{
HostProject_For_2_0 = new HostProject("Test.csproj", FallbackRazorConfiguration.MVC_2_0);
HostProject_For_NonSerializableConfiguration = new HostProject(
"Test.csproj",
new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "Blazor-0.1", Array.Empty <RazorExtension>()));
CustomFactories = new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>[]
{
new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>(
() => new LegacyProjectEngineFactory_2_0(),
typeof(LegacyProjectEngineFactory_2_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()),
// We don't really use this factory, we just use it to ensure that the call is going to go out of process.
new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>(
() => new LegacyProjectEngineFactory_2_1(),
new ExportCustomProjectEngineFactoryAttribute("Blazor-0.1")
{
SupportsSerialization = false,
}),
};
FallbackFactory = new FallbackProjectEngineFactory();
Workspace = new AdhocWorkspace();
var info = ProjectInfo.Create(ProjectId.CreateNewId("Test"), VersionStamp.Default, "Test", "Test", LanguageNames.CSharp, filePath: "Test.csproj");
WorkspaceProject = Workspace.CurrentSolution.AddProject(info).GetProject(info.Id);
ErrorReporter = new DefaultErrorReporter();
ProjectManager = new TestProjectSnapshotManager(Workspace);
EngineFactory = new DefaultProjectEngineFactoryService(ProjectManager, FallbackFactory, CustomFactories);
}
public async Task CalculateUpdatedStateAsync_ReturnsStateForAllProjects()
{
// Arrange
var projectSnapshotManager = new TestProjectSnapshotManager(ProjectSnapshot1, ProjectSnapshot2);
using var proxy = new DefaultProjectSnapshotManagerProxy(
new TestCollaborationSession(true),
Dispatcher,
projectSnapshotManager,
JoinableTaskFactory);
// Act
var state = await JoinableTaskFactory.RunAsync(() => proxy.CalculateUpdatedStateAsync(projectSnapshotManager.Projects));
// Assert
Assert.Collection(
state.ProjectHandles,
handle =>
{
Assert.Equal("vsls:/path/to/project1.csproj", handle.FilePath.ToString());
Assert.Equal(ProjectSnapshot1.TagHelpers, handle.ProjectWorkspaceState.TagHelpers);
},
handle =>
{
Assert.Equal("vsls:/path/to/project2.csproj", handle.FilePath.ToString());
Assert.Equal(ProjectSnapshot2.TagHelpers, handle.ProjectWorkspaceState.TagHelpers);
});
}
public void ProjectSnapshotManager_Changed_DocumentRemoved_DoesNotEvictDocument()
{
// Arrange
var documentVersionCache = new DefaultDocumentVersionCache(Dispatcher);
var projectSnapshotManager = TestProjectSnapshotManager.Create(Dispatcher);
projectSnapshotManager.AllowNotifyListeners = true;
documentVersionCache.Initialize(projectSnapshotManager);
var document = TestDocumentSnapshot.Create("C:/file.cshtml");
document.TryGetText(out var text);
document.TryGetTextVersion(out var textVersion);
var textAndVersion = TextAndVersion.Create(text, textVersion);
documentVersionCache.TrackDocumentVersion(document, 1337);
projectSnapshotManager.ProjectAdded(document.ProjectInternal.HostProject);
projectSnapshotManager.DocumentAdded(document.ProjectInternal.HostProject, document.State.HostDocument, TextLoader.From(textAndVersion));
// Act - 1
var result = documentVersionCache.TryGetDocumentVersion(document, out var version);
// Assert - 1
Assert.True(result);
// Act - 2
projectSnapshotManager.DocumentRemoved(document.ProjectInternal.HostProject, document.State.HostDocument);
result = documentVersionCache.TryGetDocumentVersion(document, out version);
// Assert - 2
Assert.True(result);
}
public void Queue_ProcessesNotifications_AndRestarts()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.ProjectAdded(HostProject1);
projectManager.ProjectAdded(HostProject2);
projectManager.DocumentAdded(HostProject1, Documents[0], null);
projectManager.DocumentAdded(HostProject1, Documents[1], null);
var project = projectManager.GetLoadedProject(HostProject1.FilePath);
var queue = new TestBackgroundDocumentGenerator(Dispatcher)
{
Delay = TimeSpan.FromMilliseconds(1),
BlockBackgroundWorkStart = new ManualResetEventSlim(initialState: false),
NotifyBackgroundWorkStarting = new ManualResetEventSlim(initialState: false),
NotifyBackgroundCapturedWorkload = new ManualResetEventSlim(initialState: false),
BlockBackgroundWorkCompleting = new ManualResetEventSlim(initialState: false),
NotifyBackgroundWorkCompleted = new ManualResetEventSlim(initialState: false),
};
// Act & Assert
queue.Enqueue(project.GetDocument(Documents[0].FilePath));
Assert.True(queue.IsScheduledOrRunning, "Queue should be scheduled during Enqueue");
Assert.True(queue.HasPendingNotifications, "Queue should have a notification created during Enqueue");
// Allow the background work to start.
queue.BlockBackgroundWorkStart.Set();
queue.NotifyBackgroundWorkStarting.Wait(TimeSpan.FromSeconds(1));
Assert.True(queue.IsScheduledOrRunning, "Worker should be processing now");
queue.NotifyBackgroundCapturedWorkload.Wait(TimeSpan.FromSeconds(1));
Assert.False(queue.HasPendingNotifications, "Worker should have taken all notifications");
queue.Enqueue(project.GetDocument(Documents[1].FilePath));
Assert.True(queue.HasPendingNotifications); // Now we should see the worker restart when it finishes.
// Allow work to complete, which should restart the timer.
queue.BlockBackgroundWorkCompleting.Set();
queue.NotifyBackgroundWorkCompleted.Wait(TimeSpan.FromSeconds(3));
queue.NotifyBackgroundWorkCompleted.Reset();
// It should start running again right away.
Assert.True(queue.IsScheduledOrRunning, "Queue should be scheduled during Enqueue");
Assert.True(queue.HasPendingNotifications, "Queue should have a notification created during Enqueue");
// Allow the background work to proceed.
queue.BlockBackgroundWorkStart.Set();
queue.BlockBackgroundWorkCompleting.Set();
queue.NotifyBackgroundWorkCompleted.Wait(TimeSpan.FromSeconds(3));
Assert.False(queue.IsScheduledOrRunning, "Queue should not have restarted");
Assert.False(queue.HasPendingNotifications, "Queue should have processed all notifications");
}
internal ProjectSnapshotManagerBase CreateProjectSnapshotManager(bool allowNotifyListeners = false)
{
var snapshotManager = TestProjectSnapshotManager.Create(Dispatcher);
snapshotManager.AllowNotifyListeners = allowNotifyListeners;
return(snapshotManager);
}
public DefaultGeneratedCodeContainerStoreTest()
{
var documentVersionCache = Mock.Of <DocumentVersionCache>();
var csharpPublisher = Mock.Of <CSharpPublisher>();
Store = new DefaultGeneratedCodeContainerStore(Dispatcher, documentVersionCache, csharpPublisher);
ProjectManager = TestProjectSnapshotManager.Create(Dispatcher);
Store.Initialize(ProjectManager);
}
public DefaultWorkspaceSemanticTokensRefreshTriggerTest()
{
ProjectManager = TestProjectSnapshotManager.Create(LegacyDispatcher);
ProjectManager.AllowNotifyListeners = true;
HostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
ProjectManager.ProjectAdded(HostProject);
HostDocument = new HostDocument("/path/to/file.razor", "file.razor");
ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath));
}
public DefaultGeneratedCodeContainerStoreTest()
{
var documentVersionCache = Mock.Of <DocumentVersionCache>();
var server = new Lazy <ILanguageServer>(() => null);
Store = new DefaultGeneratedCodeContainerStore(Dispatcher, documentVersionCache, server);
ProjectManager = TestProjectSnapshotManager.Create(Dispatcher);
Store.Initialize(ProjectManager);
}
public DefaultGeneratedDocumentPublisherTest()
{
Server = new TestServer();
ProjectManager = TestProjectSnapshotManager.Create(Dispatcher);
ProjectManager.AllowNotifyListeners = true;
HostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
ProjectManager.ProjectAdded(HostProject);
HostDocument = new HostDocument("/path/to/file.razor", "file.razor");
ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath));
}
public DocumentOutputReferenceCapturerTest()
{
ProjectManager = TestProjectSnapshotManager.Create(Dispatcher);
ProjectManager.AllowNotifyListeners = true;
HostProject = new HostProject("C:/path/to/project.csproj", RazorConfiguration.Default, "TestNamespace");
ProjectManager.ProjectAdded(HostProject);
HostDocument = new HostDocument("C:/path/to/file.razor", "file.razor");
ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath));
DocumentOutputReferenceCapturer = new DocumentOutputReferenceCapturer();
DocumentOutputReferenceCapturer.Initialize(ProjectManager);
}
public ProjectSnapshotSynchronizationServiceTest()
{
JoinableTaskContext = new JoinableTaskContext();
JoinableTaskFactory = new JoinableTaskFactory(JoinableTaskContext);
SessionContext = new TestCollaborationSession(isHost: false);
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace);
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build()
}, default);
}
public DefaultVisualStudioDocumentTrackerTest()
{
RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) == true);
TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType);
FilePath = "C:/Some/Path/TestDocumentTracker.cshtml";
ProjectPath = "C:/Some/Path/TestProject.csproj";
ImportDocumentManager = Mock.Of <ImportDocumentManager>();
WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(Mock.Of <ForegroundDispatcher>(), Mock.Of <EditorSettingsManager>());
TagHelperResolver = new TestTagHelperResolver();
SomeTagHelpers = new List <TagHelperDescriptor>()
{
TagHelperDescriptorBuilder.Create("test", "test").Build(),
};
HostServices = TestServices.Create(
new IWorkspaceService[] { },
new ILanguageService[] { TagHelperResolver, });
Workspace = TestWorkspace.Create(HostServices, w =>
{
WorkspaceProject = w.AddProject(ProjectInfo.Create(
ProjectId.CreateNewId(),
new VersionStamp(),
"Test1",
"TestAssembly",
LanguageNames.CSharp,
filePath: ProjectPath));
});
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace)
{
AllowNotifyListeners = true
};
HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1);
OtherHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0);
DocumentTracker = new DefaultVisualStudioDocumentTracker(
Dispatcher,
FilePath,
ProjectPath,
ProjectManager,
WorkspaceEditorSettings,
Workspace,
TextBuffer,
ImportDocumentManager);
}
public ProjectSnapshotSynchronizationServiceTest()
{
var joinableTaskContext = new JoinableTaskContextNode(new JoinableTaskContext());
JoinableTaskFactory = new JoinableTaskFactory(joinableTaskContext.Context);
var collabSession = new TestCollaborationSession(isHost: false);
SessionAccessor = Mock.Of <LiveShareSessionAccessor>(accessor => accessor.IsGuestSessionActive == true && accessor.Session == collabSession);
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace);
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build()
});
}
public void Create_UnknownProjectPath_UsesLatest()
{
// Arrange
var projectManager = new TestProjectSnapshotManager(Workspace);
var factoryService = new DefaultProjectEngineFactoryService(projectManager);
// Act
var engine = factoryService.Create("/TestPath/DifferentPath/", b =>
{
b.Features.Add(new MyCoolNewFeature());
});
// Assert
Assert.Single(engine.Engine.Features.OfType <MyCoolNewFeature>());
Assert.Single(engine.Engine.Features.OfType <MvcLatest.MvcViewDocumentClassifierPass>());
Assert.Single(engine.Engine.Features.OfType <MvcLatest.ViewComponentTagHelperPass>());
}
public void UpdateProject_UpdatesProjectWorkspaceState()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
var hostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
projectManager.ProjectAdded(hostProject);
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectManager);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.LatestMajor);
// Act
projectService.UpdateProject(hostProject.FilePath, hostProject.Configuration, hostProject.RootNamespace, projectWorkspaceState, EmptyDocuments);
// Assert
var project = projectManager.GetLoadedProject(hostProject.FilePath);
Assert.Same(projectWorkspaceState, project.ProjectWorkspaceState);
}
public void DocumentAdded_IgnoresClosedDocument()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.ProjectAdded(HostProject1);
projectManager.ProjectAdded(HostProject2);
projectManager.AllowNotifyListeners = true;
var queue = new TestOpenDocumentGenerator(Dispatcher);
queue.Initialize(projectManager);
// Act & Assert
projectManager.DocumentAdded(HostProject1, Documents[0], null);
Assert.False(queue.IsScheduledOrRunning, "Queue should not be scheduled when a document is added for the first time (closed by default)");
}
public async Task GetStateAsync_CachesState()
{
// Arrange
var projectSnapshotManager = new TestProjectSnapshotManager(ProjectSnapshot1);
var proxy = new DefaultProjectSnapshotManagerProxy(
new TestCollaborationSession(true),
Dispatcher,
projectSnapshotManager,
JoinableTaskFactory);
// Act
var state1 = await JoinableTaskFactory.RunAsync(() => proxy.GetProjectManagerStateAsync(CancellationToken.None));
var state2 = await JoinableTaskFactory.RunAsync(() => proxy.GetProjectManagerStateAsync(CancellationToken.None));
// Assert
Assert.Same(state1, state2);
}
public async Task GetLatestProjectsAsync_ReturnsSnapshotManagerProjects()
{
// Arrange
var projectSnapshotManager = new TestProjectSnapshotManager(ProjectSnapshot1);
var proxy = new DefaultProjectSnapshotManagerProxy(
new TestCollaborationSession(true),
Dispatcher,
projectSnapshotManager,
JoinableTaskFactory);
// Act
var projects = await proxy.GetLatestProjectsAsync();
// Assert
var project = Assert.Single(projects);
Assert.Same(ProjectSnapshot1, project);
}
public DefaultVisualStudioDocumentTrackerTest()
{
RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) && c.IsOfType(RazorConstants.LegacyContentType), MockBehavior.Strict);
TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType, MockBehavior.Strict);
FilePath = TestProjectData.SomeProjectFile1.FilePath;
ProjectPath = TestProjectData.SomeProject.FilePath;
RootNamespace = TestProjectData.SomeProject.RootNamespace;
ImportDocumentManager = new Mock <ImportDocumentManager>(MockBehavior.Strict).Object;
Mock.Get(ImportDocumentManager).Setup(m => m.OnSubscribed(It.IsAny <VisualStudioDocumentTracker>())).Verifiable();
Mock.Get(ImportDocumentManager).Setup(m => m.OnUnsubscribed(It.IsAny <VisualStudioDocumentTracker>())).Verifiable();
var projectSnapshotManagerDispatcher = new Mock <ProjectSnapshotManagerDispatcher>(MockBehavior.Strict);
projectSnapshotManagerDispatcher.Setup(d => d.AssertDispatcherThread(It.IsAny <string>())).Verifiable();
WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(projectSnapshotManagerDispatcher.Object, Mock.Of <EditorSettingsManager>(MockBehavior.Strict));
SomeTagHelpers = new List <TagHelperDescriptor>()
{
TagHelperDescriptorBuilder.Create("test", "test").Build(),
};
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace)
{
AllowNotifyListeners = true
};
HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1, RootNamespace);
UpdatedHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0, RootNamespace);
OtherHostProject = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.AnotherProject.RootNamespace);
DocumentTracker = new DefaultVisualStudioDocumentTracker(
Dispatcher,
JoinableTaskFactory.Context,
FilePath,
ProjectPath,
ProjectManager,
WorkspaceEditorSettings,
Workspace,
TextBuffer,
ImportDocumentManager);
}
public void Enqueue_IgnoresClosedDocuments()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.ProjectAdded(HostProject1);
projectManager.DocumentAdded(HostProject1, Documents[0], null);
var project = projectManager.GetLoadedProject(HostProject1.FilePath);
var queue = new TestOpenDocumentGenerator(Dispatcher);
queue.Initialize(projectManager);
// Act & Assert
queue.Enqueue(project.GetDocument(Documents[0].FilePath));
Assert.False(queue.IsScheduledOrRunning, "Queue should not have anything pending");
}
public RazorDiagnosticsPublisherTest()
{
var testProjectManager = TestProjectSnapshotManager.Create(Dispatcher);
var hostProject = new HostProject("/C:/project/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
testProjectManager.ProjectAdded(hostProject);
var sourceText = SourceText.From(string.Empty);
var textAndVersion = TextAndVersion.Create(sourceText, VersionStamp.Default);
var openedHostDocument = new HostDocument("/C:/project/open_document.cshtml", "/C:/project/open_document.cshtml");
testProjectManager.DocumentAdded(hostProject, openedHostDocument, TextLoader.From(textAndVersion));
testProjectManager.DocumentOpened(hostProject.FilePath, openedHostDocument.FilePath, sourceText);
var closedHostDocument = new HostDocument("/C:/project/closed_document.cshtml", "/C:/project/closed_document.cshtml");
testProjectManager.DocumentAdded(hostProject, closedHostDocument, TextLoader.From(textAndVersion));
OpenedDocument = testProjectManager.Projects[0].GetDocument(openedHostDocument.FilePath);
ClosedDocument = testProjectManager.Projects[0].GetDocument(closedHostDocument.FilePath);
ProjectManager = testProjectManager;
}
public void Changed_NoopsIfProxyDisposed()
{
// Arrange
var projectSnapshotManager = new TestProjectSnapshotManager(ProjectSnapshot1);
var proxy = new DefaultProjectSnapshotManagerProxy(
new TestCollaborationSession(true),
Dispatcher,
projectSnapshotManager,
JoinableTaskFactory);
var changedArgs = new ProjectChangeEventArgs(ProjectSnapshot1, ProjectSnapshot1, ProjectChangeKind.ProjectChanged);
proxy.Changed += (sender, args) => throw new InvalidOperationException("Should not have been called.");
proxy.Dispose();
// Act
projectSnapshotManager.TriggerChanged(changedArgs);
// Assert
Assert.Null(proxy._processingChangedEventTestTask);
}
