public void WhenNotTopLevelOrResolved_ShouldDoNothing()
{
var dependency = IDependencyFactory.Implement(
id: "mydependency1",
topLevel: false);
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
}.ToImmutableDictionary().ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
null,
dependency.Object,
worldBuilder,
null,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
}
public void WhenSdkAndPackageUnresolved_ShouldDoNothing()
{
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[] { dependency.Object, otherDependency.Object }.ToImmutableDictionary(d => d.Id).ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
mockTargetFramework,
dependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
otherDependency.VerifyAll();
}
public void 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,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
sdkDependency.VerifyAll();
Assert.Equal(topLevelBuilder.First().Id, sdkDependency.Object.Id);
}
public void BeforeAddOrUpdate_WhenSdk_ShouldFindMatchingPackageAndSetProperties()
{
var dependencyIDs = ImmutableList.Create("id1", "id2");
var targetFramework = new TargetFramework("tfm");
const string sdkName = "sdkName";
var sdkDependency = new TestDependency
{
Id = "dependency1Id",
Name = sdkName,
TopLevel = true,
Resolved = false,
Flags = DependencyTreeFlags.SdkSubTreeNodeFlags
};
var packageDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, PackageRuleHandler.ProviderTypeString, sdkName),
Resolved = true,
DependencyIDs = dependencyIDs,
Flags = DependencyTreeFlags.PackageNodeFlags
};
var worldBuilder = new IDependency[] { sdkDependency, packageDependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new AddDependencyContext(worldBuilder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
null,
targetFramework,
sdkDependency,
null,
null,
context);
var acceptedDependency = context.GetResult(filter);
// Dependency should be accepted, but converted to resolved state
Assert.NotNull(acceptedDependency);
Assert.NotSame(sdkDependency, acceptedDependency);
acceptedDependency.AssertEqualTo(
sdkDependency.ToResolved(
schemaName: ResolvedSdkReference.SchemaName,
dependencyIDs: dependencyIDs));
// No changes other than the filtered dependency
Assert.False(context.Changed);
}
public void BeforeAddOrUpdate_WhenPackage_ShouldFindMatchingSdkAndSetProperties()
{
var dependencyIDs = ImmutableList.Create("id1", "id2");
var targetFramework = new TargetFramework("tfm");
const string packageName = "packageName";
var sdkDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, packageName),
TopLevel = false,
Resolved = true,
Flags = DependencyTreeFlags.PackageNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags) // to see if unresolved is fixed
};
var packageDependency = new TestDependency
{
Id = "packageId",
Name = packageName,
Flags = DependencyTreeFlags.PackageNodeFlags,
TopLevel = true,
Resolved = true,
DependencyIDs = dependencyIDs
};
var worldBuilder = new IDependency[] { packageDependency, sdkDependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new AddDependencyContext(worldBuilder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
null,
targetFramework,
packageDependency,
null,
null,
context);
// Accepts unchanged dependency
Assert.Same(packageDependency, context.GetResult(filter));
// Other changes made
Assert.True(context.Changed);
Assert.True(context.TryGetDependency(sdkDependency.Id, out IDependency sdkDependencyAfter));
sdkDependencyAfter.AssertEqualTo(
sdkDependency.ToResolved(
schemaName: ResolvedSdkReference.SchemaName,
dependencyIDs: dependencyIDs));
}
public void WhenPackageRemoving_ShouldCleanupSdk()
{
var resolvedFlags = DependencyTreeFlags.SdkSubTreeNodeFlags.Union(DependencyTreeFlags.ResolvedFlags);
var unresolvedFlags = DependencyTreeFlags.SdkSubTreeNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags).Except(DependencyTreeFlags.ResolvedFlags);
var targetFramework = new TargetFramework("tfm");
var packageName = "mydependency1";
var packageDependency = IDependencyFactory.Implement(
id: "mydependency1id",
flags: DependencyTreeFlags.PackageNodeFlags,
name: packageName,
topLevel: true,
resolved: true);
var modifiedSdkDependency = IDependencyFactory.Implement().Object;
var sdkDependency = IDependencyFactory.Implement(
id: $"{targetFramework.ShortName}\\{SdkRuleHandler.ProviderTypeString}\\{packageName}",
flags: resolvedFlags,
setPropertiesDependencyIDs: ImmutableList <string> .Empty,
setPropertiesResolved: false,
setPropertiesSchemaName: SdkReference.SchemaName,
setPropertiesFlags: unresolvedFlags,
setPropertiesReturn: modifiedSdkDependency,
mockBehavior: MockBehavior.Loose);
var worldBuilder = new[] { packageDependency.Object, sdkDependency.Object }.ToImmutableDictionary(d => d.Id).ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
Assert.True(filter.BeforeRemove(
projectPath: null,
targetFramework,
packageDependency.Object,
worldBuilder,
out bool filterAnyChanges));
packageDependency.VerifyAll();
sdkDependency.VerifyAll();
Assert.True(filterAnyChanges);
Assert.True(worldBuilder.TryGetValue(packageDependency.Object.Id, out var afterPackageDependency));
Assert.Same(packageDependency.Object, afterPackageDependency);
Assert.True(worldBuilder.TryGetValue(sdkDependency.Object.Id, out var afterSdkDependency));
Assert.Same(modifiedSdkDependency, afterSdkDependency);
}
public void BeforeRemove_WhenPackageRemoving_ShouldCleanupSdk()
{
const string packageName = "packageName";
var targetFramework = new TargetFramework("tfm");
var sdkDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, packageName),
TopLevel = false,
Resolved = true,
Flags = DependencyTreeFlags.SdkSubTreeNodeFlags.Union(DependencyTreeFlags.ResolvedFlags)
};
var packageDependency = new TestDependency
{
Id = "packageId",
Name = packageName,
Flags = DependencyTreeFlags.PackageNodeFlags,
TopLevel = true,
Resolved = true
};
var worldBuilder = new IDependency[] { packageDependency, sdkDependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new RemoveDependencyContext(worldBuilder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeRemove(
projectPath: null,
targetFramework: targetFramework,
dependency: packageDependency,
context);
// Accepts removal
Assert.True(context.GetResult(filter));
// Makes other changes too
Assert.True(context.Changed);
Assert.True(worldBuilder.TryGetValue(packageDependency.Id, out var afterPackageDependency));
Assert.Same(packageDependency, afterPackageDependency);
Assert.True(worldBuilder.TryGetValue(sdkDependency.Id, out var afterSdkDependency));
afterSdkDependency.AssertEqualTo(
afterSdkDependency.ToUnresolved(
SdkReference.SchemaName,
dependencyIDs: ImmutableList <string> .Empty));
}
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 BeforeRemove_WhenPackageRemoving_ShouldCleanupSdk()
{
const string packageName = "packageName";
var targetFramework = new TargetFramework("tfm");
var sdkDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, packageName),
Resolved = true,
Flags = DependencyTreeFlags.SdkDependency.Union(DependencyTreeFlags.Resolved)
};
var packageDependency = new TestDependency
{
Id = "packageId",
Name = packageName,
Flags = DependencyTreeFlags.PackageDependency,
Resolved = true
};
var builder = new IDependency[] { packageDependency, sdkDependency }.ToDictionary(d => d.Id);
var context = new RemoveDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeRemove(
targetFramework: targetFramework,
dependency: packageDependency,
context);
// Accepts removal
Assert.True(context.GetResult(filter));
// Makes other changes too
Assert.True(context.Changed);
Assert.True(builder.TryGetValue(packageDependency.Id, out var afterPackageDependency));
Assert.Same(packageDependency, afterPackageDependency);
Assert.True(builder.TryGetValue(sdkDependency.Id, out var afterSdkDependency));
DependencyAssert.Equal(
afterSdkDependency.ToUnresolved(
SdkReference.SchemaName), afterSdkDependency);
}
public void BeforeAddOrUpdate_WhenPackage_ShouldFindMatchingSdkAndSetProperties()
{
var targetFramework = new TargetFramework("tfm");
const string packageName = "packageName";
var sdkDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, packageName),
Resolved = true,
Flags = DependencyTreeFlags.PackageDependency.Union(DependencyTreeFlags.Unresolved) // to see if unresolved is fixed
};
var packageDependency = new TestDependency
{
Id = "packageId",
Name = packageName,
Flags = DependencyTreeFlags.PackageDependency,
Resolved = true
};
var builder = new IDependency[] { packageDependency, sdkDependency }.ToDictionary(d => d.Id);
var context = new AddDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
targetFramework,
packageDependency,
null !,
null,
context);
// Accepts unchanged dependency
Assert.Same(packageDependency, context.GetResult(filter));
// Other changes made
Assert.True(context.Changed);
Assert.True(context.TryGetDependency(sdkDependency.Id, out IDependency sdkDependencyAfter));
DependencyAssert.Equal(
sdkDependency.ToResolved(
schemaName: ResolvedSdkReference.SchemaName), sdkDependencyAfter);
}
public void SdkAndPackagesDependenciesSnapshotFilter_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,
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(
projectPath: null,
targetFramework: mockTargetFramework,
dependency: sdkDependency.Object,
worldBuilder: worldBuilder,
topLevelBuilder: topLevelBuilder);
sdkDependency.VerifyAll();
otherDependency.VerifyAll();
}
public void BeforeRemove_WhenPackageRemoving_ShouldCleanupSdk()
{
const string packageName = "packageName";
var sdkDependency = new TestDependency
{
Id = packageName,
ProviderType = SdkRuleHandler.ProviderTypeString,
Resolved = true,
Flags = DependencyTreeFlags.SdkDependency.Union(ProjectTreeFlags.ResolvedReference)
};
var packageDependency = new TestDependency
{
Id = packageName,
ProviderType = PackageRuleHandler.ProviderTypeString,
Flags = DependencyTreeFlags.PackageDependency,
Resolved = true
};
var builder = new IDependency[] { packageDependency, sdkDependency }.ToDictionary(IDependencyExtensions.GetDependencyId);
var context = new RemoveDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeRemove(
dependency: packageDependency,
context);
// Accepts removal
Assert.True(context.GetResult(filter));
// Makes other changes too
Assert.True(context.Changed);
Assert.True(builder.TryGetValue(packageDependency.GetDependencyId(), out var afterPackageDependency));
Assert.Same(packageDependency, afterPackageDependency);
Assert.True(builder.TryGetValue(sdkDependency.GetDependencyId(), out var afterSdkDependency));
DependencyAssert.Equal(
afterSdkDependency.ToUnresolved(SdkReference.SchemaName),
afterSdkDependency);
}
public void BeforeAddOrUpdate_WhenSdk_ShouldFindMatchingPackageAndSetProperties()
{
const string sdkName = "sdkName";
var sdkDependency = new TestDependency
{
Id = sdkName,
ProviderType = SdkRuleHandler.ProviderTypeString,
Resolved = false,
Flags = DependencyTreeFlags.SdkDependency
};
var packageDependency = new TestDependency
{
Id = sdkName,
ProviderType = PackageRuleHandler.ProviderTypeString,
Resolved = true,
Flags = DependencyTreeFlags.PackageDependency
};
var builder = new IDependency[] { sdkDependency, packageDependency }.ToDictionary(IDependencyExtensions.GetDependencyId);
var context = new AddDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
sdkDependency,
null !,
null,
context);
var acceptedDependency = context.GetResult(filter);
// Dependency should be accepted, but converted to resolved state
Assert.NotNull(acceptedDependency);
Assert.NotSame(sdkDependency, acceptedDependency);
DependencyAssert.Equal(
sdkDependency.ToResolved(schemaName: ResolvedSdkReference.SchemaName, diagnosticLevel: DiagnosticLevel.None),
acceptedDependency !);
// No changes other than the filtered dependency
Assert.False(context.Changed);
}
public void BeforeAddOrUpdate_WhenPackage_ShouldFindMatchingSdkAndSetProperties()
{
const string packageName = "packageName";
var sdkDependency = new TestDependency
{
Id = packageName,
ProviderType = SdkRuleHandler.ProviderTypeString,
Resolved = true,
Flags = DependencyTreeFlags.PackageDependency.Union(ProjectTreeFlags.BrokenReference) // to see if unresolved is fixed
};
var packageDependency = new TestDependency
{
Id = packageName,
ProviderType = PackageRuleHandler.ProviderTypeString,
Flags = DependencyTreeFlags.PackageDependency,
Resolved = true
};
var builder = new IDependency[] { packageDependency, sdkDependency }.ToDictionary(IDependencyExtensions.GetDependencyId);
var context = new AddDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
packageDependency,
null !,
null,
context);
// Accepts unchanged dependency
Assert.Same(packageDependency, context.GetResult(filter));
// Other changes made
Assert.True(context.Changed);
Assert.True(context.TryGetDependency(sdkDependency.GetDependencyId(), out IDependency sdkDependencyAfter));
DependencyAssert.Equal(
sdkDependency.ToResolved(schemaName: ResolvedSdkReference.SchemaName, diagnosticLevel: DiagnosticLevel.None),
sdkDependencyAfter);
}
public void BeforeAddOrUpdate_WhenSdkAndPackageUnresolved_ShouldDoNothing()
{
var targetFramework = new TargetFramework("tfm");
const string sdkName = "sdkName";
var sdkDependency = new TestDependency
{
Id = "dependency1",
Name = sdkName,
TopLevel = false,
Resolved = true,
Flags = DependencyTreeFlags.SdkSubTreeNodeFlags
};
var packageDependency = new TestDependency
{
Id = Dependency.GetID(targetFramework, PackageRuleHandler.ProviderTypeString, sdkName),
Resolved = false,
Flags = DependencyTreeFlags.PackageNodeFlags
};
var worldBuilder = new IDependency[] { sdkDependency, packageDependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new AddDependencyContext(worldBuilder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
null,
targetFramework,
sdkDependency,
null,
null,
context);
// Accepts unchanged dependency
Assert.Same(sdkDependency, context.GetResult(filter));
// No other changes made
Assert.False(context.Changed);
}
public void WhenSdk_ShouldFindMatchingPackageAndSetProperties()
{
var dependencyIDs = new [] { "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 worldBuilder = new[] { sdkDependency.Object, otherDependency.Object }.ToImmutableDictionary(d => d.Id).ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
null,
mockTargetFramework,
sdkDependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges);
sdkDependency.VerifyAll();
otherDependency.VerifyAll();
}
public void BeforeAddOrUpdate_WhenSdkAndPackageUnresolved_ShouldDoNothing()
{
const string sdkName = "sdkName";
var sdkDependency = new TestDependency
{
Id = "dependency1",
ProviderType = SdkRuleHandler.ProviderTypeString,
OriginalItemSpec = sdkName,
Resolved = true,
Flags = DependencyTreeFlags.SdkDependency
};
var packageDependency = new TestDependency
{
Id = sdkName,
ProviderType = PackageRuleHandler.ProviderTypeString,
Resolved = false,
Flags = DependencyTreeFlags.PackageDependency
};
var builder = new IDependency[] { sdkDependency, packageDependency }.ToDictionary(IDependencyExtensions.GetDependencyId);
var context = new AddDependencyContext(builder);
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
filter.BeforeAddOrUpdate(
sdkDependency,
null !,
null,
context);
// Accepts unchanged dependency
Assert.Same(sdkDependency, context.GetResult(filter));
// No other changes made
Assert.False(context.Changed);
}
public void SdkAndPackagesDependenciesSnapshotFilter_WhenNotTopLevelOrResolved_ShouldDoNothing()
{
var dependency = IDependencyFactory.Implement(
id: "mydependency1",
topLevel: false);
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
}.ToImmutableDictionary().ToBuilder();
var filter = new SdkAndPackagesDependenciesSnapshotFilter();
var resultDependency = filter.BeforeAdd(
projectPath: null,
targetFramework: null,
dependency: dependency.Object,
worldBuilder: worldBuilder,
topLevelBuilder: null);
dependency.VerifyAll();
}
public void SdkAndPackagesDependenciesSnapshotFilter_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(
projectPath: null,
targetFramework: mockTargetFramework,
dependency: dependency.Object,
worldBuilder: worldBuilder,
topLevelBuilder: null);
dependency.VerifyAll();
otherDependency.VerifyAll();
}
