public void QuandoExceptionForLancadaResultadoIsSuccessDeveSerFalso()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
//Criando um moq do repositorio
var moq = new Mock <IRepositorioTarefas>();
var moqLogger = new Mock <ILogger <CadastraTarefaHandler> >();
// Quando o argumento de entrada Incluir tarefas for chamado com qualquer parametro do tipo Tarefas[]
// Vai lan�ar uma exce��o do tipo Exception
moq.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(new Exception("Houve um erro ao inserir a(s) tarefa(s)"));
//Retornando o repositorio
var repo = moq.Object;
var handler = new CadastraTarefaHandler(repo, moqLogger.Object);
//act
CommandResult success = handler.Execute(comando); //SUT >> CadastraTarefaHandlerExecute
//assert
Assert.False(success.IsSuccess);
}
public void QuandoExceptionForLancadaDeveLogarMensagemDaExcecao()
{
//Given
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
string mensagemErro = "Houve um erro ao inserir a(s) tarefa(s)";
var excecaoEsperada = new Exception(mensagemErro);
//Criando um moq do repositorio
var moq = new Mock <IRepositorioTarefas>();
var moqLogger = new Mock <ILogger <CadastraTarefaHandler> >();
moq.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(excecaoEsperada);
//Retornando o repositorio
var repo = moq.Object;
var handler = new CadastraTarefaHandler(repo, moqLogger.Object);
//When
handler.Execute(comando);
//Then
moqLogger.Verify(x => x.Log(
It.IsAny <LogLevel>(),
It.IsAny <EventId>(),
It.IsAny <object>(),
It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >()
), Times.Once());
}
public void DadaTarefaComInfoValidaDeveLogar()
{
//arrange
string TituloTarefaEsperado = "Usar Moq para aprofundar conhecimento de API";
LogLevel logLevelCapturado = LogLevel.Trace;
string logMensagemCapturado = string.Empty;
var command = new CadastraTarefa(TituloTarefaEsperado, new Categoria("Estudo"), new DateTime(2019, 12, 31));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
CapturaLog captura = (logLevel, eventId, state, exception, function) =>
{
logLevelCapturado = logLevel;
logMensagemCapturado = function(state, exception);
};
mockLogger.Setup(l => l.Log(
It.IsAny <LogLevel>(),
It.IsAny <EventId>(),
It.IsAny <object>(),
It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >())
).Callback(captura);
var mockRepositorioTarefas = new Mock <IRepositorioTarefas>();
var handler = new CadastraTarefaHandler(mockRepositorioTarefas.Object, mockLogger.Object);
//action
var resultado = handler.Execute(command);
//assert
Assert.Equal(LogLevel.Information, logLevelCapturado);
Assert.Contains(TituloTarefaEsperado, logMensagemCapturado);
}
public void QuandoExceptionForLancadaDeveLogarAMensagemDaExcecao()
{
var mensagemDeErroEsperada = "Houve um erro na inclusão de tarefas";
var excecaoEsperada = new Exception(mensagemDeErroEsperada);
var comando = new CadastraTarefa("Estudar XUnit",
new Categoria("Estudo"),
new DateTime(2019, 12, 31));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
mock.Setup(x => x.IncluirTarefas(It.IsAny <Tarefa[]>())).Throws(excecaoEsperada);
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
CommandResult resultado = handler.Execute(comando);
mockLogger.Verify(l =>
l.Log(
LogLevel.Error, //nível de log => LogError
It.IsAny <EventId>(), //identificador do evento
It.IsAny <object>(), //objeto que será logado
excecaoEsperada, //exceção que será logada
It.IsAny <Func <object, Exception, string> >()
), //função que converte objeto+exceção >> string
Times.Once());
}
public void QuandoExceptionForLancadaIssSuccessDeveSerFalse()
{
//arange
var comando = new CadastraTarefa("Estudar XUnit",
new Categoria("Estudo"),
DateTime.Now.AddDays(1)
);
var mock = new Mock <IRepositorioTarefas>();
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(new Exception("Erro ao Incluir Tarefa"));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//act
CommandResult result = handler.Execute(comando);
//assert
Assert.False(result.IsSuccess);
}
public void DataTarefaComInformacoesValidasDeveIncluirNoRepositorio_InMemoryDatabase()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Core.Models.Categoria("Estudo"), new DateTime(2019, 12, 31));
//setup do dublê
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("Teste de Integração")
.Options;
var contexto = new DbTarefasContext(options);
var repo = new RepositorioTarefa(contexto);
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
var logger = mock.Object;
var handler = new CadastraTarefaHandler(repo, logger);
//act
handler.Execute(comando);
//assert
var tarefa = repo.ObtemTarefas(t => t.Categoria.Descricao == "Estudo").FirstOrDefault();
Assert.NotNull(tarefa);
Assert.Equal("Estudar Xunit", tarefa.Titulo);
Assert.Equal(new DateTime(2019, 12, 31), tarefa.Prazo);
}
public void DadaTarefaComInformacoesValidasDeveLogarAOperacao()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Core.Models.Categoria("Estudo"), new DateTime(2019, 12, 31));
//setup dos dublês
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("Teste de Integração")
.Options;
var contexto = new DbTarefasContext(options);
var repo = new RepositorioTarefa(contexto);
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
string logOutput = string.Empty;
CaptureLogMessage capture = (l, i, v, e, f) =>
{
logOutput = logOutput + v.ToString();
};
mock.Setup(x => x.Log(LogLevel.Debug, It.IsAny <EventId>(), It.IsAny <object>(), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >())).Callback(capture);
var logger = mock.Object;
var handler = new CadastraTarefaHandler(repo, logger);
//act
handler.Execute(comando);
//assert
//COMO VERIFICAR SE O LOG FOI REALIZADO?
Assert.Contains("Persistindo a tarefa...", logOutput);
}
public void QuandoExceptionForLancadaDeveLogarAMensagem()
{
//Arrange
var comando = new CadastraTarefa("Estudar XUnit", new Categoria("Estudo"), new DateTime(2020, 1, 1));
var excecaoEsperada = new Exception("Houve um erro na inclusão de tarefas");
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
mock.Setup(x => x.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(excecaoEsperada);
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//Act
CommandResult resultado = handler.Execute(comando);
////Assert
mockLogger.Verify(x => x.Log(LogLevel.Error,
It.IsAny <EventId>(),
It.IsAny <object>(),
It.IsAny <Exception>(),
It.IsAny <Func <object, Exception, string> >()),
Times.Once());
}
public void QuandoExceptionForLancadaDeveLogarAMensagemDaExcessao()
{
//arrange
var mensagemDeErroEsperada = "Houve um erro na inclusão de tarefas";
var exception = new Exception(mensagemDeErroEsperada);
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(exception);
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//act
CommandResult resultado = handler.Execute(comando);
//assert
mockLogger.Verify(l => l.Log(
LogLevel.Error,
It.IsAny <EventId>(),
It.IsAny <object>(),
exception,
It.IsAny <Func <object, Exception, string> >()
),
Times.Once());
}
public void TarefaDadaInfoCorretaCadastraNoBD()
{
//arange
var comando = new CadastraTarefa("Estudar XUnit",
new Categoria("Estudo"),
DateTime.Now.AddDays(1)
);
//var repositorio = new RepositorioTarefasFake();
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefasContext")
.Options;
var context = new DbTarefasContext(options);
var repositorio = new RepositorioTarefa(context);
var handler = new CadastraTarefaHandler(repositorio, mock.Object);
//act
handler.Execute(comando);
//assert
var tarefa = repositorio.ObtemTarefas(t => t.Titulo == "Estudar XUnit");
Assert.NotNull(tarefa);
}
public void QuandoExeceptionForLancadaDeveLogarAMensagemDaExcecao()
{
var mensagemErroEsperada = "Houve Um Eroo na Inclusao de Tarefas";
var excecaoEsperada = new Exception(mensagemErroEsperada);
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
//var repo = new RepositorioFake(); //Dublê para o teste
var mock = new Mock <IRepositorioTarefas>();
var mockLog = new Mock <ILogger <CadastraTarefaHandler> >();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))// parametro com os dados para o metodo IncluirTarefas
.Throws(excecaoEsperada);
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLog.Object);
//act
CommandResult resultado = handler.Execute(comando);
//Assert
mockLog.Verify(l =>
l.Log(
LogLevel.Error, // nível de log => LogError
It.IsAny <EventId>(), // identificador do evento
It.IsAny <object>(), // objeto que sera logado
excecaoEsperada, // excecao que sera logada
It.IsAny <Func <object, Exception, string> >() // funcao que converte objeto + exceção em string
),
Times.Once()
);
}
public void DadaTarefaComInformacoesValidasDeveIncluirNoBD()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
//var repo = new RepositorioFake(); //Dublê para o teste
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefasContext")
.Options;
var contexto = new DbTarefasContext(options);
var repo = new RepositorioTarefa(contexto);
var handler = new CadastraTarefaHandler(repo, mock.Object);
//act
handler.Execute(comando);
//assert
var tarefas = repo.ObtemTarefas(t => t.Titulo == "Estudar Xunit").FirstOrDefault();
Assert.NotNull(tarefas);
}
public IActionResult EndpointCadastraTarefa(CadastraTarefaVM model)
{
var cmdObtemCateg = new ObtemCategoriaPorId(model.IdCategoria);
var categoria = new ObtemCategoriaPorIdHandler(_repo).Execute(cmdObtemCateg);
if (categoria == null)
{
return(NotFound("Categoria não encontrada"));
}
var comando = new CadastraTarefa(model.Titulo, categoria, model.Prazo);
var handler = new CadastraTarefaHandler(_repo, _logger);
var retorno = handler.Execute(comando);
if (retorno.IsSuccess)
{
return(Ok());
}
else
{
return(new StatusCodeResult(500));
}
}
public void Test1()
{
var comando = new CadastraTarefa("Estudar xUnit", new Categoria("Estudo"), new DateTime(2019, 12, 10));
//var repoFakeTarefas = new FakeRepositoryTarefas();
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefasContext")
.Options;
var dbContext = new DbTarefasContext(options);
var repoInMemory = new RepositorioTarefa(dbContext);
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
//var handler = new CadastraTarefaHandler(repoFakeTarefas);
var handler = new CadastraTarefaHandler(repoInMemory, mockLogger.Object);
handler.Execute(comando);
//Vamos fazer o teste do repositório por mock utilizando um repositorio fake.
//var tarefa = repoFakeTarefas.ObtemTarefas(t => t.Titulo == "Estudar xUnit").FirstOrDefault();
var tarefa = repoInMemory.ObtemTarefas(x => x.Titulo == "Estudar xUnit").FirstOrDefault();
Assert.NotNull(tarefa);
}
public void GravarTarefaGeraLog()
{
var tituloTarefaEsperado = "Aprender API via testes com Moq";
var comando = new CadastraTarefa(tituloTarefaEsperado, new Categoria("Estudo"), new DateTime(2019, 12, 10));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
LogLevel levelCapturado = LogLevel.Error;
string mensagemCapturada = string.Empty;
CapturaMensagemLog capturaTarefa = (level, eventId, state, exception, func) =>
{
levelCapturado = level;
mensagemCapturada = state.ToString();
};
mockLogger.Setup(l =>
l.Log(
It.IsAny <LogLevel>(),
It.IsAny <EventId>(),
It.IsAny <object>(),
It.IsAny <Exception>(),
(Func <object, Exception, string>)It.IsAny <object>()
)).Callback(capturaTarefa);
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
CommandResult resultado = handler.Execute(comando);
Assert.Equal(LogLevel.Debug, levelCapturado);
Assert.Contains(tituloTarefaEsperado, mensagemCapturada);
}
public void Execute(CadastraTarefa comando)
{
var tarefa = new Tarefa
(
id: 0,
titulo: comando.Titulo,
prazo: comando.Prazo,
categoria: comando.Categoria,
concluidaEm: null,
status: StatusTarefa.Criada
);
_logger.LogDebug("Persistindo a tarefa...");
_repo.IncluirTarefas(tarefa);
}
public IActionResult EndpointCadastraTarefa(CadastraTarefaVM model)
{
var cmdObtemCateg = new ObtemCategoriaPorId(model.IdCategoria);
var categoria = new ObtemCategoriaPorIdHandler().Execute(cmdObtemCateg);
if (categoria == null)
{
return(NotFound("Categoria não encontrada"));
}
var comando = new CadastraTarefa(model.Titulo, categoria, model.Prazo);
var handler = new CadastraTarefaHandler();
handler.Execute(comando);
return(Ok());
}
public void QuandoLancarExceptionIsSuccededFalse()
{
//arrange
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mockRepositorioTarefas = new Mock <IRepositorioTarefas>();
mockRepositorioTarefas.Setup(t => t.IncluirTarefas(It.IsAny <Tarefa[]>())).Throws(new Exception("Houve um erro na inclusão de tarefas."));
var repositorioTarefas = mockRepositorioTarefas.Object;
var command = new CadastraTarefa("Estudar XUnit", new Categoria("Estudo"), new DateTime(2020, 10, 01));
var handler = new CadastraTarefaHandler(repositorioTarefas, mockLogger.Object);
//action
var resultado = handler.Execute(command);
//assert
Assert.False(resultado.IsSucceded);
}
public void FalhaAoLancarExcecao()
{
var comando = new CadastraTarefa("Estudar xUnit", new Categoria("Estudo"), DateTime.Now.AddMonths(3));
var mock = new Mock <IRepositorioTarefas>();
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(new Exception("Não foi possivel adicionar as tarefas."));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
CommandResult resultado = handler.Execute(comando);
Assert.False(resultado.IsSuccess);
}
public void QuandoExceptionForLancadaResultadoIsSuccessDeveSerFalse()
{
//Arrange
var comando = new CadastraTarefa("Estudar xUnit", new Categoria("Estudo"), new DateTime(2021, 12, 31));
var mock = new Mock <IRepositorioTarefas>();
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>())).Throws(new Exception("Houve um erro na inclusão de tarefas"));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//Act
CommandResult resultado = handler.Execute(comando);
//Assert
Assert.False(resultado.IsSuccess);
}
public void QuandoExceptionForLancadaResultadoIsSuccessDeveSerFalse()
{
var comando = new CadastraTarefa("Estudar XUnit",
new Alura.CoisasAFazer.Core.Models.Categoria("Estudo"),
new DateTime(2019, 12, 31));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
mock.Setup(x => x.IncluirTarefas(It.IsAny <Tarefa[]>())).Throws(new Exception("Houve um erro"));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
CommandResult resultado = handler.Execute(comando);
Assert.False(resultado.IsSucess);
}
public void QuandoExceptionForLancadaResultadoIsSucessDeveSerFalse()
{
//Arrange
var comando = new CadastraTarefa("Estudar XUnit", new Categoria("Estudo"), new DateTime(2020, 1, 1));
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var mock = new Mock <IRepositorioTarefas>();
mock.Setup(x => x.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws <Exception>();
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//Act
CommandResult resultado = handler.Execute(comando);
//Assert
Assert.Equal(false, resultado.IsSuccess);
}
public void DadaTarefaComInfoValidasIncluiNoBancoDados()
{
//Arrange
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefas")
.Options;
var context = new DbTarefasContext(options);
IRepositorioTarefas repositorioTarefas = new RepositorioTarefas(context);
var command = new CadastraTarefa("Estudar XUnit", new Categoria("Estudo"), new DateTime(2020, 10, 01));
var handler = new CadastraTarefaHandler(repositorioTarefas, mockLogger.Object);
//Action
handler.Execute(command);
var tarefa = repositorioTarefas.ObtemTarefas(t => t.Titulo.Equals("Estudar XUnit", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
//Assert
Assert.NotNull(tarefa);
}
public void DadaTarefaComInfoValidasDeveIncluirNoDb()
{
//Arrange
var comando = new CadastraTarefa("Estudar xUnit", new Categoria("Estudo"), new DateTime(2021, 12, 31));
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefasContext", new InMemoryDatabaseRoot())
.Options;
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
var contexto = new DbTarefasContext(options);
var repo = new RepositorioTarefa(contexto);
var handler = new CadastraTarefaHandler(repo, mock.Object);
//Act
handler.Execute(comando);
//Assert
var tarefa = repo.ObtemTarefas(t => t.Titulo == "Estudar xUnit").FirstOrDefault();
Assert.NotNull(tarefa);
}
public void QuandoExceptionForLancadaResultadoIsSucceesDeveSerFalse()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
//var repo = new RepositorioFake(); //Dublê para o teste
var mock = new Mock <IRepositorioTarefas>();
var mocklog = new Mock <ILogger <CadastraTarefaHandler> >();
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))// parametro com os dados para o metodo IncluirTarefas
.Throws(new Exception("Houve Um Eroo na Inclusao de Tarefas"));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mocklog.Object);
//act
CommandResult resultado = handler.Execute(comando);
//assert
Assert.False(resultado.IsSuccess);
}
public void QuandoExceptionForLancadaResultadoIsSuccessDeveSerFalso()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
var mock = new Mock <IRepositorioTarefas>();
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
// Quando chamar o método IncluirTarefas para qualquer array de tarefas,
// lance uma exception
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(new Exception("Houve um erro na inclusão de tarefas"));
var repo = mock.Object;
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//act
var resultado = handler.Execute(comando);
//assert
Assert.False(resultado.IsSuccess);
}
public void DadaTarefaComInformacoesValidasDeveInclurNoBd()
{
var comando = new CadastraTarefa("Estudar XUnit",
new Alura.CoisasAFazer.Core.Models.Categoria("Estudo"),
new DateTime(2019, 12, 31));
var mock = new Mock <ILogger <CadastraTarefaHandler> >();
var options = new DbContextOptionsBuilder <DbTarefasContext>().UseInMemoryDatabase("DbTarefasContext").Options;
var contexto = new DbTarefasContext(options);
var repo = new RepositorioTarefa(contexto);
var handler = new CadastraTarefaHandler(repo, mock.Object);
handler.Execute(comando);
var tarefa = repo.ObtemTarefas(x => x.Titulo == "Estudar XUnit").FirstOrDefault();
Assert.NotNull(tarefa);
}
public void TarefaDeveSerIncluidaNoBD()
{
var novaTarefa = new CadastraTarefa("Estudar xUnit", new Categoria("Estudo"), DateTime.Now.AddMonths(3));
var options = new DbContextOptionsBuilder <DbTarefasContext>()
.UseInMemoryDatabase("DbTarefasContext")
.Options;
var contexto = new DbTarefasContext(options);
var repositorio = new RepositorioTarefa(contexto);
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var tarefaHandler = new CadastraTarefaHandler(repositorio, mockLogger.Object);
tarefaHandler.Execute(novaTarefa);
var tarefa = repositorio.ObtemTarefas(t => t.Titulo == "Estudar xUnit");
Assert.NotNull(tarefa);
}
public void QuandoSQLExceptionEhLancadaDeveComunicarResultadoNoComando()
{
//arrange
var comando = new CadastraTarefa("Estudar Xunit", new Core.Models.Categoria("Estudo"), new DateTime(2019, 12, 31));
//setup do dublê
var mock = new Mock <IRepositorioTarefas>();
var repo = mock.Object;
//como configurar o lançamento da exceção? no próprio teste!
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>())).Throws(new Exception("Houve um erro na inclusão..."));
var logger = new Mock <ILogger <CadastraTarefaHandler> >().Object;
var handler = new CadastraTarefaHandler(repo, logger);
//act: mudança no design da solução! TDD
var resultado = handler.Execute(comando);
//assert
Assert.False(resultado.Success);
}
public void QuandoExceptionForLancadaDeveLogarAMensagemDaExcecao()
{
//arrange
var mensagemDeErroEsperada = "Houve um erro na inclusão de tarefas";
var excecaoEsperada = new Exception(mensagemDeErroEsperada);
var comando = new CadastraTarefa("Estudar Xunit", new Categoria("Estudo"), new DateTime(2019, 12, 31));
var mock = new Mock <IRepositorioTarefas>();
var mockLogger = new Mock <ILogger <CadastraTarefaHandler> >();
var repo = mock.Object;
mock.Setup(r => r.IncluirTarefas(It.IsAny <Tarefa[]>()))
.Throws(excecaoEsperada);
var handler = new CadastraTarefaHandler(repo, mockLogger.Object);
//act
var resultado = handler.Execute(comando);
//assert
mockLogger.Verify(l =>
l.Log(
LogLevel.Error,
It.IsAny <EventId>(),
It.Is <object>((v, t) => true),
excecaoEsperada,
It.Is <Func <object, Exception, string> >((v, t) => true)),
Times.Once());
// abordagem alternativa para verificação
//mockLogger.Verify(l =>
// l.Log(
// LogLevel.Error,
// It.IsAny<EventId>(),
// It.IsAny<object>(),
// excecaoEsperada,
// (Func<object, Exception, string>)It.IsAny<object>()),
// Times.Once());
}
