private EditProjectFileCommand CreateInstance(
UnconfiguredProject unconfiguredProject = null,
bool implementCapabilities = true,
IMsBuildAccessor msbuildAccessor = null,
IFileSystem fileSystem = null,
ITextDocumentFactoryService textDocumentService = null,
IVsEditorAdaptersFactoryService editorAdapterService = null,
IProjectThreadingService threadingService = null,
IVsShellUtilitiesHelper shellUtilities = null
)
{
UnitTestHelper.IsRunningUnitTests = true;
var uProj = unconfiguredProject ?? IUnconfiguredProjectFactory.Create();
var capabilities = IProjectCapabilitiesServiceFactory.ImplementsContains(CapabilityChecker(implementCapabilities));
var msbuild = msbuildAccessor ?? IMsBuildAccessorFactory.Create();
var fs = fileSystem ?? new IFileSystemMock();
var tds = textDocumentService ?? ITextDocumentFactoryServiceFactory.Create();
var eas = editorAdapterService ?? IVsEditorAdaptersFactoryServiceFactory.Create();
var threadServ = threadingService ?? IProjectThreadingServiceFactory.Create();
var shellUt = shellUtilities ?? new TestShellUtilitiesHelper(
(sp, path) => Tuple.Create(IVsHierarchyFactory.Create(), (uint)1, IVsPersistDocDataFactory.Create(), (uint)1),
(sp, path, edType, logView) => IVsWindowFrameFactory.Create());
return(new EditProjectFileCommand(uProj, capabilities, IServiceProviderFactory.Create(), msbuild, fs, tds, eas, threadServ, shellUt));
}
public async Task ShowProjectDesignerAsync_WhenWindowShowReturnsHResult_Throws()
{
Guid editorGuid = Guid.NewGuid();
var hierarchy = IVsHierarchyFactory.Create();
hierarchy.ImplementGetProperty(VsHierarchyPropID.SupportsProjectDesigner, result: true);
hierarchy.ImplementGetGuid(VsHierarchyPropID.ProjectDesignerEditor, result: editorGuid);
var project = (IVsProject4)hierarchy;
var frame = IVsWindowFrameFactory.ImplementShow(() => VSConstants.E_FAIL);
project.ImplementOpenItemWithSpecific(editorGuid, VSConstants.LOGVIEWID_Primary, frame);
var projectVsServices = IUnconfiguredProjectVsServicesFactory.Implement(() => hierarchy, () => project);
var designerService = CreateInstance(projectVsServices);
#pragma warning disable RS0003 // Do not directly await a Task (see https://github.com/dotnet/roslyn/issues/6770)
await Assert.ThrowsAsync <COMException>(() => {
return(designerService.ShowProjectDesignerAsync());
});
#pragma warning restore RS0003 // Do not directly await a Task
}
public async Task AbstractEditProjectFileCommand_NonSaveAction_DoesNotOverwriteProjectFile(FileActionTypes actionType)
{
var projectPath = $"C:\\Project1\\Project1.{EditProjectFileCommand.Extension}";
var tempFile = "C:\\Temp\\asdf.xyz";
var tempProjFile = $"{tempFile}.{EditProjectFileCommand.Extension}";
var expectedCaption = $"Project1.{EditProjectFileCommand.Extension}";
var projectXml = @"<Project></Project>";
var fileSystem = new IFileSystemMock();
var textDoc = ITextDocumentFactory.Create();
var frame = IVsWindowFrameFactory.ImplementShowAndSetProperty(VSConstants.S_OK, (prop, obj) => VSConstants.S_OK);
var command = SetupScenario(projectXml, tempFile, tempProjFile, projectPath, expectedCaption, fileSystem, textDoc, frame);
var tree = ProjectTreeParser.Parse(@"
Root (flags: {ProjectRoot})
");
var nodes = ImmutableHashSet.Create(tree);
// Verify the frame was setup correctly
Assert.True(await command.TryHandleCommandAsync(nodes, CommandId, true, 0, IntPtr.Zero, IntPtr.Zero));
var args = new TextDocumentFileActionEventArgs(tempProjFile, DateTime.Now, actionType);
Mock.Get(textDoc).Raise(t => t.FileActionOccurred += null, args);
Assert.False(fileSystem.FileExists(projectPath));
}
public async Task ShowProjectDesignerAsync_WhenOpenedInInternalEditor_ShowsWindow()
{
Guid editorGuid = Guid.NewGuid();
var hierarchy = IVsHierarchyFactory.Create();
hierarchy.ImplementGetProperty(VsHierarchyPropID.SupportsProjectDesigner, result: true);
hierarchy.ImplementGetGuid(VsHierarchyPropID.ProjectDesignerEditor, result: editorGuid);
var project = (IVsProject4)hierarchy;
int callCount = 0;
var frame = IVsWindowFrameFactory.ImplementShow(() => { callCount++; return(0); });
project.ImplementOpenItemWithSpecific(editorGuid, VSConstants.LOGVIEWID_Primary, frame);
var projectVsServices = IUnconfiguredProjectVsServicesFactory.Implement(() => hierarchy, () => project);
var designerService = CreateInstance(projectVsServices);
#pragma warning disable RS0003 // Do not directly await a Task (see https://github.com/dotnet/roslyn/issues/6770)
await designerService.ShowProjectDesignerAsync();
#pragma warning restore RS0003 // Do not directly await a Task
Assert.Equal(1, callCount);
}
public async Task ProjectFileEditorPresenter_SaveProjectFile_OnlySavesInEditorOpen(int state)
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.Create();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var threadingService = IProjectThreadingServiceFactory.Create();
var editorState = new ProjectFileEditorPresenterTester(
threadingService,
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory)
{
CurrentState = (ProjectFileEditorPresenter.EditorState)state
};
// When SaveAsync is called, we should hit an assert in the NoEditor case.
bool assertHit = false;
try
{
await editorState.SaveProjectFileAsync();
}
catch (InvalidOperationException)
{
assertHit = true;
}
Assert.True(state != (int)ProjectFileEditorPresenter.EditorState.NoEditor || assertHit);
var textBufferMock = Mock.Get(textBufferManager);
textBufferMock.Verify(t => t.SetReadOnlyAsync(It.IsAny <bool>()), Times.Never);
textBufferMock.Verify(t => t.SaveAsync(), Times.Never);
}
public async Task ProjectFileEditorPresenter_UpdateProjectFile_SchedulesUpdate()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.Create();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var threadingService = IProjectThreadingServiceFactory.Create();
var editorState = new ProjectFileEditorPresenterTester(
threadingService,
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
// Implement ResetBuffer so we can verify that the editor is in BufferUpdateScheduled when calling ResetBuffer. While here,
// verify that the buffer was set to readonly before reset was called
var textBufferMock = Mock.Get(textBufferManager);
textBufferMock.Setup(t => t.ResetBufferAsync()).Callback(() =>
{
Assert.Equal(ProjectFileEditorPresenter.EditorState.BufferUpdateScheduled, editorState.CurrentState);
textBufferMock.Verify(t => t.SetReadOnlyAsync(true), Times.Once);
}).Returns(Task.CompletedTask);
await editorState.OpenEditorAsync();
var jt = editorState.ScheduleProjectFileUpdate();
// Ensure the update actually runs
await jt.JoinAsync();
textBufferMock.Verify(t => t.SetReadOnlyAsync(true), Times.Once);
textBufferMock.Verify(t => t.ResetBufferAsync(), Times.Once);
textBufferMock.Verify(t => t.SetReadOnlyAsync(false), Times.Once);
}
public async Task ProjectFileEditorPresenter_SaveProjectFile_SavesFile()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.Create();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var threadingService = IProjectThreadingServiceFactory.Create();
var editorState = new ProjectFileEditorPresenterTester(
threadingService,
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
var textBufferMock = Mock.Get(textBufferManager);
// Implement textBufferManager.SaveAsync to verify the editor is in WritingProjectFile while saving
textBufferMock.Setup(t => t.SaveAsync()).Callback(() =>
{
Assert.Equal(ProjectFileEditorPresenter.EditorState.WritingProjectFile, editorState.CurrentState);
textBufferMock.Verify(t => t.SetReadOnlyAsync(true), Times.Once);
}).Returns(Task.CompletedTask);
await editorState.OpenEditorAsync();
await editorState.SaveProjectFileAsync();
textBufferMock.Verify(t => t.SetReadOnlyAsync(true), Times.Once);
textBufferMock.Verify(t => t.SaveAsync(), Times.Once);
textBufferMock.Verify(t => t.SetReadOnlyAsync(false), Times.Once);
}
public async Task ProjectFileEditorPresenter_DisposeWithOpen_DisposesListeners()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.ImplementCloseFrame(options =>
{
Assert.Equal((uint)__FRAMECLOSE.FRAMECLOSE_PromptSave, options);
return(VSConstants.S_OK);
});
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
// Mock dispose for one of the listeners so it can verify the editor is actually in EditorClosing
Mock.Get(textBufferListener).Setup(t => t.Dispose()).Callback(() =>
Assert.Equal(ProjectFileEditorPresenter.EditorState.EditorClosing, editorState.CurrentState));
await editorState.OpenEditorAsync();
await editorState.CloseCurrentEditorAsync();
Mock.Get(textBufferManager).Verify(t => t.Dispose(), Times.Once);
Mock.Get(textBufferListener).Verify(t => t.Dispose(), Times.Once);
Mock.Get(frameListener).Verify(f => f.DisposeAsync(), Times.Once);
Mock.Get(projectFileWatcher).Verify(p => p.Dispose(), Times.Once);
Assert.Equal(ProjectFileEditorPresenter.EditorState.NoEditor, editorState.CurrentState);
}
public async Task FrameOpenCloseListener_InitializeEventsAsync_SetsUpWindowFrameEvents()
{
var uiShell = IVsUIShell7Factory.ImplementAdviseWindowEvents(l => 1);
uint eventsCookie = 2;
var solution = IVsSolutionFactory.CreateWithAdviseUnadviseSolutionEvents(eventsCookie);
var serviceProvider = IServiceProviderFactory.ImplementGetService(ServiceTypeChecker(uiShell, solution));
var listener = new FrameOpenCloseListener(serviceProvider,
IProjectFileEditorPresenterFactory.Create(),
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create());
await listener.InitializeEventsAsync(IVsWindowFrameFactory.Create());
Mock.Get(uiShell).Verify(u => u.AdviseWindowFrameEvents(listener), Times.Once);
Mock.Get(solution).Verify(s => s.AdviseSolutionEvents(listener, out eventsCookie), Times.Once);
}
public async Task ProjectFileEditorPresenter_MultipleOpen_CallsShowSecondTime()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.Create();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
await editorState.OpenEditorAsync();
Mock.Get(windowFrame).Verify(w => w.Show(), Times.Never);
// On the second call, we should call show on the frame, and none of the listeners should have been set up again
await editorState.OpenEditorAsync();
Mock.Get(windowFrame).Verify(w => w.Show(), Times.Once);
Mock.Get(textBufferManager).Verify(t => t.InitializeBufferAsync(), Times.Once);
Mock.Get(textBufferListener).Verify(t => t.InitializeListenerAsync(filePath), Times.Once);
Mock.Get(frameListener).Verify(f => f.InitializeEventsAsync(windowFrame), Times.Once);
Mock.Get(projectFileWatcher).Verify(p => p.InitializeModelWatcher(), Times.Once);
Assert.Equal(editorState.CurrentState, ProjectFileEditorPresenter.EditorState.EditorOpen);
}
public async Task FrameOpenCloseListener_Dispose_UnsubscribesCorrectly()
{
var uiShell = IVsUIShell7Factory.ImplementAdviseUnadviseWindowEvents(l => 1234, c => Assert.Equal <uint>(1234, c));
var solution = IVsSolutionFactory.CreateWithAdviseUnadviseSolutionEvents(4321);
var serviceProvider = IServiceProviderFactory.ImplementGetService(ServiceTypeChecker(uiShell, solution));
var listener = new FrameOpenCloseListener(serviceProvider,
IProjectFileEditorPresenterFactory.Create(),
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create());
await listener.InitializeEventsAsync(IVsWindowFrameFactory.Create());
await listener.DisposeAsync();
Mock.Get(uiShell).Verify(u => u.UnadviseWindowFrameEvents(1234), Times.Once);
Mock.Get(solution).Verify(s => s.UnadviseSolutionEvents(4321), Times.Once);
}
public async Task ShowProjectDesignerAsync_WhenWindowShowReturnsHResult_Throws()
{
var vsProjectDesignerPageService = IVsProjectDesignerPageServiceFactory.ImplementIsProjectDesignerSupported(() => true);
var editorGuid = Guid.NewGuid();
var hierarchy = IVsHierarchyFactory.Create();
hierarchy.ImplementGetGuid(VsHierarchyPropID.ProjectDesignerEditor, result: editorGuid);
var project = (IVsProject4)hierarchy;
var frame = IVsWindowFrameFactory.ImplementShow(() => VSConstants.E_FAIL);
project.ImplementOpenItemWithSpecific(editorGuid, VSConstants.LOGVIEWID_Primary, frame);
var projectVsServices = IUnconfiguredProjectVsServicesFactory.Implement(() => hierarchy, () => project);
var designerService = CreateInstance(projectVsServices, vsProjectDesignerPageService);
await Assert.ThrowsAsync <COMException>(designerService.ShowProjectDesignerAsync);
}
public async Task ProjectFileEditorPresenter_OpenEditor_SetsUpListeners()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.Create();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
// Mock textBufferManager.InitializeBufferAsync so it can verify the editor is actually in Initializing
Mock.Get(textBufferManager).Setup(t => t.InitializeBufferAsync()).Callback(() =>
Assert.Equal(ProjectFileEditorPresenter.EditorState.Initializing, editorState.CurrentState)).Returns(Task.CompletedTask);
await editorState.OpenEditorAsync();
Mock.Get(textBufferManager).Verify(t => t.InitializeBufferAsync(), Times.Once);
Mock.Get(textBufferListener).Verify(t => t.InitializeListenerAsync(filePath), Times.Once);
Mock.Get(frameListener).Verify(f => f.InitializeEventsAsync(windowFrame), Times.Once);
Mock.Get(projectFileWatcher).Verify(p => p.InitializeModelWatcher(), Times.Once);
Assert.Equal(editorState.CurrentState, ProjectFileEditorPresenter.EditorState.EditorOpen);
}
public async Task DisposeWithoutOpen_DoesNothing()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.ImplementCloseFrame(options =>
{
Assert.Equal((uint)__FRAMECLOSE.FRAMECLOSE_PromptSave, options);
return(VSConstants.S_OK);
});
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
await editorState.CloseCurrentEditorAsync();
Mock.Get(textBufferManager).Verify(t => t.Dispose(), Times.Never);
Mock.Get(textBufferListener).Verify(t => t.Dispose(), Times.Never);
Mock.Get(frameListener).Verify(f => f.DisposeAsync(), Times.Never);
Mock.Get(projectFileWatcher).Verify(p => p.Dispose(), Times.Never);
}
public async Task ShowProjectDesignerAsync_WhenOpenedInInternalEditor_ShowsWindow()
{
var vsProjectDesignerPageService = IVsProjectDesignerPageServiceFactory.ImplementIsProjectDesignerSupported(() => true);
var editorGuid = Guid.NewGuid();
var hierarchy = IVsHierarchyFactory.Create();
hierarchy.ImplementGetGuid(VsHierarchyPropID.ProjectDesignerEditor, result: editorGuid);
var project = (IVsProject4)hierarchy;
int callCount = 0;
var frame = IVsWindowFrameFactory.ImplementShow(() => { callCount++; return 0; });
project.ImplementOpenItemWithSpecific(editorGuid, VSConstants.LOGVIEWID_Primary, frame);
var projectVsServices = IUnconfiguredProjectVsServicesFactory.Implement(() => hierarchy, () => project);
var designerService = CreateInstance(projectVsServices, vsProjectDesignerPageService);
await designerService.ShowProjectDesignerAsync();
Assert.Equal(1, callCount);
}
public async Task ProjectFileEditorPresenter_CloseWindowFail_ReturnsStopClose()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.ImplementCloseFrame(options =>
{
Assert.Equal((uint)__FRAMECLOSE.FRAMECLOSE_PromptSave, options);
return(VSConstants.E_FAIL);
});
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
await editorState.OpenEditorAsync();
Assert.False(await editorState.CanCloseWindowAsync());
}
public async Task AbstractEditProjectFileCommand_CorrectNode_CreatesWindowCorrectly()
{
var projectPath = $"C:\\Project1\\Project1.{EditProjectFileCommand.Extension}";
var tempFile = "C:\\Temp\\asdf.xyz";
var tempProjFile = $"{tempFile}.{EditProjectFileCommand.Extension}";
var expectedCaption = $"Project1.{EditProjectFileCommand.Extension}";
var projectXml = @"<Project></Project>";
var captionSet = false;
var autoOpenSet = false;
var listenerSet = false;
IVsWindowFrameNotify2 notifier = null;
var fileSystem = new IFileSystemMock();
var textDoc = ITextDocumentFactory.Create();
var frame = IVsWindowFrameFactory.ImplementShowAndSetProperty(VSConstants.S_OK, (property, obj) =>
{
switch (property)
{
case (int)__VSFPROPID5.VSFPROPID_OverrideCaption:
captionSet = true;
break;
case (int)__VSFPROPID5.VSFPROPID_DontAutoOpen:
autoOpenSet = true;
break;
case (int)__VSFPROPID.VSFPROPID_ViewHelper:
listenerSet = true;
Assert.IsAssignableFrom <IVsWindowFrameNotify2>(obj);
notifier = obj as IVsWindowFrameNotify2;
break;
default:
Assert.False(true, $"Unexpected property ID {property}");
break;
}
return(VSConstants.S_OK);
});
var command = SetupScenario(projectXml, tempFile, tempProjFile, projectPath, expectedCaption, fileSystem, textDoc, frame);
var tree = ProjectTreeParser.Parse(@"
Root (flags: {ProjectRoot})
");
var nodes = ImmutableHashSet.Create(tree);
// Verify the frame was setup correctly
Assert.True(await command.TryHandleCommandAsync(nodes, CommandId, true, 0, IntPtr.Zero, IntPtr.Zero));
Assert.Equal(projectXml, fileSystem.ReadAllText(tempProjFile));
Mock.Get(frame).Verify(f => f.SetProperty((int)__VSFPROPID5.VSFPROPID_OverrideCaption, expectedCaption));
Mock.Get(frame).Verify(f => f.Show());
Assert.True(captionSet);
Assert.True(autoOpenSet);
Assert.True(listenerSet);
Assert.NotNull(notifier);
// Now see if the event correctly saved the text from the buffer into the project file
var args = new TextDocumentFileActionEventArgs(tempProjFile, DateTime.Now, FileActionTypes.ContentSavedToDisk);
Mock.Get(textDoc).Raise(t => t.FileActionOccurred += null, args);
Assert.Equal(projectXml, fileSystem.ReadAllText(projectPath));
// Finally, ensure the cleanup works as expected. We don't do anything with the passed option. The notifier
// should remove the file temp file from the filesystem.
Assert.Equal(VSConstants.S_OK, notifier.OnClose(0));
Assert.False(fileSystem.FileExists(tempProjFile));
}
