public void HasSameTarget()
{
var targetFramework1 = ITargetFrameworkFactory.Implement("tfm1");
var targetFramework2 = ITargetFrameworkFactory.Implement("tfm2");
var dependency1 = IDependencyFactory.Implement(targetFramework: targetFramework1).Object;
var dependency2 = IDependencyFactory.Implement(targetFramework: targetFramework1).Object;
var dependency3 = IDependencyFactory.Implement(targetFramework: targetFramework2).Object;
Assert.True(dependency1.HasSameTarget(dependency2));
Assert.False(dependency1.HasSameTarget(dependency3));
}
public void SdkAndPackagesDependenciesSnapshotFilter_WhenPackage_ShouldFindMatchingSdkAndSetProperties()
{
var dependencyIDs = new List <string> {
"id1", "id2"
}.ToImmutableList();
var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm");
var dependency = IDependencyFactory.Implement(
id: "mydependency1id",
flags: DependencyTreeFlags.PackageNodeFlags,
name: "mydependency1",
topLevel: true,
resolved: true,
dependencyIDs: dependencyIDs);
var flags = DependencyTreeFlags.PackageNodeFlags
.Union(DependencyTreeFlags.ResolvedFlags)
.Except(DependencyTreeFlags.UnresolvedFlags);
var sdkDependency = IDependencyFactory.Implement(
id: $"tfm\\{SdkRuleHandler.ProviderTypeString}\\mydependency1",
flags: DependencyTreeFlags.PackageNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags), // to see if unresolved is fixed
setPropertiesResolved: true,
setPropertiesDependencyIDs: dependencyIDs,
setPropertiesFlags: flags,
setPropertiesSchemaName: ResolvedSdkReference.SchemaName,
equals: true);
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
{ sdkDependency.Object.Id, sdkDependency.Object }
}.ToImmutableDictionary().ToBuilder();
var topLevelBuilder = ImmutableHashSet <IDependency> .Empty.Add(sdkDependency.Object).ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
mockTargetFramework,
dependency.Object,
worldBuilder,
topLevelBuilder,
out bool filterAnyChanges);
dependency.VerifyAll();
sdkDependency.VerifyAll();
Assert.True(topLevelBuilder.First().Id.Equals(sdkDependency.Object.Id));
}
public void Dependency_Constructor_WhenValidModelProvided_ShouldSetAllProperties()
{
var mockModel = IDependencyModelFactory.FromJson(@"
{
""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""
}",
flags: DependencyTreeFlags.DependencyFlags.Union(DependencyTreeFlags.GenericDependency),
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 dependency = new Dependency(mockModel, targetFramework, @"C:\Foo\Project.csproj");
Assert.Equal(mockModel.ProviderType, dependency.ProviderType);
Assert.Equal(mockModel.Name, dependency.Name);
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.Single(dependency.Properties);
Assert.True(dependency.Properties.ContainsKey("prop1"));
Assert.Single(dependency.DependencyIDs);
Assert.Equal("Tfm1\\xxx\\otherid", dependency.DependencyIDs[0]);
Assert.True(dependency.Flags.Contains(DependencyTreeFlags.Resolved));
Assert.True(dependency.Flags.Contains(DependencyTreeFlags.DependencyFlags));
}
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 dependency = new Dependency(mockModel, mockTargetFramework, @"C:\Foo\Project.csproj");
Assert.Equal(expectedAlias, dependency.Alias);
}
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 BeforeAddOrUpdate_WhenProjectSnapshotFoundAndNoUnresolvedDependencies_ShouldDoNothing()
{
const string projectPath = @"c:\project\project.csproj";
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 = 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),
FullPath = projectPath,
TargetFramework = targetFramework
};
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 unchanged dependency
Assert.Same(dependency, context.GetResult(filter));
// No other changes made
Assert.False(context.Changed);
aggregateSnapshotProvider.VerifyAll();
}
public void WhenSdk_ShouldFindMatchingPackageAndSetProperties()
{
var dependencyIDs = new List <string> {
"id1", "id2"
}.ToImmutableList();
var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm");
var flags = DependencyTreeFlags.SdkSubTreeNodeFlags
.Union(DependencyTreeFlags.ResolvedFlags)
.Except(DependencyTreeFlags.UnresolvedFlags);
var sdkDependency = IDependencyFactory.Implement(
flags: DependencyTreeFlags.SdkSubTreeNodeFlags,
id: "mydependency1id",
name: "mydependency1",
topLevel: true,
setPropertiesDependencyIDs: dependencyIDs,
setPropertiesResolved: true,
setPropertiesSchemaName: ResolvedSdkReference.SchemaName,
setPropertiesFlags: flags);
var otherDependency = IDependencyFactory.Implement(
id: $"tfm\\{PackageRuleHandler.ProviderTypeString}\\mydependency1",
resolved: true,
dependencyIDs: dependencyIDs);
var topLevelBuilder = ImmutableHashSet <IDependency> .Empty.Add(sdkDependency.Object).ToBuilder();
var worldBuilder = new Dictionary <string, IDependency>()
{
{ sdkDependency.Object.Id, sdkDependency.Object },
{ otherDependency.Object.Id, otherDependency.Object }
}.ToImmutableDictionary().ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
mockTargetFramework,
sdkDependency.Object,
worldBuilder,
topLevelBuilder,
null,
null,
out bool filterAnyChanges);
sdkDependency.VerifyAll();
otherDependency.VerifyAll();
}
public void WhenPackageRemoving_ShouldCleanupSdk()
{
var dependencyIDs = ImmutableList <string> .Empty;
var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm");
var dependency = IDependencyFactory.Implement(
id: "mydependency1id",
flags: DependencyTreeFlags.PackageNodeFlags,
name: "mydependency1",
topLevel: true,
resolved: true);
var flags = DependencyTreeFlags.SdkSubTreeNodeFlags
.Union(DependencyTreeFlags.UnresolvedFlags)
.Except(DependencyTreeFlags.ResolvedFlags);
var sdkDependency = IDependencyFactory.Implement(
id: $"tfm\\{SdkRuleHandler.ProviderTypeString}\\mydependency1",
flags: DependencyTreeFlags.SdkSubTreeNodeFlags.Union(DependencyTreeFlags.ResolvedFlags), // to see if resolved is fixed
setPropertiesDependencyIDs: dependencyIDs,
setPropertiesResolved: false,
setPropertiesSchemaName: SdkReference.SchemaName,
setPropertiesFlags: flags);
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
{ sdkDependency.Object.Id, sdkDependency.Object },
}.ToImmutableDictionary().ToBuilder();
// try to have empty top level hash set - no error should happen when removing sdk and readding
var topLevelBuilder = ImmutableHashSet <IDependency> .Empty.ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeRemove(
null,
mockTargetFramework,
dependency.Object,
worldBuilder,
topLevelBuilder,
out bool filterAnyChanges);
dependency.VerifyAll();
sdkDependency.VerifyAll();
Assert.Equal(topLevelBuilder.First().Id, sdkDependency.Object.Id);
}
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 BeforeAddOrUpdate_WhenProjectSnapshotFoundAndHasUnresolvedDependencies_ShouldMakeUnresolved()
{
const string projectPath = @"c:\project\project.csproj";
var targetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm1");
var dependency = new TestDependency
{
Id = "dependency1",
TopLevel = true,
Resolved = true,
Flags = DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags),
TargetFramework = targetFramework,
FullPath = projectPath
};
var targetedSnapshot = ITargetedDependenciesSnapshotFactory.Implement(hasUnresolvedDependency: true);
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 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 TCreateEmpty()
{
const string projectPath = @"c:\somefolder\someproject\a.csproj";
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var catalogs = IProjectCatalogSnapshotFactory.Create();
var snapshot = TargetedDependenciesSnapshot.CreateEmpty(projectPath, targetFramework, catalogs);
Assert.Same(projectPath, snapshot.ProjectPath);
Assert.Same(catalogs, snapshot.Catalogs);
Assert.Same(targetFramework, snapshot.TargetFramework);
Assert.False(snapshot.HasUnresolvedDependency);
Assert.Empty(snapshot.DependenciesWorld);
Assert.Empty(snapshot.TopLevelDependencies);
Assert.False(snapshot.CheckForUnresolvedDependencies("foo"));
Assert.Empty(snapshot.GetDependencyChildren(new TestDependency()));
}
public void TConstructor()
{
const string projectPath = @"c:\somefolder\someproject\a.csproj";
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var catalogs = IProjectCatalogSnapshotFactory.Create();
var snapshot = new TargetedDependenciesSnapshot(
projectPath,
targetFramework,
catalogs,
ImmutableDictionary <string, IDependency> .Empty);
Assert.NotNull(snapshot.TargetFramework);
Assert.Equal("tfm1", snapshot.TargetFramework.FullName);
Assert.Equal(projectPath, snapshot.ProjectPath);
Assert.Equal(catalogs, snapshot.Catalogs);
Assert.Empty(snapshot.TopLevelDependencies);
Assert.Empty(snapshot.DependenciesWorld);
}
public void Dependency_SetProperties()
{
var mockModel = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId");
var dependency = new Dependency(mockModel, ITargetFrameworkFactory.Implement("tfm1"));
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 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 GetTopLevelId()
{
var dependency1 = IDependencyFactory.FromJson(@"
{
""Id"":""id1"",
""ProviderType"": ""ProjectDependency""
}");
Assert.Equal("id1", dependency1.GetTopLevelId());
var dependency2 = IDependencyFactory.FromJson(@"
{
""Id"":""id1"",
""Path"":""xxxxxxx"",
""ProviderType"": ""MyProvider""
}", targetFramework: ITargetFrameworkFactory.Implement("tfm1"));
Assert.Equal("tfm1\\MyProvider\\xxxxxxx", dependency2.GetTopLevelId());
}
public void Dependency_SetProperties()
{
var mockModel = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId");
var dependency = new Dependency(mockModel, ITargetFrameworkFactory.Implement("tfm1"), @"C:\Foo\Project.csproj");
var newDependency = dependency.SetProperties(
caption: "newcaption",
resolved: true,
flags: DependencyTreeFlags.BaseReferenceFlags,
dependencyIDs: ImmutableArray.Create("aaa"));
Assert.Equal("newcaption", newDependency.Caption);
Assert.True(newDependency.Resolved);
Assert.True(newDependency.Flags.Equals(DependencyTreeFlags.BaseReferenceFlags));
Assert.Single(newDependency.DependencyIDs);
Assert.Equal("aaa", newDependency.DependencyIDs[0]);
}
public void TFromChanges_Empty()
{
const string projectPath = @"c:\somefolder\someproject\a.csproj";
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var catalogs = IProjectCatalogSnapshotFactory.Create();
var previousSnapshot = TargetedDependenciesSnapshot.CreateEmpty(projectPath, targetFramework, catalogs);
var changes = new DependenciesChanges();
var snapshot = TargetedDependenciesSnapshot.FromChanges(
projectPath,
previousSnapshot,
changes,
catalogs,
Array.Empty <IDependenciesSnapshotFilter>(),
new Dictionary <string, IProjectDependenciesSubTreeProvider>(),
null);
Assert.Same(previousSnapshot, snapshot);
}
public void Dependency_EqualsAndGetHashCode()
{
var mockModel1 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId1");
var mockModel2 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId1");
var mockModel3 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId_other");
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var dependency1 = new Dependency(mockModel1, targetFramework);
var dependency2 = new Dependency(mockModel2, targetFramework);
var dependency3 = new Dependency(mockModel3, targetFramework);
Assert.Equal(dependency1, dependency2);
Assert.NotEqual(dependency1, dependency3);
Assert.Equal(@"tfm1\providertype\someid1".GetHashCode(), dependency1.GetHashCode());
}
public void WhenSdkAndPackageUnresolved_ShouldDoNothing()
{
var dependencyIDs = new List <string> {
"id1", "id2"
}.ToImmutableList();
var mockTargetFramework = ITargetFrameworkFactory.Implement(moniker: "tfm");
var dependency = IDependencyFactory.Implement(
flags: DependencyTreeFlags.SdkSubTreeNodeFlags,
id: "mydependency1id",
name: "mydependency1",
topLevel: true);
var otherDependency = IDependencyFactory.Implement(
id: $"tfm\\{PackageRuleHandler.ProviderTypeString}\\mydependency1",
resolved: false);
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
{ otherDependency.Object.Id, otherDependency.Object }
}.ToImmutableDictionary().ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
mockTargetFramework,
dependency.Object,
worldBuilder,
null,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
otherDependency.VerifyAll();
}
public void Dependency_Constructor_WhenOptionalValuesNotProvided_ShouldSetDefaults()
{
var mockModel = IDependencyModelFactory.FromJson(@"
{
""ProviderType"": ""xxx"",
""Id"": ""mymodel""
}");
var dependency = new Dependency(mockModel, ITargetFrameworkFactory.Implement("tfm1"), @"C:\Foo\Project.csproj");
Assert.Equal(mockModel.ProviderType, dependency.ProviderType);
Assert.Equal(string.Empty, dependency.Name);
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);
AssertEx.CollectionLength(dependency.Properties, 2);
Assert.True(dependency.Properties.ContainsKey("Identity"));
Assert.True(dependency.Properties.ContainsKey("FullPath"));
Assert.Empty(dependency.DependencyIDs);
}
public void TargetedDependenciesSnapshot_Constructor()
{
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.Moniker);
Assert.Equal(projectPath, snapshot.ProjectPath);
Assert.Equal(catalogs, snapshot.Catalogs);
Assert.Equal(previousSnapshot.TopLevelDependencies, snapshot.TopLevelDependencies);
Assert.Equal(previousSnapshot.DependenciesWorld, snapshot.DependenciesWorld);
}
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(
targetFramework: targetFramework,
topLevel: true,
resolved: true,
flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags),
fullPath: @"c:\myproject1\project.csproj",
setPropertiesResolved: false,
setPropertiesSchemaName: ProjectReference.SchemaName,
setPropertiesFlags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags));
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, targetFrameworkProvider);
var resultDependency = filter.BeforeAdd(
null,
null,
dependency.Object,
null,
null,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
}
public void Dependency_EqualsAndGetHashCode()
{
var mockModel1 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId1");
var mockModel2 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId1");
var mockModel3 = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "someId_other");
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var dependency1 = new Dependency(mockModel1, targetFramework, @"C:\Foo\Project.csproj");
var dependency2 = new Dependency(mockModel2, targetFramework, @"C:\Foo\Project.csproj");
var dependency3 = new Dependency(mockModel3, targetFramework, @"C:\Foo\Project.csproj");
Assert.Equal(dependency1, dependency2);
Assert.NotEqual(dependency1, dependency3);
Assert.False(dependency1.Equals(other: null));
Assert.Equal(dependency1.GetHashCode(), dependency2.GetHashCode());
Assert.NotEqual(dependency1.GetHashCode(), dependency3.GetHashCode());
}
public void Dependency_SetProperties_PreservesDependencyIDs()
{
var mockModel = IDependencyModelFactory.Implement(
providerType: "providerType",
id: "cube",
dependencyIDs: ImmutableList <string> .Empty.Add("glass"));
var dependency = new Dependency(mockModel, ITargetFrameworkFactory.Implement("tfm1"), @"C:\Foo\Project.csproj");
var expectedId = "tfm1\\providerType\\cube";
var expectedDependencyId = "tfm1\\providerType\\glass";
Assert.Equal(expectedId, dependency.Id);
Assert.Single(dependency.DependencyIDs);
Assert.Equal(expectedDependencyId, dependency.DependencyIDs[0]);
var newDependency = dependency.SetProperties(
caption: "newcaption");
Assert.Equal("newcaption", newDependency.Caption);
Assert.Equal(expectedId, newDependency.Id);
Assert.Single(newDependency.DependencyIDs);
Assert.Equal(expectedDependencyId, newDependency.DependencyIDs[0]);
}
public void Dependency_Constructor_WhenOptionalValuesNotProvided_ShouldSetDefaults()
{
const string jsonModel = @"
{
""ProviderType"": ""xxx"",
""Id"": ""mymodel""
}";
var mockModel = IDependencyModelFactory.FromJson(jsonModel);
var dependency = new Dependency(mockModel, ITargetFrameworkFactory.Implement("tfm1"));
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 TFromChanges_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,
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.Single(snapshot.TopLevelDependencies);
AssertEx.CollectionLength(snapshot.DependenciesWorld, 2);
}
public void TFromChanges_RemovedAndAddedChanges()
{
const string projectPath = @"c:\somefolder\someproject\a.csproj";
var targetFramework = ITargetFrameworkFactory.Implement("tfm1");
var dependencyModelTop1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""topdependency1"",
""Name"":""TopDependency1"",
""Caption"":""TopDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyModelChild1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""childdependency1"",
""Name"":""ChildDependency1"",
""Caption"":""ChildDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyModelAdded1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""addeddependency1"",
""Name"":""AddedDependency1"",
""Caption"":""AddedDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyModelAdded2 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""addeddependency2"",
""Name"":""AddedDependency2"",
""Caption"":""AddedDependency2"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyModelAdded3 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""addeddependency3"",
""Name"":""AddedDependency3"",
""Caption"":""AddedDependency3"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true"",
""TopLevel"":""false""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyAdded2Changed = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""tfm1\\xxx\\addeddependency2"",
""Name"":""AddedDependency2Changed"",
""Caption"":""AddedDependency2Changed"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyRemoved1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""tfm1\\xxx\\Removeddependency1"",
""Name"":""RemovedDependency1"",
""Caption"":""RemovedDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyModelRemoved1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""Removeddependency1"",
""Name"":""RemovedDependency1"",
""Caption"":""RemovedDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var dependencyInsteadRemoved1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""tfm1\\xxx\\InsteadRemoveddependency1"",
""Name"":""InsteadRemovedDependency1"",
""Caption"":""InsteadRemovedDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement(
dependenciesWorld: new Dictionary <string, IDependency>()
{
{ @"tfm1\xxx\topdependency1", dependencyModelTop1 },
{ @"tfm1\xxx\childdependency1", dependencyModelChild1 },
{ @"tfm1\xxx\Removeddependency1", dependencyRemoved1 },
},
topLevelDependencies: new List <IDependency>()
{
dependencyModelTop1
});
var addedNodes = new List <IDependencyModel> {
dependencyModelAdded1, dependencyModelAdded2, dependencyModelAdded3
};
var removedNodes = new List <IDependencyModel> {
dependencyModelRemoved1
};
var changes = IDependenciesChangesFactory.Implement(addedNodes: addedNodes, removedNodes: removedNodes);
var snapshotFilter = new TestDependenciesSnapshotFilter()
.ImplementBeforeAddResult(FilterAction.Cancel, @"tfm1\xxx\addeddependency1", null)
.ImplementBeforeAddResult(FilterAction.ShouldBeAdded, @"tfm1\xxx\addeddependency2", dependencyAdded2Changed)
.ImplementBeforeRemoveResult(FilterAction.ShouldBeAdded, @"tfm1\xxx\Removeddependency1", dependencyInsteadRemoved1);
var catalogs = IProjectCatalogSnapshotFactory.Create();
var snapshot = TargetedDependenciesSnapshot.FromChanges(
projectPath,
targetFramework,
previousSnapshot,
changes,
catalogs,
new[] { snapshotFilter },
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.True(anyChanges);
AssertEx.CollectionLength(snapshot.TopLevelDependencies, 2);
Assert.Contains(snapshot.TopLevelDependencies, x => x.Id.Equals(@"topdependency1"));
Assert.Contains(snapshot.TopLevelDependencies, x => x.Id.Equals(@"tfm1\xxx\addeddependency2") && x.Caption.Equals("AddedDependency2Changed"));
AssertEx.CollectionLength(snapshot.DependenciesWorld, 5);
Assert.True(snapshot.DependenciesWorld.ContainsKey(@"tfm1\xxx\topdependency1"));
Assert.True(snapshot.DependenciesWorld.ContainsKey(@"tfm1\xxx\childdependency1"));
Assert.True(snapshot.DependenciesWorld.ContainsKey(@"tfm1\xxx\addeddependency2"));
Assert.True(snapshot.DependenciesWorld.ContainsKey(@"tfm1\xxx\InsteadRemoveddependency1"));
Assert.True(snapshot.DependenciesWorld.ContainsKey(@"tfm1\xxx\addeddependency3"));
}
public void TFromChanges_ReportedChangesAfterBeforeRemoveFilterDeclinedChange()
{
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 dependencyModelTop1Removed = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""topdependency1"",
""Name"":""TopDependency1"",
""Caption"":""TopDependency1"",
""SchemaItemType"":""Xxx"",
""Resolved"":""true""
}", icon: KnownMonikers.Uninstall, expandedIcon: KnownMonikers.Uninstall);
var previousSnapshot = ITargetedDependenciesSnapshotFactory.Implement(
dependenciesWorld: new Dictionary <string, IDependency>(StringComparer.OrdinalIgnoreCase)
{
{ dependencyModelTop1.Id, dependencyModelTop1 },
{ dependencyModelChild1.Id, dependencyModelChild1 },
},
topLevelDependencies: new List <IDependency>()
{
dependencyModelTop1
});
var addedNodes = new List <IDependencyModel>();
var removedNodes = new List <IDependencyModel> {
dependencyModelTop1Removed
};
var changes = IDependenciesChangesFactory.Implement(addedNodes: addedNodes, removedNodes: removedNodes);
var snapshotFilter = new TestDependenciesSnapshotFilter()
.ImplementBeforeRemoveResult(FilterAction.Cancel, @"tfm1\xxx\topdependency1", null)
.ImplementFilterAnyChanges(true);
var catalogs = IProjectCatalogSnapshotFactory.Create();
var snapshot = TargetedDependenciesSnapshot.FromChanges(
projectPath,
targetFramework,
previousSnapshot,
changes,
catalogs,
new[] { snapshotFilter },
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.True(anyChanges);
Assert.Single(snapshot.TopLevelDependencies);
AssertEx.CollectionLength(snapshot.DependenciesWorld, 2);
}
public void TargetedDependenciesSnapshot_FromChanges_NoChangesAfterBeforeAddFilterDeclinedChange()
{
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 dependencyModelNew1 = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Xxx"",
""Id"": ""newdependency1"",
""Name"":""NewDependency1"",
""Caption"":""NewDependency1"",
""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> {
dependencyModelNew1
};
var removedNodes = new List <IDependencyModel>();
var changes = IDependenciesChangesFactory.Implement(addedNodes: addedNodes, removedNodes: removedNodes);
var snapshotFilter = new TestDependenciesSnapshotFilter()
.ImplementBeforeAddResult(FilterAction.Cancel, @"tfm1\xxx\newdependency1", null);
var catalogs = IProjectCatalogSnapshotFactory.Create();
var snapshot = TargetedDependenciesSnapshot.FromChanges(
projectPath,
targetFramework,
previousSnapshot,
changes,
catalogs,
new[] { snapshotFilter },
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);
}
