public RepositoryTests()
{
_context = new ContextoAplicacao("Server=localhost\\sqlexpress;Database=LivrariaHBSIS;Trusted_Connection=True;");
_livroRepository = new LivroRepository(_context);
_categoriaRepository = new CategoriaRepository(_context);
_unitOfWork = new UnitOfWork(_context);
}
public void Setup()
{
_livroRepository = Substitute.For <ILivroRepository>();
_livroMapper = Substitute.For <ILivroMapper>();
_livroBusiness = new LivroBusiness(_livroRepository, _livroMapper);
}
public LivroService(
IAutorRepository autorRepository,
ILivroRepository livroRepository)
{
_autorRepository = autorRepository;
_livroRepository = livroRepository;
}
public LivroController(ILivroRepository livroRepository)
{
_criarLivro = new CriarLivro(livroRepository);
_alterarLivro = new AlterarLivro(livroRepository);
_excluirLivro = new ExcluirLivro(livroRepository);
_consultarLivro = new ConsultarLivro(livroRepository);
}
public EmprestimoService(IEmprestimoRepository emprestimoRepository,
IEstoqueRepository estoqueRepository,
ILivroRepository livroRepository)
{
_emprestimoRepository = emprestimoRepository;
_estoqueRepository = estoqueRepository;
_livroRepository = livroRepository;
}
public LivroBLL(ILivroRepository repository,
IGeneroRepository generoRepository,
IAutorRepository autorRepository)
{
_repository = repository;
_autorRepository = autorRepository;
_generoRepository = generoRepository;
}
public LivroAppService(IMapper mapper,
ILivroRepository livroRepository,
IMediatorHandler bus)
{
_mapper = mapper;
_livroRepository = livroRepository;
Bus = bus;
}
public HomeController(ILivroRepository livroRepository,
IAutorRepository autorReposity,
IClienteRepository clienteRepository)
{
_livroRepository = livroRepository;
_autorRepository = autorReposity;
_clienteRepository = clienteRepository;
}
public LivroQuery(ILivroRepository repository)
{
Field <ListGraphType <LivroType> >(
"livros",
resolve: context =>
repository.ObterLivros()
);
}
public RetornaSelectListItemRepository(IAutorRepository autorRepository, ICategoriaRepository categoriaRepository, IClienteRepository clienteRepository, ILivroRepository livroRepository, IFormaPagamentoRepository formaPagamentoRepository)
{
_AutorRepository = autorRepository;
_CategoriaRepository = categoriaRepository;
_ClienteRepository = clienteRepository;
_LivroRepository = livroRepository;
_FormaPagamentoRepository = formaPagamentoRepository;
}
public LivroCommandHandler(ILivroRepository livroRepository,
IUnitOfWork uow,
INotificationHandler <DomainNotification> notifications,
IMediatorHandler mediator) : base(uow, mediator, notifications)
{
_livroRepository = livroRepository;
_mediator = mediator;
}
public LivroCommandHandler(ILivroRepository livroRepository,
IUnitOfWork uow,
IMediatorHandler bus,
INotificationHandler <DomainNotification> notifications) : base(uow, bus, notifications)
{
_livroRepository = livroRepository;
Bus = bus;
}
public LivroHandler(IUnitOfWork uow,
IMediatorHandler bus,
INotificationHandler <DomainNotification> notifications,
ILivroRepository livroRepository)
: base(uow, bus, notifications)
{
_livroRepository = livroRepository;
_mediatr = bus;
}
public LivroService(ILivroRepository repository,
ILivroAssuntoRepository livroAssuntoRepository,
ILivroAutorRepository livroAutorRepository
) : base(repository)
{
_repository = repository;
_livroAssuntoRepository = livroAssuntoRepository;
_livroAutorRepository = livroAutorRepository;
}
public LivrosController(INotificationHandler <DomainNotification> notifications,
ILivroRepository livroRepository,
IMapper mapper,
IMediatorHandler mediator) : base(notifications, mediator)
{
_livroRepository = livroRepository;
_mapper = mapper;
_mediator = mediator;
}
public LivroApplication(
IMapper mapper,
ILivroService livroService,
ILivroRepository livroRepository)
{
_mapper = mapper;
_livroService = livroService;
_livroRepository = livroRepository;
}
public LivroService(
ILivroRepository livroRepository,
IMapper mapper,
ILogger <LivroService> logger,
IConfiguration configuration) :
base(mapper, logger, configuration)
{
_livroRepository = livroRepository;
}
public void LivroSystemTestSetUp()
{
BaseSqlTest.SeedDeleteDatabase();
BaseSqlTest.SeedInsertDatabase();
_livroRepository = new LivroRepository();
_livroService = new LivroService(_livroRepository);
_livroDefault = LivroObjectMother.Default;
}
public LivrosController(ILivroRepository livroRepository,
IEditoraRepository editoraRepository,
ILivroService livroService,
INotificador notificador,
IMapper mapper) : base(notificador)
{
_livroRepository = livroRepository;
_editoraRepository = editoraRepository;
_livroService = livroService;
_mapper = mapper;
}
public AtualizarLivroUseCase(IMapper mapper,
INotificador notificador,
ILivroRepository livroRepository,
IBuscarEditoraPorIdUseCase buscarEditoraUseCase,
IBuscarAutorPorIdUseCase buscarAutorUseCase)
{
_mapper = mapper;
_notificador = notificador;
_livroRepository = livroRepository;
_buscarEditoraUseCase = buscarEditoraUseCase;
_buscarAutorUseCase = buscarAutorUseCase;
}
public LivroServiceTest()
{
_fixture = new Fixture();
_logger = Substitute.For <ILogger <LivroService> >();
_mapper = Substitute.For <IMapper>();
_repository = Substitute.For <ILivroRepository>();
_configuration = Substitute.For <IConfiguration>();
_baseResponse = _fixture.Create <BaseResponse>();
_livro = _fixture.Create <Livro>();
_listaLivro = _fixture.Create <IEnumerable <Livro> >();
_requestLivro = _fixture.Create <RequestLivro>();
_responseLivro = _fixture.Create <ResponseLivro>();
_service = new LivroService(_repository, _mapper, _logger, _configuration);
}
public void Setup()
{
GerarDadosParaTeste();
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Livro, LivroViewModel>();
cfg.CreateMap <LivroViewModel, Livro>();
});
LivroRepository = Substitute.For <ILivroRepository>();
LivroRepository.Get(LivroComId.Id).Returns(LivroComId);
LivroRepository.GetAll().Returns(Livros);
LivroService = new LivroService(configuration.CreateMapper(), LivroRepository);
}
public void Setup()
{
_listaLivros = LivrariaLivrosFake.LivrosFake;
_mockSet = new Mock<DbSet<Livro>>();
_mockSet.As<IQueryable<Livro>>().Setup(m => m.Provider).Returns(_listaLivros.Provider);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.Expression).Returns(_listaLivros.Expression);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.ElementType).Returns(_listaLivros.ElementType);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.GetEnumerator()).Returns(_listaLivros.GetEnumerator());
_mockContext = new Mock<LivrariaContext>();
_mockContext.Setup(c => c.Livro).Returns(_mockSet.Object);
_livroRepository = new LivroRepository(_mockContext.Object);
}
public static void GerarServico(ILivroRepository livroRepository, IClienteRepository clienteRepository, IEmprestimoRepository emprestimoRepository, Guid livroId, Guid clienteId)
{
try
{
var cliente = clienteRepository.GetById(clienteId);
var livro = livroRepository.GetById(livroId);
Emprestimo emprestimo = new Emprestimo(cliente, livro);
emprestimoRepository.Save(emprestimo);
}
catch (Exception ex)
{
throw ex;
}
}
public void Setup()
{
_listaLivros = LivrariaLivrosFake.LivrosFake;
_listaLivrosView = LivrariaLivrosFake.LivrosViewFake;
var config = new MapperConfiguration(c =>
{
c.CreateMap <LivroViewModel, Livro>();
c.CreateMap <Livro, LivroViewModel>();
});
var mapper = config.CreateMapper();
_livroRepository = Substitute.For <ILivroRepository>();
_livroService = new LivroService(_livroRepository, mapper);
}
public void SetUp()
{
livroRepositoryMock = Substitute.For <ILivroRepository>();
autorRepositoryMock = Substitute.For <IAutorRepository>();
vinculacaoAutorLivroMock = Substitute.For <VinculacaoAutorLivroDto>();
vinculacaoAutorLivroMock.AutorId = 1;
vinculacaoAutorLivroMock.LivroId = 1;
livroMock = Substitute.For <Livro>();
livroMock.Id = vinculacaoAutorLivroMock.LivroId;
autorMock = Substitute.For <Autor>();
livroMock.Id = vinculacaoAutorLivroMock.AutorId;
livroRepositoryMock.ExisteAutorVinculadoNoLivro(vinculacaoAutorLivroMock.LivroId,
vinculacaoAutorLivroMock.AutorId).Returns(false);
}
public void Deve_buscar_o_livro_pelo_id()
{
var livro = LivrariaLivrosFake.LivroQueryableFake;
_mockSet = new Mock<DbSet<Livro>>();
_mockSet.As<IQueryable<Livro>>().Setup(m => m.Provider).Returns(livro.Provider);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.Expression).Returns(livro.Expression);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.ElementType).Returns(livro.ElementType);
_mockSet.As<IQueryable<Livro>>().Setup(m => m.GetEnumerator()).Returns(livro.GetEnumerator());
_mockContext = new Mock<LivrariaContext>();
_mockContext.Setup(c => c.Livro).Returns(_mockSet.Object);
_livroRepository = new LivroRepository(_mockContext.Object);
var livroEsperado = livro.First();
var livroAtual = _livroRepository.BuscarPorId(livroEsperado.LivroId);
Assert.AreEqual(livroEsperado, livroAtual);
}
public LivroMutation(ILivroRepository _repository)
{
Field <LivroType>(
"addLivro",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LivroInputType> >()
{
Name = "livro"
}),
resolve: context =>
{
var livro = context.GetArgument <Livro>("livro");
if (livro == null)
{
return(null);
}
return(_repository.AdicionarLivro(livro));
});
}
public LivroService(ILivroRepository LivroRepository) : base(LivroRepository)
{
_LivroRepository = LivroRepository;
}
public ClienteController(IClienteRepository clienteRepository, ILivroRepository livroRepository)
{
_clienteRepository = clienteRepository;
_livroRepository = livroRepository;
}
public LivroController()
{
_repository = new LivroRepository();
_service = new LivroService(new LivroRepository());
}
public LivroController(ILivroRepository repository)
{
_repository = repository;
}
public LivroService(ILivroRepository livroRepository)
{
_livroRepository = livroRepository;
}
