public void SetOutput_AcceptsSameVersionedDocuments()
{
// Arrange
var services = TestWorkspace.Create().Services;
var hostProject = new HostProject("C:/project.csproj", RazorConfiguration.Default);
var projectState = ProjectState.Create(services, hostProject);
var project = new DefaultProjectSnapshot(projectState);
var text = SourceText.From("...");
var textAndVersion = TextAndVersion.Create(text, VersionStamp.Default);
var hostDocument = new HostDocument("C:/file.cshtml", "C:/file.cshtml");
var documentState = new DocumentState(services, hostDocument, text, VersionStamp.Default, () => Task.FromResult(textAndVersion));
var document = new DefaultDocumentSnapshot(project, documentState);
var newDocument = new DefaultDocumentSnapshot(project, documentState);
var csharpDocument = RazorCSharpDocument.Create("...", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
var version = VersionStamp.Create();
var container = new GeneratedCodeContainer();
container.SetOutput(document, csharpDocument, version, version);
// Act
container.SetOutput(newDocument, csharpDocument, version, version);
// Assert
Assert.Same(newDocument, container.LatestDocument);
}
public ProjectState WithHostProject(HostProject hostProject)
{
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
if (HostProject.Configuration.Equals(hostProject.Configuration))
{
return(this);
}
var documents = Documents.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.WithConfigurationChange(), FilePathComparer.Instance);
// If the host project has changed then we need to recompute the imports map
var importsToRelatedDocuments = EmptyImportsToRelatedDocuments;
foreach (var document in documents)
{
var importTargetPaths = GetImportDocumentTargetPaths(document.Value.HostDocument);
importsToRelatedDocuments = AddToImportsToRelatedDocuments(importsToRelatedDocuments, document.Value.HostDocument, importTargetPaths);
}
var state = new ProjectState(this, ProjectDifference.ConfigurationChanged, hostProject, ProjectWorkspaceState, documents, importsToRelatedDocuments);
return(state);
}
public BackgroundDocumentGeneratorTest()
{
Documents = new HostDocument[]
{
new HostDocument("c:\\Test1\\Index.cshtml", "Index.cshtml"),
new HostDocument("c:\\Test1\\Components\\Counter.cshtml", "Components\\Counter.cshtml"),
};
HostProject1 = new HostProject("c:\\Test1\\Test1.csproj", FallbackRazorConfiguration.MVC_1_0);
HostProject2 = new HostProject("c:\\Test2\\Test2.csproj", FallbackRazorConfiguration.MVC_1_0);
Workspace = TestWorkspace.Create();
var projectId1 = ProjectId.CreateNewId("Test1");
var projectId2 = ProjectId.CreateNewId("Test2");
var solution = Workspace.CurrentSolution
.AddProject(ProjectInfo.Create(
projectId1,
VersionStamp.Default,
"Test1",
"Test1",
LanguageNames.CSharp,
"c:\\Test1\\Test1.csproj"))
.AddProject(ProjectInfo.Create(
projectId2,
VersionStamp.Default,
"Test2",
"Test2",
LanguageNames.CSharp,
"c:\\Test2\\Test2.csproj"));;
WorkspaceProject1 = solution.GetProject(projectId1);
WorkspaceProject2 = solution.GetProject(projectId2);
}
public void HostProjectChanged_WithWorkspaceProject_RetainsComputedState_NotifiesListeners_AndStartsBackgroundWorker()
{
// Arrange
ProjectManager.HostProjectAdded(HostProject);
ProjectManager.WorkspaceProjectAdded(WorkspaceProject);
ProjectManager.Reset();
// Adding some computed state
var snapshot = ProjectManager.GetSnapshot(HostProject);
var updateContext = snapshot.CreateUpdateContext();
ProjectManager.ProjectUpdated(updateContext);
ProjectManager.Reset();
var project = new HostProject(HostProject.FilePath, FallbackRazorConfiguration.MVC_1_0); // Simulate a project change
// Act
ProjectManager.HostProjectChanged(project);
// Assert
snapshot = ProjectManager.GetSnapshot(project);
Assert.True(snapshot.IsDirty);
Assert.True(snapshot.IsInitialized);
Assert.True(ProjectManager.ListenersNotified);
Assert.True(ProjectManager.WorkerStarted);
}
public void ProjectUpdated_WhenHostProjectChanged_StillDirty_WithSignificantChanges_NotifiesListeners_AndStartsBackgroundWorker()
{
// Arrange
ProjectManager.HostProjectAdded(HostProject);
ProjectManager.WorkspaceProjectAdded(WorkspaceProject);
ProjectManager.Reset();
// Generate the update
var snapshot = ProjectManager.GetSnapshot(HostProject);
var updateContext = snapshot.CreateUpdateContext();
var project = new HostProject(HostProject.FilePath, FallbackRazorConfiguration.MVC_1_0); // Simulate a project change
ProjectManager.HostProjectChanged(project);
ProjectManager.Reset();
// Act
ProjectManager.ProjectUpdated(updateContext);
// Assert
snapshot = ProjectManager.GetSnapshot(project);
Assert.True(snapshot.IsDirty);
Assert.True(ProjectManager.ListenersNotified);
Assert.True(ProjectManager.WorkerStarted);
}
public BackgroundDocumentGeneratorTest()
{
Documents = new HostDocument[]
{
TestProjectData.SomeProjectFile1,
TestProjectData.AnotherProjectFile1,
};
HostProject1 = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0);
HostProject2 = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_1_0);
var projectId1 = ProjectId.CreateNewId("Test1");
var projectId2 = ProjectId.CreateNewId("Test2");
var solution = Workspace.CurrentSolution
.AddProject(ProjectInfo.Create(
projectId1,
VersionStamp.Default,
"Test1",
"Test1",
LanguageNames.CSharp,
TestProjectData.SomeProject.FilePath))
.AddProject(ProjectInfo.Create(
projectId2,
VersionStamp.Default,
"Test2",
"Test2",
LanguageNames.CSharp,
TestProjectData.AnotherProject.FilePath));;
WorkspaceProject1 = solution.GetProject(projectId1);
WorkspaceProject2 = solution.GetProject(projectId2);
DynamicFileInfoProvider = new RazorDynamicFileInfoProvider(new DefaultDocumentServiceProviderFactory());
}
public async Task ProjectWorkspaceStateChange_WithProjectWorkspaceState_CSharpLanguageVersionChange_DoesNotCacheOutput()
{
// Arrange
var csharp8ValidConfiguration = RazorConfiguration.Create(RazorLanguageVersion.Version_3_0, HostProject.Configuration.ConfigurationName, HostProject.Configuration.Extensions);
var hostProject = new HostProject(TestProjectData.SomeProject.FilePath, csharp8ValidConfiguration, TestProjectData.SomeProject.RootNamespace);
var originalWorkspaceState = new ProjectWorkspaceState(SomeTagHelpers, LanguageVersion.CSharp7);
var original =
ProjectState.Create(Workspace.Services, hostProject, originalWorkspaceState)
.WithAddedHostDocument(HostDocument, () => Task.FromResult(TextAndVersion.Create(SourceText.From("@DateTime.Now"), VersionStamp.Default)));
var changedWorkspaceState = new ProjectWorkspaceState(SomeTagHelpers, LanguageVersion.CSharp8);
var(originalOutput, originalInputVersion, originalCSharpOutputVersion, originalHtmlOutputVersion) = await GetOutputAsync(original, HostDocument);
// Act
var state = original.WithProjectWorkspaceState(changedWorkspaceState);
// Assert
var(actualOutput, actualInputVersion, actualCSharpOutputVersion, actualHtmlOutputVersion) = await GetOutputAsync(state, HostDocument);
Assert.NotSame(originalOutput, actualOutput);
Assert.NotEqual(originalInputVersion, actualInputVersion);
Assert.NotEqual(originalCSharpOutputVersion, actualCSharpOutputVersion);
Assert.Equal(originalHtmlOutputVersion, actualHtmlOutputVersion);
Assert.Equal(state.ProjectWorkspaceStateVersion, actualInputVersion);
}
// Must be called inside the lock.
protected async Task UpdateProjectUnsafeAsync(HostProject project)
{
await CommonServices.ThreadingService.SwitchToUIThread();
var projectManager = GetProjectManager();
if (_current == null && project == null)
{
// This is a no-op. This project isn't using Razor.
}
else if (_current == null && project != null)
{
projectManager.HostProjectAdded(project);
}
else if (_current != null && project == null)
{
projectManager.HostProjectRemoved(_current);
}
else
{
projectManager.HostProjectChanged(project);
}
_current = project;
}
public DocumentStateTest()
{
TagHelperResolver = new TestTagHelperResolver();
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0);
HostProjectWithConfigurationChange = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0);
var projectId = ProjectId.CreateNewId("Test");
var solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create(
projectId,
VersionStamp.Default,
"Test",
"Test",
LanguageNames.CSharp,
TestProjectData.SomeProject.FilePath));
WorkspaceProject = solution.GetProject(projectId);
SomeTagHelpers = new List <TagHelperDescriptor>();
SomeTagHelpers.Add(TagHelperDescriptorBuilder.Create("Test1", "TestAssembly").Build());
HostDocument = TestProjectData.SomeProjectFile1;
Text = SourceText.From("Hello, world!");
TextLoader = () => Task.FromResult(TextAndVersion.Create(Text, VersionStamp.Create()));
}
public DefaultProjectSnapshotTest()
{
TagHelperResolver = new TestTagHelperResolver();
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0);
HostProjectWithConfigurationChange = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0);
ProjectWorkspaceState = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build(),
});
SomeTagHelpers = new List <TagHelperDescriptor>
{
TagHelperDescriptorBuilder.Create("Test1", "TestAssembly").Build()
};
Documents = new HostDocument[]
{
TestProjectData.SomeProjectFile1,
TestProjectData.SomeProjectFile2,
// linked file
TestProjectData.AnotherProjectNestedFile3,
};
}
public DefaultProjectSnapshotManagerTest()
{
TagHelperResolver = new TestTagHelperResolver();
Documents = new HostDocument[]
{
TestProjectData.SomeProjectFile1,
TestProjectData.SomeProjectFile2,
// linked file
TestProjectData.AnotherProjectNestedFile3,
TestProjectData.SomeProjectComponentFile1,
TestProjectData.SomeProjectComponentFile2,
};
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.SomeProject.RootNamespace);
HostProjectWithConfigurationChange = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.SomeProject.RootNamespace);
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Enumerable.Empty <ProjectSnapshotChangeTrigger>(), Workspace);
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(TagHelperResolver.TagHelpers, default);
SourceText = SourceText.From("Hello world");
}
public override void DocumentAdded(HostProject hostProject, HostDocument document, TextLoader textLoader)
{
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
_foregroundDispatcher.AssertForegroundThread();
if (_projects.TryGetValue(hostProject.FilePath, out var entry))
{
var loader = textLoader == null ? DocumentState.EmptyLoader : (Func <Task <TextAndVersion> >)(() =>
{
return(textLoader.LoadTextAndVersionAsync(Workspace, null, CancellationToken.None));
});
var state = entry.State.WithAddedHostDocument(document, loader);
// Document updates can no-op.
if (!object.ReferenceEquals(state, entry.State))
{
var oldSnapshot = entry.GetSnapshot();
entry = new Entry(state);
_projects[hostProject.FilePath] = entry;
NotifyListeners(new ProjectChangeEventArgs(oldSnapshot, entry.GetSnapshot(), document.FilePath, ProjectChangeKind.DocumentAdded));
}
}
}
public DefaultRazorDocumentInfoProviderTest()
{
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace);
var hostProject = new HostProject("C:/path/to/project.csproj", RazorConfiguration.Default, "RootNamespace");
ProjectSnapshotManager.ProjectAdded(hostProject);
var hostDocument = new HostDocument("C:/path/to/document.cshtml", "/C:/path/to/document.cshtml");
var sourceText = SourceText.From("Hello World");
var textAndVersion = TextAndVersion.Create(sourceText, VersionStamp.Default, hostDocument.FilePath);
ProjectSnapshotManager.DocumentAdded(hostProject, hostDocument, TextLoader.From(textAndVersion));
ProjectSnapshot = ProjectSnapshotManager.Projects[0];
DocumentSnapshot = ProjectSnapshot.GetDocument(hostDocument.FilePath);
var factory = new Mock <VisualStudioMacDocumentInfoFactory>();
factory.Setup(f => f.CreateEmpty(It.IsAny <string>(), It.IsAny <ProjectId>()))
.Returns <string, ProjectId>((razorFilePath, projectId) =>
{
var documentId = DocumentId.CreateNewId(projectId);
var documentInfo = DocumentInfo.Create(documentId, "testDoc", filePath: razorFilePath);
return(documentInfo);
});
Factory = factory.Object;
}
public override void DocumentRemoved(HostProject hostProject, HostDocument document)
{
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
_foregroundDispatcher.AssertForegroundThread();
if (_projects.TryGetValue(hostProject.FilePath, out var entry))
{
var state = entry.State.WithRemovedHostDocument(document);
// Document updates can no-op.
if (!object.ReferenceEquals(state, entry.State))
{
var oldSnapshot = entry.GetSnapshot();
entry = new Entry(state);
_projects[hostProject.FilePath] = entry;
NotifyListeners(new ProjectChangeEventArgs(oldSnapshot, entry.GetSnapshot(), document.FilePath, ProjectChangeKind.DocumentRemoved));
}
}
}
protected void UpdateProjectUnsafe(HostProject project)
{
var projectManager = GetProjectManager();
if (Current is null && project is null)
{
// This is a no-op. This project isn't using Razor.
}
public DefaultProjectSnapshot WithHostProject(HostProject hostProject)
{
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
return(new DefaultProjectSnapshot(hostProject, this));
}
// Internal for testing
internal async Task OnProjectChanged(IProjectVersionedValue <IProjectSubscriptionUpdate> update)
{
if (IsDisposing || IsDisposed)
{
return;
}
await CommonServices.TasksService.LoadedProjectAsync(async() =>
{
await ExecuteWithLock(async() =>
{
if (TryGetConfiguration(update.Value.CurrentState, out var configuration))
{
TryGetRootNamespace(update.Value.CurrentState, out var rootNamespace);
// We need to deal with the case where the project was uninitialized, but now
// is valid for Razor. In that case we might have previously seen all of the documents
// but ignored them because the project wasn't active.
//
// So what we do to deal with this, is that we 'remove' all changed and removed items
// and then we 'add' all current items. This allows minimal churn to the PSM, but still
// makes us up to date.
var documents = GetCurrentDocuments(update.Value);
var changedDocuments = GetChangedAndRemovedDocuments(update.Value);
await UpdateAsync(() =>
{
var hostProject = new HostProject(CommonServices.UnconfiguredProject.FullPath, configuration, rootNamespace);
if (TryGetIntermediateOutputPath(update.Value.CurrentState, out var intermediatePath))
{
var projectRazorJson = Path.Combine(intermediatePath, "project.razor.json");
_razorProjectChangePublisher.SetPublishFilePath(hostProject.FilePath, projectRazorJson);
}
UpdateProjectUnsafe(hostProject);
for (var i = 0; i < changedDocuments.Length; i++)
{
RemoveDocumentUnsafe(changedDocuments[i]);
}
for (var i = 0; i < documents.Length; i++)
{
AddDocumentUnsafe(documents[i]);
}
}).ConfigureAwait(false);
}
else
{
// Ok we can't find a configuration. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe).ConfigureAwait(false);
}
}).ConfigureAwait(false);
}, registerFaultHandler : true);
}
public WorkspaceProjectStateChangeDetectorTest()
{
EmptySolution = Workspace.CurrentSolution.GetIsolatedSolution();
var projectId1 = ProjectId.CreateNewId("One");
var projectId2 = ProjectId.CreateNewId("Two");
var projectId3 = ProjectId.CreateNewId("Three");
CshtmlDocumentId = DocumentId.CreateNewId(projectId1);
var cshtmlDocumentInfo = DocumentInfo.Create(CshtmlDocumentId, "Test", filePath: "file.cshtml.g.cs");
RazorDocumentId = DocumentId.CreateNewId(projectId1);
var razorDocumentInfo = DocumentInfo.Create(RazorDocumentId, "Test", filePath: "file.razor.g.cs");
BackgroundVirtualCSharpDocumentId = DocumentId.CreateNewId(projectId1);
var backgroundDocumentInfo = DocumentInfo.Create(BackgroundVirtualCSharpDocumentId, "Test", filePath: "file.razor__bg__virtual.cs");
PartialComponentClassDocumentId = DocumentId.CreateNewId(projectId1);
var partialComponentClassDocumentInfo = DocumentInfo.Create(PartialComponentClassDocumentId, "Test", filePath: "file.razor.cs");
SolutionWithTwoProjects = Workspace.CurrentSolution
.AddProject(ProjectInfo.Create(
projectId1,
VersionStamp.Default,
"One",
"One",
LanguageNames.CSharp,
filePath: "One.csproj",
documents: new[] { cshtmlDocumentInfo, razorDocumentInfo, partialComponentClassDocumentInfo, backgroundDocumentInfo }))
.AddProject(ProjectInfo.Create(
projectId2,
VersionStamp.Default,
"Two",
"Two",
LanguageNames.CSharp,
filePath: "Two.csproj"));
SolutionWithOneProject = EmptySolution.GetIsolatedSolution()
.AddProject(ProjectInfo.Create(
projectId3,
VersionStamp.Default,
"Three",
"Three",
LanguageNames.CSharp,
filePath: "Three.csproj"));
ProjectNumberOne = SolutionWithTwoProjects.GetProject(projectId1);
ProjectNumberTwo = SolutionWithTwoProjects.GetProject(projectId2);
ProjectNumberThree = SolutionWithOneProject.GetProject(projectId3);
HostProjectOne = new HostProject("One.csproj", FallbackRazorConfiguration.MVC_1_1, "One");
HostProjectTwo = new HostProject("Two.csproj", FallbackRazorConfiguration.MVC_1_1, "Two");
HostProjectThree = new HostProject("Three.csproj", FallbackRazorConfiguration.MVC_1_1, "Three");
}
public override void ReportError(Exception exception, HostProject hostProject)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
var snapshot = hostProject?.FilePath == null ? null : GetLoadedProject(hostProject.FilePath);
_errorReporter.ReportError(exception, snapshot);
}
public override void ReportError(Exception exception, HostProject hostProject)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
var project = hostProject?.FilePath == null ? null : this.GetProjectWithFilePath(hostProject.FilePath);
_errorReporter.ReportError(exception, project);
}
// Internal for testing
internal async Task OnProjectChanged(IProjectVersionedValue <IProjectSubscriptionUpdate> update)
{
if (IsDisposing || IsDisposed)
{
return;
}
await CommonServices.TasksService.LoadedProjectAsync(async() =>
{
await ExecuteWithLock(async() =>
{
var languageVersion = update.Value.CurrentState[Rules.RazorGeneral.SchemaName].Properties[Rules.RazorGeneral.RazorLangVersionProperty];
var defaultConfiguration = update.Value.CurrentState[Rules.RazorGeneral.SchemaName].Properties[Rules.RazorGeneral.RazorDefaultConfigurationProperty];
RazorConfiguration configuration = null;
if (!string.IsNullOrEmpty(languageVersion) && !string.IsNullOrEmpty(defaultConfiguration))
{
if (!RazorLanguageVersion.TryParse(languageVersion, out var parsedVersion))
{
parsedVersion = RazorLanguageVersion.Latest;
}
var extensions = update.Value.CurrentState[Rules.RazorExtension.PrimaryDataSourceItemType].Items.Select(e =>
{
return(new ProjectSystemRazorExtension(e.Key));
}).ToArray();
var configurations = update.Value.CurrentState[Rules.RazorConfiguration.PrimaryDataSourceItemType].Items.Select(c =>
{
var includedExtensions = c.Value[Rules.RazorConfiguration.ExtensionsProperty]
.Split(';')
.Select(name => extensions.Where(e => e.ExtensionName == name).FirstOrDefault())
.Where(e => e != null)
.ToArray();
return(new ProjectSystemRazorConfiguration(parsedVersion, c.Key, includedExtensions));
}).ToArray();
configuration = configurations.Where(c => c.ConfigurationName == defaultConfiguration).FirstOrDefault();
}
if (configuration == null)
{
// Ok we can't find a language version. Let's assume this project isn't using Razor then.
await UpdateProjectUnsafeAsync(null).ConfigureAwait(false);
return;
}
var hostProject = new HostProject(CommonServices.UnconfiguredProject.FullPath, configuration);
await UpdateProjectUnsafeAsync(hostProject).ConfigureAwait(false);
});
}, registerFaultHandler : true);
}
protected void UpdateProjectUnsafe(HostProject project)
{
var projectManager = GetProjectManager();
if (_current == null && project == null)
{
// This is a no-op. This project isn't using Razor.
}
else if (_current == null && project != null)
{
// This is temporary code for initializing the companion project. We expect
// this to be provided by the Managed Project System in the near future.
var projectContextFactory = GetProjectContextFactory();
if (projectContextFactory != null)
{
var assembly = Assembly.Load("Microsoft.VisualStudio.ProjectSystem.Managed, Version=2.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
var type = assembly.GetType("Microsoft.VisualStudio.ProjectSystem.LanguageServices.IProjectHostProvider");
var exportProviderType = CommonServices.UnconfiguredProject.Services.ExportProvider.GetType();
var method = exportProviderType.GetMethod(nameof(ExportProvider.GetExportedValue), Array.Empty <Type>()).MakeGenericMethod(type);
var export = method.Invoke(CommonServices.UnconfiguredProject.Services.ExportProvider, Array.Empty <object>());
var host = new IProjectHostProvider(export);
var displayName = Path.GetFileNameWithoutExtension(CommonServices.UnconfiguredProject.FullPath) + " (Razor)";
_projectContext = projectContextFactory.CreateProjectContext(
LanguageNames.CSharp,
displayName,
CommonServices.UnconfiguredProject.FullPath,
Guid.NewGuid(),
host.UnconfiguredProjectHostObject.ActiveIntellisenseProjectHostObject,
null,
null);
}
// END temporary code
projectManager.HostProjectAdded(project);
}
else if (_current != null && project == null)
{
Debug.Assert(_currentDocuments.Count == 0);
projectManager.HostProjectRemoved(_current);
_projectContext?.Dispose();
_projectContext = null;
}
else
{
projectManager.HostProjectChanged(project);
}
_current = project;
}
private ProjectState(
HostWorkspaceServices services,
HostProject hostProject,
Project workspaceProject)
{
Services = services;
HostProject = hostProject;
WorkspaceProject = workspaceProject;
Documents = EmptyDocuments;
Version = VersionStamp.Create();
_lock = new object();
}
public ProjectStateGeneratedOutputTest()
{
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.SomeProject.RootNamespace);
HostProjectWithConfigurationChange = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.SomeProject.RootNamespace);
SomeTagHelpers = new List <TagHelperDescriptor>();
SomeTagHelpers.Add(TagHelperDescriptorBuilder.Create("Test1", "TestAssembly").Build());
HostDocument = TestProjectData.SomeProjectFile1;
Text = SourceText.From("Hello, world!");
TextLoader = () => Task.FromResult(TextAndVersion.Create(Text, VersionStamp.Create()));
}
public DefaultProjectSnapshot(HostProject hostProject, Project workspaceProject, VersionStamp?version = null)
{
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
HostProject = hostProject;
WorkspaceProject = workspaceProject; // Might be null
FilePath = hostProject.FilePath;
Version = version ?? VersionStamp.Default;
}
public BackgroundDocumentGeneratorTest()
{
Documents = new HostDocument[]
{
TestProjectData.SomeProjectFile1,
TestProjectData.AnotherProjectFile1,
};
HostProject1 = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.SomeProject.RootNamespace);
HostProject2 = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.AnotherProject.RootNamespace);
DynamicFileInfoProvider = new RazorDynamicFileInfoProvider(new DefaultDocumentServiceProviderFactory());
}
public DefaultProjectSnapshotManagerTest()
{
HostProject = new HostProject("Test.csproj", FallbackRazorConfiguration.MVC_2_0);
Workspace = TestWorkspace.Create();
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Enumerable.Empty <ProjectSnapshotChangeTrigger>(), Workspace);
var projectId = ProjectId.CreateNewId("Test");
var solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create(
projectId,
VersionStamp.Default,
"Test",
"Test",
LanguageNames.CSharp,
"Test.csproj"));
WorkspaceProject = solution.GetProject(projectId);
var vbProjectId = ProjectId.CreateNewId("VB");
solution = solution.AddProject(ProjectInfo.Create(
vbProjectId,
VersionStamp.Default,
"VB",
"VB",
LanguageNames.VisualBasic,
"VB.vbproj"));
VBWorkspaceProject = solution.GetProject(vbProjectId);
var projectWithoutFilePathId = ProjectId.CreateNewId("NoFile");
solution = solution.AddProject(ProjectInfo.Create(
projectWithoutFilePathId,
VersionStamp.Default,
"NoFile",
"NoFile",
LanguageNames.CSharp));
WorkspaceProjectWithoutFilePath = solution.GetProject(projectWithoutFilePathId);
// Approximates a project with multi-targeting
var projectIdWithDifferentTfm = ProjectId.CreateNewId("TestWithDifferentTfm");
solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create(
projectIdWithDifferentTfm,
VersionStamp.Default,
"Test (Different TFM)",
"Test",
LanguageNames.CSharp,
"Test.csproj"));
WorkspaceProjectWithDifferentTfm = solution.GetProject(projectIdWithDifferentTfm);
}
public static ProjectState Create(HostWorkspaceServices services, HostProject hostProject, Project workspaceProject = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (hostProject == null)
{
throw new ArgumentNullException(nameof(hostProject));
}
return(new ProjectState(services, hostProject, workspaceProject));
}
// Internal for testing
internal async Task OnProjectChanged(IProjectVersionedValue <IProjectSubscriptionUpdate> update)
{
if (IsDisposing || IsDisposed)
{
return;
}
await CommonServices.TasksService.LoadedProjectAsync(async() =>
{
await ExecuteWithLock(async() =>
{
string mvcReferenceFullPath = null;
if (update.Value.CurrentState.ContainsKey(ResolvedCompilationReference.SchemaName))
{
var references = update.Value.CurrentState[ResolvedCompilationReference.SchemaName].Items;
foreach (var reference in references)
{
if (reference.Key.EndsWith(MvcAssemblyFileName, StringComparison.OrdinalIgnoreCase))
{
mvcReferenceFullPath = reference.Key;
break;
}
}
}
if (mvcReferenceFullPath == null)
{
// Ok we can't find an MVC version. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe).ConfigureAwait(false);
return;
}
var version = GetAssemblyVersion(mvcReferenceFullPath);
if (version == null)
{
// Ok we can't find an MVC version. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe).ConfigureAwait(false);
return;
}
var configuration = FallbackRazorConfiguration.SelectConfiguration(version);
var hostProject = new HostProject(CommonServices.UnconfiguredProject.FullPath, configuration);
await UpdateAsync(() =>
{
UpdateProjectUnsafe(hostProject);
}).ConfigureAwait(false);
});
}, registerFaultHandler : true);
}
private ProjectState(
HostWorkspaceServices services,
HostProject hostProject,
ProjectWorkspaceState projectWorkspaceState)
{
Services = services;
HostProject = hostProject;
ProjectWorkspaceState = projectWorkspaceState;
Documents = EmptyDocuments;
ImportsToRelatedDocuments = EmptyImportsToRelatedDocuments;
Version = VersionStamp.Create();
DocumentCollectionVersion = Version;
_lock = new object();
}
