public void Dependency_Constructor_WhenOptionalValuesNotProvided_ShouldSetDefaults() { const string jsonModel = @" { ""ProviderType"": ""xxx"", ""Id"": ""mymodel"" }"; var mockModel = IDependencyModelFactory.FromJson(jsonModel); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Create(); var dependency = new Dependency(mockModel, mockSnapshot); Assert.Equal(mockModel.ProviderType, dependency.ProviderType); Assert.Equal(string.Empty, dependency.Name); Assert.Equal(string.Empty, dependency.Version); Assert.Equal(string.Empty, dependency.Caption); Assert.Equal(string.Empty, dependency.OriginalItemSpec); Assert.Equal(string.Empty, dependency.Path); Assert.Equal("Folder", dependency.SchemaName); Assert.Equal("Folder", dependency.SchemaItemType); Assert.True(dependency.Properties.Count == 2); Assert.True(dependency.Properties.ContainsKey("Identity")); Assert.True(dependency.Properties.ContainsKey("FullPath")); Assert.True(dependency.DependencyIDs.Count == 0); }
public void UnsupportedProjectsSnapshotFilter_WhenProjectSnapshotFoundAndHasUnresolvedDependencies_ShouldMakeUnresolved() { // Arrange var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement(hasUnresolvedDependency: true); var targets = new Dictionary <ITargetFramework, ITargetedDependenciesSnapshot> { { targetFramework, targetedSnapshot } }; var snapshot = IDependenciesSnapshotFactory.Implement(targets: targets); var snapshotProvider = IDependenciesSnapshotProviderFactory.Implement(currentSnapshot: snapshot); var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Implement(getSnapshotProvider: snapshotProvider); var targetFrameworkProvider = ITargetFrameworkProviderFactory.Implement(getNearestFramework: targetFramework); var dependency = IDependencyFactory.Implement( topLevel: true, resolved: true, flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags), originalItemSpec: @"c:\myproject2\project.csproj", snapshot: targetedSnapshot, setPropertiesResolved: false, setPropertiesFlags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags)); var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, targetFrameworkProvider); var resultDependency = filter.BeforeAdd( projectPath: null, targetFramework: null, dependency: dependency.Object, worldBuilder: null, topLevelBuilder: null); dependency.VerifyAll(); }
public void UnsupportedProjectsSnapshotFilter_WhenProjectSnapshotFoundAndNoUnresolvedDependencies_ShouldDoNothing() { // Arrange var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement(hasUnresolvedDependency: false); var targets = new Dictionary <ITargetFramework, ITargetedDependenciesSnapshot> { { targetFramework, targetedSnapshot } }; var snapshot = IDependenciesSnapshotFactory.Implement(targets: targets); var snapshotProvider = IDependenciesSnapshotProviderFactory.Implement(currentSnapshot: snapshot); var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Implement(getSnapshotProvider: snapshotProvider); var targetFrameworkProvider = ITargetFrameworkProviderFactory.Implement(getNearestFramework: targetFramework); var dependency = IDependencyFactory.Implement( topLevel: true, resolved: true, flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags), fullPath: @"c:\myproject1\project.csproj", targetFramework: targetFramework ); var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, targetFrameworkProvider); var resultDependency = filter.BeforeAdd( null, null, dependency.Object, null, null, null, out bool filterAnyChanges); dependency.VerifyAll(); }
public void Dependency_DependenciesProperty() { var mockModel1 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId1", dependencyIDs: new[] { "someId2", "someId_other" }); var mockModel2 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId2"); var mockModel3 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId_other"); var targetFramework = ITargetFrameworkFactory.Implement("Tfm1"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementMock(targetFramework: targetFramework); var dependency1 = new Dependency(mockModel1, mockSnapshot.Object); var dependency2 = new Dependency(mockModel2, mockSnapshot.Object); var dependency3 = new Dependency(mockModel3, mockSnapshot.Object); var children = new Dictionary <string, IDependency>() { { dependency2.Id, dependency2 }, { dependency3.Id, dependency3 }, }; mockSnapshot.Setup(x => x.DependenciesWorld).Returns( ImmutableDictionary <string, IDependency> .Empty.AddRange(children)); Assert.True(dependency1.Dependencies.Count() == 2); Assert.True(dependency1.Dependencies.Any(x => x.Equals(dependency2))); Assert.True(dependency1.Dependencies.Any(x => x.Equals(dependency3))); }
public void DependencyExtensionsTests_ToViewModel() { var dependencyResolved = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Yyy"", ""Id"": ""tfm1\\yyy\\dependencyExisting"", ""Name"":""dependencyExisting"", ""Caption"":""DependencyExisting"", ""HasUnresolvedDependency"":""false"", ""SchemaName"":""MySchema"", ""SchemaItemType"":""MySchemaItemType"", ""Priority"":""1"", ""Resolved"":""true"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.AbsolutePosition, unresolvedIcon: KnownMonikers.AboutBox, unresolvedExpandedIcon: KnownMonikers.Abbreviation); var dependencyUnresolved = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Yyy"", ""Id"": ""tfm1\\yyy\\dependencyExisting"", ""Name"":""dependencyExisting"", ""Caption"":""DependencyExisting"", ""HasUnresolvedDependency"":""false"", ""SchemaName"":""MySchema"", ""SchemaItemType"":""MySchemaItemType"", ""Priority"":""1"", ""Resolved"":""false"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.AbsolutePosition, unresolvedIcon: KnownMonikers.AboutBox, unresolvedExpandedIcon: KnownMonikers.Abbreviation); var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("someId1", true); var viewModelResolved = dependencyResolved.ToViewModel(mockSnapshot); Assert.Equal(dependencyResolved.Caption, viewModelResolved.Caption); Assert.Equal(dependencyResolved.Flags, viewModelResolved.Flags); Assert.Equal(dependencyResolved.Id, viewModelResolved.FilePath); Assert.Equal(dependencyResolved.SchemaName, viewModelResolved.SchemaName); Assert.Equal(dependencyResolved.SchemaItemType, viewModelResolved.SchemaItemType); Assert.Equal(dependencyResolved.Priority, viewModelResolved.Priority); Assert.Equal(dependencyResolved.Icon, viewModelResolved.Icon); Assert.Equal(dependencyResolved.ExpandedIcon, viewModelResolved.ExpandedIcon); Assert.Equal(dependencyResolved.Properties, viewModelResolved.Properties); var viewModelUnresolved = dependencyUnresolved.ToViewModel(mockSnapshot); Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolved.Caption); Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolved.Flags); Assert.Equal(dependencyUnresolved.Id, viewModelUnresolved.FilePath); Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolved.SchemaName); Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolved.SchemaItemType); Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolved.Priority); Assert.Equal(dependencyUnresolved.UnresolvedIcon, viewModelUnresolved.Icon); Assert.Equal(dependencyUnresolved.UnresolvedExpandedIcon, viewModelUnresolved.ExpandedIcon); Assert.Equal(dependencyUnresolved.Properties, viewModelUnresolved.Properties); }
public void Dependency_Constructor_WhenRequiredParamsNotProvided_ShouldThrow() { Assert.Throws <ArgumentNullException>("dependencyModel", () => { new Dependency(null, null); }); Assert.Throws <ArgumentNullException>("snapshot", () => { var mockModel = IDependencyModelFactory.Create(); new Dependency(mockModel, null); }); Assert.Throws <ArgumentNullException>("ProviderType", () => { var mockModel = IDependencyModelFactory.Create(); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Create(); new Dependency(mockModel, mockSnapshot); }); Assert.Throws <ArgumentNullException>("Id", () => { var mockModel = IDependencyModelFactory.Implement(providerType: "someprovider"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Create(); new Dependency(mockModel, mockSnapshot); }); }
public void TFromChanges_Empty() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = ITargetFrameworkFactory.Implement("tfm1"); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( dependenciesWorld: new Dictionary <string, IDependency>(), topLevelDependencies: new List <IDependency>()); var addedNodes = new List <IDependencyModel>(); var removedNodes = new List <IDependencyModel>(); var changes = IDependenciesChangesFactory.Implement(addedNodes: addedNodes, removedNodes: removedNodes); IEnumerable <IDependenciesSnapshotFilter> snapshotFilters = null; var catalogs = IProjectCatalogSnapshotFactory.Create(); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, targetFramework, previousSnapshot, changes, catalogs, snapshotFilters, null, null, out bool anyChanges); Assert.NotNull(snapshot.TargetFramework); Assert.Equal("tfm1", snapshot.TargetFramework.FullName); Assert.Equal(projectPath, snapshot.ProjectPath); Assert.Equal(catalogs, snapshot.Catalogs); Assert.False(anyChanges); Assert.Empty(snapshot.TopLevelDependencies); Assert.Empty(snapshot.DependenciesWorld); }
public void TargetedDependenciesSnapshot_FromChanges_NoChanges() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = ITargetFrameworkFactory.Implement("tfm1"); var dependencyModelTop1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\topdependency1"", ""Name"":""TopDependency1"", ""Caption"":""TopDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall); var dependencyModelChild1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\childdependency1"", ""Name"":""ChildDependency1"", ""Caption"":""ChildDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( dependenciesWorld: new Dictionary <string, IDependency>() { { dependencyModelTop1.Id, dependencyModelTop1 }, { dependencyModelChild1.Id, dependencyModelChild1 }, }, topLevelDependencies: new List <IDependency>() { dependencyModelTop1 }); var addedNodes = new List <IDependencyModel>(); var removedNodes = new List <IDependencyModel>(); var changes = IDependenciesChangesFactory.Implement(addedNodes: addedNodes, removedNodes: removedNodes); IEnumerable <IDependenciesSnapshotFilter> snapshotFilters = null; var catalogs = IProjectCatalogSnapshotFactory.Create(); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, targetFramework, previousSnapshot, changes, catalogs, snapshotFilters, out bool anyChanges); Assert.NotNull(snapshot.TargetFramework); Assert.Equal("tfm1", snapshot.TargetFramework.Moniker); Assert.Equal(projectPath, snapshot.ProjectPath); Assert.Equal(catalogs, snapshot.Catalogs); Assert.False(anyChanges); Assert.Equal(1, snapshot.TopLevelDependencies.Count); Assert.Equal(2, snapshot.DependenciesWorld.Count); }
public void IsOrHasUnresolvedDependency() { var dependency1 = new TestDependency { ProviderType = "Yyy", Id = "tfm1\\yyy\\dependencyExisting", Name = "dependencyExisting", Caption = "DependencyExisting", Resolved = false }; var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(); Assert.True(dependency1.IsOrHasUnresolvedDependency(mockSnapshot)); var dependency2 = new TestDependency { ClonePropertiesFrom = dependency1, Resolved = true }; mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("tfm1\\yyy\\dependencyExisting", true); Assert.True(dependency2.IsOrHasUnresolvedDependency(mockSnapshot)); mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("tfm1\\yyy\\dependencyExisting", false); Assert.False(dependency2.IsOrHasUnresolvedDependency(mockSnapshot)); }
public void Dependency_DependencyIDsProperty() { var mockModel1 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId1", dependencyIDs: new[] { "someId2", "someId_other" }); var mockModel2 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId2"); var mockModel3 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId_other"); var targetFramework = ITargetFrameworkFactory.Implement("Tfm1"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementMock(targetFramework: targetFramework); var projectPath = "projectPath"; var dependency1 = new Dependency(mockModel1, targetFramework, projectPath); var dependency2 = new Dependency(mockModel2, targetFramework, projectPath); var dependency3 = new Dependency(mockModel3, targetFramework, projectPath); var children = new IDependency[] { dependency1, dependency2, dependency3 }.ToImmutableDictionary(d => d.Id); mockSnapshot.Setup(x => x.DependenciesWorld).Returns(children); AssertEx.CollectionLength(dependency1.DependencyIDs, 2); Assert.Contains(dependency1.DependencyIDs, x => x.Equals(dependency2.Id)); Assert.Contains(dependency1.DependencyIDs, x => x.Equals(dependency3.Id)); }
public void FromChanges_NotEmpty_NoChanges() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = new TargetFramework("tfm1"); var dependencyTop1 = new TestDependency { Id = @"tfm1\xxx\topdependency1", ProviderType = "Xxx", Resolved = true, TopLevel = true }; var catalogs = IProjectCatalogSnapshotFactory.Create(); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( projectPath: projectPath, targetFramework: targetFramework, catalogs: catalogs, dependenciesWorld: new [] { dependencyTop1 }, topLevelDependencies: new [] { dependencyTop1 }); var changes = new DependenciesChangesBuilder(); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, previousSnapshot, changes.Build(), catalogs, ImmutableArray <IDependenciesSnapshotFilter> .Empty, new Dictionary <string, IProjectDependenciesSubTreeProvider>(), null); Assert.Same(previousSnapshot, snapshot); }
public void Dependency_Constructor_WhenValidModelProvided_ShouldSetAllProperties() { const string jsonModel = @" { ""ProviderType"": ""xxx"", ""Id"": ""mymodelid"", ""Name"": ""mymodelname"", ""Version"": ""2.0.0-1"", ""Caption"": ""mymodel"", ""OriginalItemSpec"": ""mymodeloriginal"", ""Path"": ""mymodelpath"", ""SchemaName"": ""MySchema"", ""SchemaItemType"": ""MySchemaItemType"", ""Resolved"": ""true"", ""TopLevel"": ""true"", ""Implicit"": ""true"", ""Visible"": ""true"", ""Priority"": ""3"" }"; var mockModel = IDependencyModelFactory.FromJson( jsonModel, flags: DependencyTreeFlags.DependencyFlags.Union(DependencyTreeFlags.GenericDependencyFlags), icon: KnownMonikers.Path, expandedIcon: KnownMonikers.PathIcon, unresolvedIcon: KnownMonikers.PathListBox, unresolvedExpandedIcon: KnownMonikers.PathListBoxItem, properties: new Dictionary <string, string>() { { "prop1", "val1" } }, dependenciesIds: new[] { "otherid" }); var targetFramework = ITargetFrameworkFactory.Implement("Tfm1"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(targetFramework: targetFramework); var dependency = new Dependency(mockModel, mockSnapshot); Assert.Equal(mockModel.ProviderType, dependency.ProviderType); Assert.Equal(mockModel.Name, dependency.Name); Assert.Equal(mockModel.Version, dependency.Version); Assert.Equal(mockModel.Caption, dependency.Caption); Assert.Equal(mockModel.OriginalItemSpec, dependency.OriginalItemSpec); Assert.Equal(mockModel.Path, dependency.Path); Assert.Equal(mockModel.SchemaName, dependency.SchemaName); Assert.Equal(mockModel.SchemaItemType, dependency.SchemaItemType); Assert.Equal(mockModel.Resolved, dependency.Resolved); Assert.Equal(mockModel.TopLevel, dependency.TopLevel); Assert.Equal(mockModel.Implicit, dependency.Implicit); Assert.Equal(mockModel.Visible, dependency.Visible); Assert.Equal(mockModel.Priority, dependency.Priority); Assert.True(dependency.Properties.Count == 1); Assert.True(dependency.Properties.ContainsKey("prop1")); Assert.True(dependency.DependencyIDs.Count == 1); Assert.Equal("Tfm1\\xxx\\otherid", dependency.DependencyIDs[0]); Assert.True(dependency.Flags.Contains(DependencyTreeFlags.ResolvedFlags)); Assert.True(dependency.Flags.Contains(DependencyTreeFlags.DependencyFlags)); }
public void TFromChanges_NoChangesAfterBeforeRemoveFilterDeclinedChange() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = ITargetFrameworkFactory.Implement("tfm1"); var dependencyTop1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\topdependency1"", ""Name"":""TopDependency1"", ""Caption"":""TopDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"", ""TopLevel"":""true"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall); var dependencyChild1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\childdependency1"", ""Name"":""ChildDependency1"", ""Caption"":""ChildDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"", ""TopLevel"":""false"" }", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall); var catalogs = IProjectCatalogSnapshotFactory.Create(); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( projectPath: projectPath, targetFramework: targetFramework, catalogs: catalogs, dependenciesWorld: new [] { dependencyTop1, dependencyChild1 }, topLevelDependencies: new [] { dependencyTop1 }); var changes = new DependenciesChanges(); changes.IncludeRemovedChange(dependencyTop1.ProviderType, dependencyTop1.Id); var snapshotFilter = new TestDependenciesSnapshotFilter() .ImplementBeforeRemoveResult(FilterAction.Cancel, @"tfm1\xxx\newdependency1", null); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, previousSnapshot, changes, catalogs, new[] { snapshotFilter }, new Dictionary <string, IProjectDependenciesSubTreeProvider>(), null); Assert.Same(previousSnapshot, snapshot); }
public void Dependency_Id_NoSnapsotTargetFramework(string modelId, string expectedId) { var mockModel = IDependencyModelFactory.Implement(providerType: "xxx", id: modelId); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Create(); var dependency = new Dependency(mockModel, mockSnapshot); Assert.Equal(mockModel.ProviderType, dependency.ProviderType); Assert.Equal(expectedId, dependency.Id); }
public void Dependency_Id(string modelId, string expectedId) { var mockModel = IDependencyModelFactory.Implement(providerType: "providerType", id: modelId); var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(targetFramework: mockTargetFramework); var dependency = new Dependency(mockModel, mockSnapshot); Assert.Equal(mockModel.ProviderType, dependency.ProviderType); Assert.Equal(expectedId, dependency.Id); }
public void BeforeAddOrUpdate_WhenProjectSnapshotFoundAndHasUnresolvedDependencies_ShouldMakeUnresolved() { const string projectPath = @"c:\project\project.csproj"; var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement(hasUnresolvedDependency: true); var targets = new Dictionary <ITargetFramework, ITargetedDependenciesSnapshot> { { targetFramework, targetedSnapshot } }; var snapshot = IDependenciesSnapshotFactory.Implement(targets: targets); var snapshotProvider = IDependenciesSnapshotProviderFactory.Implement(currentSnapshot: snapshot); var aggregateSnapshotProvider = new Mock <IAggregateDependenciesSnapshotProvider>(MockBehavior.Strict); aggregateSnapshotProvider.Setup(x => x.GetSnapshotProvider(projectPath)).Returns(snapshotProvider); var targetFrameworkProvider = ITargetFrameworkProviderFactory.Implement(getNearestFramework: targetFramework); var dependency = new TestDependency { Id = "dependency1", TopLevel = true, Resolved = true, Flags = DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags), TargetFramework = targetFramework, FullPath = projectPath }; var worldBuilder = ImmutableDictionary <string, IDependency> .Empty.ToBuilder(); var context = new AddDependencyContext(worldBuilder); var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider.Object, targetFrameworkProvider); filter.BeforeAddOrUpdate( null, null, dependency, null, null, context); // Accepts unresolved version var acceptedDependency = context.GetResult(filter); acceptedDependency.AssertEqualTo( dependency.ToUnresolved(ProjectReference.SchemaName)); // No other changes made Assert.False(context.Changed); aggregateSnapshotProvider.VerifyAll(); }
public void FromChanges_NoChangesAfterBeforeRemoveFilterDeclinedChange() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = new TargetFramework("tfm1"); var dependencyTop1 = new TestDependency { ProviderType = "Xxx", Id = Dependency.GetID(targetFramework, "Xxx", "topdependency1"), Name = "TopDependency1", Caption = "TopDependency1", SchemaItemType = "Xxx", Resolved = true, TopLevel = true }; var dependencyChild1 = new TestDependency { ProviderType = "Xxx", Id = Dependency.GetID(targetFramework, "Xxx", "childdependency1"), Name = "ChildDependency1", Caption = "ChildDependency1", SchemaItemType = "Xxx", Resolved = true, TopLevel = false }; var catalogs = IProjectCatalogSnapshotFactory.Create(); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( projectPath: projectPath, targetFramework: targetFramework, catalogs: catalogs, dependenciesWorld: new [] { dependencyTop1, dependencyChild1 }, topLevelDependencies: new [] { dependencyTop1 }); var changes = new DependenciesChangesBuilder(); changes.Removed(dependencyTop1.ProviderType, dependencyTop1.Id); var snapshotFilter = new TestDependenciesSnapshotFilter(); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, previousSnapshot, changes.Build(), catalogs, ImmutableArray.Create <IDependenciesSnapshotFilter>(snapshotFilter), new Dictionary <string, IProjectDependenciesSubTreeProvider>(), null); Assert.Same(previousSnapshot, snapshot); }
public void FromChanges_NoChangesAfterBeforeRemoveFilterDeclinedChange() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = new TargetFramework("tfm1"); var dependencyTop1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\topdependency1"", ""Name"":""TopDependency1"", ""Caption"":""TopDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"", ""TopLevel"":""true"" }"); var dependencyChild1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Xxx"", ""Id"": ""tfm1\\xxx\\childdependency1"", ""Name"":""ChildDependency1"", ""Caption"":""ChildDependency1"", ""SchemaItemType"":""Xxx"", ""Resolved"":""true"", ""TopLevel"":""false"" }"); var catalogs = IProjectCatalogSnapshotFactory.Create(); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( projectPath: projectPath, targetFramework: targetFramework, catalogs: catalogs, dependenciesWorld: new [] { dependencyTop1, dependencyChild1 }, topLevelDependencies: new [] { dependencyTop1 }); var changes = new DependenciesChangesBuilder(); changes.Removed(dependencyTop1.ProviderType, dependencyTop1.Id); var snapshotFilter = new TestDependenciesSnapshotFilter(); var snapshot = TargetedDependenciesSnapshot.FromChanges( projectPath, previousSnapshot, changes.Build(), catalogs, ImmutableArray.Create <IDependenciesSnapshotFilter>(snapshotFilter), new Dictionary <string, IProjectDependenciesSubTreeProvider>(), null); Assert.Same(previousSnapshot, snapshot); }
public void Dependency_HasUnresolvedDependency() { var dependencyModel = new TestDependencyModel { ProviderType = "providerType", Id = "someId1", Resolved = true }; var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency(@"tfm1\providerType\someid1", hasUnresolvedDependency: true); var dependency = new Dependency(dependencyModel, new TargetFramework("tfm1"), @"C:\Foo\Project.csproj"); Assert.True(dependency.HasUnresolvedDependency(mockSnapshot)); Assert.True(dependency.IsOrHasUnresolvedDependency(mockSnapshot)); }
public void Dependency_HasUnresolvedDependency() { var mockModel1 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId1", resolved: true); var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency(@"tfm1\providerType\someid1", hasUnresolvedDependency: true); var dependency = new Dependency(mockModel1, ITargetFrameworkFactory.Implement("tfm1"), @"C:\Foo\Project.csproj"); Assert.True(dependency.HasUnresolvedDependency(mockSnapshot)); Assert.True(dependency.IsOrHasUnresolvedDependency(mockSnapshot)); }
public void Dependency_HasUnresolvedDependency() { var mockModel1 = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId1", resolved: true); var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("someId1", true); var dependency = new Dependency(mockModel1, mockSnapshot); Assert.True(dependency.HasUnresolvedDependency); Assert.True(dependency.IsOrHasUnresolvedDependency()); }
public void Dependency_Alias(string originalItemSpec, string path, string caption, string expectedAlias) { var mockModel = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId", originalItemSpec: originalItemSpec, path: path, caption: caption); var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(targetFramework: mockTargetFramework); var dependency = new Dependency(mockModel, mockSnapshot); Assert.Equal(expectedAlias, dependency.Alias); }
public void DependencyExtensionsTests_HasSameTarget() { var targetedSnapshot1 = ITargetedDependenciesSnapshotFactory.Implement( targetFramework: ITargetFrameworkFactory.Implement("tfm1")); var targetedSnapshot2 = ITargetedDependenciesSnapshotFactory.Implement( targetFramework: ITargetFrameworkFactory.Implement("tfm2")); var dependency1 = IDependencyFactory.Implement(snapshot: targetedSnapshot1).Object; var dependency2 = IDependencyFactory.Implement(snapshot: targetedSnapshot1).Object; var dependency3 = IDependencyFactory.Implement(snapshot: targetedSnapshot2).Object; Assert.True(dependency1.HasSameTarget(dependency2)); Assert.False(dependency1.HasSameTarget(dependency3)); }
public void DependenciesViewModelFactoryTests_CreateTargetViewModel_NoUnresolvedDependency() { var project = UnconfiguredProjectFactory.Create(); var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tFm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement( hasUnresolvedDependency: false, targetFramework: targetFramework); var factory = new DependenciesViewModelFactory(project); var result = factory.CreateTargetViewModel(targetedSnapshot); Assert.NotNull(result); Assert.Equal(targetFramework.Moniker, result.Caption); Assert.Equal(KnownMonikers.Library, result.Icon); Assert.Equal(KnownMonikers.Library, result.ExpandedIcon); Assert.True(result.Flags.Contains(DependencyTreeFlags.TargetNodeFlags)); Assert.True(result.Flags.Contains("$TFM:tFm1")); }
public void CreateTargetViewModel_HasUnresolvedDependency() { var project = UnconfiguredProjectFactory.Create(); var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tFm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement( hasUnresolvedDependency: true, targetFramework: targetFramework); var factory = new DependenciesViewModelFactory(project); var result = factory.CreateTargetViewModel(targetedSnapshot); Assert.NotNull(result); Assert.Equal(targetFramework.FullName, result.Caption); Assert.Equal(ManagedImageMonikers.LibraryWarning, result.Icon); Assert.Equal(ManagedImageMonikers.LibraryWarning, result.ExpandedIcon); Assert.True(result.Flags.Contains(DependencyTreeFlags.TargetNode)); Assert.True(result.Flags.Contains("$TFM:tFm1")); }
public void BeforeAddOrUpdate_WhenProjectSnapshotFoundAndNoUnresolvedDependencies_ShouldDoNothing() { const string projectPath = @"c:\project\project.csproj"; var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm1"); var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement(hasUnresolvedDependency: false); var dependency = new TestDependency { Id = "dependency1", TopLevel = true, Resolved = true, Flags = DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags), FullPath = projectPath, TargetFramework = targetFramework }; var aggregateSnapshotProvider = new Mock <IAggregateDependenciesSnapshotProvider>(MockBehavior.Strict); aggregateSnapshotProvider.Setup(x => x.GetSnapshot(dependency)).Returns(targetedSnapshot); var worldBuilder = ImmutableDictionary <string, IDependency> .Empty.ToBuilder(); var context = new AddDependencyContext(worldBuilder); var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider.Object); filter.BeforeAddOrUpdate( null, null, dependency, null, null, context); // Accepts unchanged dependency Assert.Same(dependency, context.GetResult(filter)); // No other changes made Assert.False(context.Changed); aggregateSnapshotProvider.VerifyAll(); }
private IDependenciesSnapshot GetSnapshot(Dictionary <ITargetFramework, List <IDependency> > testData) { var catalogs = IProjectCatalogSnapshotFactory.Create(); var targets = new Dictionary <ITargetFramework, ITargetedDependenciesSnapshot>(); foreach (var kvp in testData) { var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement( catalogs: catalogs, topLevelDependencies: kvp.Value, checkForUnresolvedDependencies: false, targetFramework: kvp.Key); targets.Add(kvp.Key, targetedSnapshot); } return(IDependenciesSnapshotFactory.Implement( targets: targets, hasUnresolvedDependency: false, activeTarget: testData.First().Key)); }
public void Dependency_SetProperties() { var mockModel = IDependencyModelFactory.Implement( providerType: "providerType", id: "someId"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(); var dependency = new Dependency(mockModel, mockSnapshot); var newDependency = dependency.SetProperties( caption: "newcaption", resolved: true, flags: DependencyTreeFlags.BaseReferenceFlags, dependencyIDs: ImmutableList <string> .Empty.Add("aaa")); Assert.Equal("newcaption", newDependency.Caption); Assert.Equal(true, newDependency.Resolved); Assert.True(newDependency.Flags.Equals(DependencyTreeFlags.BaseReferenceFlags)); Assert.True(newDependency.DependencyIDs.Count == 1); }
public void IsOrHasUnresolvedDependency() { var dependency1 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Yyy"", ""Id"": ""tfm1\\yyy\\dependencyExisting"", ""Name"":""dependencyExisting"", ""Caption"":""DependencyExisting"", ""Resolved"":""false"" }"); var mockSnapshot = ITargetedDependenciesSnapshotFactory.Implement(); Assert.True(dependency1.IsOrHasUnresolvedDependency(mockSnapshot)); var dependency2 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Yyy"", ""Id"": ""tfm1\\yyy\\dependencyExisting"", ""Name"":""dependencyExisting"", ""Caption"":""DependencyExisting"", ""Resolved"":""true"" }"); mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("tfm1\\yyy\\dependencyExisting", true); Assert.True(dependency2.IsOrHasUnresolvedDependency(mockSnapshot)); var dependency3 = IDependencyFactory.FromJson(@" { ""ProviderType"": ""Yyy"", ""Id"": ""tfm1\\yyy\\dependencyExisting"", ""Name"":""dependencyExisting"", ""Caption"":""DependencyExisting"", ""Resolved"":""true"" }"); mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementHasUnresolvedDependency("tfm1\\yyy\\dependencyExisting", false); Assert.False(dependency3.IsOrHasUnresolvedDependency(mockSnapshot)); }
public void TConstructor() { const string projectPath = @"c:\somefolder\someproject\a.csproj"; var targetFramework = ITargetFrameworkFactory.Implement("tfm1"); var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement( dependenciesWorld: new Dictionary <string, IDependency>(), topLevelDependencies: new List <IDependency>()); var catalogs = IProjectCatalogSnapshotFactory.Create(); var snapshot = new TestableTargetedDependenciesSnapshot( projectPath, targetFramework, previousSnapshot, catalogs); Assert.NotNull(snapshot.TargetFramework); Assert.Equal("tfm1", snapshot.TargetFramework.FullName); Assert.Equal(projectPath, snapshot.ProjectPath); Assert.Equal(catalogs, snapshot.Catalogs); Assert.Equal(previousSnapshot.TopLevelDependencies, snapshot.TopLevelDependencies); Assert.Equal(previousSnapshot.DependenciesWorld, snapshot.DependenciesWorld); }