def test_update_time_sheet(self):
ts_storage = TimeSheetsStorage(FakeDb().build())
e_storage = EmployeesStorage(FakeDb().build())
e_provider = EmployeeProvider()
ts_provider = TimeSheetProvider()
e_use_case = GetEmployeeUseCase(e_provider, e_storage)
calculator = VacationCalculator()
use_case = UpdateTimeSheetUseCase(ts_provider, e_use_case, calculator,
ts_storage)
use_case.update_time_sheet(0, sheet=fixtures.load('february'), norm=19)
saved_time_sheet = ts_storage.find_by_id(0)
self.assertEqual(saved_time_sheet.id, 0)
self.assertEqual(saved_time_sheet.sheet, fixtures.load('february'))
self.assertEqual(saved_time_sheet.norm, 19)
self.assertNotEqual(saved_time_sheet.vacation, 1.0)
use_case.update_time_sheet_for(0,
2019,
1,
sheet=fixtures.load('full_january'))
saved_time_sheet = ts_storage.find_first_by(employee_id=0,
year=2019,
month=1)
self.assertEqual(saved_time_sheet.employee_id, 0)
self.assertEqual(saved_time_sheet.sheet, fixtures.load('full_january'))
self.assertEqual(saved_time_sheet.norm, 19)
self.assertNotEqual(saved_time_sheet.vacation, 1.0)
def test_get_time_sheet(self):
ts_storage = TimeSheetsStorage(FakeDb().build())
e_storage = EmployeesStorage(FakeDb().build())
e_provider = EmployeeProvider()
ts_provider = TimeSheetProvider()
e_use_case = GetEmployeeUseCase(e_provider, e_storage)
use_case = GetTimeSheetUseCase(ts_provider, e_use_case, ts_storage)
time_sheet = use_case.get_for_employee(employee_id=0,
year=2019,
month=1)
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheet = use_case.get_by_id(time_sheet_id=0)
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
def test_update_time_sheet(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("january"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS,
norm=22)
time_sheet = TimeSheetProvider.update_with(time_sheet, norm=28)
self.assertEqual(time_sheet.norm, 28)
time_sheet = TimeSheetProvider.update_with(
time_sheet, work_days_sheet=fixtures.load("february"))
self.assertEqual(time_sheet.sheet, fixtures.load("february"))
def test_create_time_sheet(self):
storage = TimeSheetsStorage(FakeDb().build())
controller = TimeSheetProvider()
use_case = CreateTimeSheetUseCase(controller, storage)
now = datetime(2019, 2, 1)
use_case.create_time_sheet(now, fixtures.load('january'), 0, 10, 10)
saved_time_sheet = storage.find_by_id(2)
self.assertEqual(saved_time_sheet.year, 2019)
self.assertEqual(saved_time_sheet.month, 2)
self.assertEqual(saved_time_sheet.sheet, fixtures.load('january'))
self.assertEqual(saved_time_sheet.employee_id, 0)
self.assertEqual(saved_time_sheet.rate, 10)
self.assertEqual(saved_time_sheet.norm, 10)
def test_create_time_sheet(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("january"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS,
norm=22)
self.assertIsNotNone(time_sheet)
self.assertEqual(time_sheet.id, None)
self.assertEqual(time_sheet.norm, 22)
self.assertEqual(time_sheet.rate, RateCalculator.DAYS_FOR_3_YEARS)
self.assertEqual(time_sheet.sheet, fixtures.load("january"))
self.assertEqual(time_sheet.year, 2018)
self.assertEqual(time_sheet.month, 1)
self.assertEqual(time_sheet.employee_id, 0)
self.assertEqual(time_sheet.closed, False)
def test_get_profile(self):
employee = fixtures.load('admin_user')
headers = self.__get_authorization_header_for(employee)
response = self.client.simulate_get('/api/profile', headers=headers)
del employee['password']
employee['rate'] = 10
self.assertEqual(response.json, employee)
def test_update_employee(self):
serialized_employee = fixtures.load("unactivated_user")
employee = EmployeeProvider.deserialize(serialized_employee)
employee = EmployeeProvider.update_with(employee, name="New Name")
self.assertEqual(employee.name, "New Name")
employee = EmployeeProvider.update_with(employee,
employment_date=datetime(
2019, 1, 30))
self.assertEqual(employee.employment_date, datetime(2019, 1, 30))
self.assertEqual(employee.rate, RateCalculator.MAX_DAYS)
employee = EmployeeProvider.update_with(employee, email="*****@*****.**")
self.assertEqual(employee.email, "*****@*****.**")
employee = EmployeeProvider.update_with(employee,
password="******")
self.assertEqual(employee.password, "new_password")
employee = EmployeeProvider.activate(employee)
self.assertEqual(employee.activated, True)
employee = EmployeeProvider.deactivate(employee)
self.assertEqual(employee.activated, False)
self.assertEqual(employee.is_admin, False)
employee = EmployeeProvider.set_balance_vac(employee, 10)
self.assertEqual(employee.vacation, 10)
def load_data(self):
self.__load_user('admin_user')
self.__load_user('unaccepted_user')
self.__load_user('unactivated_user')
self.__load_user('user_with_vacation')
self.__create_and_load_time_sheet()
self.__create_and_load_time_sheet(employee_id=3)
self.__create_and_load_time_sheet(
date=datetime(2019, 2, 1),
sheet=fixtures.load('february'),
norm=20
)
self.__create_and_load_time_sheet(
date=datetime(2019, 3, 1),
sheet=[1, 1, 0, 0, 1,
1, 1, 1, 1, 0,
0, 1, 1, 1, 1,
1, 0, 0, 1, 1,
1, 1, 1, 0, 0,
1, 1, 1, 1, 1,
0],
norm=22
)
self.__create_and_load_time_sheet(
date=datetime(2018, 12, 1),
sheet=[1, 0, 0, 1,
1, 1, 1, 1, 0,
0, 1, 1, 1, 1,
1, 0, 0, 1, 1,
1, 1, 1, 0, 0,
1, 1, 1, 1, 1,
0, 0],
norm=21
)
def test_run(self):
'''
should run and give correct answers in trivial case
'''
X = fixtures.load('synthetic_fixation')
r = fixationmodel.fit(X)
self.assertEqual(r['centroid'], [0.0, 0.0])
self.assertEqual(r['mean_squared_error'], 0.0)
def test_gaps(self):
'''
should ignore [None, None] points
'''
X = fixtures.load('synthetic_gapped') # Gaps added to microsaccade
r = fixationmodel.fit(X)
self.assertEqual(r['centroid'], [0.4, 0.4])
self.assertAlmostEqual(r['mean_squared_error'], 3.68)
def test_centroid(self):
'''
should give correct answers in nontrivial case
'''
X = fixtures.load('synthetic_microsaccade')
r = fixationmodel.fit(X)
self.assertEqual(r['centroid'], [0.4, 0.4])
self.assertAlmostEqual(r['mean_squared_error'], 3.68)
def test_get_employees(self):
employee = fixtures.load('admin_user')
headers = self.__get_authorization_header_for(employee)
response = self.client.simulate_get('/api/employees/', headers=headers)
self.assertTrue(response.json.__len__() > 0)
first_employee = response.json[0]
del employee['password']
self.assertEqual(first_employee, employee)
def test_create_time_sheet_without_norm(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("january"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS)
self.assertIsNotNone(time_sheet)
self.assertIsNone(time_sheet.norm)
def test_update_profile(self):
employee = fixtures.load('admin_user')
headers = self.__get_authorization_header_for(employee)
to_hash = ToHash()
body = json.dumps({
'name': 'new name',
'old_password': '******',
'new_password': '******'
})
response = self.client.simulate_patch('/api/profile',
headers=headers,
body=body)
profile = response.json['profile']
self.assertEqual(profile['name'], 'new name')
self.assertEqual(profile['email'], employee['email'])
token = response.json['token']
self.assertIsNotNone(token)
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertTrue(
to_hash.check_with_hash('new pass', updated_employee.password))
body = json.dumps({'name': 'the newest name'})
response = self.client.simulate_patch('/api/profile',
headers=headers,
body=body)
profile = response.json['profile']
self.assertEqual(profile['name'], 'the newest name')
self.assertEqual(profile['email'], employee['email'])
token = response.json['token']
self.assertIsNotNone(token)
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertTrue(
to_hash.check_with_hash('new pass', updated_employee.password))
body = json.dumps({
'name': 'admin',
'email': '*****@*****.**',
'old_password': '******',
'new_password': '******',
})
response = self.client.simulate_patch('/api/profile',
headers=headers,
body=body)
profile = response.json['profile']
self.assertEqual(profile['name'], 'admin')
self.assertEqual(profile['email'], '*****@*****.**')
token = response.json['token']
self.assertIsNotNone(token)
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertTrue(
to_hash.check_with_hash('admin', updated_employee.password))
def __load_user(self, name):
serialized_employee = fixtures.load(name)
password = ToHash().to_hash(serialized_employee['password'])
serialized_employee['password'] = password
employee = self.employee_provider.deserialize(serialized_employee)
self.employee_storage.save(employee)
email = serialized_employee['email']
data = {'email': email, 'password': password}
self.tokens[email] = self.tokenizer.get_token_by_data(data)
def test_run(self):
'''
should be capable to analyze the synthetic saccade
'''
X = fixtures.load('synthetic')
r = saccademodel.fit(X)
self.assertEqual(len(r['source_points']), 2)
self.assertEqual(len(r['saccade_points']), 6)
self.assertEqual(len(r['target_points']), 2)
def __create_and_load_time_sheet(self,
date: datetime = datetime(2019, 1, 1),
sheet=fixtures.load('january'),
employee_id=0,
rate=RateCalculator.MIN_DAYS,
norm=23):
self.app.create_time_sheet_use_case.create_time_sheet(
date=date, sheet=sheet, employee_id=employee_id, rate=rate, norm=norm
)
def test_register_user(self):
admin = fixtures.load('admin_user')
headers = self.__get_authorization_header_for(admin)
unaccepted = fixtures.load('unaccepted_user')
path = '/api/employees/{}/register'.format(unaccepted['id'])
body = json.dumps({'employment_date': '2018.1.2', 'vacation': '1'})
response = self.client.simulate_post(path=path,
body=body,
headers=headers)
self.assertEqual(response.status, falcon.HTTP_201)
accepted_employee = self.factory.employee_storage.find_by_email(
unaccepted['email'])
self.assertEqual(accepted_employee.vacation, 1)
self.assertEqual(accepted_employee.employment_date.year, 2018)
self.assertEqual(accepted_employee.employment_date.month, 1)
self.assertEqual(accepted_employee.employment_date.day, 2)
self.assertTrue(accepted_employee.activated)
def build(self):
session = super().build()
admin_user = EmployeeProvider.deserialize(fixtures.load("admin_user"))
unaccepted_user = EmployeeProvider.deserialize(
fixtures.load("unaccepted_user"))
user_with_vacation = EmployeeProvider.deserialize(
fixtures.load("user_with_vacation"))
session.add(admin_user)
session.add(unaccepted_user)
session.add(user_with_vacation)
session.commit()
january_ts = TimeSheetProvider.deserialize(
fixtures.load('january_time_sheet'))
half_january_ts = TimeSheetProvider.deserialize(
fixtures.load('half_january_time_sheet'))
session.add(january_ts)
session.add(half_january_ts)
session.commit()
return session
def test_register_employee(self):
storage = EmployeesStorage(FakeDb().build())
controller = EmployeeProvider()
use_case = RegisterEmployeeUseCase(controller, storage)
now = datetime.now()
serialized_employee = fixtures.load("unaccepted_user")
use_case.register_employee(serialized_employee["id"], employment_date=now)
saved_employee = storage.find_by_email(serialized_employee["email"])
self.assertEqual(saved_employee.employment_date, now)
self.assertEqual(saved_employee.vacation, 0)
self.assertEqual(saved_employee.activated, True)
def test_close_time_sheet(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("january"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS,
norm=22)
time_sheet = TimeSheetProvider.close(time_sheet)
try:
TimeSheetProvider.update_with(time_sheet, 10)
raise Exception("Closed time sheet has been updated")
except AccessDeniedToUpdateTimeSheetError:
self.assertEqual(time_sheet.closed, True)
def test_deserialize_time_sheet(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("february"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS,
norm=22)
serialized_time_sheet = TimeSheetProvider.serialize(time_sheet)
time_sheet = TimeSheetProvider.deserialize(serialized_time_sheet)
self.assertEqual(time_sheet.id, None)
self.assertEqual(time_sheet.year, 2018)
self.assertEqual(time_sheet.month, 1)
self.assertEqual(time_sheet.norm, 22)
self.assertEqual(time_sheet.rate, RateCalculator.DAYS_FOR_3_YEARS)
self.assertEqual(time_sheet.vacation, None)
self.assertEqual(time_sheet.employee_id, 0)
self.assertEqual(time_sheet.closed, False)
self.assertEqual(time_sheet.sheet, fixtures.load("february"))
time_sheet = TimeSheetProvider.close(time_sheet)
serialized_time_sheet = TimeSheetProvider.serialize(time_sheet)
time_sheet = TimeSheetProvider.deserialize(serialized_time_sheet)
self.assertEqual(time_sheet.closed, True)
def test_deserialize_employee(self):
serialized_employee = fixtures.load("unactivated_user")
employee = EmployeeProvider.deserialize(serialized_employee)
self.assertIsNotNone(employee)
self.assertEqual(employee.id, 2)
self.assertEqual(employee.name, 'Unactivated User')
self.assertEqual(employee.password, 'user')
self.assertEqual(employee.email, '*****@*****.**')
self.assertEqual(datetime(2019, 1, 1), employee.employment_date)
self.assertEqual(datetime(2019, 1, 1), employee.acceptance_date)
self.assertEqual(employee.vacation, 1.0)
self.assertEqual(employee.activated, False)
self.assertEqual(employee.is_admin, False)
def test_update_time_sheet_for_not_exist(self):
ts_storage = TimeSheetsStorage(FakeDb().build())
e_storage = EmployeesStorage(FakeDb().build())
e_provider = EmployeeProvider()
ts_provider = TimeSheetProvider()
e_use_case = GetEmployeeUseCase(e_provider, e_storage)
calculator = VacationCalculator()
use_case = UpdateTimeSheetUseCase(ts_provider, e_use_case, calculator,
ts_storage)
try:
ts_storage.find_first_by(employee_id=3, year=2019, month=5)
raise Exception('Time sheet should not exist')
except NotFoundError:
pass
use_case.update_time_sheet_for(employee_id=3,
year=2019,
month=5,
sheet=fixtures.load('february'))
saved_time_sheet = ts_storage.find_first_by(employee_id=3,
year=2019,
month=5)
self.assertEqual(saved_time_sheet.sheet, fixtures.load('february'))
def test_serialize_time_sheet(self):
time_sheet = TimeSheetProvider.create(
date=datetime(2018, 1, 30),
work_days_sheet=fixtures.load("january"),
employee_id=0,
employee_rate=RateCalculator.DAYS_FOR_3_YEARS,
norm=22)
serialized_time_sheet = TimeSheetProvider.serialize(time_sheet)
self.assertEqual(serialized_time_sheet['id'], None)
self.assertEqual(serialized_time_sheet['year'], 2018)
self.assertEqual(serialized_time_sheet['month'], 1)
self.assertEqual(serialized_time_sheet['norm'], 22)
self.assertEqual(serialized_time_sheet['rate'],
RateCalculator.DAYS_FOR_3_YEARS)
self.assertEqual(serialized_time_sheet['vacation'], None)
self.assertEqual(serialized_time_sheet['employee_id'], 0)
self.assertEqual(serialized_time_sheet['closed'], False)
self.assertEqual(serialized_time_sheet['sheet'],
fixtures.load("january"))
time_sheet = TimeSheetProvider.close(time_sheet)
serialized_time_sheet = TimeSheetProvider.serialize(time_sheet)
self.assertEqual(serialized_time_sheet['closed'], True)
def test_deserialize_unaccepted_employee(self):
serialized_employee = fixtures.load("unaccepted_user")
employee = EmployeeProvider.deserialize(serialized_employee)
self.assertIsNotNone(employee)
self.assertEqual(employee.id, 1)
self.assertEqual(employee.name, 'Unregistered User')
self.assertEqual(employee.password, 'user')
self.assertEqual(employee.email, '*****@*****.**')
self.assertFalse(employee.activated)
self.assertFalse(employee.is_admin)
self.assertIsNone(employee.vacation)
self.assertIsNone(employee.employment_date)
self.assertIsNone(employee.acceptance_date)
def test_register_employee_without_balance_vacation(self):
serialized_employee = fixtures.load("unaccepted_user")
employee = EmployeeProvider.deserialize(serialized_employee)
now_date = datetime.now()
employee = EmployeeProvider.register(employee=employee,
employment_date=now_date)
self.assertIsNotNone(employee)
self.assertEqual(employee.acceptance_date.year, now_date.year)
self.assertEqual(employee.acceptance_date.month, now_date.month)
self.assertEqual(employee.acceptance_date.day, now_date.day)
self.assertEqual(employee.employment_date, now_date)
self.assertEqual(employee.activated, True)
self.assertEqual(employee.is_admin, False)
self.assertEqual(employee.vacation, 0)
def test_get_calculation(self):
employee = fixtures.load('admin_user')
saved_employee = self.factory.employee_storage.find_by_email(
employee['email'])
saved_employee.employment_date = datetime(2016, 8, 1)
self.factory.employee_storage.update(saved_employee)
headers = self.__get_authorization_header_for(employee)
path = '/api/employees/{}/vacation'.format(employee['id'])
body = json.dumps({'year': 2019, 'month': 1})
response = self.client.simulate_post(path=path,
body=body,
headers=headers)
self.assertEqual(response.status, falcon.HTTP_200)
month_vacation = response.json['month_vacation']
total_vacation = response.json['total_vacation']
self.assertEqual(month_vacation, 3.29)
self.assertEqual(total_vacation, 4.29)
def test_calculate_with_compensation_sheet(self):
time_sheet = self.january_time_sheet
time_sheet.sheet = fixtures.load("compensation_january")
calculator = VacationCalculator()
time_sheet.rate = RateCalculator.MIN_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 3.29)
time_sheet.rate = RateCalculator.DAYS_FOR_3_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 2.88)
time_sheet.rate = RateCalculator.DAYS_FOR_2_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 2.56)
time_sheet.rate = RateCalculator.MAX_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 2.3)
def test_calculate_with_half_time_sheet(self):
time_sheet = self.january_time_sheet
time_sheet.sheet = fixtures.load("half_january")
calculator = VacationCalculator()
time_sheet.rate = RateCalculator.MIN_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, -5.86)
time_sheet.rate = RateCalculator.DAYS_FOR_3_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, -6.12)
time_sheet.rate = RateCalculator.DAYS_FOR_2_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, -6.33)
time_sheet.rate = RateCalculator.MAX_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, -6.5)
def test_calculate_with_full_sheet(self):
time_sheet = self.january_time_sheet
time_sheet.sheet = fixtures.load("full_january")
calculator = VacationCalculator()
time_sheet.rate = RateCalculator.MIN_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 4.43)
time_sheet.rate = RateCalculator.DAYS_FOR_3_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 3.88)
time_sheet.rate = RateCalculator.DAYS_FOR_2_YEARS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 3.44)
time_sheet.rate = RateCalculator.MAX_DAYS
time_sheet = calculator.calculate_vacation(time_sheet)
self.assertEqual(time_sheet.vacation, 3.1)
def test_update_employee(self):
employee = fixtures.load('admin_user')
headers = self.__get_authorization_header_for(employee)
body = json.dumps({'name': 'new name', 'password': '******'})
response = self.client.simulate_patch('/api/employees/0',
headers=headers,
body=body)
self.assertEqual(response.json['name'], 'new name')
self.assertEqual(response.json['email'], employee['email'])
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertEqual(updated_employee.password, 'new pass')
body = json.dumps({'name': 'the newest name'})
response = self.client.simulate_patch('/api/employees/0',
headers=headers,
body=body)
self.assertEqual(response.json['name'], 'the newest name')
self.assertEqual(response.json['email'], employee['email'])
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertEqual(updated_employee.password, 'new pass')
body = json.dumps({
'name': 'admin',
'email': '*****@*****.**',
'password': '******'
})
response = self.client.simulate_patch('/api/employees/0',
headers=headers,
body=body)
self.assertEqual(response.json['name'], 'admin')
self.assertEqual(response.json['email'], '*****@*****.**')
updated_employee = self.factory.employee_storage.find_by_id(0)
self.assertEqual(updated_employee.password, 'admin')
def test_calculate_with_half_time_sheet_for_day(self):
time_sheet = self.january_time_sheet
time_sheet.sheet = fixtures.load("half_january")
calculator = VacationCalculator()
time_sheet.rate = RateCalculator.MIN_DAYS
time_sheet = calculator.calculate_vacation(time_sheet, 12)
self.assertEqual(time_sheet.vacation, 2.14)
self.assertEqual(time_sheet.norm, 23)
time_sheet.rate = RateCalculator.DAYS_FOR_3_YEARS
time_sheet = calculator.calculate_vacation(time_sheet, 12)
self.assertEqual(time_sheet.vacation, 1.88)
self.assertEqual(time_sheet.norm, 23)
time_sheet.rate = RateCalculator.DAYS_FOR_2_YEARS
time_sheet = calculator.calculate_vacation(time_sheet, 12)
self.assertEqual(time_sheet.vacation, 1.67)
self.assertEqual(time_sheet.norm, 23)
time_sheet.rate = RateCalculator.MAX_DAYS
time_sheet = calculator.calculate_vacation(time_sheet, 12)
self.assertEqual(time_sheet.vacation, 1.5)
self.assertEqual(time_sheet.norm, 23)
def test_get_time_sheets(self):
storage = TimeSheetsStorage(FakeDb().build())
controller = TimeSheetProvider()
e_storage = EmployeesStorage(FakeDb().build())
e_provider = EmployeeProvider()
e_use_case = GetEmployeeUseCase(e_provider, e_storage)
use_case = GetTimeSheetsUseCase(controller, e_use_case, storage)
time_sheets = use_case.get_for_employee(employee_id=0,
year=2019,
month=1)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_employee(employee_id=0, year=2019)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_all_employees(year=2019)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_all_employees(year=2019, month=1)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_all_employees(month=1)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_employee(employee_id=0, month=1)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_for_employee(employee_id=0)
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
time_sheets = use_case.get_all()
time_sheet = time_sheets[0]
self.assertEqual(time_sheet['year'], 2019)
self.assertEqual(time_sheet['month'], 1)
self.assertEqual(time_sheet['sheet'], fixtures.load('january'))
self.assertEqual(time_sheet['employee_id'], 0)
self.assertEqual(time_sheet['rate'], 10)
self.assertEqual(time_sheet['norm'], 23)
