public void GetAllSalaries_ShouldReturnEmptyListWhenDBIsEmpty()
{
var dao = new PostgresDataAccessObjectService(dbContext);
var objects = dao.GetAllSalaries();
Assert.Empty(objects);
}
public async Task AddSalary_WhenNotEmptyTable()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 2 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.SaveChangesAsync();
var objToBeAdded = new Salary {
SalaryId = 3, Value = 300, TimePeriod = "some2", EmployeeId = 2
};
var dao = new PostgresDataAccessObjectService(dbContext);
dao.AddSalary(objToBeAdded);
var coll = dao.GetAllSalaries();
Assert.Equal(3, coll.Count);
Assert.Equal(100f, coll[0].Value);
Assert.Equal(200f, coll[1].Value);
Assert.Equal(1, coll[0].EmployeeId);
Assert.Equal(1, coll[1].EmployeeId);
Assert.Equal(2, coll[2].EmployeeId);
}
public void GetSalariesForAnEmployee_ShouldReturnNull_IfNoMatching()
{
var dao = new PostgresDataAccessObjectService(dbContext);
var obj = dao.GetSalariesForAnEmployee(55);
Assert.Empty(obj);
}
public async Task AddSalary_Duplicate()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.SaveChangesAsync();
var objToBeAdded = new Salary {
SalaryId = 3, Value = 300, TimePeriod = "some2", EmployeeId = 1
};
var dao = new PostgresDataAccessObjectService(dbContext);
bool exThrown = false;
try {
exThrown = true;
dao.AddSalary(objToBeAdded);
} catch (Exception ex) {
Assert.Equal(typeof(ArgumentException), ex.GetType());
Assert.Equal("Salary with TimePeriod: some2 for Employee: 1 already exists", ex.Message);
}
Assert.True(exThrown);
}
public async Task EditEmployeeHours_WhenNotExists()
{
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 101, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 102, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var newEH = new EmployeeHours {
EmployeeHoursId = 666, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4
};
bool exThrown = false;
try {
exThrown = true;
dao.EditEmployeeHours(newEH);
} catch (Exception e) {
Assert.Equal(typeof(InvalidOperationException), e.GetType());
Assert.Equal("EmployeeHours object not found", e.Message);
}
Assert.True(exThrown);
}
public async Task EditEmployeeHours_WhenExists()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 101, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 102, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var newEH = new EmployeeHours {
EmployeeHoursId = 101, Value = 777f, TimePeriod = "02.01.2019_08.01.2022", EmployeeId = 4
};
dao.EditEmployeeHours(newEH);
var obj = dao.GetOneEmployeeHours(101);
Assert.NotNull(obj);
Assert.Equal(101, obj.EmployeeHoursId);
Assert.Equal(777f, obj.Value);
Assert.Equal("02.01.2019_08.01.2022", obj.TimePeriod);
Assert.Equal(4, obj.EmployeeId);
}
public async Task AddEmployeeHours_WhenNotEmptyTable_KeepId_ConflictingKeyValues()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 100, Value = 100, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var emp = new EmployeeHours {
EmployeeHoursId = 100, Value = 100, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4
};
var dao = new PostgresDataAccessObjectService(dbContext);
bool exThrown = false;
try {
exThrown = true;
dao.AddEmployeeHours(emp, true);
} catch (Exception ex) {
Assert.Equal(typeof(ArgumentException), ex.GetType());
Assert.Equal("EmployeeHours with EmployeeHoursId: 100 already exists", ex.Message);
}
Assert.True(exThrown);
}
public void GetAllEmployees_ShouldReturnEmptyListWhenDBIsEmpty()
{
var dao = new PostgresDataAccessObjectService(dbContext);
var employees = dao.GetAllEmployees();
Assert.Empty(employees);
}
public async Task AddEmployeeHours_Fails_WhenAddedAlreadyWithTheSameTimePeriodEndEmployeeId()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 100, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var eh = new EmployeeHours {
EmployeeHoursId = 101, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4
};
var dao = new PostgresDataAccessObjectService(dbContext);
bool exThrown = false;
try {
exThrown = true;
dao.AddEmployeeHours(eh);
} catch (Exception e) {
Assert.Equal(typeof(ArgumentException), e.GetType());
Assert.Equal("EmployeeHours with EmployeeId: 4 and TimePeriod 02.01.2019_08.01.2019 already exists", e.Message);
}
var coll = dao.GetEmployeeHoursForAnEmployee(4);
Assert.Single(coll);
Assert.True(exThrown);
}
public async Task AddEmployeeHours_WhenNotEmptyTable()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 100, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var eh = new EmployeeHours();
eh.EmployeeId = 4;
eh.Value = 90;
eh.TimePeriod = "02.03.2019_08.03.2019";
var dao = new PostgresDataAccessObjectService(dbContext);
dao.AddEmployeeHours(eh);
var coll = dao.GetEmployeeHoursForAnEmployee(4);
Assert.Equal(2, coll.Count);
Assert.Equal(100f, coll[0].Value);
Assert.Equal(90f, coll[1].Value);
Assert.Equal(100, coll[0].EmployeeHoursId);
Assert.Equal(101, coll[1].EmployeeHoursId);
}
public void GetEmployeeHoursForAnEmployee_ShouldReturnEmptyListWhenDBIsEmpty()
{
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetEmployeeHoursForAnEmployee(0);
Assert.Empty(coll);
}
public async Task Synchronize_Works_StartWithEmplyDb_HQEmpty()
{
var cs = CommonHelpers.MockConfServ(false);
var hqApiClient = new Moq.Mock <IHQAPIClient>();
// no employees in HQ
hqApiClient.Setup(m => m.ListEmployees(cs.GetBranchOfficeId())).Returns(
Task.FromResult(new List <HQEmployee>())
);
// no salaries in HQ
hqApiClient.Setup(m => m.ListSalariesForEmployee(Moq.It.IsAny <int>())).Returns(
Task.FromResult(new List <HQSalary>())
);
var dao = new PostgresDataAccessObjectService(dbContext);
var ss = new SynchronizatorService(hqApiClient.Object, cs, dao);
await ss.Synchronize();
hqApiClient.Verify(m => m.ListEmployees(0), Moq.Times.Once);
// ListEmployees did not succeed, so no new http requests are handled
hqApiClient.Verify(m => m.ListSalariesForEmployee(Moq.It.IsAny <int>()), Moq.Times.Never);
ss.Dispose();
var emps = dao.GetAllEmployees();
var eh = dao.GetAllEmployeeHours();
Assert.Empty(emps);
Assert.Empty(eh);
}
public async Task GetAllEmployees_ShouldReturnAllEmployeesWhenSomeInDB()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**" });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var employees = dao.GetAllEmployees();
Assert.Single(employees);
}
public async Task GetEmployeeHoursForAnEmployee_ShouldReturnAllEmployeesHoursWhenSomeInDB()
{
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 100, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 0 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetEmployeeHoursForAnEmployee(0);
Assert.Single(coll);
}
public async Task Synchronize_Works_StartWithEmplyDb_HQNotEmpty()
{
var cs = CommonHelpers.MockConfServ(false);
var hqApiClient = new Moq.Mock <IHQAPIClient>();
var hqEmp1 = new HQEmployee {
Name = "Jan K", Email = "*****@*****.**", IsManager = false, ID = 1
};
var hqEmp2 = new HQEmployee {
Name = "Ela K", Email = "*****@*****.**", IsManager = true, ID = 2
};
var hqEmps = new List <HQEmployee>();
hqEmps.Add(hqEmp1);
hqEmps.Add(hqEmp2);
var hqSalary1 = new HQSalary {
ID = 1, EmployeeID = 1, Value = 1000, TimePeriod = "01.02.2019-06.02.2019"
};
var hqSalary2 = new HQSalary {
ID = 2, EmployeeID = 1, Value = 1000, TimePeriod = "07.02.2019-09.02.2019"
};
var hqSalaries = new List <HQSalary>();
hqSalaries.Add(hqSalary1);
hqSalaries.Add(hqSalary2);
hqApiClient.Setup(m => m.ListEmployees(cs.GetBranchOfficeId())).Returns(
Task.FromResult(hqEmps)
);
hqApiClient.Setup(m => m.ListSalariesForEmployee(1)).Returns(
Task.FromResult(hqSalaries)
);
var dao = new PostgresDataAccessObjectService(dbContext);
var ss = new SynchronizatorService(hqApiClient.Object, cs, dao);
await ss.Synchronize();
hqApiClient.Verify(m => m.ListEmployees(0), Moq.Times.Once);
// 1 for each hq employee
hqApiClient.Verify(m => m.ListSalariesForEmployee(Moq.It.IsAny <int>()), Moq.Times.Exactly(2));
ss.Dispose();
var emps = dao.GetAllEmployees();
var eh = dao.GetAllEmployeeHours();
var salaries = dao.GetAllSalaries();
Assert.Equal(2, emps.Count);
Assert.Equal("*****@*****.**", emps[0].Email);
Assert.Equal("*****@*****.**", emps[1].Email);
Assert.Empty(eh);
Assert.Equal(2, salaries.Count);
}
public void DeleteSalary_WhenNotExists()
{
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetAllSalaries();
Assert.Empty(coll);
dao.DeleteSalary(1);
coll = dao.GetAllSalaries();
Assert.Empty(coll);
}
public async Task GetOneEmployee_ShouldReturnNull_IfNoEmployee()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**", EmployeeId = 0 });
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var employee = dao.GetOneEmployee(55);
Assert.Null(employee);
}
public async Task GetAllSalaries_ShouldReturnListWhenSomeInDB()
{
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var objects = dao.GetAllSalaries();
Assert.Equal(2, objects.Count);
Assert.Equal(200, objects[1].Value);
}
public async Task GetOneEmployeeHours_ShouldReturnNull_IfNoEmployeeHours()
{
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 101, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 102, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var obj = dao.GetOneEmployeeHours(55);
Assert.Null(obj);
}
public async Task GetOneSalary_ShouldReturnNull_IfNoMatch()
{
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 3, Value = 300, TimePeriod = "some2", EmployeeId = 2 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var obj = dao.GetOneSalary(11);
Assert.Null(obj);
}
public async Task GetSalariesForAnEmployee_ShouldReturnObj_IfExists()
{
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 3, Value = 300, TimePeriod = "some2", EmployeeId = 2 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var objects = dao.GetSalariesForAnEmployee(1);
Assert.Equal(2, objects.Count);
Assert.Equal(200, objects[1].Value);
}
public async Task GetOneEmployee_ShouldReturnSpecifiedEmployee_IfExists()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola Dwa", Email = "*****@*****.**", EmployeeId = 0 });
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var employee = dao.GetOneEmployee(4);
Assert.NotNull(employee);
Assert.Equal("Ola AAA", employee.Name);
Assert.Equal(4, employee.EmployeeId);
Assert.Equal("*****@*****.**", employee.Email);
}
public void AddEmployee_WhenEmptyTable()
{
var emp = new Employee {
Name = "Ola 2", Email = "*****@*****.**", EmployeeId = 44
};
var dao = new PostgresDataAccessObjectService(dbContext);
dao.AddEmployee(emp);
var coll = dao.GetAllEmployees();
Assert.Single(coll);
Assert.Equal("Ola 2", coll[0].Name);
Assert.Equal("*****@*****.**", coll[0].Email);
Assert.Equal(1, coll[0].EmployeeId);// apparently we must start from 1
}
public async Task EditEmployee_WhenExists()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 5 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var newEH = new Employee {
Name = "Ola 2", Email = "*****@*****.**", EmployeeId = 5
};
dao.EditEmployee(newEH);
var returned = dao.GetOneEmployee(5);
Assert.Equal(returned.EmployeeId, newEH.EmployeeId);
Assert.Equal(returned.Name, newEH.Name);
Assert.Equal(returned.Email, newEH.Email);
}
public async Task AddSalary_WhenEmptyTable()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var objToBeAdded = new Salary {
SalaryId = 3, Value = 300, TimePeriod = "some2", EmployeeId = 4
};
var dao = new PostgresDataAccessObjectService(dbContext);
dao.AddSalary(objToBeAdded);
var coll = dao.GetAllSalaries();
Assert.Single(coll);
Assert.Equal(4, coll[0].EmployeeId);
}
public async Task DeleteEmployee_WhenNotExists()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.Employees.AddAsync(new Employee { Name = "Ola 2", Email = "*****@*****.**", EmployeeId = 5 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetAllEmployees();
Assert.Equal(2, coll.Count);
dao.DeleteEmployee(477);
coll = dao.GetAllEmployees();
Assert.Equal(2, coll.Count);
}
public async Task DeleteSalary_WhenExists()
{
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 1, Value = 100, TimePeriod = "some", EmployeeId = 1 });
await dbContext.Salaries.AddAsync(new Salary { SalaryId = 2, Value = 200, TimePeriod = "some2", EmployeeId = 1 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetAllSalaries();
Assert.Equal(2, coll.Count);
dao.DeleteSalary(1);
coll = dao.GetAllSalaries();
Assert.Single(coll);
Assert.Equal(2, coll[0].SalaryId);
}
public async Task DeleteEmployeeHours_WhenNotExists()
{
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 101, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.EmployeeHoursCollection.AddAsync(
new EmployeeHours { EmployeeHoursId = 102, Value = 100f, TimePeriod = "02.01.2019_08.01.2019", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var coll = dao.GetEmployeeHoursForAnEmployee(4);
Assert.Equal(2, coll.Count);
dao.DeleteEmployeeHours(100);
coll = dao.GetEmployeeHoursForAnEmployee(4);
Assert.Equal(2, coll.Count);
}
public async Task AddSalary_WhenEmployeeIdNotSet()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 9 });
await dbContext.SaveChangesAsync();
var objToBeAdded = new Salary {
SalaryId = 3, Value = 300, TimePeriod = "some2"
};
var dao = new PostgresDataAccessObjectService(dbContext);
bool exThrown = false;
try {
exThrown = true;
dao.AddSalary(objToBeAdded);
} catch (Exception e) {
Assert.Equal(typeof(ArgumentException), e.GetType());
Assert.Equal("EmployeeId was not set", e.Message);
}
Assert.True(exThrown);
}
public async Task EditEmployee_WhenNotExists()
{
await dbContext.Employees.AddAsync(new Employee { Name = "Ola AAA", Email = "*****@*****.**", EmployeeId = 4 });
await dbContext.SaveChangesAsync();
var dao = new PostgresDataAccessObjectService(dbContext);
var newEH = new Employee {
Name = "Ola 2", Email = "*****@*****.**", EmployeeId = 5
};
bool exThrown = false;
try {
exThrown = true;
dao.EditEmployee(newEH);
} catch (Exception e) {
Assert.Equal(typeof(InvalidOperationException), e.GetType());
Assert.Equal("Employee object not found", e.Message);
}
Assert.True(exThrown);
}
