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