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(); }