public void ShouldFindByFirstName()
{
// Arrange
string expectedFirstName = "Thomas";
var employees = new List <Employee> {
Testdata.Employees.CreateEmployee1(), Testdata.Employees.CreateEmployee2(), Testdata.Employees.CreateEmployee3()
};
using (IEmployeeRepository employeeRepository = new EmployeeRepository(this.CreateContext()))
{
employeeRepository.AddRange(employees);
employeeRepository.Save();
}
// Act
IEnumerable <Employee> foundEmployees;
using (IEmployeeReadOnlyRepository employeeRepository = new EmployeeReadOnlyRepository(this.CreateContext()))
{
foundEmployees = employeeRepository.FindBy(employee => employee.FirstName == expectedFirstName).ToList();
}
// Assert
foundEmployees.Should().HaveCount(1);
foundEmployees.ElementAt(0).FirstName.Should().Be(expectedFirstName);
}
public void ShouldGetAnyTrueIfEmployeeExists_WithExpression()
{
// Arrange
var employees = new List <Employee> {
Testdata.Employees.CreateEmployee1(), Testdata.Employees.CreateEmployee2(), Testdata.Employees.CreateEmployee3()
};
using (IEmployeeRepository employeeRepository = new EmployeeRepository(this.CreateContext()))
{
employeeRepository.AddRange(employees);
employeeRepository.Save();
}
var expectedId = employees[0].Id;
// Act
bool hasAny;
using (IEmployeeReadOnlyRepository employeeRepository = new EmployeeReadOnlyRepository(this.CreateContext()))
{
hasAny = employeeRepository.Any(e => e.Id == expectedId);
}
// Assert
hasAny.Should().BeTrue();
}
public void ShouldFindEmployeeById()
{
// Arrange
var employees = new List <Employee> {
Testdata.Employees.CreateEmployee1(), Testdata.Employees.CreateEmployee2(), Testdata.Employees.CreateEmployee3()
};
using (IEmployeeRepository employeeRepository = new EmployeeRepository(this.CreateContext()))
{
employeeRepository.AddRange(employees);
employeeRepository.Save();
}
var expectedId = employees[0].Id;
// Act
Employee foundEmployee;
using (IEmployeeReadOnlyRepository employeeRepository = new EmployeeReadOnlyRepository(this.CreateContext()))
{
foundEmployee = employeeRepository.FindById(expectedId);
}
// Assert
foundEmployee.Should().NotBeNull();
foundEmployee.Id.Should().Be(expectedId);
}
public async Task test_GetEmployeeById()
{
//Assemble
var options = new DbContextOptionsBuilder <EmployeeContext>()
.UseInMemoryDatabase(databaseName: "in-memory-read-db-2")
.Options;
EmployeeEntity employee;
using (var context = new EmployeeContext(options))
{
var writeRepo = new EmployeeWriteOnlyRepository(context);
//act
await writeRepo.AddEmployee(new EmployeeEntity()
{
Name = "user2", Department = "dept2"
});
}
using (var context = new EmployeeContext(options))
{
var readRepo = new EmployeeReadOnlyRepository(context);
employee = await readRepo.GetEmployeeById(2);
}
//Assert
Assert.True(employee.Name == "user2");
}
public async Task test_GetAllEmployees()
{
//Assemble
var options = new DbContextOptionsBuilder <EmployeeContext>()
.UseInMemoryDatabase(databaseName: "in-memory-read-db")
.Options;
IEnumerable <EmployeeEntity> employees;
using (var context = new EmployeeContext(options))
{
var writeRepo = new EmployeeWriteOnlyRepository(context);
//act
await writeRepo.AddEmployee(new EmployeeEntity()
{
Name = "user1", Department = "dept1"
});
}
using (var context = new EmployeeContext(options))
{
var readRepo = new EmployeeReadOnlyRepository(context);
employees = await readRepo.GetAllEmployees();
}
//Assert
Assert.True(employees.Count() == 1);
}
public void ShouldReturnEmptyGetAll()
{
// Arrange
IReadOnlyRepository <Employee> employeeRepository = new EmployeeReadOnlyRepository(this.CreateContext());
// Act
var allEmployees = employeeRepository.GetAll().ToList();
// Assert
allEmployees.Should().HaveCount(0);
}
public GetEmployeeQueryHandler(EmployeeReadOnlyRepository repository,
ITranslator <Domain.Employee.Employee, EmployeeDto> employeeDtoTranslator)
{
this.repository = repository;
this.employeeDtoTranslator = employeeDtoTranslator;
}
