private static async Task selectAllUsersTest(UserImplementation _repository)
{
var _listUsers = await _repository.SelectAsync();
Assert.True(_listUsers.Count() > 0);
Assert.NotNull(_listUsers);
}
public async Task UpdateTest()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registroCriado = await _repositorio.InsertAsync(_entity);
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repositorio.UpdateAsync(_entity);
//Assert.NotNull(_registroAtualizado);
//Assert.Equal(_entity.Name, _registroAtualizado.Name);
//Assert.Equal(_entity.Email, _registroAtualizado.Email);
_registroAtualizado.Should().NotBeNull();
_registroAtualizado.Name.Should().Equals(_registroCriado.Name);
_registroAtualizado.Email.Should().Equals(_registroCriado.Email);
}
}
public async Task PerformUserCrud()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
//Test InsertAsync
UserEntity _recordCreated = await _repository.InsertAsync(_entity);
Assert.NotNull(_recordCreated);
Assert.Equal(_entity.Email, _recordCreated.Email);
Assert.Equal(_entity.Name, _recordCreated.Name);
Assert.False(_recordCreated.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
//Test Update
UserEntity _recordUpdate = await _repository.UpdateAsync(_entity);
Assert.NotNull(_recordUpdate);
Assert.Equal(_entity.Email, _recordUpdate.Email);
Assert.Equal(_entity.Name, _recordUpdate.Name);
//Test Exist
bool _recordExist = await _repository.ExistAsync(_recordUpdate.Id);
Assert.True(_recordExist);
//Test Select
UserEntity _recordSelect = await _repository.SelectAsync(_recordUpdate.Id);
Assert.NotNull(_recordSelect);
Assert.Equal(_recordUpdate.Email, _recordSelect.Email);
Assert.Equal(_recordUpdate.Name, _recordSelect.Name);
//Test GetAll
IEnumerable <UserEntity> _recordGetAll = await _repository.SelectAsync();
Assert.NotNull(_recordGetAll);
Assert.True(_recordGetAll.Count() > 1);
//Test Exist
bool _recordDelete = await _repository.DeleteAsync(_recordUpdate.Id);
Assert.True(_recordDelete);
//Test FindByLogin
UserEntity _defaultUser = await _repository.FindByLoginAsync("*****@*****.**");
Assert.NotNull(_defaultUser);
Assert.Equal("Administrator", _defaultUser.Name);
Assert.Equal("*****@*****.**", _defaultUser.Email);
}
}
public async Task E_Possivel_Realizar_CRUD_Usuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
//Create
var _registroCriado = await _repositorio.InsertAsync(_entity);
Assert.NotNull(_registroCriado);
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
//Update
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repositorio.UpdateAsync(_entity);
Assert.NotNull(_registroAtualizado);
Assert.Equal(_entity.Email, _registroAtualizado.Email);
Assert.Equal(_entity.Name, _registroAtualizado.Name);
//Exists
var _registroExiste = await _repositorio.ExistAsync(_registroAtualizado.Id);
Assert.True(_registroExiste);
//select
var _registroSelecionado = await _repositorio.SelectAsync(_registroAtualizado.Id);
Assert.NotNull(_registroSelecionado);
Assert.Equal(_registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(_registroAtualizado.Name, _registroSelecionado.Name);
//select all
var _todosRegistros = await _repositorio.SelectAsync();
Assert.NotNull(_todosRegistros);
Assert.True(_todosRegistros.Count() > 0);
//delete
var _removeu = await _repositorio.DeleteAsync(_registroSelecionado.Id);
Assert.True(_removeu);
var _usuarioPadrao = await _repositorio.FindByLogin("*****@*****.**");
Assert.NotNull(_usuarioPadrao);
Assert.Equal("*****@*****.**", _usuarioPadrao.Email);
Assert.Equal("Administrador", _usuarioPadrao.Name);
}
}
private async Task CreateTest(UserImplementation _repository, UserEntity _entity)
{
var _createdUser = await _repository.InsertAsync(_entity);
Assert.NotNull(_createdUser);
Assert.Equal(_entity.Email, _createdUser.Email);
Assert.Equal(_entity.Name, _createdUser.Name);
Assert.False(_createdUser.Id == Guid.Empty);
}
public async Task Is_Possible_To_Resolve_User()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation repository = new UserImplementation(context);
UserEntity entity = new UserEntity()
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var entityCreated = await repository.InsertAsync(entity);
Assert.NotNull(entityCreated);
Assert.Equal(entity.Email, entityCreated.Email);
Assert.Equal(entity.Name, entityCreated.Name);
Assert.NotNull(entityCreated.CreatedAt);
Assert.Null(entityCreated.UpdatedAt);
Assert.False(entityCreated.Id == Guid.Empty);
entity.Name = Faker.Name.First();
var entityUpdated = await repository.UpdateAsync(entity);
Assert.NotNull(entityUpdated);
Assert.Equal(entity.Email, entityUpdated.Email);
Assert.Equal(entity.Name, entityUpdated.Name);
Assert.NotNull(entityUpdated.CreatedAt);
Assert.NotNull(entityUpdated.UpdatedAt);
Assert.False(entityUpdated.Id == Guid.Empty);
var entityExists = await repository.ExistsAsync(entity.Id);
Assert.True(entityExists);
var getEntity = await repository.SelectAsync(entity.Id);
Assert.NotNull(getEntity);
Assert.Equal(getEntity.Email, entityUpdated.Email);
Assert.Equal(getEntity.Name, entityUpdated.Name);
var getAllEntities = await repository.SelectAsync();
Assert.NotNull(getAllEntities);
Assert.True(getAllEntities.Count() > 0);
var isDeleted = await repository.DeleteAsync(getEntity.Id);
Assert.True(isDeleted);
var defaultEntity = await repository.FindByLogin("*****@*****.**");
Assert.NotNull(defaultEntity);
Assert.Equal("*****@*****.**", defaultEntity.Email);
Assert.Equal("Admin", defaultEntity.Name);
}
}
private async Task SelectUserByIdTest(UserImplementation _repository, UserEntity _updatedUser)
{
var _selectedUser = await _repository.SelectAsync(_updatedUser.Id);
Assert.Equal(_updatedUser.Email, _selectedUser.Email);
Assert.Equal(_updatedUser.Name, _selectedUser.Name);
Assert.NotNull(_selectedUser);
await DeleteTest(_repository, _selectedUser);
}
public async Task E_Possivel_Realizar_CRUD_Usuario()
{
await using (var context = _serviceProvider.GetService <MyContext>())
{
var repository = new UserImplementation(context);
var entity = new UserEntity
{
Name = Faker.Internet.Email(),
Email = Faker.Name.FullName()
};
// Insert
var registroCriado = await repository.InsertAsync(entity);
Assert.NotNull(registroCriado);
Assert.False(registroCriado.Id == Guid.Empty);
Assert.Equal(entity.Name, registroCriado.Name);
Assert.Equal(entity.Email, registroCriado.Email);
//Update
entity.Name = Faker.Name.First();
var registroAtualizado = await repository.UpdateAsync(entity);
Assert.NotNull(registroAtualizado);
Assert.Equal(entity.Email, registroAtualizado.Email);
Assert.Equal(entity.Name, registroAtualizado.Name);
// Exist?
var registroExiste = await repository.ExistAsync(registroAtualizado.Id);
Assert.True(registroExiste);
// Select
var registroSelecionado = await repository.SelectAsync(registroAtualizado.Id);
Assert.NotNull(registroSelecionado);
Assert.Equal(registroSelecionado.Name, registroAtualizado.Name);
Assert.Equal(registroSelecionado.Email, registroAtualizado.Email);
// GetAll
var todosRegistros = await repository.SelectAsync();
Assert.NotNull(todosRegistros);
Assert.True(todosRegistros.Any());
// Login
var usuarioPadrao = await repository.FindByLogin("*****@*****.**");
Assert.NotNull(usuarioPadrao);
Assert.Equal("Administrador", usuarioPadrao.Name);
Assert.Equal("*****@*****.**", usuarioPadrao.Email);
}
}
public async Task Crud()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity()
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _createEntity = await _repository.InsertAsync(_entity);
Assert.NotNull(_createEntity);
Assert.Equal(_entity.Email, _createEntity.Email);
Assert.Equal(_entity.Name, _createEntity.Name);
Assert.True(_createEntity.Id > 0);
_entity.Name = Faker.Name.First();
var _updatedEntity = await _repository.UpdateAsync(_entity);
Assert.NotNull(_updatedEntity);
Assert.Equal(_entity.Email, _updatedEntity.Email);
Assert.Equal(_entity.Name, _updatedEntity.Name);
var _existEntity = await _repository.ExistAsync(_updatedEntity.Id);
Assert.True(_existEntity);
var _selectedEntity = await _repository.SelectAsync(_updatedEntity.Id);
Assert.NotNull(_selectedEntity);
Assert.Equal(_updatedEntity.Email, _selectedEntity.Email);
Assert.Equal(_updatedEntity.Name, _selectedEntity.Name);
var _allEntities = await _repository.SelectAsync();
Assert.NotNull(_allEntities);
Assert.True(_allEntities.Count() > 0);
var _removeEntity = await _repository.DeleteAsync(_selectedEntity.Id);
Assert.True(_removeEntity);
var _defaultUser = await _repository.FindByLogin("*****@*****.**");
Assert.NotNull(_defaultUser);
Assert.Equal("*****@*****.**", _defaultUser.Email);
Assert.Equal("Aislan Michel", _defaultUser.Name);
}
}
public async Task E_Possivel_Realizar_Crud_Usuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName(),
Password = Faker.Lorem.Words(10).ToString()
};
var _registroCriado = await _repository.InsertAsync(_entity);
Assert.NotNull(_registroCriado);
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repository.UpdasteAsync(_registroCriado.Id, _registroCriado);
Assert.NotNull(_registroAtualizado);
Assert.Equal(_entity.Email, _registroAtualizado.Email);
Assert.Equal(_entity.Name, _registroAtualizado.Name);
var _registroExiste = await _repository.ExistAsync(_registroAtualizado.Id);
Assert.True(_registroExiste);
var _registroSelecionado = await _repository.UpdasteAsync(_registroAtualizado.Id, _registroCriado);
Assert.NotNull(_registroSelecionado);
Assert.Equal(_registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(_registroAtualizado.Name, _registroSelecionado.Name);
var _todosRegistros = await _repository.SelectAsync();
Assert.NotNull(_todosRegistros);
Assert.True(_todosRegistros.Count() > 0);
var _usuarioLogado = await _repository.Login(_registroAtualizado.Email, _registroAtualizado.Password);
Assert.NotNull(_usuarioLogado);
Assert.Equal(_registroAtualizado.Email, _usuarioLogado.Email);
Assert.Equal(_registroAtualizado.Name, _usuarioLogado.Name);
var _excluirRegistro = await _repository.DeleteAsync(_registroAtualizado.Id);
Assert.True(_excluirRegistro);
}
}
public async Task E_Possivel_Realizar_Crud_Usuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var registroCriado = await _repositorio.InsertAsync(entity);
Assert.NotNull(registroCriado);
Assert.Equal(entity.Email, registroCriado.Email);
Assert.Equal(entity.Name, registroCriado.Name);
Assert.False(registroCriado.Id == Guid.Empty);
entity.Name = Faker.Name.First();
var registroAtualizado = await _repositorio.UpdateAsync(entity);
Assert.NotNull(registroAtualizado);
Assert.Equal(entity.Email, registroAtualizado.Email);
Assert.Equal(entity.Name, registroAtualizado.Name);
var registroExiste = await _repositorio.ExistAsync(registroAtualizado.Id);
Assert.True(registroExiste);
var registroSelecionado = await _repositorio.SelectAsync(registroAtualizado.Id);
Assert.NotNull(registroSelecionado);
Assert.Equal(registroAtualizado.Email, registroSelecionado.Email);
Assert.Equal(registroAtualizado.Name, registroSelecionado.Name);
var todosRegistros = await _repositorio.SelectAsync();
Assert.NotNull(todosRegistros);
Assert.True(todosRegistros.Count() > 0);
var logarEmail = await _repositorio.FindByLogin(registroSelecionado.Email);
Assert.NotNull(logarEmail);
Assert.Equal(logarEmail.Email, registroSelecionado.Email);
Assert.Equal(logarEmail.Name, registroSelecionado.Name);
var registroDeletado = await _repositorio.ExistAsync(registroSelecionado.Id);
Assert.True(registroDeletado);
}
}
public async Task E_Possivel_Realizar_CRUD_User()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity()
{
Name = Faker.Name.FullName(),
Email = Faker.Internet.Email()
};
var _registroCriado = await _repository.InsertAsync(_entity);
Assert.NotNull(_registroCriado);
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repository.UpdateAsync(_entity);
Assert.NotNull(_registroAtualizado);
Assert.Equal(_entity.Email, _registroAtualizado.Email);
Assert.Equal(_entity.Name, _registroAtualizado.Name);
var _registroExiste = await _repository.ExistAsync(_registroAtualizado.Id);
Assert.True(_registroExiste);
var _registroSelecionado = await _repository.SelectAsync(_registroAtualizado.Id);
Assert.NotNull(_registroSelecionado);
Assert.Equal(_registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(_registroAtualizado.Name, _registroSelecionado.Name);
var _todosRegistros = await _repository.SelectAsync();
Assert.NotNull(_todosRegistros);
Assert.True(_todosRegistros.Count() > 1);
var _removeu = await _repository.DeleteAsync(_registroSelecionado.Id);
Assert.True(_removeu);
var _usuarioPadrao = await _repository.FindByLogin("*****@*****.**");
Assert.NotNull(_usuarioPadrao);
Assert.Equal("*****@*****.**", _usuarioPadrao.Email);
Assert.Equal("Julio", _usuarioPadrao.Name);
}
}
public async Task CRUD_Usuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registerCreated = await _repository.InsertAsync(_entity);
Assert.NotNull(_registerCreated);
Assert.Equal(_entity.Email, _registerCreated.Email);
Assert.Equal(_entity.Name, _registerCreated.Name);
Assert.False(_registerCreated.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var _registerUpdated = await _repository.UpdateAsync(_entity);
Assert.NotNull(_registerUpdated);
Assert.Equal(_entity.Email, _registerUpdated.Email);
Assert.Equal(_entity.Name, _registerUpdated.Name);
var _registerExists = await _repository.ExistAsync(_registerUpdated.Id);
Assert.True(_registerExists);
var _registerSelected = await _repository.SelectAsync(_registerUpdated.Id);
Assert.NotNull(_registerSelected);
Assert.Equal(_registerUpdated.Email, _registerSelected.Email);
Assert.Equal(_registerUpdated.Name, _registerSelected.Name);
var _allRegisters = await _repository.SelectAsync();
Assert.NotNull(_allRegisters);
Assert.True(_allRegisters.Count() > 1);
var _removed = await _repository.DeleteAsync(_registerSelected.Id);
Assert.True(_removed);
var _defaultAdminUser = await _repository.FindByLogin("*****@*****.**");
Assert.NotNull(_defaultAdminUser);
Assert.Equal("*****@*****.**", _defaultAdminUser.Email);
Assert.Equal("Admin", _defaultAdminUser.Name);
}
}
public async Task PossivelRealizarCrudusuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registroCriado = await _repositorio.InsertAsync(_entity);
Assert.NotNull(_registroCriado);
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repositorio.UpdateAsync(_entity);
Assert.NotNull(_registroAtualizado);
Assert.Equal(_entity.Email, _registroAtualizado.Email);
Assert.Equal(_entity.Name, _registroAtualizado.Name);
var _registroExiste = await _repositorio.ExistAsync(_registroAtualizado.Id);
Assert.True(_registroExiste);
var _registroSelecionado = await _repositorio.SelectAsync(_registroAtualizado.Id);
Assert.NotNull(_registroSelecionado);
Assert.Equal(_registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(_registroAtualizado.Name, _registroSelecionado.Name);
var _todosOsRegistros = await _repositorio.SelectAsync();
Assert.NotNull(_todosOsRegistros);
Assert.True(_todosOsRegistros.Count() > 0);
var _remover = await _repositorio.DeleteAsync(_registroSelecionado.Id);
Assert.True(_remover);
var _usuarioPadrao = await _repositorio.FindByLogin("*****@*****.**");
Assert.NotNull(_usuarioPadrao);
Assert.Equal("*****@*****.**", _usuarioPadrao.Email);
Assert.Equal("adm", _usuarioPadrao.Name);
}
}
public async Task Testando_Crud_de_Usuarios()
{
using (var context = _serviceProvider.GetService <ApplicationDbContext>())
{
var _repositorio = new UserImplementation(context);
var _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registroCriado = await _repositorio.InsertAsync(_entity);
Assert.NotNull(_registroCriado);
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var _registroAtualizado = await _repositorio.UpdateAsync(_entity);
Assert.NotNull(_registroAtualizado);
Assert.Equal(_entity.Email, _registroAtualizado.Email);
Assert.Equal(_entity.Name, _registroAtualizado.Name);
var _registroExiste = await _repositorio.ExistsAsync(_registroAtualizado.Id);
Assert.True(_registroExiste);
var _registroSelecionado = await _repositorio.SelectAsync(_registroAtualizado.Id);
Assert.NotNull(_registroSelecionado);
Assert.Equal(_registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(_registroAtualizado.Name, _registroSelecionado.Name);
var _todosRegistros = await _repositorio.SelectAsync();
Assert.NotNull(_todosRegistros);
Assert.True(_todosRegistros.Count() > 0);
var _remove = await _repositorio.DeleteAsync(_registroSelecionado.Id);
Assert.True(_remove);
var _userDefault = await _repositorio.FindByLogin("*****@*****.**");
Assert.NotNull(_userDefault);
Assert.Equal("*****@*****.**", _userDefault.Email);
Assert.Equal("Administrador", _userDefault.Name);
}
}
public async Task E_Possivel_Realizar_Crid_Usuario()
{
using (var context = _serviceProdive.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var registroCriado = await _repository.InsertAsync(_entity);
Assert.NotNull(registroCriado); // o registro não deve ser null
Assert.Equal(_entity.Email, registroCriado.Email);
Assert.Equal(_entity.Name, registroCriado.Name);
Assert.False(registroCriado.Id == Guid.Empty);
_entity.Name = Faker.Name.First();
var registroAtualizado = await _repository.UpdateAsync(_entity);
Assert.NotNull(registroAtualizado);
Assert.Equal(_entity.Name, registroAtualizado.Name);
Assert.Equal(_entity.Email, registroCriado.Email);
Assert.Equal(registroCriado.Id, registroAtualizado.Id);
var _registroExiste = await _repository.ExistsAsync(registroAtualizado.Id);
Assert.True(_registroExiste);
var _registroSelecionado = await _repository.SelectAsync(registroAtualizado.Id);
Assert.NotNull(_registroSelecionado);
Assert.Equal(registroAtualizado.Name, _registroSelecionado.Name);
Assert.Equal(registroAtualizado.Email, _registroSelecionado.Email);
Assert.Equal(registroAtualizado.Id, _registroSelecionado.Id);
var _todosRegistros = await _repository.SelectAsync();
Assert.NotNull(_todosRegistros);
Assert.True(_todosRegistros.Count() > 0);
var _removeu = await _repository.DeleteAsync(_registroSelecionado.Id);
Assert.True(_removeu);
}
}
public async Task CRUD()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
// Create
var repository = new UserImplementation(context);
var entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var firstRegister = await repository.InsertAsync(entity);
Assert.NotNull(firstRegister);
Assert.Equal(entity.Email, firstRegister.Email);
Assert.Equal(entity.Name, firstRegister.Name);
Assert.True(firstRegister.Id != Guid.Empty);
// Read
var registerExits = await repository.ExistsAsync(firstRegister.Id);
Assert.True(registerExits);
var selectedRegister = await repository.SelectAsync(firstRegister.Id);
Assert.NotNull(selectedRegister);
Assert.Equal(selectedRegister.Email, firstRegister.Email);
Assert.Equal(selectedRegister.Name, firstRegister.Name);
var registerList = await repository.SelectAsync();
Assert.NotNull(registerList);
Assert.True(registerList.Count() > 0);
// Update
firstRegister.Name = Faker.Name.First();
var updatedRegister = await repository.UpdateAsync(firstRegister);
Assert.NotNull(updatedRegister);
Assert.Equal(firstRegister.Email, updatedRegister.Email);
Assert.Equal(firstRegister.Name, updatedRegister.Name);
// Delete
var registerHasDeleted = await repository.DeleteAsync(selectedRegister.Id);
Assert.True(registerHasDeleted);
}
}
public async Task E_Possivel_Realizar_CRUD_Usuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
await CreateTest(_repository, _entity);
await UpdateTest(_repository, _entity);
}
}
private async Task UpdateTest(UserImplementation _repository, UserEntity _entity)
{
_entity.Name = Faker.Name.First();
var _updatedUser = await _repository.UpdateAsync(_entity);
Assert.NotNull(_updatedUser);
Assert.Equal(_entity.Email, _updatedUser.Email);
Assert.Equal(_entity.Name, _updatedUser.Name);
findByLoginTest(_repository, _updatedUser);
await ExistTest(_repository, _updatedUser);
await selectAllUsersTest(_repository);
await SelectUserByIdTest(_repository, _updatedUser);
}
public async Task ShouldCreateAUser()
{
using (var context = serviceProvider.GetService <MyContext>())
{
UserImplementation repository = new UserImplementation(context);
UserEntity entity = new UserEntity
{
Email = Faker.Internet.Email(),
Nome = Faker.Name.FullName()
};
var createdResult = await repository.InsertAsync(entity);
Assert.NotNull(createdResult);
Assert.Equal(entity.Email, createdResult.Email);
Assert.Equal(entity.Nome, createdResult.Nome);
Assert.False(createdResult.Id == Guid.Empty);
entity.Nome = Faker.Name.First();
var createdResultUpdate = await repository.UpdateAsync(entity);
Assert.NotNull(createdResult);
Assert.Equal(entity.Email, createdResultUpdate.Email);
Assert.Equal(entity.Nome, createdResultUpdate.Nome);
var resultExists = await repository.ExistAsync(createdResultUpdate.Id);
Assert.True(resultExists);
var selectResult = await repository.SelectAsync(createdResultUpdate.Id);
Assert.NotNull(selectResult);
Assert.Equal(entity.Email, selectResult.Email);
Assert.Equal(entity.Nome, selectResult.Nome);
var selectAll = await repository.SelectAsync();
Assert.NotNull(selectAll);
Assert.True(selectAll.Count() > 1);
var removed = await repository.DeleteAsyinc(selectResult.Id);
Assert.True(removed);
}
}
public async Task PossivelRealizarCRUDUsuario()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity entity = new UserEntity()
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var usuarioCriado = await _repository.InsertAsync(entity);
Assert.NotNull(usuarioCriado);
Assert.Equal(entity.Email, usuarioCriado.Email);
Assert.Equal(entity.Name, usuarioCriado.Name);
Assert.False(usuarioCriado.Id == Guid.Empty);
entity.Name = Faker.Name.First();
var registroAtualizado = await _repository.UpdateAsync(entity);
Assert.NotNull(registroAtualizado);
Assert.Equal(entity.Email, registroAtualizado.Email);
Assert.Equal(entity.Name, registroAtualizado.Name);
var registroExiste = await _repository.ExistsAsync(entity.Id);
Assert.True(registroExiste);
var registroSelecionado = await _repository.SelectAsync(entity.Id);
Assert.True(registroExiste);
Assert.Equal(entity.Email, registroSelecionado.Email);
Assert.Equal(entity.Name, registroSelecionado.Name);
var todosRegistros = await _repository.GetAllAsync();
Assert.NotNull(todosRegistros);
Assert.True(todosRegistros.Count() > 0);
var removeu = await _repository.DeleteAync(entity.Id);
Assert.True(removeu);
}
}
public async Task Login()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
var repository = new UserImplementation(context);
var entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var firstRegister = await repository.InsertAsync(entity);
var login = await repository.FindByLoginAsync(firstRegister.Email);
Assert.NotNull(login);
Assert.Equal(firstRegister.Email, login.Email);
}
}
public async Task Its_Possible_Create_New_User()
{
using (var context = _serviceProvider.GetService <AppDbContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var userCreated = await _repository.AddAsync(_entity);
Assert.NotNull(userCreated);
Assert.Equal(_entity.Email, userCreated.Email);
Assert.Equal(_entity.Name, userCreated.Name);
}
}
static void Main(string[] args)
{
AutoMapperConfigurator.Configure();
//User user = new User();
//user.FirstName = "BL user name 2";
//user.LastName = "BL user last name 2";
//user.Login = "******";
UserImplementation imp = new UserImplementation();
// var user = imp.GetUserByID();
//Console.WriteLine("User was readed" + user.FirstName);
imp.SaveUser(new User {
FirstName = "Test 112346", LastName = "Peters", Login = "******"
});
Console.WriteLine("User was added");
Console.ReadKey();
}
public async Task Its_Possible_Delete_Users()
{
using (var context = _serviceProvider.GetService <AppDbContext>())
{
UserImplementation _repository = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var userCreated = await _repository.AddAsync(_entity);
var result = await _repository.DeleteAsync(userCreated.Id);
Assert.True(result);
}
}
public async Task UserExistsTest()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registroCriado = await _repositorio.InsertAsync(_entity);
var _registroExiste = await _repositorio.ExistsAsync(_registroCriado.Id);
//Assert.True(_registroExiste);
_registroExiste.Should().BeTrue(because: "O Usuário foi encontrado");
}
}
public async Task DeleteTest()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
var _registroCriado = await _repositorio.InsertAsync(_entity);
var _removeu = await _repositorio.DeleteAsync(_registroCriado.Id);
//Assert.True(_removeu);
_removeu.Should().BeTrue(because: "O Usuário foi removido corretamente");
}
}
public async Task Its_Possible_List_Users()
{
using (var context = _serviceProvider.GetService <AppDbContext>())
{
UserImplementation _repository = new UserImplementation(context);
for (int i = 0; i < 5; i++)
{
UserEntity _entity = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
await _repository.AddAsync(_entity);
}
var listEntities = await _repository.GetAsync();
Assert.True(listEntities.Count() > 0);
}
}
public async Task GetAllTest()
{
using (var context = _serviceProvider.GetService <MyContext>())
{
UserImplementation _repositorio = new UserImplementation(context);
UserEntity _entity1 = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
UserEntity _entity2 = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
UserEntity _entity3 = new UserEntity
{
Email = Faker.Internet.Email(),
Name = Faker.Name.FullName()
};
await _repositorio.InsertAsync(_entity1);
await _repositorio.InsertAsync(_entity2);
await _repositorio.InsertAsync(_entity3);
var _todosRegistros = await _repositorio.SelectAsync();
//Assert.NotNull(_todosRegistros);
//Assert.True(_todosRegistros.Count() == 3);
_todosRegistros.Should().NotBeNull();
_todosRegistros.Should().HaveCount(3, because: "Existem 3 usuários cadastrados");
}
}
public async Task E_Possivel_Realizar_Login()
{
using (var context = _serviceProdive.GetService <MyContext>())
{
UserImplementation _repository = new UserImplementation(context);
var _entity = new UserEntity
{
Name = Faker.Name.FullName(),
Email = Faker.Internet.Email()
};
var _registroCriado = await _repository.InsertAsync(_entity);
Assert.NotNull(_registroCriado); // o registro não deve ser null
Assert.Equal(_entity.Email, _registroCriado.Email);
Assert.Equal(_entity.Name, _registroCriado.Name);
Assert.False(_registroCriado.Id == Guid.Empty);
var _usuarioLogin = await _repository.FindByLogin(_registroCriado.Email);
Assert.NotNull(_usuarioLogin);
Assert.Equal(_registroCriado.Email, _usuarioLogin.Email);
}
}
