public async Task New_User_Should_Have_Name(UserInput user) { var mockUserWriteOnlyRepository = new Mock <IUserWriteOnlyRepository>(); var sut = new UserUseCase(null, mockUserWriteOnlyRepository.Object); await Assert.ThrowsAsync <InvalidValueException>(() => sut.CreateUser(user)); }
public async Task New_Task_Should_Have_Name(TaskInput task) { var mockTaskWriteOnlyRepository = new Mock <ITaskWriteOnlyRepository>(); var sut = new TaskUseCase(null, mockTaskWriteOnlyRepository.Object); await Assert.ThrowsAsync <InvalidValueException>(() => sut.Create(Guid.NewGuid(), task)); }
public async Task Create_InValidUser_ReturnsCreatedUser() { UserService userService = new UserService(_fixture.context, _mailOptions); User user = new User(); user.EMail = "*****@*****.**"; await Assert.ThrowsAsync <AppException>(() => userService.Create(user)); }
public async Task PutInvalidUserId_ReturnsThrowException() { MonitoredItemsServices itemsService = new MonitoredItemsServices(_fixture.context); MonitoredItem item = new MonitoredItem { ElementName = "CreatedTest", Url = "www.google.com", Frequency = 5 }; await Assert.ThrowsAsync <AppException>(() => itemsService.Create(Guid.Parse("00000000-0000-0000-0000-000000000002"), item)); }
public async Task InterServiceDisposeNullFailureFunc() { // Setup: Create a query service and dispose params var qes = new QueryExecutionService(null, null); Func <Task> successFunc = () => Task.FromResult(0); // If: I call the inter-service API to dispose a query with a null success function // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceDisposeQuery(Constants.OwnerUri, successFunc, null)); }
public async Task Given_In_Correct_Email_Returns_Error() { var user = new IdentityUser { UserName = "******", PasswordHash = "GenericUsername", Email = "*****@*****.**" }; await Assert.ThrowsAsync <ArgumentException>(async() => await Controller.Login(user, user.PasswordHash)); }
public async Task InterServiceExecuteNullEventSender() { // Setup: Create a query service, and execute params var qes = new QueryExecutionService(null, null); var executeParams = new ExecuteStringParams(); // If: I call the inter-service API to execute a query with a a null event sender // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceExecuteQuery(executeParams, null, null, null, null, null, null)); }
public void Given_Non_Existing_User_To_Update_Returns_Exception() { var identityUser = new IdentityUser { UserName = "******", PasswordHash = "GenericUsername", Email = "*****@*****.**" }; Assert.ThrowsAsync <Exception>(() => Controller.Update(identityUser)); }
public async Task InterServiceExecuteNullExecuteParams() { // Setup: Create a query service var qes = new QueryExecutionService(null, null); var eventSender = new EventFlowValidator <ExecuteRequestResult>().Complete().Object; // If: I call the inter-service API to execute with a null execute params // Then: It should throw await Assert.ThrowsAsync <ArgumentNullException>( () => qes.InterServiceExecuteQuery(null, null, eventSender, null, null, null, null)); }
public async Task Delete() { var project = await this.Add(); var message = new HttpRequestMessage(HttpMethod.Delete, $"{API}/{project.Id}"); var responseMessage = await this.HttpClient.SendAsync(message); await responseMessage.AsResult(); var exception = await Assert.ThrowsAsync <SaeException>(() => this.Get(project.Id)); Assert.Equal(StatusCode.ResourcesNotExist, exception.Code); }
public async Task LoadMoreItemsAsync_OnlySupportsOneLoadOperationAtOnce() { var loadingTaskSource = new TaskCompletionSource <IEnumerable <object> >(); var mockDataSource = CreateMockDataSource(GetSampleData()); mockDataSource .Arrange(dataSource => dataSource.GetItemsAsync(Arg.IsAny <uint>(), Arg.IsAny <uint>())) .Returns(loadingTaskSource.Task); var collection = new IncrementalLoadingCollection <object>(mockDataSource); collection.LoadMoreItemsAsync(1); await Assert.ThrowsAsync <InvalidOperationException>(async() => await collection.LoadMoreItemsAsync(1)); }
public void Deve_Dar_Erro_Ao_Deletar_Produto_E_Nao_Encontrar_ID() { var produtosMock = _produtoFixture.ProdutoMock(); var mensagemErro = Produto.ProdutoNaoEncontrato; var marcaService = new Mock <IMarcaService>(); var produtoRespository = new Mock <IProdutoRepository>(); produtoRespository.Setup(x => x.Deleta(It.IsAny <Produto>())) .Throws(new NotFoundExepction(mensagemErro)); var service = new ProdutoService(produtoRespository.Object, marcaService.Object); var produtosRetorno = Assert.ThrowsAsync <NotFoundExepction>( async() => service.Deleta(produtosMock.First())); Assert.Equal(mensagemErro, produtosRetorno.Result.Message); }
public void Deve_Dar_Erro_Ao_Deletar_Produto() { var produtoMock = _produtoFixture.ProdutoMock().First(); var mensagemErro = Produto.ErroAoModificarProduto; var marcaService = new Mock <IMarcaService>(); var produtoRespository = new Mock <IProdutoRepository>(); produtoRespository.Setup(x => x.ObterPorId(It.IsAny <int>())) .Returns(produtoMock); produtoRespository.Setup(x => x.Deleta(It.IsAny <Produto>())) .Throws(new Exception(mensagemErro)); var service = new ProdutoService(produtoRespository.Object, marcaService.Object); Assert.ThrowsAsync <Exception>(async() => service.Deleta(produtoMock)); }
public async Task AsyncThrowsExceptionExactlyOfTypeReference() { async Task a() { await Task.Delay(1); throw new ArgumentNullException("id"); } Func <Task> action = a; Type t = typeof(ArgumentException); Exception ex; // MSTest does not support this case. // NUnit Assert.That(a, Throws.TypeOf(t), () => "Some context"); // Some context // Expected: <System.ArgumentException> // But was: <System.ArgumentNullException> // XUnit ex = await XUnitAssert.ThrowsAsync(t, action); // Assert.Throws() Failure // Expected: typeof(System.ArgumentException) // Actual: typeof(System.ArgumentNullException): Value cannot be null. // Parameter name: id // ---- System.ArgumentNullException: Value cannot be null. // Parameter name: id // Fluent does not support this case. // Shouldly ex = await Should.ThrowAsync(action, "Some context", t); // Shouldly uses your source code to generate its great error messages, build your test project with full debug information to get better error messages // The provided expression // handle aggregate exception // System.ArgumentException // but was // System.ArgumentNullException // // Additional Info: // Some context }
public async Task TestSequence(IAccountGrain account, bool hasLogStored) { Assert.Equal(0u, await account.Balance()); var initialdepositguid = Guid.NewGuid(); await account.Deposit(100, initialdepositguid, "initial deposit"); Assert.Equal(100u, await account.Balance()); var firstwithdrawalguid = Guid.NewGuid(); var success = await account.Withdraw(70, firstwithdrawalguid, "first withdrawal"); Assert.True(success); Assert.Equal(30u, await account.Balance()); var secondwithdrawalguid = Guid.NewGuid(); success = await account.Withdraw(70, secondwithdrawalguid, "second withdrawal"); Assert.False(success); Assert.Equal(30u, await account.Balance()); if (hasLogStored) { // check the transaction log var log = await account.GetTransactionLog(); Assert.Equal(2, log.Count()); Assert.Equal(initialdepositguid, log[0].Guid); Assert.Equal("initial deposit", log[0].Description); Assert.Equal(firstwithdrawalguid, log[1].Guid); Assert.Equal("first withdrawal", log[1].Description); Assert.True(log[0].IssueTime < log[1].IssueTime); } else { await Assert.ThrowsAsync(typeof(NotSupportedException), async() => await account.GetTransactionLog()); } }
public async Task AsyncThrowsExceptionExactlyOfStaticType() { async Task a() { await Task.Delay(1); throw new ArgumentNullException("id"); } Func <Task> action = a; ArgumentException ae; // MSTest ae = await MSTestAssert.ThrowsExceptionAsync <ArgumentException>(action, "Some context"); // Assert.ThrowsException failed. Threw exception ArgumentNullException, but exception ArgumentException was expected. Some context // Exception Message: Value cannot be null. // Parameter name: id // Stack Trace: ... // NUnit does not support this use case. // XUnit ae = await XUnitAssert.ThrowsAsync <ArgumentException>(action); // Assert.Throws() Failure // Expected: typeof(System.ArgumentException) // Actual: typeof(System.ArgumentNullException): Value cannot be null. // Parameter name: id // ---- System.ArgumentNullException: Value cannot be null. // Parameter name: id // Fluent ae = action.Should().ThrowExactly <ArgumentException>("SOME REASONS").Which; // Expected type to be System.ArgumentException because SOME REASONS, but found System.ArgumentNullException. // Shouldly does not support this case. }
public async Task I_can_assert_an_async_exception_and_get_an_error_if_no_exception_was_thrown() { await Assert.ThrowsAsync <AssertionException>( () => SutAssert.ThrowsAsync <IOException>(() => Task.CompletedTask) ); }
public async Task I_can_assert_an_async_exception_and_get_an_error_if_another_was_thrown() { await Assert.ThrowsAsync <AssertionException>( () => SutAssert.ThrowsAsync <IOException>(() => Task.FromException(new FileNotFoundException())) ); }