public async Task WheEmptySnapshotAndVisibilityMarkerProvided_ShouldDisplaySubTreeRoot()
{
var dependencyModelRootYyy = new TestDependencyModel
{
ProviderType = "Yyy",
Id = "YyyDependencyRoot",
Name = "YyyDependencyRoot",
Caption = "YyyDependencyRoot",
Resolved = true
};
var dependencyVisibilityMarker = new TestDependency
{
ProviderType = "Yyy",
Id = "someid",
Name = "someid",
Caption = "someid",
Resolved = false,
Visible = false,
Flags = DependencyTreeFlags.ShowEmptyProviderRootNode
};
var dependenciesRoot = new TestProjectTree
{
Caption = "MyDependencies",
Children =
{
new TestProjectTree
{
Caption = "YyyDependencyRoot",
FilePath = "YyyDependencyRoot"
}
}
};
var provider = CreateProvider(rootModels: new[] { dependencyModelRootYyy });
var snapshot = GetSnapshot((_tfm1, new[] { dependencyVisibilityMarker }));
// Act
var resultTree = await provider.BuildTreeAsync(dependenciesRoot, snapshot);
// Assert
var expectedFlatHierarchy =
@"Caption=MyDependencies, FilePath=, IconHash=325248080, ExpandedIconHash=325248080, Rule=, IsProjectItem=False, CustomTag=
Caption=YyyDependencyRoot, FilePath=YyyDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=";
Assert.Equal(expectedFlatHierarchy, ToTestDataString((TestProjectTree)resultTree));
}
public async Task WhenEmptySnapshotAndVisibilityMarkerNotProvided_ShouldHideSubTreeRoot()
{
var dependencyModelRootYyy = new TestDependencyModel
{
ProviderType = "Yyy",
Id = "YyyDependencyRoot",
OriginalItemSpec = "YyyDependencyRoot",
Caption = "YyyDependencyRoot",
Resolved = true
};
var dependencyVisibilityMarker = new TestDependency
{
ProviderType = "Yyy",
Id = "someid",
OriginalItemSpec = "someid",
Caption = "someid",
Resolved = false,
Visible = false
};
var dependenciesRoot = new TestProjectTree
{
Caption = "MyDependencies",
Children =
{
new TestProjectTree
{
Caption = "YyyDependencyRoot"
}
}
};
var provider = CreateProvider(rootModels: new[] { dependencyModelRootYyy });
var snapshot = GetSnapshot((_tfm1, new[] { dependencyVisibilityMarker }));
// Act
var resultTree = await provider.BuildTreeAsync(dependenciesRoot, snapshot);
// Assert
var expectedFlatHierarchy =
@"Caption=MyDependencies, IconHash=325248080, ExpandedIconHash=325248080, Rule=, IsProjectItem=False, CustomTag=";
AssertTestData(expectedFlatHierarchy, resultTree);
}
public void Test1()
{
var integrationTestMockBuilder = MockBuilder.IntegrationTest <ITestIntegrationApp, TestIntegrationApp>(
new Installer(),
config => config.WithTestDependenciesToMock(TestDependency.Of <IExternalSupplierClass>()));
var mockDataFromSupplier = "Mock data from supplier";
integrationTestMockBuilder.AddMockActionOf <IExternalSupplierClass>(mock =>
mock.Setup(x => x.GetDataFromUnreliableSupplier()).Returns(() => mockDataFromSupplier));
var expectedResult = "Logged a message" + mockDataFromSupplier + "Data from DB" + "Other data from DB";
var result = integrationTestMockBuilder.GetTestedService().DoStuffWithServices();
result.Should().Be(expectedResult);
}
public async Task Should_resolve_arguments_When_action_has_parameters()
{
// Arrange
var arrangeObject = new TestDependency();
var expectedByType = arrangeObject;
ITestDependency expectedByInterface = arrangeObject;
TestDependency actualByType = null;
ITestDependency actualByInterface = null;
var arrangeAction = new Action <TestDependency, ITestDependency>(
(
byType,
byInterface) =>
{
actualByType = byType;
actualByInterface = byInterface;
});
var mockServices = new Mock <IServiceProvider>();
mockServices
.Setup(instance => instance.GetService(typeof(TestDependency)))
.Returns(expectedByType)
.Verifiable();
mockServices
.Setup(instance => instance.GetService(typeof(ITestDependency)))
.Returns(expectedByInterface)
.Verifiable();
var arrangeServices = mockServices.Object;
var arrangeInvocationContext = this.CreateInvocationContext();
var arrangeInvoker = this.CreateInvokerInstance(arrangeAction, arrangeServices);
// Act
await arrangeInvoker.InvokeAsync(arrangeInvocationContext, CancellationToken.None);
// Assert
mockServices.Verify();
Assert.Same(expectedByType, actualByType);
Assert.Same(expectedByInterface, actualByInterface);
}
public void ActorOfWithoutNameInjectsDependencies()
{
using (var actorSystem = ActorSystem.Create("Sunruse-Influx"))
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <ActorOfWithoutNameTestActor.ChildTestActor>();
var testDependency = new TestDependency();
containerBuilder.RegisterInstance(testDependency).As <ITestDependency>();
new AutoFacDependencyResolver(containerBuilder.Build(), actorSystem);
var actor = actorSystem.ActorOf <ActorOfWithoutNameTestActor>("TestParent");
ActorOfWithoutNameTestActor.ChildTestActor.Instances.Clear();
actor.Ask <Start>(new Start());
ExpectNoMsg();
Assert.Equal(testDependency, ActorOfWithoutNameTestActor.ChildTestActor.Instances[0].TestDependency);
}
}
public void ResolverFunctionsProperly()
{
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "RockLib.Logging:Type", typeof(TestLogger).AssemblyQualifiedName },
{ "RockLib.Logging:Value:Name", "foo" }
}).Build();
var dependency = new TestDependency();
var resolver = new Resolver(t => dependency, t => t == typeof(ITestDependency));
var section = config.GetSection("RockLib.Logging");
var logger = (TestLogger)section.CreateLogger("foo", resolver: resolver, reloadOnConfigChange: false);
logger.Dependency.Should().BeSameAs(dependency);
}
public static void Should_resolve_lower_level_container_registration_When_lower_level_container_has_same_registration_as_upper_container(
HierarchyServiceRegistration.Case @case)
{
// Arrange
var theoryItem = @case.Promise.Resolve();
var arrangeUpperLevelObject = new TestDependency();
var arrangeLowerLevelObject = new TestDependency();
object expectedUpperLevelObject = arrangeUpperLevelObject;
object actualUpperLevelObject = null;
object expectedLowerLevelObject = arrangeLowerLevelObject;
object actualLowerLevelObject = null;
// Act
theoryItem.SetupConfig(
(
builder,
provider) =>
{
builder.ConfigureServices(
(
context,
collection) =>
{
collection.AddSingleton <ITestDependency>(arrangeUpperLevelObject);
});
});
theoryItem.SetupCheck(
host =>
{
actualUpperLevelObject = host.Services.GetService <ITestDependency>();
});
theoryItem.SetupExtension(new ConfigureDependenciesTheoryExtension().Setup(s => s.AddSingleton <ITestDependency>(arrangeLowerLevelObject)));
theoryItem.SetupExtension(new PickDependencyTheoryExtension().Setup(typeof(ITestDependency), o => actualLowerLevelObject = o));
theoryItem.Try();
// Assert
Assert.Same(expectedUpperLevelObject, actualUpperLevelObject);
Assert.Same(expectedLowerLevelObject, actualLowerLevelObject);
}
public void CreateViewModelUsingViewModelWithDependencyTest()
{
var container = new WindsorDependencyContainer();
var testDependency = new TestDependency();
container.Singleton(testDependency);
container.Singleton <DependencyViewModel>();
var factory = new ViewModelFactory(container);
var viewModelType = typeof(DependencyViewModel);
var parameters = Enumerable.Empty <object>().ToArray();
var viewModel =
factory.CreateWithLocatorOrWithReflection(viewModelType, parameters)
.Convert <DependencyViewModel>();
viewModel.Should().NotBeNull();
viewModel.TestDependency.Should().NotBeNull();
viewModel.TestDependency.Should().BeSameAs(testDependency);
}
public void CreateViewModelUsingViewModelWithDependencyTest()
{
var container = new WindsorDependencyContainer();
var testDependency = new TestDependency();
container.Singleton(testDependency);
container.Singleton<DependencyViewModel>();
var factory = new ViewModelFactory(container);
var viewModelType = typeof(DependencyViewModel);
var parameters = Enumerable.Empty<object>().ToArray();
var viewModel =
factory.CreateWithLocatorOrWithReflection(viewModelType, parameters)
.Convert<DependencyViewModel>();
viewModel.Should().Not.Be.Null();
viewModel.TestDependency.Should().Not.Be.Null();
viewModel.TestDependency.Should().Be.SameInstanceAs(testDependency);
}
public void CreateViewModelUsingViewModelWithDependencyAndRuntimeParameterTest()
{
var container = new WindsorDependencyContainer();
var testDependency = new TestDependency();
container.Container.Register(Component.For <TestDependency>().Instance(testDependency));
container.Container.Register(Component.For <DependencyViewModel>());
var factory = new ViewModelFactory(container);
var viewModelType = typeof(DependencyViewModel);
var runtimeParameterValue = new object();
var viewModel =
factory.CreateWithLocatorOrWithReflection(viewModelType, runtimeParameterValue)
.Convert <DependencyViewModel>();
viewModel.Should().NotBeNull();
viewModel.TestDependency.Should().NotBeNull();
viewModel.TestDependency.Should().BeSameAs(testDependency);
viewModel.Id.Should().BeSameAs(runtimeParameterValue);
}
public void CreateViewModelUsingViewModelWithDependencyAndRuntimeParameterTest()
{
var container = new WindsorDependencyContainer();
var testDependency = new TestDependency();
container.Container.Register(Component.For<TestDependency>().Instance(testDependency));
container.Container.Register(Component.For<DependencyViewModel>());
var factory = new ViewModelFactory(container);
var viewModelType = typeof(DependencyViewModel);
var runtimeParameterValue = new object();
var viewModel =
factory.CreateWithLocatorOrWithReflection(viewModelType, runtimeParameterValue)
.Convert<DependencyViewModel>();
viewModel.Should().Not.Be.Null();
viewModel.TestDependency.Should().Not.Be.Null();
viewModel.TestDependency.Should().Be.SameInstanceAs(testDependency);
viewModel.Id.Should().Be.SameInstanceAs(runtimeParameterValue);
}
public TestAggregate(TestDependency dependency) => Dependency = dependency;
public AnotherTestAggregate(TestDependency dependency) => Dependency = dependency;
public TestJob(TestDependency testDependency)
{
_testDependency = testDependency;
}
public TestService(TestDependency testDependency)
{
_testDependency = testDependency;
}
public TestDependencyModule(TestDependency testDependency) => _testDependency = testDependency;
public DependencyViewModel(TestDependency testDependency, object id)
{
TestDependency = testDependency;
Id = id;
}
public DependencyViewModel(TestDependency testDependency, object id)
{
TestDependency = testDependency;
Id = id;
}
public TestCtorObject(TestDependency dependency)
{
this.Dependency = dependency;
}
public DependencyViewModel(TestDependency testDependency)
{
TestDependency = testDependency;
}
public TestClassWithDependency(TestDependency dependency)
{
this.dependency = dependency;
}
public async Task WhenMultipleTargetSnapshotsWithExistingDependencies_ShouldApplyChanges()
{
var dependencyModelRootXxx = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "XxxDependencyRoot",
OriginalItemSpec = "XxxDependencyRoot",
Caption = "XxxDependencyRoot",
Resolved = true
};
var dependencyXxx1 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
FilePath = "dependencyxxxpath",
OriginalItemSpec = "dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyModelRootYyy = new TestDependencyModel
{
ProviderType = "Yyy",
Id = "YyyDependencyRoot",
OriginalItemSpec = "YyyDependencyRoot",
Caption = "YyyDependencyRoot"
};
var dependencyYyy1 = new TestDependency
{
ProviderType = "Yyy",
Id = "dependency1",
FilePath = "dependencyyyypath",
OriginalItemSpec = "dependency1",
Caption = "Dependency1",
SchemaItemType = "Yyy",
Resolved = true
};
var dependencyYyyExisting = new TestDependency
{
ProviderType = "Yyy",
Id = "dependencyExisting",
FilePath = "dependencyyyyExistingpath",
OriginalItemSpec = "dependencyExisting",
Caption = "DependencyExisting",
SchemaItemType = "Yyy",
Resolved = true
};
var dependencyModelRootZzz = new TestDependencyModel
{
ProviderType = "Zzz",
Id = "ZzzDependencyRoot",
OriginalItemSpec = "ZzzDependencyRoot",
Caption = "ZzzDependencyRoot",
Resolved = true,
Flags = ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp)
};
var dependencyAny1 = new TestDependency
{
ProviderType = "Zzz",
Id = "ZzzDependencyAny1",
FilePath = "ZzzDependencyAny1path",
OriginalItemSpec = "ZzzDependencyAny1",
Caption = "ZzzDependencyAny1"
};
var dependenciesRoot = new TestProjectTree
{
Caption = "MyDependencies",
Children =
{
new TestProjectTree
{
Caption = "OldRootChildToBeRemoved"
},
new TestProjectTree
{
Caption = "YyyDependencyRoot",
Children =
{
new TestProjectTree
{
Caption = "DependencyExisting",
}
}
}
}
};
var targetModel1 = new TestDependencyModel
{
Id = "tfm1",
OriginalItemSpec = "tfm1",
Caption = "tfm1"
};
var targetModel2 = new TestDependencyModel
{
Id = "tfm2",
OriginalItemSpec = "tfm2",
Caption = "tfm2"
};
var provider = CreateProvider(
rootModels: new[] { dependencyModelRootXxx, dependencyModelRootYyy, dependencyModelRootZzz },
targetModels: new[] { targetModel1, targetModel2 });
var snapshot = GetSnapshot(
(_tfm1, new[] { dependencyXxx1, dependencyYyy1, dependencyYyyExisting }),
(_tfm2, new[] { dependencyXxx1, dependencyYyy1, dependencyYyyExisting }),
(TargetFramework.Any, new[] { dependencyAny1 }));
// Act
var resultTree = await provider.BuildTreeAsync(dependenciesRoot, snapshot);
// Assert
const string expectedFlatHierarchy =
@"Caption=MyDependencies, IconHash=325248080, ExpandedIconHash=325248080, Rule=, IsProjectItem=False, CustomTag=
Caption=ZzzDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=ZzzDependencyAny1, IconHash=325248665, ExpandedIconHash=325248817, Rule=, IsProjectItem=False, CustomTag=
Caption=tfm2, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=, BubbleUpFlag=True
Caption=XxxDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=False, CustomTag=
Caption=YyyDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=False, CustomTag=
Caption=DependencyExisting, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=False, CustomTag=
Caption=tfm1, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=, BubbleUpFlag=True
Caption=XxxDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=
Caption=YyyDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=
Caption=DependencyExisting, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=";
AssertTestData(expectedFlatHierarchy, resultTree);
}
public async Task WhenOneTargetSnapshotAndDependencySupportsHierarchyAndIsResolved_ShouldRead()
{
var dependencyModelRootYyy = new TestDependencyModel
{
ProviderType = "Yyy",
Id = "YyyDependencyRoot",
Name = "YyyDependencyRoot",
Caption = "YyyDependencyRoot",
Resolved = true
};
var dependencyYyyExisting = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyExisting",
Name = "dependencyExisting",
Path = "dependencyExistingpath",
Caption = "DependencyExisting",
SchemaItemType = "Yyy",
Resolved = true,
Flags = DependencyTreeFlags.SupportsHierarchy,
TargetFramework = _tfm1
};
var dependenciesRoot = new TestProjectTree
{
Caption = "MyDependencies",
Children =
{
new TestProjectTree
{
Caption = "YyyDependencyRoot",
FilePath = "YyyDependencyRoot",
Children =
{
new TestProjectTree
{
Caption = "DependencyExisting",
FilePath = "tfm1\\yyy\\dependencyExisting",
CustomTag = "ShouldBeCleanedSinceNodeWillBeRecreated",
Flags = DependencyTreeFlags.Unresolved
}
}
}
}
};
var provider = CreateProvider(rootModels: new[] { dependencyModelRootYyy });
var snapshot = GetSnapshot((_tfm1, new[] { dependencyYyyExisting }));
// Act
var resultTree = await provider.BuildTreeAsync(dependenciesRoot, snapshot);
// Assert
var expectedFlatHierarchy =
@"Caption=MyDependencies, FilePath=, IconHash=325248080, ExpandedIconHash=325248080, Rule=, IsProjectItem=False, CustomTag=
Caption=YyyDependencyRoot, FilePath=YyyDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=DependencyExisting, FilePath=tfm1\Yyy\dependencyExistingpath, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=";
Assert.Equal(expectedFlatHierarchy, ToTestDataString((TestProjectTree)resultTree));
}
public TestService(TestDependency testDependency)
{
_testDependency = testDependency;
}
public DependencyViewModel(TestDependency testDependency)
{
TestDependency = testDependency;
}
public TestJob(TestDependency testDependency)
{
_testDependency = testDependency;
}
public async Task WhenOneTargetSnapshotWithExistingDependencies_ShouldApplyChanges()
{
var dependencyModelRootXxx = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "XxxDependencyRoot",
OriginalItemSpec = "XxxDependencyRoot",
Caption = "XxxDependencyRoot",
Resolved = true
};
var dependencyModelRootYyy = new TestDependencyModel
{
ProviderType = "Yyy",
Id = "YyyDependencyRoot",
OriginalItemSpec = "YyyDependencyRoot",
Caption = "YyyDependencyRoot"
};
var dependencyXxx1 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "dependency1",
FilePath = "dependencyXxxpath",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyYyy1 = new TestDependency
{
ProviderType = "Yyy",
Id = "dependency1",
OriginalItemSpec = "dependency1",
FilePath = "dependencyYyypath",
Caption = "Dependency1",
SchemaItemType = "Yyy",
Resolved = true
};
var dependencyYyyExisting = new TestDependency
{
ProviderType = "Yyy",
Id = "dependencyExisting",
OriginalItemSpec = "dependencyExisting",
FilePath = "dependencyExistingPath",
Caption = "DependencyExisting",
SchemaItemType = "Yyy",
Resolved = true
};
var dependenciesRoot = new TestProjectTree
{
Caption = "MyDependencies",
Children =
{
new TestProjectTree
{
Caption = "OldRootChildToBeRemoved"
},
new TestProjectTree
{
Caption = "YyyDependencyRoot",
Children =
{
new TestProjectTree
{
Caption = "DependencyExisting"
}
}
}
}
};
var provider = CreateProvider(rootModels: new[] { dependencyModelRootXxx, dependencyModelRootYyy });
var snapshot = GetSnapshot((_tfm1, new[] { dependencyXxx1, dependencyYyy1, dependencyYyyExisting }));
// Act
var resultTree = await provider.BuildTreeAsync(dependenciesRoot, snapshot);
// Assert
const string expectedFlatHierarchy =
@"Caption=MyDependencies, IconHash=325248080, ExpandedIconHash=325248080, Rule=, IsProjectItem=False, CustomTag=
Caption=YyyDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=DependencyExisting, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=
Caption=XxxDependencyRoot, IconHash=0, ExpandedIconHash=0, Rule=, IsProjectItem=False, CustomTag=
Caption=Dependency1, IconHash=325248088, ExpandedIconHash=325248260, Rule=, IsProjectItem=True, CustomTag=";
AssertTestData(expectedFlatHierarchy, resultTree);
}
public TestCtorObject(TestDependency dependency)
{
this.Dependency = dependency;
}
