public void BeforeAddOrUpdate_WhenDependencyNotRecognized_ShouldDoNothing()
{
var acceptable = new TestDependency
{
Id = "dependency1",
TopLevel = true,
Resolved = true,
Flags = DependencyTreeFlags.ProjectNodeFlags
};
AssertNoChange(new TestDependency
{
ClonePropertiesFrom = acceptable,
TopLevel = false
});
AssertNoChange(new TestDependency
{
ClonePropertiesFrom = acceptable,
Resolved = false
});
AssertNoChange(new TestDependency
{
ClonePropertiesFrom = acceptable,
Flags = ProjectTreeFlags.Empty
});
AssertNoChange(new TestDependency
{
ClonePropertiesFrom = acceptable,
Flags = DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.SharedProjectFlags)
});
return;
void AssertNoChange(IDependency dependency)
{
var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Create();
var worldBuilder = new[] { dependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new AddDependencyContext(worldBuilder);
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider);
filter.BeforeAddOrUpdate(
null,
dependency,
null,
null,
context);
// Accepts unchanged dependency
Assert.Same(dependency, context.GetResult(filter));
// No other changes made
Assert.False(context.Changed);
}
}
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 UnsupportedProjectsSnapshotFilter_WhenProjectSnapshotNotFound_ShouldDoNothing()
{
// Arrange
var snapshotProvider = IDependenciesSnapshotProviderFactory.Implement(currentSnapshot: null);
var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Implement(getSnapshotProvider: snapshotProvider);
var dependency = IDependencyFactory.Implement(
topLevel: true,
resolved: true,
flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags),
fullPath: @"c:\myproject1\project.csproj");
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, null);
var resultDependency = filter.BeforeAdd(
null,
null,
dependency.Object,
null,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
}
public void UnsupportedProjectsSnapshotFilter_WhenProjectSnapshotNotFound_ShouldMakeUnresolved()
{
// Arrange
var snapshotProvider = IDependenciesSnapshotProviderFactory.Implement(currentSnapshot: null);
var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Implement(getSnapshotProvider: snapshotProvider);
var dependency = IDependencyFactory.Implement(
topLevel: true,
resolved: true,
flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.ResolvedFlags),
originalItemSpec: @"c:\myproject2\project.csproj",
setPropertiesResolved: false,
setPropertiesSchemaName: ProjectReference.SchemaName,
setPropertiesFlags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.UnresolvedFlags));
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, null);
var resultDependency = filter.BeforeAdd(
null,
null,
dependency.Object,
null,
null,
null,
null,
out bool filterAnyChanges);
dependency.VerifyAll();
}
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 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 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();
}
static void AssertNoChange(IDependency dependency)
{
var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Create();
var worldBuilder = new[] { dependency }.ToImmutableDictionary(d => d.Id).ToBuilder();
var context = new AddDependencyContext(worldBuilder);
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider);
filter.BeforeAddOrUpdate(
null,
dependency,
null,
null,
context);
// Accepts unchanged dependency
Assert.Same(dependency, context.GetResult(filter));
// No other changes made
Assert.False(context.Changed);
}
public void UnsupportedProjectsSnapshotFilter_WhenDependencyNotRecognized_ShouldDoNothing()
{
var aggregateSnapshotProvider = IAggregateDependenciesSnapshotProviderFactory.Create();
var targetFrameworkProvider = ITargetFrameworkProviderFactory.Create();
var dependency = IDependencyFactory.Implement(
id: "mydependency1",
topLevel: false);
var topLevelDependency = IDependencyFactory.Implement(
id: "mydependency2",
topLevel: true,
resolved: false);
var topLevelResolvedDependency = IDependencyFactory.Implement(
id: "mydependency3",
topLevel: true,
resolved: true,
flags: ProjectTreeFlags.Empty);
var topLevelResolvedSharedProjectDependency = IDependencyFactory.Implement(
id: "mydependency4",
topLevel: true,
resolved: true,
flags: DependencyTreeFlags.ProjectNodeFlags.Union(DependencyTreeFlags.SharedProjectFlags));
var worldBuilder = new Dictionary <string, IDependency>()
{
{ dependency.Object.Id, dependency.Object },
{ topLevelDependency.Object.Id, topLevelDependency.Object },
{ topLevelResolvedDependency.Object.Id, topLevelResolvedDependency.Object },
{ topLevelResolvedSharedProjectDependency.Object.Id, topLevelResolvedSharedProjectDependency.Object },
}.ToImmutableDictionary().ToBuilder();
var filter = new UnsupportedProjectsSnapshotFilter(aggregateSnapshotProvider, targetFrameworkProvider);
var resultDependency = filter.BeforeAdd(
null,
null,
dependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges);
resultDependency = filter.BeforeAdd(
null,
null,
topLevelDependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges2);
resultDependency = filter.BeforeAdd(
null,
null,
topLevelResolvedDependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges3);
resultDependency = filter.BeforeAdd(
null,
null,
topLevelResolvedSharedProjectDependency.Object,
worldBuilder,
null,
null,
out bool filterAnyChanges4);
dependency.VerifyAll();
topLevelDependency.VerifyAll();
}
