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 void ToProjectRestoreInfo_SetsCoreProperties()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""NuGetRestore"": {
""Properties"": {
""MSBuildProjectExtensionsPath"": ""C:\\Project\\obj"",
""TargetFrameworks"": ""net45"",
""TargetFrameworkMoniker"": "".NETFramework, Version=v4.5""
},
}
}
}
");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal("C:\\Project\\obj", result.BaseIntermediatePath);
Assert.Equal("net45", result.OriginalTargetFrameworks);
Assert.Equal(1, result.TargetFrameworks.Count);
var targetFramework = result.TargetFrameworks.Item(0);
Assert.Equal(".NETFramework, Version=v4.5", targetFramework.TargetFrameworkMoniker);
}
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 async Task VerifyDesignTimeInputsProcessed(string projectState, string[] designTimeInputs, string[] sharedDesignTimeInputs)
{
using DesignTimeInputsDataSource dataSource = CreateDesignTimeInputsDataSource(out ProjectValueDataSource <IProjectSubscriptionUpdate> sourceItemsRuleSource);
const string defaultProjectConfig = @"""ProjectConfiguration"": {
""Name"": ""Debug|AnyCPU"",
""Dimensions"": {
""Configuration"": ""Debug"",
""Platform"": ""AnyCPU""
}
}";
// Create a block to receive the results of the block under test
DesignTimeInputs inputs = null;
var receiver = DataflowBlockSlim.CreateActionBlock <IProjectVersionedValue <DesignTimeInputs> >(val =>
{
inputs = val.Value;
});
dataSource.SourceBlock.LinkTo(receiver, DataflowOption.PropagateCompletion);
// Construct our input value, including a default project config
var configUpdate = IProjectSubscriptionUpdateFactory.FromJson("{ " + projectState + "," + defaultProjectConfig + " }");
// Send our input, and wait for our receiver to complete
await sourceItemsRuleSource.SendAndCompleteAsync(configUpdate, receiver);
// Assert
Assert.NotNull(inputs);
Assert.Equal(designTimeInputs, inputs.Inputs);
Assert.Equal(sharedDesignTimeInputs, inputs.SharedInputs);
}
public void ToProjectRestoreInfo_WhenEmpty_SetsCorePropertiesToEmpty()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""NuGetRestore"": {
""Properties"": {
""MSBuildProjectExtensionsPath"": """",
""TargetFrameworks"": """",
""TargetFrameworkMoniker"": """"
},
}
}
}
");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Empty(result.BaseIntermediatePath);
Assert.Empty(result.OriginalTargetFrameworks);
Assert.Equal(1, result.TargetFrameworks.Count);
var targetFramework = result.TargetFrameworks.Item(0);
Assert.Empty(targetFramework.TargetFrameworkMoniker);
}
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 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 static IProjectVersionedValue <IProjectSubscriptionUpdate> FromJson(IComparable version, string jsonString)
{
var update = IProjectSubscriptionUpdateFactory.FromJson(jsonString);
// Every IProjectSubscriptionUpdate contains the version of the configured project
return(Create(update, identity: ProjectDataSources.ConfiguredProjectVersion, version));
}
public void ToProjectRestoreInfo_SetsToolReferences()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""DotNetCliToolReference"": {
""Items"" : {
""ToolReference1"" : {
""Version"" : ""1.0.0.0"",
},
""ToolReference2"" : {
""Version"" : ""2.0.0.0"",
},
""ToolReference3"" : {
""Name"" : ""Value""
}
}
}
}
}
");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
var references = result.ToolReferences;
Assert.Equal(3, references.Count);
Assert.Equal("ToolReference1", references.Item("ToolReference1").Name);
AssertContainsProperty("Version", "1.0.0.0", references.Item("ToolReference1").Properties);
Assert.Equal("ToolReference2", references.Item("ToolReference2").Name);
AssertContainsProperty("Version", "2.0.0.0", references.Item("ToolReference2").Properties);
Assert.Equal("ToolReference3", references.Item("ToolReference3").Name);
AssertContainsProperty("Name", "Value", references.Item("ToolReference3").Properties);
}
public void ToProjectRestoreInfo_SetsProjectReferences()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(ProjectWithItems);
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal(1, result.TargetFrameworks.Count);
var references = result.TargetFrameworks.Item(0).ProjectReferences;
Assert.Equal(3, references.Count);
Assert.Equal("..\\Project\\Project1.csproj", references.Item("..\\Project\\Project1.csproj").Name);
Assert.Equal("ProjectFileFullPath", references.Item("..\\Project\\Project1.csproj").Properties.Item("ProjectFileFullPath").Name);
Assert.Equal("C:\\Solution\\Project\\Project1.csproj", references.Item("..\\Project\\Project1.csproj").Properties.Item("ProjectFileFullPath").Value);
Assert.Equal("..\\Project\\Project2.csproj", references.Item("..\\Project\\Project2.csproj").Name);
Assert.Equal("ProjectFileFullPath", references.Item("..\\Project\\Project2.csproj").Properties.Item("ProjectFileFullPath").Name);
Assert.Equal("C:\\Solution\\Project\\Project2.csproj", references.Item("..\\Project\\Project2.csproj").Properties.Item("ProjectFileFullPath").Value);
Assert.Equal("..\\Project\\Project3.csproj", references.Item("..\\Project\\Project3.csproj").Name);
Assert.Equal("ProjectFileFullPath", references.Item("..\\Project\\Project3.csproj").Properties.Item("ProjectFileFullPath").Name);
Assert.Equal("C:\\Solution\\Project\\Project3.csproj", references.Item("..\\Project\\Project3.csproj").Properties.Item("ProjectFileFullPath").Value);
Assert.Equal("Property", references.Item("..\\Project\\Project3.csproj").Properties.Item("Property").Name);
Assert.Equal("Value", references.Item("..\\Project\\Project3.csproj").Properties.Item("Property").Value);
}
public void ToProjectRestoreInfo_WhenNoItems_ReturnsEmptyItemCollections()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""ProjectReference"": {
""Items"" : {}
},
""PackageReference"": {
""Items"" : {}
},
""DotNetCliToolReference"": {
""Items"" : {}
},
""CollectedFrameworkReference"": {
""Items"" : {}
},
""CollectedPackageDownload"": {
""Items"" : {}
}
}
}
");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
AssertNoItems(result);
}
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 void ToProjectRestoreInfo_SetsFrameworkReferences()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""CollectedFrameworkReference"": {
""Items"" : {
""WindowsForms"" : {
},
""WPF"" : {
""PrivateAssets"" : ""all"",
}
}
}
}
}");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal(1, result.TargetFrameworks.Count);
var references = result.TargetFrameworks.Item(0).FrameworkReferences;
Assert.Equal(2, references.Count);
var reference1 = references.Item("WindowsForms");
Assert.Equal("WindowsForms", reference1.Name);
Assert.Empty(reference1.Properties);
var reference2 = references.Item("WPF");
Assert.Equal("WPF", reference2.Name);
AssertContainsProperty("PrivateAssets", "all", reference2.Properties);
}
public void NuGetDependenciesSubTreeProvider_ProcessDependenciesChanges_EmptyTreeAndBothResolvedAndUnresolvedAreProvided(
string projectSubscriptionUpdateJson,
string existingTopLevelNodesJson,
string existingDependenciesChanges)
{
// Arrange
var projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(projectSubscriptionUpdateJson);
var mockRootNode = IDependencyNodeFactory.Implement(existingTopLevelNodesJson);
var provider = new TestableNuGetDependenciesSubTreeProvider();
provider.SetRootNode(mockRootNode);
// Act
var resultDependenciesChange = provider.TestDependenciesChanged(projectSubscriptionUpdate, catalogs: null);
// Assert
// check that DependenciesChange returned is as expected
var expectedResult = DependenciesChangeFactory.FromJson(existingDependenciesChanges);
Assert.True(DependenciesChangeFactory.AreEqual(expectedResult, resultDependenciesChange));
// Check if all added items were added to Snapshot
var currentSnapshot = provider.GetCurrentSnapshotDependenciesWorld();
foreach (var addedNode in expectedResult.AddedNodes)
{
if (addedNode.Id.ItemSpec.Contains("/"))
{
// if it is a resolved package
Assert.True(currentSnapshot.Any(x => x.Equals(addedNode.Id.ItemSpec, StringComparison.OrdinalIgnoreCase)));
}
}
}
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 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);
}
public void ToProjectRestoreInfo_WhenItemsAreMissing_ReturnsEmptyItemCollections()
{
var update = IProjectSubscriptionUpdateFactory.CreateEmpty();
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
AssertNoItems(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 void ToProjectRestoreInfo_SetsCoreProperties()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(ProjectWithEmptyItems);
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal("C:\\Project\\obj", result.BaseIntermediatePath);
Assert.Equal("net45", result.OriginalTargetFrameworks);
Assert.Equal(1, result.TargetFrameworks.Count);
Assert.Equal(".NETFramework, Version=v4.5", result.TargetFrameworks.Item(0).TargetFrameworkMoniker);
}
public void ToProjectRestoreInfo_WhenNuGetRestoreRuleMissing_ReturnsEmpty()
{
var update = IProjectSubscriptionUpdateFactory.CreateEmpty();
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Empty(result.BaseIntermediatePath);
Assert.Empty(result.OriginalTargetFrameworks);
Assert.Equal(1, result.TargetFrameworks.Count);
var targetFramework = result.TargetFrameworks.Item(0);
Assert.Empty(targetFramework.TargetFrameworkMoniker);
Assert.Empty(targetFramework.Properties);
}
public void ToProjectRestoreInfo_WhenNoItems_ReturnsEmptyItemCollections()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(ProjectWithEmptyItems);
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Empty(result.ToolReferences);
Assert.Equal(1, result.TargetFrameworks.Count);
var targetFramework = result.TargetFrameworks.Item(0);
Assert.Empty(targetFramework.PackageReferences);
Assert.Empty(targetFramework.ProjectReferences);
}
[InlineData(new [] { "A", "B", "D", "E" }, new [] { "B", "C", "E", "F" }, new [] { "C", "F" }, new [] { "A", "D" })] // Addition and deletion in jumbled order with the same no of elements as before
public void UpdateNamespaceImportListTest(string[] initialState, string[] updateToApply, string[] expectedAdded, string[] expectedRemoved)
{
var list = VisualBasicNamespaceImportsListFactory.CreateInstance(initialState);
var json = ConstructNamespaceImportChangeJson(updateToApply);
var projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(json);
list.TestApply(projectSubscriptionUpdate);
// Updates represent the final state, so they are the expected list too
Assert.Equal(updateToApply.OrderBy(s => s), list.OrderBy(s => s));
Assert.Equal(expectedAdded.OrderBy(s => s), list.ImportsAdded.OrderBy(s => s));
Assert.Equal(expectedRemoved.OrderBy(s => s), list.ImportsRemoved.OrderBy(s => s));
return;
public void NuGetDependenciesSubTreeProvider_ProcessDependenciesChanges(
string projectSubscriptionUpdateJson,
string existingTopLevelNodesJson,
string packageToTestVersionUpdate,
string existingDependenciesChanges)
{
// Arrange
var projectSubscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(projectSubscriptionUpdateJson);
var mockRootNode = IDependencyNodeFactory.Implement(existingTopLevelNodesJson);
var provider = new TestableNuGetDependenciesSubTreeProvider();
provider.SetRootNode(mockRootNode);
// Act
var resultDependenciesChange = provider.TestDependenciesChanged(projectSubscriptionUpdate, catalogs: null);
// Assert
// Check that for updated/changed nodes, properties were updated
var propertyToCheck = "Version";
var itemsProperties = projectSubscriptionUpdate.ProjectChanges.Values
.Where(y => y.Difference.AnyChanges &&
y.Difference.ChangedItems.Any(x => x.Equals(packageToTestVersionUpdate)))
.Select(x => x.After.Items)
.FirstOrDefault();
var expectedPropertyValue = itemsProperties[packageToTestVersionUpdate][propertyToCheck];
var properties = provider.GetDependencyProperties(packageToTestVersionUpdate);
Assert.Equal(expectedPropertyValue, properties[propertyToCheck]);
// check that DependenciesChange returned is as expected
var expectedResult = DependenciesChangeFactory.FromJson(existingDependenciesChanges);
Assert.True(DependenciesChangeFactory.AreEqual(expectedResult, resultDependenciesChange));
// Check if all added items were added to Snapshot
var currentSnapshot = provider.GetCurrentSnapshotDependenciesWorld();
foreach (var addedNode in expectedResult.AddedNodes)
{
if (addedNode.Id.ItemSpec.Contains("/"))
{
// if it is a resolved package
Assert.True(currentSnapshot.Any(x => x.Equals(addedNode.Id.ItemSpec, StringComparison.OrdinalIgnoreCase)));
}
}
}
public void ToProjectRestoreInfo_SetsProjectReferences()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""ProjectReference"": {
""Items"" : {
""..\\Project\\Project1.csproj"" : {
""ProjectFileFullPath"" : ""C:\\Solution\\Project\\Project1.csproj"",
},
""..\\Project\\Project2.csproj"" : {
""ProjectFileFullPath"" : ""C:\\Solution\\Project\\Project2.csproj"",
},
""..\\Project\\Project3.csproj"" : {
""ProjectFileFullPath"" : ""C:\\Solution\\Project\\Project3.csproj"",
""MetadataName"": ""MetadataValue""
}
}
}
}
}");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal(1, result.TargetFrameworks.Count);
var references = result.TargetFrameworks.Item(0).ProjectReferences;
Assert.Equal(3, references.Count);
var reference1 = references.Item("..\\Project\\Project1.csproj");
Assert.Equal("..\\Project\\Project1.csproj", reference1.Name);
AssertContainsProperty("ProjectFileFullPath", "C:\\Solution\\Project\\Project1.csproj", reference1.Properties);
var reference2 = references.Item("..\\Project\\Project2.csproj");
Assert.Equal("..\\Project\\Project2.csproj", reference2.Name);
AssertContainsProperty("ProjectFileFullPath", "C:\\Solution\\Project\\Project2.csproj", reference2.Properties);
var reference3 = references.Item("..\\Project\\Project3.csproj");
Assert.Equal("..\\Project\\Project3.csproj", reference3.Name);
AssertContainsProperty("ProjectFileFullPath", "C:\\Solution\\Project\\Project3.csproj", reference3.Properties);
AssertContainsProperty("MetadataName", "MetadataValue", reference3.Properties);
}
public void ToProjectRestoreInfo_SetsCentralPackageVersions()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""CollectedPackageVersion"": {
""Items"" : {
""Newtonsoft.Json"" : {
""Version"" : ""1.0"",
},
""System.IO"" : {
""Version"" : ""2.0"",
},
""Microsoft.Extensions"" : {
""Version"" : ""3.0""
}
}
}
}
}");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal(1, result.TargetFrameworks.Count);
var versions = ((IVsTargetFrameworkInfo3)result.TargetFrameworks.Item(0)).CentralPackageVersions;
Assert.Equal(3, versions.Count);
var reference1 = versions.Item("Newtonsoft.Json");
Assert.Equal("Newtonsoft.Json", reference1.Name);
AssertContainsProperty("Version", "1.0", reference1.Properties);
var reference2 = versions.Item("System.IO");
Assert.Equal("System.IO", reference2.Name);
AssertContainsProperty("Version", "2.0", reference2.Properties);
var reference3 = versions.Item("Microsoft.Extensions");
Assert.Equal("Microsoft.Extensions", reference3.Name);
AssertContainsProperty("Version", "3.0", reference3.Properties);
}
private void SendDesignTimeInputs(DesignTimeInputs inputs, string?intermediateOutputPath = null)
{
_intermediateOutputPath = intermediateOutputPath ?? _intermediateOutputPath;
var ruleUpdate = @"{
""ProjectChanges"": {
""ConfigurationGeneral"": {
""Difference"": {
""ChangedProperties"": [ ";
if (_lastIntermediateOutputPath != _intermediateOutputPath)
{
ruleUpdate += @" ""IntermediateOutputPath"",";
}
// root namespace and project folder have changed if its the first time we've sent inputs
if (_lastIntermediateOutputPath == null)
{
ruleUpdate += @" ""ProjectDir"",
""RootNamespace""";
}
ruleUpdate = ruleUpdate.TrimEnd(',');
ruleUpdate += @" ]
},
""After"": {
""Properties"": {
""ProjectDir"": """ + _projectFolder.Replace("\\", "\\\\") + @""",
""IntermediateOutputPath"": """ + _intermediateOutputPath.Replace("\\", "\\\\") + @""",
""RootNamespace"": ""MyNamespace""
}
}
}
}
}";
IProjectSubscriptionUpdate subscriptionUpdate = IProjectSubscriptionUpdateFactory.FromJson(ruleUpdate);
_lastIntermediateOutputPath = _intermediateOutputPath;
// Ensure our input files are in the mock file system
foreach (string file in inputs.Inputs.Concat(inputs.SharedInputs))
{
var fullFilePath = Path.Combine(_projectFolder, file);
}
_changeTracker.ProcessDataflowChanges(new ProjectVersionedValue <Tuple <DesignTimeInputs, IProjectSubscriptionUpdate> >(new Tuple <DesignTimeInputs, IProjectSubscriptionUpdate>(inputs, subscriptionUpdate), ImmutableDictionary <NamedIdentity, IComparable> .Empty));
}
public void ToProjectRestoreInfo_RespectsNuGetTargetMonikerIfPresent()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(@"
{
""CurrentState"": {
""NuGetRestore"": {
""Properties"": {
""NuGetTargetMoniker"": ""UWP, Version=v10"",
""TargetFrameworkMoniker"": "".NETFramework, Version=v4.5""
},
}
}
}
");
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
var targetFramework = result.TargetFrameworks.Item(0);
Assert.Equal("UWP, Version=v10", targetFramework.TargetFrameworkMoniker);
}
public async Task VerifyFileWatcherRegistration(string inputTree, string fileToWatch)
{
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
var tasksService = IUnconfiguredProjectTasksServiceFactory.ImplementLoadedProjectAsync <ConfiguredProject>(t => t());
using (var watcher = new ProjectAssetFileWatcher(IVsServiceFactory.Create <SVsFileChangeEx, Shell.IVsAsyncFileChangeEx>(fileChangeService), IProjectTreeProviderFactory.Create(), IUnconfiguredProjectCommonServicesFactory.Create(threadingService: IProjectThreadingServiceFactory.Create()), tasksService, IActiveConfiguredProjectSubscriptionServiceFactory.Create()))
{
var tree = ProjectTreeParser.Parse(inputTree);
var projectUpdate = IProjectSubscriptionUpdateFactory.FromJson(ProjectCurrentStateJson);
watcher.Load();
await watcher.DataFlow_ChangedAsync(IProjectVersionedValueFactory.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.AdviseFileChangeAsync(fileToWatch ?? It.IsAny <string>(), It.IsAny <_VSFILECHANGEFLAGS>(), watcher, CancellationToken.None), times);
}
}
public void ToProjectRestoreInfo_SetsToolReferences()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(ProjectWithItems);
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
var references = result.ToolReferences;
Assert.Equal(3, references.Count);
Assert.Equal("ToolReference1", references.Item("ToolReference1").Name);
Assert.Equal("Version", references.Item("ToolReference1").Properties.Item("Version").Name);
Assert.Equal("1.0.0.0", references.Item("ToolReference1").Properties.Item("Version").Value);
Assert.Equal("ToolReference2", references.Item("ToolReference2").Name);
Assert.Equal("Version", references.Item("ToolReference2").Properties.Item("Version").Name);
Assert.Equal("2.0.0.0", references.Item("ToolReference2").Properties.Item("Version").Value);
Assert.Equal("ToolReference3", references.Item("ToolReference3").Name);
Assert.Equal("Name", references.Item("ToolReference3").Properties.Item("Name").Name);
Assert.Equal("Value", references.Item("ToolReference3").Properties.Item("Name").Value);
}
public void ToProjectRestoreInfo_SetsTargetFrameworkPropertiesToAllProperties()
{
var update = IProjectSubscriptionUpdateFactory.FromJson(ProjectWithEmptyItems);
var result = RestoreBuilder.ToProjectRestoreInfo(update.CurrentState);
Assert.Equal(1, result.TargetFrameworks.Count);
var properties = result.TargetFrameworks.Item(0).Properties;
Assert.Equal("MSBuildProjectExtensionsPath", properties.Item("MSBuildProjectExtensionsPath").Name);
Assert.Equal("C:\\Project\\obj", properties.Item("MSBuildProjectExtensionsPath").Value);
Assert.Equal("TargetFrameworks", properties.Item("TargetFrameworks").Name);
Assert.Equal("net45", properties.Item("TargetFrameworks").Value);
Assert.Equal("TargetFrameworkMoniker", properties.Item("TargetFrameworkMoniker").Name);
Assert.Equal(".NETFramework, Version=v4.5", properties.Item("TargetFrameworkMoniker").Value);
Assert.Equal("Property", properties.Item("Property").Name);
Assert.Equal("Value", properties.Item("Property").Value);
}
