public void It_calls_VerifyAll_on_all_objects_that_are_mocks()
{
mocker.Use <IService2>(x => x.Other == Mock.Of <IService1>());
var selfMock = mocker.CreateInstance <WithService>();
Assert.Throws(MockVerificationException, () => mocker.VerifyAll());
}
public async Task Handle_ChapterNotExist_ChapterShouldNotFound()
{
//Arrange
_chapterRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Chapter> >()))
.ReturnsAsync(false);
var command = new CreateQuizCommand
{
Title = "anonymousQuizTitle",
Priority = (int)Priority.Low,
ChapterId = Guid.NewGuid(),
Questions = new List <Question>()
{
new Question()
{
Title = "anonymousQuestionTitle",
CorrectAnswer = "anonymousCorrectAnswer",
Options = new List <Option>()
{
new Option()
{
Value = "anonymousValue"
}
}
}
}
};
//Act
//Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => _quizCommandHandler.Handle(command, CancellationToken.None));
_autoMocker.VerifyAll();
}
public async Task FeedingSuccessfullForSingleClosedSlotAsync()
{
var mocker = new AutoMocker();
var sensor = mocker.GetMock <IDigitalSensor>();
var gate = mocker.GetMock <IGateDevice>();
var isClosed = true;
var slot = _mocker.GetSlotWithGateAndSensor("dummy", gate, sensor);
gate
.Setup(g => g.OpenGateAsync())
.Callback(() => { isClosed = false; })
.Returns(Task.CompletedTask)
.Verifiable();
sensor
.Setup(s => s.Read())
.Returns(() => { return(isClosed); })
.Verifiable();
var manager = _mocker.CreateInstance <DefaultFeedingManager>();
manager.Slots = new[] { slot };
var result = await manager.TryFeedAsync();
_mocker.VerifyAll();
Assert.True(result.Succeeded);
Assert.Equal(slot.Name, result.SlotUsed);
}
public void It_invalidates_the_key()
{
mocker.Setup <IUserRepository>(x => x.GetByLoginKey(Guid.Empty)).Returns(new User());
mocker.Setup <IUserRepository>(x => x.Save(It.IsAny <User>())).Callback <User>(u => u.LoginKey.ShouldBeNull());
Sut.Login(Guid.Empty);
mocker.VerifyAll();
}
public void It_calls_VerifyAll_on_all_objects_that_are_mocks()
{
mocker.Use <IService2>(x => x.Other == Mock.Of <IService1>());
var _ = mocker.CreateInstance <WithService>();
var ex = Assert.ThrowsException <MockException>(() => mocker.VerifyAll());
Assert.IsTrue(ex.IsVerificationError);
}
public void It_sets_the_loginKey_for_the_user()
{
AssertUser(u => u.LoginKey.ShouldNotEqual(null));
Sut.LoginEmail(new User {
Email = "*****@*****.**"
});
mocker.VerifyAll();
}
public void TimeSheetController_WhenGetByIdFound_ItShouldReturnOkWithTimeSheet()
{
// Arrange
var request = new GetTimeSheetRequest(ValidId);
WithHandlerSetup(request, () => new GetTimeSheetReponse(Option.Some(new TimeSheet())));
// Act
var result = _subject.Get(ValidId);
// Assert
Assert.IsAssignableFrom <ActionResult <TimeSheet> >(result);
Assert.IsAssignableFrom <OkObjectResult>(result.Result);
_mocker.VerifyAll();
}
public async Task GetProfileDataAsync_GivenPinUser_VerifiesStatusAndAddsRequestedClaim()
{
var automocker = new AutoMocker();
var verificationLimit = new Mock <IVerificationLimit>();
automocker
.Setup <IMediator, Task <VerificationResult> >(x => x.Send(It.IsAny <VerifyPinUser.Command>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new VerificationResult(new PositiveTestResult(), new VerificationRecord[0], verificationLimit.Object));
var context = new ProfileDataRequestContext
{
Subject = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(InternalClaims.PinVerified, "true"),
new Claim(InternalClaims.Pseudonym, "pseudo-1")
})),
RequestedClaimTypes = new[] { DkSmittestopClaims.Covid19Status }
};
var target = automocker.CreateInstance <ProfileService>();
await target.GetProfileDataAsync(context);
context.IssuedClaims.Should().Contain(x => x.Type == DkSmittestopClaims.Covid19Status && x.Value == DkSmittestopClaims.StatusValues.Positive);
automocker.VerifyAll();
}
public void CanCreateObjectWithInitData()
{
var mocker = new AutoMocker();
var service1 = mocker.Get <IService>();
var provider = mocker.GetMock <IServiceProvider>();
var autoDIProvider = provider.As <IAutoDISerivceProvider>();
autoDIProvider.Setup(x => x.GetService(typeof(IService), It.IsAny <object[]>())).Returns(service1).Verifiable();
var initData = new InitData();
try
{
DI.Init(typeof(IService).Assembly, builder => builder.WithProvider(provider.Object));
var sut = new ClassWithInitData(initData);
Assert.AreEqual(service1, sut.Service);
Assert.AreEqual(initData, sut.Data);
mocker.VerifyAll();
}
finally
{
DI.Dispose(typeof(IService).Assembly);
}
}
public async Task Handle_GivenValidIdAndPositiveTest_ReturnsPositiveResult()
{
var automocker = new AutoMocker();
automocker
.Setup <IMsisLookupService, Task <Option <PositiveTestResult> > >(x =>
x.FindPositiveTestResult("01019098765"))
.ReturnsAsync(new PositiveTestResult
{
PositiveTestDate = DateTime.Today.AddDays(-7).Some()
}.Some);
automocker.Setup <IOptions <VerifyIdentifiedUser.Config>, VerifyIdentifiedUser.Config>(x => x.Value)
.Returns(new VerifyIdentifiedUser.Config
{
UseFixedTestCases = false
});
var target = automocker.CreateInstance <VerifyIdentifiedUser.Handler>();
var result = await target.Handle(new VerifyIdentifiedUser.Command("01019098765", "pseudo-1", false), new CancellationToken());
result.HasVerifiedPostiveTest.Should().BeTrue();
result.PositiveTestDate.Should().Be(DateTime.Today.AddDays(-7).Some());
automocker.VerifyAll();
}
public async Task Handle_GivenValidIdAndPositiveTest_ReturnsPositiveUser(string idClaimType)
{
var automocker = new AutoMocker();
automocker
.Setup <IMsisLookupService, Task <Option <PositiveTestResult> > >(x =>
x.FindPositiveTestResult("01019098765"))
.ReturnsAsync(new PositiveTestResult
{
PositiveTestDate = DateTime.Today.AddDays(-7).Some()
}.Some);
var target = automocker.CreateInstance <CreateFromExternalAuthentication.Handler>();
var result = await target.Handle(new CreateFromExternalAuthentication.Command
(
ExternalProviders.IdPorten,
new List <Claim>
{
new Claim(idClaimType, "pseudo-id-123"),
new Claim(IdPortenClaims.NationalIdentifier, "01019098765")
}
), new CancellationToken());
result.HasVerifiedPostiveTest.Should().BeTrue();
result.Id.Should().NotBeEmpty();
result.PositiveTestDate.Should().Be(DateTime.Today.AddDays(-7).Some());
automocker.VerifyAll();
}
public async Task Handle_ValidChapterData_ShouldSuccess()
{
//Arrange
var quizId = Guid.NewGuid();
var command = new DeleteQuestionCommand(quizId);
_questionRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Question> >()))
.ReturnsAsync(true);
_questionRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <ISpecification <Question> >()))
.ReturnsAsync(true);
var result = await _questionCommandHandler.Handle(command, CancellationToken.None);
//Assert
Assert.True(result);
_autoMocker.VerifyAll();
}
public void It_doesnt_call_VerifyAll_if_the_object_isnt_a_mock()
{
var mocker = new AutoMocker();
mocker.Use <IService2>(new Service2());
mocker.CreateInstance <WithService>();
mocker.VerifyAll();
}
public void It_sets_email__saves_and_redirects_to_twitter()
{
mocker.Setup <IUserRepository>(x => x.Save(It.IsAny <User>())).Callback <User>(u =>
{
u.Id = BsonObjectId.Empty;
u.Email.ShouldEqual("*****@*****.**");
});
mocker.Setup <ITwitterFactory>(x => x.GetAuthorizationUri()).Returns(new Uri("http://twitter"));
var viewModel = new SetEmailViewModel {
UserEmail = "*****@*****.**"
};
Sut.Index(viewModel).ShouldBeType <RedirectResult>();
mocker.VerifyAll();
mocker.GetMock <IContext>().VerifySet(x => x.UserId);
}
public async Task EmptyScheduleSkipsFeedingAsync()
{
var now = DateTime.Parse("2020/04/01 10:00:00");
_mocker
.Setup <ISchedulingEngine, Task <DateTime?> >(e => e.CalculateNextSlotAsync(DefaultFeedingManager.ScheduleName, now.Date))
.Returns(Task.FromResult <DateTime?>(null))
.Verifiable();
var manager = _mocker.CreateInstance <DefaultFeedingManager>();
var result = await manager.TryScheduledFeedAsync(now);
_mocker.VerifyAll();
Assert.True(result.Succeeded);
Assert.Null(result.SlotUsed);
}
private decimal?TestCalculateBonusAllocationByHrDepartment(int employeeSalary, int totalSalaryByDepartment, decimal totalBonusPool, int?bonusPoolAllocationPerc)
{
var mocker = new AutoMocker();
var subject = mocker.CreateInstance <BonusPoolService>();
var result = subject.CalculateBonusAllocationByHrDepartment(employeeSalary, totalSalaryByDepartment, totalBonusPool, bonusPoolAllocationPerc);
mocker.VerifyAll();
return(result);
}
private int TestCalculateSalaryBudget(IEnumerable <HrEmployee> hrEmployees)
{
var mocker = new AutoMocker();
var subject = mocker.CreateInstance <BonusPoolService>();
var result = subject.CalculateSalaryBudget(hrEmployees);
mocker.VerifyAll();
return(result);
}
private decimal TestCalculateBonusAllocation(int employeeSalary, int totalSalary, decimal totalBonusPool)
{
var mocker = new AutoMocker();
var subject = mocker.CreateInstance <BonusPoolService>();
var result = subject.CalculateBonusAllocation(employeeSalary, totalSalary, totalBonusPool);
mocker.VerifyAll();
return(result);
}
public async Task Handle_ValidChapterData_ShouldSuccess()
{
//Arrange
var command = new CreateChapterCommand()
{
Name = "anonymousName",
EnglishLevel = (int)EnglishLevel.Beginner
};
_chapterRepositoryMock.Setup(x => x.SaveAsync(It.IsAny <Chapter>()))
.Callback <Chapter>(x => x.Id = Guid.NewGuid())
.ReturnsAsync(true);
//Act
var result = await _chapterCommandHandler.Handle(command, CancellationToken.None);
//Assert
Assert.NotEqual(Guid.Empty, result);
_autoMocker.VerifyAll();
}
public async Task Handle_ValidQuizData_ShouldSuccess()
{
//Arrange
var quizId = Guid.NewGuid();
var command = new DeleteQuizCommand(quizId);
_quizRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Quiz> >()))
.ReturnsAsync(true);
_quizRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <ISpecification <Quiz> >()))
.ReturnsAsync(true);
_sendEndpointProviderMock = _autoMocker.GetMock <ISendEndpointProvider>();
_sendEndpointProviderMock.Setup(x => x.GetSendEndpoint(It.IsAny <Uri>()))
.Returns(Task.FromResult(_sendEndpointMock.Object));
var result = await _quizCommandHandler.Handle(command, CancellationToken.None);
//Assert
Assert.True(result);
_autoMocker.VerifyAll();
}
public async Task Handle_QuizIdNotExist_ShouldNotFound()
{
//Arrange
_quizRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Quiz> >()))
.ReturnsAsync(false);
var createQuestionCommand = new UpdateQuestionCommand()
{
QuizId = Guid.NewGuid(),
Title = "anonymousText",
CorrectAnswer = "anonymousText",
Options = new List <Option>()
{
new Option()
{
Value = "anonymousOption1"
},
new Option()
{
Value = "anonymousOption2"
},
new Option()
{
Value = "anonymousOption3"
},
new Option()
{
Value = "anonymousOption4"
},
}
};
//Act
//Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => _questionCommandHandler.Handle(createQuestionCommand, CancellationToken.None));
_autoMocker.VerifyAll();
}
public async Task Get_Payment()
{
// Arrange
var paymentId = 1000;
var merchantId = Guid.NewGuid().ToString();
_mockRepository
.Setup(x => x.GetAsync(paymentId))
.ReturnsAsync(new Payment
{
Id = paymentId,
MerchantId = merchantId
})
.Verifiable();
// Act
var actual = await SUT.GetAsync(paymentId);
// Assert
_mocker.VerifyAll();
actual.Id.Should().Be(paymentId);
actual.MerchantId.Should().Be(merchantId);
}
public async Task Handle_ValidChapterData_ShouldSuccess()
{
//Arrange
var chapterId = Guid.NewGuid();
var command = new UpdateChapterCommand()
{
Name = "anonymousName",
EnglishLevel = (int)EnglishLevel.Beginner
};
command.SetId(chapterId);
_chapterRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Chapter> >()))
.ReturnsAsync(true);
_chapterRepositoryMock.Setup(x => x.SaveAsync(It.IsAny <Chapter>()))
.ReturnsAsync(true);
//Act
var result = await _chapterCommandHandler.Handle(command, CancellationToken.None);
//Assert
Assert.Equal(chapterId, result);
_autoMocker.VerifyAll();
}
public async Task Handle_ValidChapterData_ShouldSuccess()
{
//Arrange
var chapterId = Guid.NewGuid();
var command = new DeleteChapterCommand(chapterId);
_chapterRepositoryMock.Setup(x => x.AnyAsync(It.IsAny <ISpecification <Chapter> >()))
.ReturnsAsync(true);
_chapterRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <ISpecification <Chapter> >()))
.ReturnsAsync(true);
_sendEndpointProviderMock = _autoMocker.GetMock <ISendEndpointProvider>();
_sendEndpointProviderMock.Setup(x => x.GetSendEndpoint(It.IsAny <Uri>()))
.Returns(Task.FromResult(_sendEndpointMock.Object));
//TODO: How to mock?
//_sendEndpointProviderMock.Setup(x => x.Send(It.IsAny<DeleteChapterMessage>(), It.IsAny<CancellationToken>()));
//Act
var result = await _chapterCommandHandler.Handle(command, CancellationToken.None);
//Assert
Assert.True(result);
_autoMocker.VerifyAll();
}
public void TestGetCloudantSecurityDocument_Should_Return_A_Valid_Document()
{
//SETUP
var mocker = new AutoMocker();
//connection returns base uri
mocker.Setup<ICouchConnection>(c => c.BaseUri).Returns(new Uri("http://localhost"));
//GetCouchResponse returns security doc as per Cloudant documentation
const string responseString = "{ " +
"\"_id\":\"_security\"," +
"\"cloudant\":" +
"{" +
" \"userwithreadonlyaccess\": [" +
" \"_reader\"" +
" ]," +
" \"userwithreadandwriteaccess\": [" +
" \"_reader\"," +
" \"_writer\"" +
" ]" +
"}," +
"\"ok\":true" +
"}";
mocker.Setup<ICouchResponse>(r => r.ResponseString).Returns(responseString);
mocker.Setup<ICouchResponse, HttpStatusCode>(r => r.StatusCode).Returns(HttpStatusCode.OK);
mocker.Setup<ICouchRequest>(r => r.GetCouchResponse()).Returns(mocker.Get<ICouchResponse>());
//couchFactory returns request
mocker.Setup<ICouchFactory>(f => f.GetRequest(It.IsAny<Uri>(), It.IsAny<ICouchConnection>()))
.Returns(mocker.Get<ICouchRequest>());
//Get request returns request
mocker.Setup<ICouchRequest>(r => r.Get()).Returns(mocker.Get<ICouchRequest>());
//Json content type returns request
mocker.Setup<ICouchRequest>(r => r.Json()).Returns(mocker.Get<ICouchRequest>());
//TEST
var database = mocker.CreateInstance<CloudantDatabase>();
var securityDocument = (CloudantSecurityDocument)database.GetSecurityDocument();
securityDocument.Id.Should().Be("_security");
securityDocument.CloudantSecuritySection.GetAssignment("userwithreadonlyaccess").Should().BeEquivalentTo("_reader");
securityDocument.CloudantSecuritySection.GetAssignment("userwithreadandwriteaccess").Should().BeEquivalentTo("_reader", "_writer");
securityDocument.Ok.Should().BeTrue();
mocker.VerifyAll();
}
public void CanFillDependenciesBeforeBaseConstructorInvocation()
{
var mocker = new AutoMocker();
var service1 = mocker.Get <IService>();
var provider = mocker.GetMock <IServiceProvider>();
var autoDIProvider = provider.As <IAutoDISerivceProvider>();
autoDIProvider.Setup(x => x.GetService(typeof(IService), It.IsAny <object[]>())).Returns(service1).Verifiable();
try
{
DI.Init(typeof(IService).Assembly, builder => builder.WithProvider(provider.Object));
var sut = new ClassWithExplicitBaseDependency();
Assert.AreEqual(service1, sut.Service);
mocker.VerifyAll();
}
finally
{
DI.Dispose(typeof(IService).Assembly);
}
}
public void CanInjectDependenciesIntoNestedTypes()
{
var mocker = new AutoMocker();
var service1 = mocker.Get <IService>();
var provider = mocker.GetMock <IServiceProvider>();
var autoDIProvider = provider.As <IAutoDISerivceProvider>();
autoDIProvider.Setup(x => x.GetService(typeof(IService), It.IsAny <object[]>())).Returns(service1).Verifiable();
try
{
DI.Init(typeof(IService).Assembly, builder => builder.WithProvider(provider.Object));
var sut = new ClassWtihNestedType.NestedType();
Assert.AreEqual(service1, sut.Service);
mocker.VerifyAll();
}
finally
{
DI.Dispose(typeof(IService).Assembly);
}
}
public async Task Handle_GivenPositiveTestLimitExceeded_ReturnsExceededAndConfig()
{
var automocker = new AutoMocker();
var verLimitConfig = new Mock <IVerificationLimitConfig>();
automocker
.Setup <IMsisLookupService, Task <Option <PositiveTestResult> > >(x =>
x.FindPositiveTestResult("01019098765"))
.ReturnsAsync(new PositiveTestResult
{
PositiveTestDate = DateTime.Today.AddDays(-7).Some()
}.Some);
automocker.Setup <IOptions <VerifyIdentifiedUser.Config>, VerifyIdentifiedUser.Config>(x => x.Value)
.Returns(new VerifyIdentifiedUser.Config
{
UseFixedTestCases = false
});
automocker
.Setup <IVerificationLimit, bool>(x => x.HasReachedLimit(It.IsAny <IEnumerable <VerificationRecord> >()))
.Returns(true);
automocker
.Setup <IVerificationLimit, IVerificationLimitConfig>(x => x.Config)
.Returns(verLimitConfig.Object);
var target = automocker.CreateInstance <VerifyIdentifiedUser.Handler>();
var result = await target.Handle(new VerifyIdentifiedUser.Command("01019098765", "pseudo-1", false), new CancellationToken());
result.HasVerifiedPostiveTest.Should().BeTrue();
result.VerificationLimitExceeded.Should().BeTrue();
result.VerificationLimitConfig.Should().Be(verLimitConfig.Object.Some());
automocker.VerifyAll();
}
public void WhenErrorOccursItIsLogged()
{
// Arrange
var mocker = new AutoMocker();
var lineSource = new LineSourceSimulator(null);
lineSource.WithError("Crash");
mocker.Use <ILineSource>(lineSource);
//Force the async call to complete synchronously
mocker
.Setup <IAsyncLogger, Task>(x => x.LogAsync("Crash"))
.Returns(Task.CompletedTask);
var parser = mocker.CreateInstance <CsvParser>();
// Act
var rows = parser.Parse().ToArray();
// Assert
Assert.AreEqual(0, rows.Length);
mocker.VerifyAll();
}
public async Task Handle_WhenNoTestResultIsFound_ReturnsNegativeResult()
{
var automocker = new AutoMocker();
automocker
.Setup <IMsisLookupService, Task <Option <PositiveTestResult> > >(x =>
x.FindPositiveTestResult("01019098765"))
.ReturnsAsync(Option.None <PositiveTestResult>());
automocker.Setup <IOptions <VerifyIdentifiedUser.Config>, VerifyIdentifiedUser.Config>(x => x.Value)
.Returns(new VerifyIdentifiedUser.Config
{
UseFixedTestCases = false
});
var target = automocker.CreateInstance <VerifyIdentifiedUser.Handler>();
var result = await target.Handle(new VerifyIdentifiedUser.Command("01019098765", "pseudo-1", false), new CancellationToken());
result.HasVerifiedPostiveTest.Should().BeFalse();
result.PositiveTestDate.Should().Be(Option.None <DateTime>());
automocker.VerifyAll();
}
public async Task GetProfileDataAsync_GivenNationalIdentifiedWithPositiveResult_VerifiesStatusAndAddsRequestedClaim()
{
var automocker = new AutoMocker();
var verificationLimit = new Mock <IVerificationLimit>();
automocker
.Setup <IMediator, Task <VerificationResult> >(x => x.Send(It.IsAny <VerifyIdentifiedUser.Command>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new VerificationResult(new PositiveTestResult
{
PositiveTestDate = DateTime.Today.AddDays(-1).Some()
}, new VerificationRecord[0], verificationLimit.Object));
automocker
.SetupOptions(new AnonymousTokensConfig
{
Enabled = false
})
.SetupOptions(DefaultVerificationLimitConfig);
var context = new ProfileDataRequestContext
{
Subject = new ClaimsPrincipal(new ClaimsIdentity(new []
{
new Claim(InternalClaims.NationalIdentifier, "08089409382"),
new Claim(InternalClaims.Pseudonym, "pseudo-1")
})),
RequestedClaimTypes = new [] { DkSmittestopClaims.Covid19Status }
};
var target = automocker.CreateInstance <ProfileService>();
await target.GetProfileDataAsync(context);
context.IssuedClaims.Should().Contain(x => x.Type == DkSmittestopClaims.Covid19Status && x.Value == DkSmittestopClaims.StatusValues.Positive);
automocker.VerifyAll();
}
public void TestUpdateSecurityDoc_Should_Succeed_For_Valid_Document()
{
//SETUP
var mocker = new AutoMocker();
//connection returns base uri
mocker.Setup<ICouchConnection>(c => c.BaseUri).Returns(new Uri("http://localhost"));
//GetCouchResponse returns security doc as per Cloudant documentation
const string responseString = "{ " +
"\"ok\":true" +
"}";
mocker.Setup<ICouchResponse>(r => r.ResponseString).Returns(responseString);
mocker.Setup<ICouchResponse, HttpStatusCode>(r => r.StatusCode).Returns(HttpStatusCode.OK);
mocker.Setup<ICouchRequest>(r => r.GetCouchResponse()).Returns(mocker.Get<ICouchResponse>());
//couchFactory returns request
mocker.Setup<ICouchFactory>(f => f.GetRequest(It.IsAny<Uri>(), It.IsAny<ICouchConnection>()))
.Returns(mocker.Get<ICouchRequest>());
//Get request returns request
mocker.Setup<ICouchRequest>(r => r.Put()).Returns(mocker.Get<ICouchRequest>());
//Json content type returns request
mocker.Setup<ICouchRequest>(r => r.Json()).Returns(mocker.Get<ICouchRequest>());
//Data returns request
mocker.Setup<ICouchRequest>(r => r.Data(It.IsAny<string>())).Returns(mocker.Get<ICouchRequest>());
//security doc
var securityDoc = new CloudantSecurityDocument();
securityDoc.CloudantSecuritySection.AddUser("user1", "_reader");
securityDoc.CloudantSecuritySection.AddUser("user2", "_reader","_writer");
//TEST
var database = mocker.CreateInstance<CloudantDatabase>();
database.UpdateSecurityDocument(securityDoc);
mocker.VerifyAll();
}
