public async Task GivenExistingConsultantEmailInConsultants_WhenCheckUniqueEmail_ThenReturnTrue()
{
var consultant = ConsultantFactory.ConsultantWithExistingEmailInConsultants(_database.DbContext);
var result = await _repository.CheckUniqueEmail(consultant.Email);
result.Should().BeTrue();
}
public async Task GivenNewConsultantEmail_WhenCheckUniqueEmail_ThenReturnFalse()
{
var consultant = ConsultantFactory.ConsultantWithUniqueEmail(_database.DbContext);
var result = await _repository.CheckUniqueEmail(consultant.Email);
result.Should().BeFalse();
}
public async Task GivenAnInexistentId_WhenDeleteAsync_ThenReturnFalse()
{
var consultant = ConsultantFactory.ValidConsultant();
var result = await _repository.DeleteAsync(consultant.Id);
result.Should().BeFalse();
}
public UpdateConsultantValidatorsTest()
{
_consultant = ConsultantFactory.ValidConsultantWithId();
var mockRepo = new Mock <IConsultantRepository>();
mockRepo.Setup(db => db.GetByIdAsync(_consultant.Id).Result).Returns(_consultant);
_validator = new UpdateConsultantByIdCommandValidator(mockRepo.Object);
}
public async Task GivenAnInexistentId_WhenGetByIdAsync_ThenReturnNull()
{
var consultant = ConsultantFactory.ValidConsultant();
var result = await _repository.GetByIdAsync(consultant.Id);
result.Should().BeNull();
}
public async Task GivenAnId_WhenDeleteAsync_ThenReturnTrue()
{
var consultant = ConsultantFactory.AddedConsultant(_database.DbContext);
var result = await _repository.DeleteAsync(consultant.Id);
result.Should().BeTrue();
}
public LoginValidatorTest()
{
var user = UserFactory.ValidUser();
var consultant = ConsultantFactory.ValidConsultant();
var mockRepo = new Mock<IAccountRepository>();
mockRepo.Setup(db => db.GetByEmailAsync<Consultant>(consultant.Email).Result).Returns(consultant);
mockRepo.Setup(db => db.GetByEmailAsync<User>(user.Email).Result).Returns(user);
_validator = new LoginCommandValidator(mockRepo.Object);
}
public static LoginCommand ValidLoginConsultantCommand()
{
var consultant = ConsultantFactory.ValidConsultant();
return(new()
{
Email = consultant.Email,
Password = "******"
});
}
public async Task GivenAListOfUsers_WhenGetAllUsers_ThenReturnListOfUsersEntity()
{
var consultant = ConsultantFactory.Added2Consultants(_database.DbContext);
var result = await _repository.GetAllAsync();
result.Should().BeOfType <List <Consultant> >();
var addedConsultant = result.FirstOrDefault(u => u.Id == consultant.Id);
addedConsultant.Should().NotBeNull();
}
/// <summary>
/// Metodo que crea los tipos de deportes
/// </summary>
/// <param name="listSportsTypes"></param>
public void CreateSport(SportsBO sport)
{
try
{
IConsultant <Sports, SportsBO> consultant = ConsultantFactory.Create <Sports, SportsBO>();
consultant.CreateObject(sport);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Metoo que permite consultar la lista de tipos
/// de deportes
/// </summary>
/// <returns></returns>
public List <SportsBO> GetSports()
{
try
{
IConsultant <Sports, SportsBO> consultant = ConsultantFactory.Create <Sports, SportsBO>();
return(consultant.GetCollection());
}
catch (Exception)
{
throw;
}
}
public async Task GivenAnId_WhenDeleteConsultantByIdCommandHandler_ThenReturnTrue()
{
var consultant = ConsultantFactory.ValidConsultant();
var command = new DeleteConsultantByIdCommand(consultant.Id);
var mockRepo = new Mock <IConsultantRepository>();
mockRepo.Setup(db => db.DeleteAsync(command.Id).Result).Returns(true);
var handler = new DeleteConsultantByIdCommandHandler(mockRepo.Object);
var result = await handler.Handle(command, CancellationToken.None);
result.Should().BeTrue();
}
public async Task GivenAnConsultantEmail_WhenGetByEmailAsync_ThenReturnAConsultant()
{
var consultant = ConsultantFactory.AddedValidConsultantWithUniqueEmail(_database.DbContext);
var result = await _repository.GetByEmailAsync <Consultant>(consultant.Email);
result.Should().NotBeNull();
result.Should().BeOfType <Consultant>();
result.Id.Should().Be(consultant.Id);
result.Username.Should().Be(consultant.Username);
result.Email.Should().Be(consultant.Email);
result.Location.Should().Be(consultant.Location);
result.Availability.Should().Be(consultant.Availability);
result.NumberOfTickets.Should().Be(consultant.NumberOfTickets);
}
public async Task GivenAConsultant_WhenUpdateConsultant_ThenReturnConsultantUpdated()
{
var consultant = ConsultantFactory.AddedConsultant(_database.DbContext);
var updatedConsultant = ConsultantFactory.UpdateUsernameAndEmailValidConsultant(consultant.Id);
var result = await _repository.UpdateConsultant(updatedConsultant);
result.Should().BeOfType <Consultant>();
result.Id.Should().Be(updatedConsultant.Id);
result.Username.Should().Be(updatedConsultant.Username);
result.Email.Should().BeEquivalentTo(updatedConsultant.Email);
result.Location.Should().BeEquivalentTo(consultant.Location);
result.Availability.Should().BeEquivalentTo(consultant.Availability);
result.NumberOfTickets.Should().Be(consultant.NumberOfTickets);
result.Skill.Should().BeEquivalentTo(consultant.Skill);
}
public async Task GivenAnUser_WhenCreateAsync_ThenReturnUserEntity()
{
var consultant = ConsultantFactory.ValidConsultant();
var password = "******";
var result = await _repository.CreateAsync(consultant, password);
result.Should().BeOfType <Consultant>();
result.Id.Should().Be(consultant.Id);
result.Username.Should().Be(consultant.Username);
result.Email.Should().Be(consultant.Email);
result.Location.Should().Be(consultant.Location);
result.Availability.Should().Be(consultant.Availability);
result.NumberOfTickets.Should().Be(consultant.NumberOfTickets);
result.Skill.Should().Be(consultant.Skill);
}
public async Task GivenAnId_WhenGetByIdAsync_ThenReturnAnUser()
{
var consultant = ConsultantFactory.AddedConsultant(_database.DbContext);
var result = await _repository.GetByIdAsync(consultant.Id);
result.Should().NotBeNull();
result.Should().BeOfType <Consultant>();
result.Id.Should().Be(consultant.Id);
result.Username.Should().Be(consultant.Username);
result.Email.Should().Be(consultant.Email);
result.Location.Should().Be(consultant.Location);
result.Availability.Should().Be(consultant.Availability);
result.NumberOfTickets.Should().Be(consultant.NumberOfTickets);
result.Skill.Should().Be(consultant.Skill);
}
public async Task GivenAList_WhenGetAllConsultantsQueryHandler_ThenReturnNotNull()
{
var consultant1 = ConsultantFactory.ValidConsultant();
var consultant2 = ConsultantFactory.ValidConsultant();
var consultants = new List <Consultant> {
consultant1, consultant2
};
var command = new GetAllConsultantsQuery();
var mockRepo = new Mock <IConsultantRepository>();
mockRepo.Setup(db => db.GetAllAsync().Result).Returns(consultants);
var handler = new GetAllConsultantsQueryHandler(mockRepo.Object);
var result = await handler.Handle(command, CancellationToken.None);
result.Should().NotContainNulls();
result.Should().HaveCount(consultants.Count);
result.Should().Contain(consultant1);
}
public static User UserWithExistingEmailInConsultants(IApplicationDbContext context)
{
var user = ValidUser();
var consultant = ConsultantFactory.ValidConsultant();
context.GetCollection <User>().InsertOne(user);
context.GetCollection <Consultant>().InsertOne(consultant);
var newUser = new User
{
Username = "******",
Location = "Romania/Iasi/Iasi",
Email = consultant.Email,
Type = "Client",
TicketsId = { "6075e868974ac5357820d428" }
};
return(newUser);
}
public BusinessObject ConsultarProcedimientoObj(string NombreProcedimiento, string nombreConexion, CommandType tipoEjecucion, Persistent parameter, MapperManager <Persistent, BusinessObject> mapper)
{
try
{
DataSet dt = new DataSet();
BusinessObject salida = Activator.CreateInstance <BusinessObject>();
using (SqlConnection unit = new SqlConnection(ConfigurationManager.ConnectionStrings[nombreConexion].ConnectionString))
{
IConsultantReader <DataTable, DataTable> consultor = (IConsultantReader <DataTable, DataTable>)ConsultantFactory.Create <DataTable, DataTable>(EnumConsultantType.Ado);
SqlCommand command = new SqlCommand(NombreProcedimiento, unit);
command.CommandType = tipoEjecucion;
if (parameter != null)
{
SqlHelper helper = new SqlHelper(nombreConexion);
command.Parameters.AddRange(helper.GetListParameters <Persistent>(NombreProcedimiento, parameter));
}
SqlDataAdapter adapter = new SqlDataAdapter(command);
unit.Open();
adapter.Fill(dt);
salida = mapper.MappearReader2BO(dt);
dt.CreateDataReader().Close();
unit.Close();
}
return(salida);
}
catch (Exception)
{
throw;
}
}
public DataSet ConsultarDatos(string NombreProcedimiento, string nombreConexion, CommandType tipoEjecucion, object[] parameter)
{
try
{
DataSet dt = new DataSet();
using (SqlConnection unit = new SqlConnection(ConfigurationManager.ConnectionStrings[nombreConexion].ConnectionString))
{
IConsultantReader <DataTable, DataTable> consultor = (IConsultantReader <DataTable, DataTable>)ConsultantFactory.Create <DataTable, DataTable>();
SqlCommand command = new SqlCommand(NombreProcedimiento, unit);
command.CommandType = tipoEjecucion;
if (parameter != null)
{
SqlHelper helper = new SqlHelper(nombreConexion);
command.Parameters.AddRange(helper.GetListParameters(NombreProcedimiento, parameter));
}
SqlDataAdapter adapter = new SqlDataAdapter(command);
unit.Open();
adapter.Fill(dt);
dt.CreateDataReader().Close();
unit.Close();
}
return(dt);
}
catch (Exception ex)
{
throw ex;
}
}
