public async Task WhenBaseIntermediateOutputPathNotSet_DoesNotAttemptToAdviseFileChange()
{
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(100);
var tasksService = IUnconfiguredProjectTasksServiceFactory.ImplementLoadedProjectAsync <ConfiguredProject>(t => t());
using var watcher = new ProjectAssetFileWatcherInstance(
IVsServiceFactory.Create <SVsFileChangeEx, IVsAsyncFileChangeEx>(fileChangeService),
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(threadingService: IProjectThreadingServiceFactory.Create()),
tasksService,
IActiveConfiguredProjectSubscriptionServiceFactory.Create());
var tree = ProjectTreeParser.Parse(@"Root (flags: {ProjectRoot}), FilePath: ""C:\Foo\foo.proj""");
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""CurrentState"": {
""ConfigurationGeneral"": {
""Properties"": {
""MSBuildProjectFullPath"": ""C:\\Foo\\foo.proj""
}
}
}
}");
await watcher.InitializeAsync();
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory.Create(Tuple.Create(IProjectTreeSnapshotFactory.Create(tree), projectUpdate)));
var fileChangeServiceMock = Mock.Get(fileChangeService);
fileChangeServiceMock.Verify(s => s.AdviseFileChangeAsync(It.IsAny <string>(), It.IsAny <_VSFILECHANGEFLAGS>(), watcher, CancellationToken.None),
Times.Never());
}
public async Task VerifyFileWatcherRegistrationOnTreeChange(string inputTree, string changedTree, int numRegisterCalls, int numUnregisterCalls)
{
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
var tasksService = IUnconfiguredProjectTasksServiceFactory.ImplementLoadedProjectAsync <ConfiguredProject>(t => t());
using var watcher = new ProjectAssetFileWatcherInstance(
IVsServiceFactory.Create <SVsFileChangeEx, IVsAsyncFileChangeEx>(fileChangeService),
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(threadingService: IProjectThreadingServiceFactory.Create()),
tasksService,
IActiveConfiguredProjectSubscriptionServiceFactory.Create());
await watcher.InitializeAsync();
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(ProjectCurrentStateJson);
var firstTree = ProjectTreeParser.Parse(inputTree);
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory.Create(Tuple.Create(IProjectTreeSnapshotFactory.Create(firstTree), projectUpdate)));
var secondTree = ProjectTreeParser.Parse(changedTree);
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory.Create(Tuple.Create(IProjectTreeSnapshotFactory.Create(secondTree), projectUpdate)));
// If fileToWatch is null then we expect to not register any filewatcher.
var fileChangeServiceMock = Mock.Get(fileChangeService);
fileChangeServiceMock.Verify(s => s.AdviseFileChangeAsync(It.IsAny <string>(), It.IsAny <_VSFILECHANGEFLAGS>(), watcher, CancellationToken.None),
Times.Exactly(numRegisterCalls));
fileChangeServiceMock.Verify(s => s.UnadviseFileChangeAsync(adviseCookie, CancellationToken.None), Times.Exactly(numUnregisterCalls));
}
public void VerifyFileWatcherRegistrationOnTreeChange(string inputTree, string changedTree, int numRegisterCalls, int numUnregisterCalls)
{
var spMock = new IServiceProviderMoq();
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
spMock.AddService(typeof(IVsFileChangeEx), typeof(SVsFileChangeEx), fileChangeService);
var propertyData = CreateBaseIntermediateOutputPathProperty("obj\\");
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
var watcher = new ProjectAssetFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(unconfiguredProject,
projectProperties: ProjectPropertiesFactory.Create(unconfiguredProject, new[] { propertyData })),
IProjectLockServiceFactory.Create());
watcher.Load();
var firstTree = ProjectTreeParser.Parse(inputTree);
watcher.ProjectTree_ChangedAsync(IProjectVersionedValueFactory <IProjectTreeSnapshot> .Create(IProjectTreeSnapshotFactory.Create(firstTree)));
var secondTree = ProjectTreeParser.Parse(changedTree);
watcher.ProjectTree_ChangedAsync(IProjectVersionedValueFactory <IProjectTreeSnapshot> .Create(IProjectTreeSnapshotFactory.Create(secondTree)));
// If fileToWatch is null then we expect to not register any filewatcher.
Mock <IVsFileChangeEx> fileChangeServiceMock = Mock.Get(fileChangeService);
fileChangeServiceMock.Verify(s => s.AdviseFileChange(It.IsAny <string>(), It.IsAny <uint>(), watcher, out adviseCookie),
Times.Exactly(numRegisterCalls));
fileChangeServiceMock.Verify(s => s.UnadviseFileChange(adviseCookie), Times.Exactly(numUnregisterCalls));
}
public void WhenBaseIntermediateOutputPathNotSet_DoesNotAttemptToAdviseFileChange()
{
var spMock = new IServiceProviderMoq();
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(100);
spMock.AddService(typeof(IVsFileChangeEx), typeof(SVsFileChangeEx), fileChangeService);
var propertyData = CreateBaseIntermediateOutputPathProperty(string.Empty);
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
var watcher = new ProjectAssetFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(unconfiguredProject,
projectProperties: ProjectPropertiesFactory.Create(unconfiguredProject, new[] { propertyData })),
IProjectLockServiceFactory.Create());
var tree = ProjectTreeParser.Parse(@"Root (flags: {ProjectRoot}), FilePath: ""C:\Foo\foo.proj""");
watcher.Load();
watcher.ProjectTree_ChangedAsync(IProjectVersionedValueFactory <IProjectTreeSnapshot> .Create(IProjectTreeSnapshotFactory.Create(tree)));
Mock <IVsFileChangeEx> fileChangeServiceMock = Mock.Get(fileChangeService);
uint cookie;
fileChangeServiceMock.Verify(s => s.AdviseFileChange(It.IsAny <string>(), It.IsAny <uint>(), watcher, out cookie),
Times.Never());
}
internal async Task OnProjectChangedAsync_WhenProjectUnloaded_TriggersCancellation()
{
var unloadSource = new CancellationTokenSource();
var instance = await CreateInitializedInstanceAsync(
tasksService : IUnconfiguredProjectTasksServiceFactory.ImplementUnloadCancellationToken(unloadSource.Token));
var registration = IDataProgressTrackerServiceRegistrationFactory.Create();
var activeConfiguredProject = ConfiguredProjectFactory.Create();
var update = IProjectVersionedValueFactory.CreateEmpty();
await Assert.ThrowsAsync <OperationCanceledException>(() =>
{
return(instance.OnProjectChangedAsync(
registration,
activeConfiguredProject,
update,
hasChange: _ => true,
applyFunc: (_, _, _, token) =>
{
// Simulate project unload during callback
unloadSource.Cancel();
token.ThrowIfCancellationRequested();
}));
});
}
public async Task ApplyProjectEvaluationAsync_IgnoresCommandLineHandlers()
{
int callCount = 0;
var handler = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, isActiveContext, logger) => { callCount++; });
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
},
""RuleName"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
await applyChangesToWorkspace.ApplyProjectEvaluationAsync(update, isActiveContext : true, CancellationToken.None);
Assert.Equal(0, callCount);
}
public async Task ApplyProjectBuildAsync_IgnoresEvaluationHandlers()
{
int callCount = 0;
var handler = IEvaluationHandlerFactory.ImplementHandle("RuleName", (version, description, state, logger) => { callCount++; });
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
},
""RuleName"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
await applyChangesToWorkspace.ApplyProjectBuildAsync(update, new ContextState(isActiveEditorContext : true, isActiveConfiguration : false), CancellationToken.None);
Assert.Equal(0, callCount);
}
public void VerifyFileWatcherRegistration(string inputTree, string fileToWatch)
{
var spMock = new IServiceProviderMoq();
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
spMock.AddService(typeof(IVsFileChangeEx), typeof(SVsFileChangeEx), fileChangeService);
var watcher = new ProjectAssetFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(),
IProjectLockServiceFactory.Create(),
IActiveConfiguredProjectSubscriptionServiceFactory.CreateInstance());
var tree = ProjectTreeParser.Parse(inputTree);
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(ProjectCurrentStateJson);
watcher.Load();
watcher.DataFlow_Changed(IProjectVersionedValueFactory <Tuple <IProjectTreeSnapshot, IProjectSubscriptionUpdate> > .Create((Tuple.Create(IProjectTreeSnapshotFactory.Create(tree), projectUpdate))));
// If fileToWatch is null then we expect to not register any filewatcher.
var times = fileToWatch == null?Times.Never() : Times.Once();
Mock.Get(fileChangeService).Verify(s => s.AdviseFileChange(fileToWatch ?? It.IsAny <string>(), It.IsAny <uint>(), watcher, out adviseCookie), times);
}
public void ApplyDesignTime_IgnoresEvaluationHandlers()
{
int callCount = 0;
var handler = IEvaluationHandlerFactory.ImplementHandle("RuleName", (version, description, isActiveContext, logger) => { callCount++; });
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
},
""RuleName"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
applyChangesToWorkspace.ApplyDesignTime(update, isActiveContext: true, CancellationToken.None);
Assert.Equal(0, callCount);
}
public void ApplyEvaluation_CallsHandler()
{
(IComparable version, IProjectChangeDescription description, bool isActiveContext, IProjectLogger logger)result = default;
var handler = IEvaluationHandlerFactory.ImplementHandle("RuleName", (version, description, isActiveContext, logger) =>
{
result = (version, description, isActiveContext, logger);
});
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(version: 2,
@"{
""ProjectChanges"": {
""RuleName"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
applyChangesToWorkspace.ApplyEvaluation(update, isActiveContext: true, CancellationToken.None);
Assert.Equal(2, result.version);
Assert.NotNull(result.description);
Assert.True(result.isActiveContext);
Assert.NotNull(result.logger);
}
public void ApplyDesignTime_WhenCancellationTokenCancelled_StopsProcessingHandlers()
{
var cancellationTokenSource = new CancellationTokenSource();
var handler1 = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, isActiveContext, logger) =>
{
cancellationTokenSource.Cancel();
});
int callCount = 0;
var handler2 = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, isActiveContext, logger) =>
{
callCount++;
});
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler1, handler2 });
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
applyChangesToWorkspace.ApplyDesignTime(update, isActiveContext: true, cancellationTokenSource.Token);
Assert.True(cancellationTokenSource.IsCancellationRequested);
Assert.Equal(0, callCount);
}
private void BroadcastChange(
Dictionary <string, IProjectRuleSnapshotModel>?projectSnapshot = null,
Dictionary <string, IProjectRuleSnapshotModel>?sourceSnapshot = null,
bool disableFastUpToDateCheck = false)
{
projectSnapshot ??= new Dictionary <string, IProjectRuleSnapshotModel>();
if (!projectSnapshot.ContainsKey(ConfigurationGeneral.SchemaName))
{
projectSnapshot[ConfigurationGeneral.SchemaName] = new IProjectRuleSnapshotModel
{
Properties = ImmutableStringDictionary <string> .EmptyOrdinal
.Add("MSBuildProjectFullPath", _msBuildProjectFullPath)
.Add("MSBuildProjectDirectory", _msBuildProjectDirectory)
.Add("MSBuildAllProjects", _msBuildAllProjects)
.Add("OutputPath", _outputPath)
.Add("DisableFastUpToDateCheck", disableFastUpToDateCheck.ToString())
};
}
var value = IProjectVersionedValueFactory.Create(
Tuple.Create(
CreateUpdate(projectSnapshot),
CreateUpdate(sourceSnapshot),
IProjectItemSchemaFactory.Create(_itemTypes)),
identity: ProjectDataSources.ConfiguredProjectVersion,
version: _projectVersion);
_buildUpToDateCheck.OnChanged(value);
return;
public async Task VerifyFileWatcherRegistrationOnTreeChange(string inputTree, string changedTree, int numRegisterCalls, int numUnregisterCalls)
{
var spMock = new IAsyncServiceProviderMoq();
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
spMock.AddService(typeof(SVsFileChangeEx), fileChangeService);
var tasksService = IUnconfiguredProjectTasksServiceFactory.ImplementLoadedProjectAsync <ConfiguredProject>(t => t());
var watcher = new ProjectAssetFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(threadingService: new IProjectThreadingServiceMock()),
tasksService,
IActiveConfiguredProjectSubscriptionServiceFactory.Create());
watcher.Load();
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(ProjectCurrentStateJson);
var firstTree = ProjectTreeParser.Parse(inputTree);
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory <Tuple <IProjectTreeSnapshot, IProjectSubscriptionUpdate> > .Create((Tuple.Create(IProjectTreeSnapshotFactory.Create(firstTree), projectUpdate))));
var secondTree = ProjectTreeParser.Parse(changedTree);
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory <Tuple <IProjectTreeSnapshot, IProjectSubscriptionUpdate> > .Create((Tuple.Create(IProjectTreeSnapshotFactory.Create(secondTree), projectUpdate))));
// If fileToWatch is null then we expect to not register any filewatcher.
var fileChangeServiceMock = Mock.Get(fileChangeService);
fileChangeServiceMock.Verify(s => s.AdviseFileChange(It.IsAny <string>(), It.IsAny <uint>(), watcher, out adviseCookie),
Times.Exactly(numRegisterCalls));
fileChangeServiceMock.Verify(s => s.UnadviseFileChange(adviseCookie), Times.Exactly(numUnregisterCalls));
}
public async Task ApplyProjectBuildAsync_WhenDesignTimeBuildFails_SetsLastDesignTimeBuildSucceededToFalse()
{
var applyChangesToWorkspace = CreateInitializedInstance(out var context);
context.LastDesignTimeBuildSucceeded = true;
var buildSnapshot = IProjectBuildSnapshotFactory.Create();
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
""After"": {
""EvaluationSucceeded"": false
}
}
}
}");
await applyChangesToWorkspace.ApplyProjectBuildAsync(update, buildSnapshot, new ContextState(), CancellationToken.None);
Assert.False(context.LastDesignTimeBuildSucceeded);
}
private void BroadcastChange(
Dictionary <string, IProjectRuleSnapshotModel> projectSnapshot = null,
Dictionary <string, IProjectRuleSnapshotModel> sourceSnapshot = null,
bool disableFastUpToDateCheck = false)
{
projectSnapshot = projectSnapshot ?? new Dictionary <string, IProjectRuleSnapshotModel>();
if (!projectSnapshot.ContainsKey(ConfigurationGeneral.SchemaName))
{
projectSnapshot[ConfigurationGeneral.SchemaName] = new IProjectRuleSnapshotModel
{
Properties = ImmutableStringDictionary <string> .EmptyOrdinal
.Add("MSBuildProjectFullPath", _msBuildProjectFullPath)
.Add("MSBuildProjectDirectory", _msBuildProjectDirectory)
.Add("MSBuildAllProjects", _msBuildAllProjects)
.Add("OutputPath", _outputPath)
.Add("DisableFastUpToDateCheck", disableFastUpToDateCheck.ToString())
};
}
var value = IProjectVersionedValueFactory <
Tuple <
IProjectSubscriptionUpdate,
IProjectSubscriptionUpdate,
IProjectItemSchema> > .Create(
Tuple.Create(
CreateUpdate(projectSnapshot),
CreateUpdate(sourceSnapshot),
IProjectItemSchemaFactory.Create(_itemTypes)),
identity : ProjectDataSources.ConfiguredProjectVersion,
version : _projectVersion);
_buildUpToDateCheck.OnChanged(value);
return;
IProjectSubscriptionUpdate CreateUpdate(Dictionary <string, IProjectRuleSnapshotModel> snapshotBySchemaName)
{
var snapshots = ImmutableDictionary <string, IProjectRuleSnapshot> .Empty;
var changes = ImmutableDictionary <string, IProjectChangeDescription> .Empty;
if (snapshotBySchemaName != null)
{
foreach ((string schemaName, IProjectRuleSnapshotModel model) in snapshotBySchemaName)
{
var change = new IProjectChangeDescriptionModel
{
After = model,
Difference = new IProjectChangeDiffModel {
AnyChanges = true
}
};
snapshots = snapshots.Add(schemaName, model.ToActualModel());
changes = changes.Add(schemaName, change.ToActualModel());
}
}
return(IProjectSubscriptionUpdateFactory.Implement(snapshots, changes));
}
}
public async Task ApplyProjectEvaluationAsync_CallsHandler()
{
(IComparable version, IProjectChangeDescription description, ContextState state, IProjectLogger logger)result = default;
var handler = IEvaluationHandlerFactory.ImplementHandle("RuleName", (version, description, state, logger) =>
{
result = (version, description, state, logger);
});
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(version: 2,
@"{
""ProjectChanges"": {
""RuleName"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
await applyChangesToWorkspace.ApplyProjectEvaluationAsync(update, new ContextState(isActiveEditorContext : true, isActiveConfiguration : true), CancellationToken.None);
Assert.Equal(2, result.version);
Assert.NotNull(result.description);
Assert.True(result.state.IsActiveEditorContext);
Assert.True(result.state.IsActiveConfiguration);
Assert.NotNull(result.logger);
}
public async Task ApplyProjectBuildAsync_WhenCancellationTokenCancelled_StopsProcessingHandlersAndThrowOperationCanceled()
{
var cancellationTokenSource = new CancellationTokenSource();
var handler1 = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, state, logger) =>
{
cancellationTokenSource.Cancel();
});
int callCount = 0;
var handler2 = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, state, logger) =>
{
callCount++;
});
var applyChangesToWorkspace = CreateInitializedInstance(handlers: new[] { handler1, handler2 });
var update = IProjectVersionedValueFactory.FromJson(
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true
},
}
}
}");
await Assert.ThrowsAsync <OperationCanceledException>(() =>
{
return(applyChangesToWorkspace.ApplyProjectBuildAsync(update, new ContextState(isActiveEditorContext: true, isActiveConfiguration: false), cancellationTokenSource.Token));
});
Assert.True(cancellationTokenSource.IsCancellationRequested);
Assert.Equal(0, callCount);
}
public async Task ApplyProjectBuildAsync_ParseCommandLineAndCallsHandler()
{
(IComparable version, BuildOptions added, BuildOptions removed, ContextState state, IProjectLogger logger)result = default;
var handler = ICommandLineHandlerFactory.ImplementHandle((version, added, removed, state, logger) =>
{
result = (version, added, removed, state, logger);
});
var parser = ICommandLineParserServiceFactory.CreateCSharp();
var applyChangesToWorkspace = CreateInitializedInstance(commandLineParser: parser, handlers: new[] { handler });
var update = IProjectVersionedValueFactory.FromJson(version: 2,
@"{
""ProjectChanges"": {
""CompilerCommandLineArgs"": {
""Difference"": {
""AnyChanges"": true,
""AddedItems"" : [ ""/reference:Added.dll"" ],
""RemovedItems"" : [ ""/reference:Removed.dll"" ]
}
}
}
}");
await applyChangesToWorkspace.ApplyProjectBuildAsync(update, new ContextState(isActiveEditorContext : true, isActiveConfiguration : false), CancellationToken.None);
Assert.Equal(2, result.version);
Assert.True(result.state.IsActiveEditorContext);
Assert.NotNull(result.logger);
Assert.Single(result.added !.MetadataReferences.Select(r => r.Reference), "Added.dll");
Assert.Single(result.removed !.MetadataReferences.Select(r => r.Reference), "Removed.dll");
}
public void VerifyFileWatcherRegistration(string inputTree, string fileToWatch)
{
var spMock = new IServiceProviderMoq();
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
spMock.AddService(typeof(IVsFileChangeEx), typeof(SVsFileChangeEx), fileChangeService);
var propertyData = new PropertyPageData
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.BaseIntermediateOutputPathProperty,
Value = "obj\\"
};
var unconfiguredProject = IUnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
var watcher = new ProjectLockFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(unconfiguredProject,
projectProperties: ProjectPropertiesFactory.Create(unconfiguredProject, new[] { propertyData })),
IProjectLockServiceFactory.Create());
var tree = ProjectTreeParser.Parse(inputTree);
watcher.Load();
watcher.ProjectTree_ChangedAsync(IProjectVersionedValueFactory <IProjectTreeSnapshot> .Create(IProjectTreeSnapshotFactory.Create(tree)));
// If fileToWatch is null then we expect to not register any filewatcher.
var times = fileToWatch == null?Times.Never() : Times.Once();
Mock.Get <IVsFileChangeEx>(fileChangeService).Verify(s => s.AdviseFileChange(fileToWatch ?? It.IsAny <string>(), It.IsAny <uint>(), watcher, out adviseCookie), times);
}
public async Task WhenBaseIntermediateOutputPathNotSet_DoesNotAttemptToAdviseFileChange()
{
var spMock = new IAsyncServiceProviderMoq();
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(100);
spMock.AddService(typeof(SVsFileChangeEx), fileChangeService);
var tasksService = IUnconfiguredProjectTasksServiceFactory.ImplementLoadedProjectAsync <ConfiguredProject>(t => t());
var watcher = new ProjectAssetFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(threadingService: new IProjectThreadingServiceMock()),
tasksService,
IActiveConfiguredProjectSubscriptionServiceFactory.Create());
var tree = ProjectTreeParser.Parse(@"Root (flags: {ProjectRoot}), FilePath: ""C:\Foo\foo.proj""");
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""CurrentState"": {
""ConfigurationGeneral"": {
""Properties"": {
""MSBuildProjectFullPath"": ""C:\\Foo\\foo.proj""
}
}
}
}");
watcher.Load();
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory <Tuple <IProjectTreeSnapshot, IProjectSubscriptionUpdate> > .Create((Tuple.Create(IProjectTreeSnapshotFactory.Create(tree), projectUpdate))));
var fileChangeServiceMock = Mock.Get(fileChangeService);
uint cookie;
fileChangeServiceMock.Verify(s => s.AdviseFileChange(It.IsAny <string>(), It.IsAny <uint>(), watcher, out cookie),
Times.Never());
}
public async Tasks.Task VerifyProjectNotAdded()
{
var projectGuid = Guid.NewGuid();
var mockIVsStartupProjectsListService = IVsStartupProjectsListServiceFactory.CreateMockInstance(projectGuid);
var iVsStartupProjectsListService = mockIVsStartupProjectsListService.Object;
var serviceProvider = SVsServiceProviderFactory.Create(iVsStartupProjectsListService);
var debuggerLaunchProvider = CreateDebuggerLaunchProviderInstance();
debuggerLaunchProvider.Debuggers.Add(GetLazyDebugLaunchProvider(debugs: false));
var activeConfiguredProjectWithLaunchProviders = ActiveConfiguredProjectFactory.ImplementValue(() => debuggerLaunchProvider);
var startupProjectRegistrar = CreateInstance(
serviceProvider,
activeConfiguredProjectWithLaunchProviders);
var testWrapperMethod = new DataFlowExtensionMethodCaller(new DataFlowExtensionMethodWrapperMock());
startupProjectRegistrar.WrapperMethodCaller = testWrapperMethod;
await startupProjectRegistrar.Load();
var projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""ProjectChanges"": {
""ConfigurationGeneral"": {
""Difference"": {
""ChangedProperties"": [ ""Something"" ]
}
}
}
}");
await startupProjectRegistrar.ConfigurationGeneralRuleBlock_ChangedAsync(
IProjectVersionedValueFactory <IProjectSubscriptionUpdate> .Create(projectSubscriptionUpdate));
mockIVsStartupProjectsListService.Verify(s => s.RemoveProject(ref projectGuid), Times.Never);
mockIVsStartupProjectsListService.Verify(s => s.AddProject(ref projectGuid), Times.Never);
projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""ProjectChanges"": {
""ConfigurationGeneral"": {
""Difference"": {
""ChangedProperties"": [ ""ProjectGuid"" ]
},
""After"": {
""Properties"": {
""ProjectGuid"": ""GuidNotParsable""
}
}
}
}
}");
await startupProjectRegistrar.ConfigurationGeneralRuleBlock_ChangedAsync(
IProjectVersionedValueFactory <IProjectSubscriptionUpdate> .Create(projectSubscriptionUpdate));
mockIVsStartupProjectsListService.Verify(s => s.RemoveProject(ref projectGuid), Times.Never);
mockIVsStartupProjectsListService.Verify(s => s.AddProject(ref projectGuid), Times.Never);
}
internal void TestApply(IProjectSubscriptionUpdate projectSubscriptionUpdate)
{
var projectVersionedValue = IProjectVersionedValueFactory.Create(projectSubscriptionUpdate);
var result = PreprocessAsync(projectVersionedValue, null);
_ = ApplyAsync(result.Result !);
}
public async Tasks.Task VerifyProjectAdded_RemovedWithChange()
{
var projectGuid = Guid.NewGuid();
var mockIVsStartupProjectsListService = IVsStartupProjectsListServiceFactory.CreateMockInstance(projectGuid);
var iVsStartupProjectsListService = IVsServiceFactory.Create <SVsStartupProjectsListService, IVsStartupProjectsListService>(mockIVsStartupProjectsListService.Object);
var serviceProvider = SVsServiceProviderFactory.Create(iVsStartupProjectsListService);
var debuggerLaunchProvider = CreateDebuggerLaunchProviderInstance();
debuggerLaunchProvider.Debuggers.Add(GetLazyDebugLaunchProvider(debugs: true));
var activeConfiguredProjectWithLaunchProviders = ActiveConfiguredProjectFactory.ImplementValue(() => debuggerLaunchProvider);
var startupProjectRegistrar = CreateInstance(
iVsStartupProjectsListService,
activeConfiguredProjectWithLaunchProviders);
var projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""ProjectChanges"": {
""ConfigurationGeneral"": {
""Difference"": {
""ChangedProperties"": [ ""ProjectGuid"" ]
},
""After"": {
""Properties"": {
""ProjectGuid"": """ + projectGuid + @"""
}
}
}
}
}");
await startupProjectRegistrar.ConfigurationGeneralRuleBlock_ChangedAsync(
IProjectVersionedValueFactory <IProjectSubscriptionUpdate> .Create(projectSubscriptionUpdate));
mockIVsStartupProjectsListService.Verify(s => s.AddProject(ref projectGuid), Times.Once);
mockIVsStartupProjectsListService.Verify(s => s.RemoveProject(ref projectGuid), Times.Never);
debuggerLaunchProvider.Debuggers.Clear();
debuggerLaunchProvider.Debuggers.Add(GetLazyDebugLaunchProvider(debugs: false));
projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(@"{
""ProjectChanges"": {
""ConfigurationGeneral"": {
""Difference"": {
""ChangedProperties"": [ ""OutputType"" ]
}
}
}
}");
await startupProjectRegistrar.ConfigurationGeneralRuleBlock_ChangedAsync(
IProjectVersionedValueFactory <IProjectSubscriptionUpdate> .Create(projectSubscriptionUpdate));
mockIVsStartupProjectsListService.Verify(s => s.RemoveProject(ref projectGuid), Times.Once);
}
public async Task <DesignTimeInputsItem> TestProcessAsync(IProjectSubscriptionUpdate compileUpdate, IProjectSubscriptionUpdate configurationGeneralUpdate, DesignTimeInputsDelta previousOutput)
{
var input = IProjectVersionedValueFactory.Create(Tuple.Create(compileUpdate, configurationGeneralUpdate));
// We always pretend this isn't the first process, which occurs on project load, because we have SetInputs for that
var result = await base.PreprocessAsync(input, previousOutput);
await base.ApplyAsync(result);
return(AppliedValue.Value);
}
public async Task OnInputsChangedAsync_NullAsRestoreInfo_DoesNotPushToRestoreService()
{
int callCount = 0;
var solutionRestoreService = IVsSolutionRestoreServiceFactory.ImplementNominateProjectAsync((projectFile, info, cancellationToken) => { callCount++; });
var instance = await CreateInitializedInstance(solutionRestoreService : solutionRestoreService);
var value = IProjectVersionedValueFactory.Create(new PackageRestoreUnconfiguredInput(null, new PackageRestoreConfiguredInput[0]));
await instance.OnInputsChangedAsync(value);
Assert.Equal(0, callCount);
}
public async Task OnRestoreInfoChangedAsync_NullAsValue_DoesNotPushToRestoreService()
{
int callCount = 0;
var solutionRestoreService = IVsSolutionRestoreServiceFactory.ImplementNominateProjectAsync((projectFile, info, cancellationToken) => { callCount++; });
var instance = await CreateInitializedInstance(solutionRestoreService : solutionRestoreService);
var value = IProjectVersionedValueFactory.Create <IVsProjectRestoreInfo2>(null);
await instance.OnRestoreInfoChangedAsync(value);
Assert.Equal(0, callCount);
}
private async Task <bool> OnRestoreCompleted(IProjectSnapshot projectSnapshot, RestoreData restoreData)
{
bool result = false;
var dataProgressTrackerService = IDataProgressTrackerServiceFactory.ImplementNotifyOutputDataCalculated(_ => { result = true; });
var instance = await CreateInitializedInstance(dataProgressTrackerService : dataProgressTrackerService);
var tuple = ValueTuple.Create(projectSnapshot, restoreData);
var value = IProjectVersionedValueFactory.Create(tuple);
instance.OnRestoreCompleted(value);
return(result);
}
public async Task OnInputsChangedAsync_UnchangedValueAsValue_DoesNotPushToRestoreService()
{
int callCount = 0;
var solutionRestoreService = IVsSolutionRestoreServiceFactory.ImplementNominateProjectAsync((projectFile, info, cancellationToken) => { callCount++; });
var instance = await CreateInitializedInstance(solutionRestoreService : solutionRestoreService);
var restoreInfo = ProjectRestoreInfoFactory.Create();
var value = IProjectVersionedValueFactory.Create(new PackageRestoreUnconfiguredInput(restoreInfo, new PackageRestoreConfiguredInput[0]));
await instance.OnInputsChangedAsync(value);
Assert.Equal(1, callCount); // Should have only been called once
}
public async Task OnInputsChangedAsync_PushesRestoreInfoToRestoreService()
{
IVsProjectRestoreInfo2?result = null;
var solutionRestoreService = IVsSolutionRestoreServiceFactory.ImplementNominateProjectAsync((projectFile, info, cancellationToken) => { result = info; });
var instance = await CreateInitializedInstance(solutionRestoreService : solutionRestoreService);
var restoreInfo = ProjectRestoreInfoFactory.Create();
var value = IProjectVersionedValueFactory.Create(new PackageRestoreUnconfiguredInput(restoreInfo, new PackageRestoreConfiguredInput[0]));
await instance.OnInputsChangedAsync(value);
Assert.Same(restoreInfo, result);
}
public void UpdateNamespaceImportListTest()
{
var list = VisualBasicNamespaceImportsListFactory.CreateInstance();
var dataList = new List <string>();
list.SetList(dataList);
// Initial add
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "C", "D")));
VerifyList(dataList, "A", "B", "C", "D");
// Remove from the end
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "C")));
VerifyList(dataList, "A", "B", "C");
// Remove from the beginning
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("B", "C")));
VerifyList(dataList, "B", "C");
// Add at the beginning
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "C")));
VerifyList(dataList, "A", "B", "C");
// Add at the end
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "C", "E")));
VerifyList(dataList, "A", "B", "C", "E");
// Add in the middle
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "C", "D", "E")));
VerifyList(dataList, "A", "B", "C", "D", "E");
// Remove from the middle
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("A", "B", "D", "E")));
VerifyList(dataList, "A", "B", "D", "E");
// Addition and Deletion in jumbled order with the same no of elements as before
list.OnNamespaceImportChanged(
IProjectVersionedValueFactory.Create(GetProjectSubscriptionUpdate("F", "C", "B", "E")));
VerifyList(dataList, "B", "C", "E", "F");
}
