public async Task TestWherePolicyNameIs()
{
// Arrange
Mock <IDummyService1> service1Mock = new Mock <IDummyService1>();
Mock <IDummyService2> service2Mock = new Mock <IDummyService2>();
PolicyScopeMock policyScopeMock = PolicyScopeMock
.AsyncPolicy("Primary")
.WithService(service1Mock.Object)
.WithResultType <int>()
.AsyncPolicy("Secondary")
.WithServices(service1Mock.Object, service2Mock.Object)
.WithNoResult()
.Build();
MultipleUsage logic = new MultipleUsage(policyScopeMock.Object);
// Act
await logic.RunAsync();
// Assert
policyScopeMock
.WherePolicyNameIs("Primary")
.VerifyRunOnce();
policyScopeMock
.WherePolicyNameIs("Secondary")
.VerifyRun(2);
policyScopeMock
.WherePolicyNameIs("Tertiary")
.VerifyRunNever();
}
public async Task TestUpdateWithPolicyScopeAsync()
{
// Arrange
MyDatabaseContext myDatabaseContext = new MyDatabaseContext();
Mock <IDatabaseUpdater> databaseManipulator = new Mock <IDatabaseUpdater>();
databaseManipulator
.Setup(d => d.UpdateAsync(myDatabaseContext))
.Returns(Task.FromResult(42));
PolicyScopeMock policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.Primary)
.WithServices(myDatabaseContext, databaseManipulator.Object)
.WithResultType <int>()
.Build();
WithPolicyScope logic = new WithPolicyScope(policyScopeMock.Object);
// Act
int result = await logic.UpdateWithPolicyScopeAsync();
// Assert
policyScopeMock.VerifyRunOnce();
Assert.Equal(42, result);
}
public async Task TestRunWithNoResult2ServiceAsync()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 0));
Mock <IDummyService2> dummyServiceMock2 = new Mock <IDummyService2>();
dummyServiceMock2
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 1));
var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)
.WithServices(dummyServiceMock1.Object, dummyServiceMock2.Object)
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act
await logic.RunWithNoResult2ServiceAsync();
// Assert
Assert.Equal((1 << 2) - 1, logic.LatestResult);
policyScopeMock.VerifyRunOnce();
}
public void TestWherePolicyIsSync()
{
// Arrange
Mock <IDummyService1> service1Mock = new Mock <IDummyService1>();
Mock <IDummyService2> service2Mock = new Mock <IDummyService2>();
PolicyScopeMock policyScopeMock = PolicyScopeMock
.SyncPolicy("Primary")
.WithService(service1Mock.Object)
.WithResultType <int>()
.SyncPolicy("Secondary")
.WithServices(service1Mock.Object, service2Mock.Object)
.WithNoResult()
.Build();
MultipleUsage logic = new MultipleUsage(policyScopeMock.Object);
// Act
logic.Run();
// Assert
policyScopeMock
.WherePolicyIsSync()
.VerifyRun(3);
policyScopeMock
.WherePolicyIsAsync()
.VerifyRunNever();
}
public async Task TestRunWithNoResult3ServiceAsync()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 0));
Mock <IDummyService2> dummyServiceMock2 = new Mock <IDummyService2>();
dummyServiceMock2
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 1));
Mock <IDummyService3> dummyServiceMock3 = new Mock <IDummyService3>();
dummyServiceMock3
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 2));
var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)
.WithNoService()
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
await Assert.ThrowsAsync <PolicyScopeMockException>(async() =>
{
await logic.RunWithNoResult3ServiceAsync();
});
}
public void TestRunWithResult2Service()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.Calculate())
.Returns(1 << 0);
Mock <IDummyService2> dummyServiceMock2 = new Mock <IDummyService2>();
dummyServiceMock2
.Setup(d => d.Calculate())
.Returns(1 << 1);
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithServices(dummyServiceMock1.Object, dummyServiceMock2.Object)
.WithResultType <int>()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act
int result = logic.RunWithResult2Service();
// Assert
Assert.Equal((1 << 2) - 1, result);
Assert.Equal((1 << 2) - 1, logic.LatestResult);
policyScopeMock.VerifyRunOnce();
}
public void TestRunWithResult3Service()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.Calculate())
.Returns(1 << 0);
Mock <IDummyService2> dummyServiceMock2 = new Mock <IDummyService2>();
dummyServiceMock2
.Setup(d => d.Calculate())
.Returns(1 << 1);
Mock <IDummyService3> dummyServiceMock3 = new Mock <IDummyService3>();
dummyServiceMock3
.Setup(d => d.Calculate())
.Returns(1 << 2);
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithNoService()
.WithResultType <int>()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
Assert.Throws <PolicyScopeMockException>(() =>
{
int result = logic.RunWithResult3Service();
});
}
public void TestNoSyncPolicyFound()
{
// Arrange
var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)
.WithNoService()
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
Assert.Throws<PolicyScopeMockException>(() =>
{
logic.RunWithNoResultNoService();
});
}
public async Task TestNoAsyncPolicyFound()
{
// Arrange
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithNoService()
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
await Assert.ThrowsAsync<PolicyScopeMockException>(async () =>
{
await logic.RunWithNoResultNoServiceAsync();
});
}
public void TestRunWithNoResultNoService()
{
// Arrange
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithNoService()
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act
logic.RunWithNoResultNoService();
// Assert
Assert.Equal((1 << 0) - 1, logic.LatestResult);
policyScopeMock.VerifyRunOnce();
}
public async Task TestRunWithResultNoServiceAsync()
{
// Arrange
var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)
.WithNoService()
.WithResultType <int>()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act
int result = await logic.RunWithResultNoServiceAsync();
// Assert
Assert.Equal((1 << 0) - 1, result);
Assert.Equal((1 << 0) - 1, logic.LatestResult);
policyScopeMock.VerifyRunOnce();
}
public async Task TestUseMultipleNestedScopesAsync()
{
// Arrange
MyDatabaseContext myDatabaseContext = new MyDatabaseContext();
MyDatabaseContext myDatabaseContext2 = new MyDatabaseContext();
Mock <IDatabaseUpdater> databaseUpdater = new Mock <IDatabaseUpdater>();
Mock <IDatabaseRemover> databaseRemover = new Mock <IDatabaseRemover>();
databaseUpdater
.Setup(d => d.UpdateAsync(myDatabaseContext))
.Returns(Task.FromResult(42));
PolicyScopeMock policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.Primary)
.WithServices(myDatabaseContext, databaseUpdater.Object)
.WithResultType <int>()
.AsyncPolicy(PolicyNames.Secondary)
.WithServices(myDatabaseContext2, databaseRemover.Object)
.WithNoResult()
.Build();
MultiplePolicyScope logic = new MultiplePolicyScope(policyScopeMock.Object);
// Act
int result = await logic.UseMultipleNestedScopesAsync();
// Assert
policyScopeMock.VerifyRun(2);
policyScopeMock
.WherePolicyNameIs(PolicyNames.Primary)
.VerifyRunOnce();
policyScopeMock
.WherePolicyNameIs(PolicyNames.Secondary)
.VerifyRunOnce();
Assert.Equal(42, result);
databaseUpdater
.Verify(d => d.UpdateAsync(myDatabaseContext), Times.Once());
databaseRemover
.Verify(d => d.RemoveAsync(myDatabaseContext2), Times.Once());
}
public void TestRunWithNoResult4Service()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.Calculate())
.Returns(1 << 0);
Mock <IDummyService2> dummyServiceMock2 = new Mock <IDummyService2>();
dummyServiceMock2
.Setup(d => d.Calculate())
.Returns(1 << 1);
Mock <IDummyService3> dummyServiceMock3 = new Mock <IDummyService3>();
dummyServiceMock3
.Setup(d => d.Calculate())
.Returns(1 << 2);
Mock <IDummyService4> dummyServiceMock4 = new Mock <IDummyService4>();
dummyServiceMock4
.Setup(d => d.Calculate())
.Returns(1 << 3);
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithServices(dummyServiceMock1.Object, dummyServiceMock2.Object, dummyServiceMock3.Object, dummyServiceMock4.Object)
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act
logic.RunWithNoResult4Service();
// Assert
Assert.Equal((1 << 4) - 1, logic.LatestResult);
policyScopeMock.VerifyRunOnce();
}
public void TestRunWithNoResult1Service()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.Calculate())
.Returns(1 << 0);
var policyScopeMock = PolicyScopeMock
.SyncPolicy(PolicyNames.SyncPolicyName)
.WithNoService()
.WithNoResult()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
Assert.Throws <PolicyScopeMockException>(() =>
{
logic.RunWithNoResult1Service();
});
}
public async Task TestRunWithResultNoServiceAsync()
{
// Arrange
Mock <IDummyService1> dummyServiceMock1 = new Mock <IDummyService1>();
dummyServiceMock1
.Setup(d => d.CalculateAsync())
.Returns(Task.FromResult(1 << 0));
var policyScopeMock = PolicyScopeMock
.AsyncPolicy(PolicyNames.AsyncPolicyName)
.WithService(dummyServiceMock1.Object)
.WithResultType <int>()
.Build();
Logic logic = new Logic(policyScopeMock.Object);
// Act and assert
await Assert.ThrowsAsync <PolicyScopeMockException>(async() =>
{
int result = await logic.RunWithResultNoServiceAsync();
});
}
