public async void GetAll_test()
{
// Given
var mocker = new AutoMocker();
var droneServiceMock = mocker.CreateInstance <DroneService>();
var faker = AutoFaker.Create();
var drones = faker.Generate <IEnumerable <Drone> >();
var responseDronesTask = Task.Factory.StartNew(() => drones);
var expectResponse = drones;
var droneRepository = mocker.GetMock <IDroneRepository>();
droneRepository.Setup(r => r.ObterTodos()).Returns(responseDronesTask).Verifiable();
//When
var result = await droneServiceMock.GetAll();
//Then
droneRepository.Verify(mock => mock.ObterTodos(), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
public async void Insert_test()
{
// Given
var mocker = new AutoMocker();
var droneServiceMock = mocker.CreateInstance <DroneService>();
var faker = AutoFaker.Create();
var drone = faker.Generate <Drone>();
var responseDroneTask = Task.Factory.StartNew(() => true);
var responseAdicionarDroneTask = Task.Factory.StartNew(() => drone);
var expectResponse = true;
var droneRepository = mocker.GetMock <IDroneRepository>();
droneRepository.Setup(r => r.Adicionar(It.IsAny <Drone>())).Returns(responseAdicionarDroneTask).Verifiable();
droneRepository.Setup(r => r.UnitOfWork.Commit()).Returns(responseDroneTask).Verifiable();
//When
var result = await droneServiceMock.Insert(drone);
//Then
// droneRepository.Verify(mock => mock.Adicionar(It.IsAny<Drone>()), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
protected ServiceFixture(ITestOutputHelper output, IAutoBinder binder)
{
_faker = AutoFaker.Create(builder =>
{
builder.WithOverride(new ProductGeneratorOverride());
if (binder != null)
{
builder.WithBinder(binder);
}
});
// Setup
var id = _faker.Generate <Guid>();
var generator = new AutoFaker <Item>(binder)
.RuleFor(item => item.Id, () => id)
.RuleFor(item => item.Name, faker => faker.Person.FullName);
_item = generator;
_items = generator.Generate(5);
_repository = Substitute.For <IRepository>();
_repository.Get(id).Returns(_item);
_repository.GetAll().Returns(_items);
_service = new Service(_repository);
_output = output;
}
public async void GetAll_test()
{
// Given
var mocker = new AutoMocker();
var userServiceMock = mocker.CreateInstance <UserService>();
var faker = AutoFaker.Create();
var user = faker.Generate <User>();
var responseUserTask = Task.Factory.StartNew(() => user);
var expectResponse = user;
var userRepository = mocker.GetMock <IUserRepository>();
userRepository.Setup(r => r.GetByUserNameEPassword(It.IsAny <string>(), It.IsAny <string>())).Returns(responseUserTask).Verifiable();
//When
var result = await userServiceMock.Authenticate(It.IsAny <string>(), It.IsAny <string>());
//Then
userRepository.Verify(mock => mock.GetByUserNameEPassword(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
public Generate_Instance()
{
var faker = AutoFaker.Create() as AutoFaker;
_faker = faker;
_config = faker.Config;
}
public void DadoQueOClientePossuaUmUsuarioCadastrado()
{
var faker = AutoFaker.Create();
var user = faker.Generate <Usuario>();
_context.Set(user);
}
public PagamentoRepositoryTests()
{
_faker = AutoFaker.Create();
_comparison = new CompareLogic();
var serviceCollection = new ServiceCollection();
serviceCollection.ResolveConverters().BuildServiceProvider();
}
public FixtureBase()
{
Faker = AutoFaker.Create(builder =>
{
builder
.WithBinder <NSubstituteBinder>()
.WithOverride(new ProductGeneratorOverride());
});
}
public void Should_Apply_Conventions_For_Alias()
{
_faker = AutoFaker.Create(builder =>
{
builder.WithConventions(c => c.Email.Aliases("anotheremail", " "));
});
var instance = _faker.Generate <TestClass>();
instance.AnotherEmail.Should().Contain("@");
}
public void Should_Not_Apply_Conventions_For_Disabled_Generator()
{
_faker = AutoFaker.Create(builder =>
{
builder.WithConventions(c => c.Email.Enabled = false);
});
var instance = _faker.Generate <TestClass>();
instance.Email.Should().NotContain("@");
}
public void Should_Apply_Conventions()
{
_faker = AutoFaker.Create(builder =>
{
builder.WithConventions();
});
var instance = _faker.Generate <TestClass>();
instance.Email.Should().Contain("@");
}
public void Generate_ExampleStruct()
{
IAutoFaker faker = AutoFaker.Create(builder =>
{
builder.WithOverride(new ExampleStructOverride());
});
var exampleStruct = faker.Generate <ExampleStruct>();
_outputHelper.WriteLine(exampleStruct.Month.ToString());
Assert.True(exampleStruct.Month > 0 && exampleStruct.Month <= 12);
}
public T Generate <T>()
{
var faker = AutoFaker.Create(builder =>
builder.WithOverride(new PrimitiveGeneratorOverride()).
WithOverride(_typeImplementationOverride).
WithBinder(new SkipNoSerializeBinder())
);
var obj = faker.Generate <T>();
GeneratedObj = obj;
return(obj);
}
public void Should_Not_Apply_Conventions_When_Generator_AlwaysGenerate_Is_False()
{
_faker = AutoFaker.Create(builder =>
{
builder
.WithOverride(new TestGeneratorOverride())
.WithConventions(c => c.Email.AlwaysGenerate = false);
});
var instance = _faker.Generate <TestClass>();
instance.Email.Should().Be("EMAIL");
}
public async void Pedido_AdicionarPedido_ComSucesso()
{
// Given
var mocker = new AutoMocker();
var faker = AutoFaker.Create();
var adicionarPedidoViewModel = faker.Generate <AdicionarPedidoViewModel>();
var usuario = faker.Generate <Usuario>();
var identity = new ClaimsIdentity(new Claim[]
{ new Claim(ClaimTypes.Name, usuario.UserName.ToString()),
new Claim(ClaimTypes.Role, usuario.Role.ToString()) });
var pedidoControllerMock = mocker.CreateInstance <PedidoController>();
pedidoControllerMock.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(identity)
}
};
var cliente = usuario.Cliente;
var pedido = faker.Generate <Pedido>();
pedido.InformarCliente(cliente);
var responsePedidoTask = Task.Factory.StartNew(() => pedido);
var responsUserTask = Task.Run(() => usuario);
var responeInserirPedidoTask = Task.Factory.StartNew(() => true);
var pedidoService = mocker.GetMock <IPedidoService>();
var userService = mocker.GetMock <IUserService>();
userService.Setup(u => u.GetByUserName(It.IsAny <string>())).Returns(responsUserTask).Verifiable();
pedidoService.Setup(p => p.IsPedidoValido(It.IsAny <Pedido>())).Returns(string.Empty).Verifiable();
pedidoService.Setup(p => p.Insert(It.IsAny <Pedido>())).Returns(responeInserirPedidoTask).Verifiable();
var expectResponse = pedidoControllerMock.Ok(responsePedidoTask);
//When
var result = await pedidoControllerMock.AdicionarPedido(adicionarPedidoViewModel);
//Then
var comparison = new CompareLogic();
pedidoService.Verify(mock => mock.Insert(It.IsAny <Pedido>()), Times.Once());
Assert.Equal(expectResponse.StatusCode, ((OkObjectResult)result).StatusCode);
}
public void DadoQueASolicitacaoDePagamentoEEnviada()
{
// Given
var faker = AutoFaker.Create();
var adicionarPagamentoCartaoViewModelFaker = new AutoFaker <AdicionarPagamentoCartaoViewModel>()
.RuleFor(p => p.AnoVencimentoCartao, f => (DateTime.Now.Year + 2))
.RuleFor(p => p.MesVencimentoCartao, f => f.Random.Int(1, 12))
.RuleFor(p => p.NumeroCartao, f => f.Finance.CreditCardNumber())
.RuleFor(p => p.Valor, f => (double)f.Finance.Amount());
var adicionarPagamentoCartaoViewModel = adicionarPagamentoCartaoViewModelFaker.Generate();
_context.Set(adicionarPagamentoCartaoViewModel);
}
public async Task QuandoOUsuarioAdicionarUmDroneAsync()
{
var mocker = new AutoMocker();
var faker = AutoFaker.Create();
var baseControllerMock = mocker.CreateInstance <DroneController>();
var droneService = mocker.GetMock <IDroneService>();
var adicionarDroneViewModel = faker.Generate <AdicionarDroneViewModel>();
droneService.Setup(r => r.Insert(It.IsAny <Domain.Entities.Drone>())).Returns(Task.FromResult(true)).Verifiable();
//When
var resut = await baseControllerMock.PostDrone(adicionarDroneViewModel);
_context.Set(resut);
}
public async Task QuandoEuSolicitarUmDronePorId()
{
var mocker = new AutoMocker();
var faker = AutoFaker.Create();
var baseControllerMock = mocker.CreateInstance <DroneController>();
var droneService = mocker.GetMock <IDroneService>();
droneService.Setup(r => r.GetById(It.IsAny <Int32>())).Returns(Task.FromResult(_context.Get <Domain.Entities.Drone>())).Verifiable();
//When
var resut = await baseControllerMock.GetDrone(It.IsAny <Int32>());
_context.Set(resut.Result);
}
public void QuandoOClienteInformaSuaSenhaCorreta()
{
var faker = AutoFaker.Create();
var password = faker.Generate <string>();
var mocker = new AutoMocker();
var baseControllerMock = mocker.CreateInstance <OAuthController>();
var userService = mocker.GetMock <IUserService>();
var loginViewModel = faker.Generate <LoginViewModel>();
userService.Setup(r => r.Authenticate(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(_context.Get <Usuario>())).Verifiable();
//When
var resut = baseControllerMock.Authenticate(loginViewModel);
_context.Set(password);
_context.Set(resut.Result);
}
public async void ConsultaDrone_Test()
{
var mocker = new AutoMoqer();
var baseQueryMock = mocker.Create <DroneQuery>();
var faker = AutoFaker.Create();
var responseDroneRepo = faker.Generate <List <DroneEntity> >();
var responseUsuarioRepo = faker.Generate <UsuarioEntity>();
var responsePedidosRepo = new List <PedidoEntity>
{
new AutoFaker <PedidoEntity>()
.RuleFor(fake => fake.Drone, fake => responseDroneRepo[0])
.RuleFor(fake => fake.DroneId, fake => responseDroneRepo[0].Id)
.RuleFor(fake => fake.CompradorId, fake => responseUsuarioRepo.Id)
.Generate()
};
var expectResponse = ExpectResponseDroneQueryList(responseDroneRepo, responsePedidosRepo, responseUsuarioRepo);;
var droneRepoMock = mocker.GetMock <IDronesRepository>();
var pedidosRepoMock = mocker.GetMock <IPedidosRepository>();
var usuarioRepoMock = mocker.GetMock <IUsuariosRepository>();
droneRepoMock.Setup(r => r.GetAll()).ReturnsAsync(responseDroneRepo).Verifiable();
pedidosRepoMock.Setup(r => r.GetByDroneID(responseDroneRepo[0].Id)).ReturnsAsync(responsePedidosRepo).Verifiable();
usuarioRepoMock.Setup(r => r.GetSingleById(responseUsuarioRepo.Id)).ReturnsAsync(responseUsuarioRepo).Verifiable();
//When
var result = await baseQueryMock.ConsultaDrone();
//Then
var comparison = new CompareLogic();
droneRepoMock.Verify(mock => mock.GetAll(), Times.Once());
pedidosRepoMock.Verify(mock => mock.GetByDroneID(It.IsAny <Guid>()), Times.Exactly(3));
usuarioRepoMock.Verify(mock => mock.GetSingleById(It.IsAny <Guid>()), Times.Once());
var comp = comparison.Compare(result, expectResponse);
Assert.True(comp.AreEqual);
}
public void Pedido_IsPedidoValido_Sucesso()
{
// Given
var mocker = new AutoMocker();
var pedidoServiceMock = mocker.CreateInstance <PedidoService>();
var faker = AutoFaker.Create();
var drones = new AutoFaker <Drone>()
.RuleFor(u => u.Capacidade, f => f.Random.Int(7, 12))
.RuleFor(u => u.Velocidade, 40)
.RuleFor(u => u.Autonomia, 40)
.Generate(3);
var cliente = new AutoFaker <Cliente>()
.RuleFor(c => c.Latitude, -23.594987)
.RuleFor(c => c.Longitude, -46.6552518).Generate();
// var pedido = faker.Generate<Pedido>();
var pedido = new AutoFaker <Pedido>()
.RuleFor(u => u.Peso, 2)
.RuleFor(u => u.Cliente, cliente).Generate();
var responseDroneTask = drones;
var responsePedidoTask = Task.Factory.StartNew(() => pedido);
var expectResponse = string.Empty;
var droneRepository = mocker.GetMock <IDroneRepository>();
droneRepository.Setup(r => r.ObterTodos()).ReturnsAsync(responseDroneTask).Verifiable();
//When
var result = pedidoServiceMock.IsPedidoValido(pedido);
//Then
droneRepository.Verify(mock => mock.ObterTodos(), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
public void DadoOUsuarioEstejaLogado()
{
var mocker = new AutoMocker();
var faker = AutoFaker.Create();
var usuario = faker.Generate <Usuario>();
var identity = new ClaimsIdentity(new Claim[]
{ new Claim(ClaimTypes.Name, usuario.UserName.ToString()),
new Claim(ClaimTypes.Role, usuario.Role.ToString()) });
var pedidoControllerMock = mocker.CreateInstance <PedidoController>();
pedidoControllerMock.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(identity)
}
};
}
public async Task Pedido_AdicionarPedido_ComSucessoAsync()
{
// Given
var mocker = new AutoMocker();
var faker = AutoFaker.Create();
var adicionarPedidoViewModel = faker.Generate <AdicionarClienteViewModel>();
var usuario = faker.Generate <Usuario>();
var cliente = faker.Generate <Cliente>();
var identity = new ClaimsIdentity(new Claim[]
{ new Claim(ClaimTypes.Name, usuario.UserName.ToString()),
new Claim(ClaimTypes.Role, usuario.Role.ToString()) });
var clienteControllerMock = mocker.CreateInstance <ClienteController>();
clienteControllerMock.ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(identity)
}
};
var responeInserirClienteTask = Task.Factory.StartNew(() => true);
var clienteService = mocker.GetMock <IClienteService>();
var usuarioService = mocker.GetMock <IUserService>();
clienteService.Setup(p => p.Insert(It.IsAny <Cliente>())).Returns(responeInserirClienteTask).Verifiable();
usuarioService.Setup(u => u.Insert(It.IsAny <Usuario>())).Returns(responeInserirClienteTask).Verifiable();
var expectResponse = clienteControllerMock.CreatedAtAction("Get", new { id = cliente.Id }, cliente);
//When
var result = await clienteControllerMock.Post(adicionarPedidoViewModel);
//Then
clienteService.Verify(p => p.Insert(It.IsAny <Cliente>()), Times.Once());
Assert.Equal((HttpStatusCode)expectResponse.StatusCode, (HttpStatusCode)Convert.ToInt32(((CreatedAtActionResult)result).StatusCode));
}
public void Should_Use_Caller_Supplied_FakerHub()
{
// We infer that our FakerHub was used by reseeding it and testing that we get the same sequence both times.
var fakerHub = new Faker();
var configure = CreateConfigure <IAutoGenerateConfigBuilder>(
AutoFaker.DefaultConfig,
builder => builder.WithFakerHub(fakerHub));
var faker = AutoFaker.Create(configure);
fakerHub.Random = new Randomizer(1);
var instance1 = faker.Generate <TestObject>();
fakerHub.Random = new Randomizer(1);
var instance2 = faker.Generate <TestObject>();
instance1.Should().BeEquivalentTo(instance2);
}
public async void GetById_test()
{
// Given
var mocker = new AutoMocker();
var pedidoServiceMock = mocker.CreateInstance <PedidoService>();
var faker = AutoFaker.Create();
var drone = faker.Generate <Drone>();
// var pedido = faker.Generate<Pedido>();
var pedidoFaker = new AutoFaker <Pedido>()
.RuleFor(u => u.DroneId, f => f.Random.Int(1));
var pedido = pedidoFaker.Generate();
var responseDroneTask = Task.Factory.StartNew(() => drone);
var responsePedidoTask = Task.Factory.StartNew(() => pedido);
var expectResponse = pedido; // pedidoServiceMock.GetById(responsePedido);
var droneRepository = mocker.GetMock <IDroneRepository>();
var pedidoRepository = mocker.GetMock <IPedidoRepository>();
droneRepository.Setup(r => r.ObterPorId(It.IsAny <Int32>())).Returns(responseDroneTask).Verifiable();
pedidoRepository.Setup(r => r.ObterPorId(It.IsAny <Guid>())).Returns(responsePedidoTask).Verifiable();
//When
var result = await pedidoServiceMock.GetById(It.IsAny <Guid>());
//Then
droneRepository.Verify(mock => mock.ObterPorId(It.IsAny <Int32>()), Times.Once());
pedidoRepository.Verify(mock => mock.ObterPorId(It.IsAny <Guid>()), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
public async void Pedido_InsertPedidoDentroDaCapacidadeDoDrone_Sucesso()
{
// Given
var mocker = new AutoMocker();
var pedidoServiceMock = mocker.CreateInstance <PedidoService>();
var faker = AutoFaker.Create();
var pedidoFaker = new AutoFaker <Pedido>()
.RuleFor(u => u.Peso, f => 10);
var pedido = pedidoFaker.Generate();
var drones = new AutoFaker <Drone>()
.RuleFor(u => u.Capacidade, f => f.Random.Int(7, 12)).Generate(3);
var responsePedidoTask = Task.Factory.StartNew(() => true);
var responseDronesTask = drones;
var expectResponse = true;
var pedidoRepository = mocker.GetMock <IPedidoRepository>();
var droneRepository = mocker.GetMock <IDroneRepository>();
pedidoRepository.Setup(r => r.Adicionar(It.IsAny <Pedido>())).Returns(responsePedidoTask).Verifiable();
pedidoRepository.Setup(r => r.UnitOfWork.Commit()).Returns(responsePedidoTask).Verifiable();
droneRepository.Setup(r => r.ObterTodos()).ReturnsAsync(responseDronesTask).Verifiable();
//When
var result = await pedidoServiceMock.Insert(pedido);
//Then
//pedidoRepository.Verify(mock => mock.Adicionar(It.IsAny<Pedido>()), Times.Once());
//droneRepository.Verify(mock => mock.ObterTodos(), Times.Once());
CompareLogic comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
public async void Insert_test()
{
// Given
var faker = AutoFaker.Create();
var bus = faker.Generate <IMediatrHandler>();
var options = new DbContextOptionsBuilder <DCDroneDelivery>()
.UseInMemoryDatabase(databaseName: "DroneDelivery")
.Options;
var clienteNovo = faker.Generate <Cliente>();
using (var contexto = new DCDroneDelivery(options, bus))
{
//when
var clienteRepository = new ClienteRepository(contexto);
await clienteRepository.Adicionar(clienteNovo);
var insertCliente = await clienteRepository.UnitOfWork.Commit();
//then
Assert.True(insertCliente);
}
}
public async void ProcessarPagamento_Test_InternalServerError()
{
//Given
var commandMock = new Mock <IPagamentoCommand>();
var faker = AutoFaker.Create();
var param = faker.Generate <CartaoParam>();
var baseControllerMock = new PagamentoController(commandMock.Object);
var expectResponse = baseControllerMock.StatusCode(500);
commandMock.Setup(r => r.ProcessarPagamento(It.IsAny <CartaoParam>())).ThrowsAsync(new Exception()).Verifiable();
//When
var result = await baseControllerMock.Post(param);
//Then
var comparison = new CompareLogic();
commandMock.Verify(mock => mock.ProcessarPagamento(It.IsAny <CartaoParam>()), Times.Once());
Assert.True(comparison.Compare(((ObjectResult)result).StatusCode, expectResponse.StatusCode).AreEqual);
}
public void Generate_OverrideRulesAreAppliedPerType()
{
//setup
var target = new AutoBogusGenerator(AutoFaker.Create(builder =>
{
builder.WithOverride <Post>((ov) =>
{
var instance = (Post)ov.Instance;
instance.CategoryId = 5;
instance.PostText = "1234";
return(instance);
});
}));
//invoke
List <Post> posts = (List <Post>)target.Generate(new GeneratorContext
{
Description = new EntityDescription <Post>()
});
//assert
AssertPostNotEmpty(posts);
}
public async void Update_test()
{
// Given
var faker = AutoFaker.Create();
var bus = faker.Generate <IMediatrHandler>();
var options = new DbContextOptionsBuilder <DCDroneDelivery>().UseInMemoryDatabase(databaseName: "DroneDelivery").Options;
var cliente = faker.Generate <Cliente>();
//Seed
using (var contexto = new DCDroneDelivery(options, bus))
{
contexto.Cliente.AddRange(cliente);
contexto.SaveChanges();
}
bool expectResponse;
bool result;
using (var contexto = new DCDroneDelivery(options, bus))
{
contexto.Cliente.Update(cliente);
expectResponse = contexto.SaveChanges() > 0;
}
using (var contexto = new DCDroneDelivery(options, bus))
{
var clienteRepository = new ClienteRepository(contexto);
await clienteRepository.Atualizar(cliente);
result = contexto.SaveChanges() > 0;
}
var comparer = new CompareLogic();
Assert.True(comparer.Compare(expectResponse, result).AreEqual);
}
