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