def __init__(self, request):
BaseController.__init__(self, request)
self.role_repo = RoleRepo()
self.user_role_repo = UserRoleRepo()
self.user_repo = UserRepo()
self.permission_repo = PermissionRepo()
self.redis_set = RedisSet()
class TestUserRoleRepo(BaseTestCase):
def setUp(self):
self.BaseSetUp()
self.repo = UserRoleRepo()
self.redis_set = RedisSet()
def tearDown(self):
self.BaseTearDown()
def test_new_user_role_method_returns_new_user_role_object(self):
role = RoleFactory.create()
location = LocationFactory.create()
user_role = UserRoleFactory.build(role_id=role.id, location=location)
new_user_role = self.repo.new_user_role(user_role.role_id,
user_role.user_id,
user_role.location_id,
user_role.email)
self.assertIsInstance(new_user_role, UserRole)
self.assertEqual(str(new_user_role.user_id), str(user_role.user_id))
self.assertEqual(new_user_role.location.id, user_role.location.id)
def test_exclude_works_user_role_instance(self):
role = RoleFactory.create()
location = LocationFactory.create()
user_role = UserRoleFactory.build(role_id=role.id,
location_id=location.id)
new_user_role = self.repo.new_user_role(user_role.role_id,
user_role.user_id,
user_role.location_id,
user_role.email)
excluded_response = new_user_role.to_dict(exclude=["user_id"])
self.assertFalse(excluded_response.get("user_id", False))
def test_new_user_role_updates_cache(self):
role = RoleFactory.create()
location = LocationFactory.create()
user_role = UserRoleFactory.build(role_id=role.id, location=location)
self.repo.new_user_role(user_role.role_id, user_role.user_id,
user_role.location_id, user_role.email)
results = self.redis_set.get(user_role.email[0:1])
self.assertTrue(user_role.email in results)
results = self.redis_set.get(user_role.email[0:3])
self.assertTrue(user_role.email in results)
results = self.redis_set.get(user_role.email[0:5])
self.assertTrue(user_role.email in results)
results = self.redis_set.get(user_role.email[0:len(user_role.email) -
1])
self.assertTrue(user_role.email in results)
class UserRoleRepo(BaseRepo):
def __init__(self):
BaseRepo.__init__(self, UserRole)
self.redis_set = RedisSet()
def new_user_role(self, role_id, user_id, location_id, email):
user_role = UserRole(role_id=role_id,
user_id=user_id,
location_id=location_id,
email=email)
user_role.save()
self.update_cache(user_role)
return user_role
def update_cache(self, user_role):
"""Populate the cache with the user email for autocomplete."""
if user_role.email is not None:
email = user_role.email.strip()
for l in range(1, len(email)):
prefix = email[0:l]
self.redis_set.push(prefix)
self.redis_set.push(email, True)
def BaseTearDown(self):
"""Teardown the session."""
db.session.close()
db.session.remove()
db.engine.dispose()
RedisSet()._delete()
def setUp(self):
self.BaseSetUp()
self.redis_set = RedisSet()
class TestRedisSet(BaseTestCase):
def setUp(self):
self.BaseSetUp()
self.redis_set = RedisSet()
def tearDown(self):
self.BaseTearDown()
def test_push(self):
self.redis_set.push('a')
self.redis_set.push('b')
self.redis_set.push('c')
values = self.redis_set.zrange(0, 3)
self.assertEquals(values, ['a', 'b', 'c'])
self.redis_set.push('b')
self.redis_set.push('a')
values = self.redis_set.zrange(0, 5)
self.assertEquals(values, ['a', 'b', 'c'])
def test_get(self):
"""all valid prefixes should return abracadabra"""
items = 'abracadabra'
for i, item in enumerate(items):
self.redis_set.push(items[0:i])
self.redis_set.push(items, True)
# all valid prefixes should return abracadabra
values = self.redis_set.get('a')
self.assertTrue(items in values)
values = self.redis_set.get('ab')
self.assertTrue(items in values)
values = self.redis_set.get('abr')
self.assertTrue(items in values)
values = self.redis_set.get('aa')
self.assertFalse(items in values)
values = self.redis_set.get('abracadx')
self.assertFalse(items in values)
class RoleController(BaseController):
def __init__(self, request):
BaseController.__init__(self, request)
self.role_repo = RoleRepo()
self.user_role_repo = UserRoleRepo()
self.user_repo = UserRepo()
self.permission_repo = PermissionRepo()
self.redis_set = RedisSet()
""" ROLES """
def list_roles(self):
roles = self.role_repo.filter_by(is_deleted=False)
role_list = [role.serialize() for role in roles.items]
return self.handle_response("OK",
payload={
"roles": role_list,
"meta": self.pagination_meta(roles)
})
def get_role(self, role_id):
role = self.role_repo.get(role_id)
if role:
return self.handle_response("OK",
payload={"role": role.serialize()})
return self.handle_response("Invalid or Missing role_id",
status_code=400)
def create_role(self):
name, help_ = self.request_params("name", "help")
role1 = self.role_repo.find_first(name=name)
if not role1:
try:
role = self.role_repo.new_role(name=name, help_=help_)
return self.handle_response("OK",
payload={"role": role.serialize()},
status_code=201)
except Exception as e:
return self.handle_response("Error processing: " + str(e),
status_code=400)
return self.handle_response("Role with this name already exists",
status_code=400)
def update_role(self, role_id):
name, help_ = self.request_params("name", "help")
role = self.role_repo.get(role_id)
if role:
updates = {}
if name:
role1 = self.role_repo.find_first(name=name)
if role1:
return self.handle_response(
"Role with this name already exists", status_code=400)
updates["name"] = name
if help_:
updates["help"] = help_
role = self.role_repo.update(role, **updates)
return self.handle_response("OK",
payload={"role": role.serialize()})
return self.handle_response("Invalid or incorrect role_id provided",
status_code=400)
def delete_role(self, role_id):
role = self.role_repo.get(role_id)
if role:
updates = {}
updates["is_deleted"] = True
self.role_repo.update(role, **updates)
return self.handle_response("role deleted",
payload={"status": "success"})
return self.handle_response("Invalid or incorrect role_id provided",
status_code=404)
""" USER ROLES """
def get_user_roles(self, user_id):
user_roles = self.user_role_repo.get_unpaginated(user_id=user_id)
if user_roles:
role_list = [role.serialize() for role in user_roles]
return self.handle_response("OK", payload={"user_role": role_list})
return self.handle_response("There are no roles for this user",
status_code=404)
def create_user_role(self):
try:
role_id, user_id = self.request_params("role_id", "user_id")
user = self.user_repo.find_first(id=user_id)
if user is None:
return self.handle_response("This user record does not exist",
status_code=400)
user_id = user.id
user_role = self.user_role_repo.get_unpaginated(role_id=role_id,
user_id=user_id,
is_deleted=False)
if not user_role:
role = self.role_repo.get(role_id)
if role:
user_role = self.user_role_repo.new_user_role(
role_id=role_id,
user_id=user_id,
)
user_role_data = user_role.serialize()
user_role_data.update(
{"name": f"{user.first_name} {user.last_name}"})
return self.handle_response(
"OK",
payload={"user_role": user_role_data},
status_code=201)
return self.handle_response("This role does not exist",
status_code=400)
return self.handle_response("This User has this Role already",
status_code=400)
except Exception as e:
return self.handle_response("Error Occurred: " + str(e),
status_code=400)
def delete_user_role(self, user_role_id):
user_role = self.user_role_repo.get(user_role_id)
if user_role:
updates = {}
updates["is_deleted"] = True
self.user_role_repo.update(user_role, **updates)
return self.handle_response("user_role deleted for user",
payload={"status": "success"})
return self.handle_response(
"Invalid or incorrect user_role_id provided", status_code=404)
def disable_user_role(self):
user_id, role_id = self.request_params("userId", "roleId")
user_role = self.user_role_repo.get_unpaginated(user_id=user_id,
role_id=role_id)[0]
if user_role:
updates = {}
updates["is_active"] = False
self.user_role_repo.update(user_role, **updates)
return self.handle_response("user_role disabled for user",
payload={"status": "success"})
return self.handle_response(
"Invalid or incorrect user_role_id provided", status_code=404)
""" PERMISSIONS """
def get_role_permissions(self, role_id):
permissions = self.permission_repo.get_unpaginated(
**{"role_id": role_id})
perm_list = [permission.serialize() for permission in permissions]
return self.handle_response("OK",
payload={
"role_id": role_id,
"role_permissions": perm_list
})
def get_single_permission(self, role_id, permission_id):
permission = self.permission_repo.filter_by(role_id=role_id,
id=permission_id)
permissions = [
permission.serialize() for permission in permission.items
]
return self.handle_response("OK", payload={"permission": permissions})
def get_all_permissions(self):
permissions = self.permission_repo.get_unpaginated()
perm_list = [permission.serialize() for permission in permissions]
return self.handle_response("OK", payload={"permissions": perm_list})
def create_role_permission(self):
role_id, name, keyword = self.request_params("role_id", "name",
"keyword")
permission = self.permission_repo.get_unpaginated(name=name,
is_deleted=False,
role_id=role_id)
if not permission:
role = self.role_repo.get(role_id)
if role:
permission = self.permission_repo.new_permission(
role_id=role_id, name=name, keyword=keyword)
return self.handle_response(
"OK",
payload={"permission": permission.serialize()},
status_code=201,
)
return self.handle_response("This role does not exist",
status_code=400)
return self.handle_response("This permission already exists",
status_code=400)
def update_permission(self, permission_id):
role_id, name, keyword = self.request_params("role_id", "name",
"keyword")
permission = self.permission_repo.get(permission_id)
if permission:
updates = {}
if name:
permission1 = self.permission_repo.find_first(name=name)
if permission1:
return self.handle_response(
"Permission with this name already exists",
status_code=400)
updates["name"] = name
if role_id:
updates["role_id"] = role_id
if keyword:
updates["keyword"] = keyword
self.role_repo.update(permission, **updates)
return self.handle_response(
"OK", payload={"permission": permission.serialize()})
return self.handle_response(
"Invalid or incorrect permission id provided", status_code=400)
def delete_role_permission(self, permission_id):
permission = self.permission_repo.get(permission_id)
if permission:
updates = {}
updates["is_deleted"] = True
self.role_repo.update(permission, **updates)
return self.handle_response("permission deleted",
payload={"status": "success"})
return self.handle_response(
"Invalid or incorrect permission id provided", status_code=404)
def autocomplete(self):
params = self.get_params("q")
rows = []
if params:
for value in self.redis_set.get(params[0]):
if value:
rows.append(value)
return self.handle_response(rows, status_code=200)
def __init__(self):
BaseRepo.__init__(self, UserRole)
self.redis_set = RedisSet()
class RoleController(BaseController):
def __init__(self, request):
BaseController.__init__(self, request)
self.role_repo = RoleRepo()
self.user_role_repo = UserRoleRepo()
self.permission_repo = PermissionRepo()
self.andela_service = AndelaService()
self.redis_set = RedisSet()
''' ROLES '''
def list_roles(self):
roles = self.role_repo.filter_by(is_deleted=False)
role_list = [role.serialize() for role in roles.items]
return self.handle_response('OK',
payload={
'roles': role_list,
'meta': self.pagination_meta(roles)
})
def get_role(self, role_id):
role = self.role_repo.get(role_id)
if role:
return self.handle_response('OK',
payload={'role': role.serialize()})
return self.handle_response('Invalid or Missing role_id',
status_code=400)
def create_role(self):
name, help_ = self.request_params('name', 'help')
role1 = self.role_repo.find_first(name=name)
if not role1:
role = self.role_repo.new_role(name=name, help_=help_)
return self.handle_response('OK',
payload={'role': role.serialize()},
status_code=201)
return self.handle_response('Role with this name already exists',
status_code=400)
def update_role(self, role_id):
name, help_ = self.request_params('name', 'help')
role = self.role_repo.get(role_id)
if role:
updates = {}
if name:
role1 = self.role_repo.find_first(name=name)
if role1:
return self.handle_response(
'Role with this name already exists', status_code=400)
updates['name'] = name
if help_:
updates['help'] = help_
self.role_repo.update(role, **updates)
return self.handle_response('OK',
payload={'role': role.serialize()})
return self.handle_response('Invalid or incorrect role_id provided',
status_code=400)
def delete_role(self, role_id):
role = self.role_repo.get(role_id)
if role:
updates = {}
updates['is_deleted'] = True
self.role_repo.update(role, **updates)
return self.handle_response('role deleted',
payload={"status": "success"})
return self.handle_response('Invalid or incorrect role_id provided',
status_code=404)
''' USER ROLES '''
def get_user_roles(self, user_id):
user_roles = self.user_role_repo.get_unpaginated(user_id=user_id)
if user_roles:
role_list = [role.serialize() for role in user_roles]
return self.handle_response('OK', payload={'user_role': role_list})
return self.handle_response('There are no roles for this user',
status_code=404)
def create_user_role(self):
location = Auth.get_location()
role_id, email_address = self.request_params('roleId', 'emailAddress')
user = self.andela_service.get_user_by_email_or_id(email_address)
if user is None:
return self.handle_response('This user record does not exist',
status_code=400)
user_id = user['id']
user_role = self.user_role_repo.get_unpaginated(role_id=role_id,
user_id=user_id,
is_deleted=False)
if not user_role:
role = self.role_repo.get(role_id)
if role:
user_role = self.user_role_repo.new_user_role(
role_id=role_id,
user_id=user_id,
location_id=location,
email=email_address)
user_role_data = user_role.serialize()
user_role_data.update({'name': user.get('name')})
return self.handle_response(
'OK',
payload={'user_role': user_role_data},
status_code=201)
return self.handle_response('This role does not exist',
status_code=400)
return self.handle_response('This User has this Role already',
status_code=400)
def delete_user_role(self, user_role_id):
user_role = self.user_role_repo.get(user_role_id)
if user_role:
updates = {}
updates['is_deleted'] = True
self.user_role_repo.update(user_role, **updates)
return self.handle_response('user_role deleted for user',
payload={"status": "success"})
return self.handle_response(
'Invalid or incorrect user_role_id provided', status_code=404)
def disable_user_role(self):
user_id, role_id = self.request_params('userId', 'roleId')
user_role = self.user_role_repo.get_unpaginated(user_id=user_id,
role_id=role_id)[0]
if user_role:
updates = {}
updates['is_active'] = False
self.user_role_repo.update(user_role, **updates)
return self.handle_response('user_role disabled for user',
payload={"status": "success"})
return self.handle_response(
'Invalid or incorrect user_role_id provided', status_code=404)
''' PERMISSIONS '''
def get_role_permissions(self, role_id):
permissions = self.permission_repo.get_unpaginated(
**{'role_id': role_id})
perm_list = [permission.serialize() for permission in permissions]
return self.handle_response('OK',
payload={
'role_id': role_id,
'role_permissions': perm_list
})
def get_single_permission(self, role_id, permission_id):
permission = self.permission_repo.filter_by(role_id=role_id,
id=permission_id)
permissions = [
permission.serialize() for permission in permission.items
]
return self.handle_response('OK', payload={'permission': permissions})
def get_all_permissions(self):
permissions = self.permission_repo.get_unpaginated()
perm_list = [permission.serialize() for permission in permissions]
return self.handle_response('OK', payload={'permissions': perm_list})
def create_role_permission(self):
role_id, name, keyword = self.request_params('role_id', 'name',
'keyword')
permission = self.permission_repo.get_unpaginated(name=name,
is_deleted=False,
role_id=role_id)
if not permission:
role = self.role_repo.get(role_id)
if role:
permission = self.permission_repo.new_permission(
role_id=role_id, name=name, keyword=keyword)
return self.handle_response(
'OK',
payload={'permission': permission.serialize()},
status_code=201)
return self.handle_response('This role does not exist',
status_code=400)
return self.handle_response('This permission already exists',
status_code=400)
def update_permission(self, permission_id):
role_id, name, keyword = self.request_params('role_id', 'name',
'keyword')
permission = self.permission_repo.get(permission_id)
if permission:
updates = {}
if name:
permission1 = self.permission_repo.find_first(name=name)
if permission1:
return self.handle_response(
'Permission with this name already exists',
status_code=400)
updates['name'] = name
if role_id:
updates['role_id'] = role_id
if keyword:
updates['keyword'] = keyword
self.role_repo.update(permission, **updates)
return self.handle_response(
'OK', payload={'permission': permission.serialize()})
return self.handle_response(
'Invalid or incorrect permission id provided', status_code=400)
def delete_role_permission(self, permission_id):
permission = self.permission_repo.get(permission_id)
if permission:
updates = {}
updates['is_deleted'] = True
self.role_repo.update(permission, **updates)
return self.handle_response('permission deleted',
payload={"status": "success"})
return self.handle_response(
'Invalid or incorrect permission id provided', status_code=404)
def autocomplete(self):
params = self.get_params('q')
rows = []
if params:
for value in self.redis_set.get(params[0]):
if value:
rows.append(value)
return self.handle_response(rows, status_code=200)
def setUp(self):
self.BaseSetUp()
self.repo = UserRoleRepo()
self.redis_set = RedisSet()
def __init__(self, request):
BaseController.__init__(self, request)
self.skill_category_repo = SkillCategoryRepo()
self.redis_set = RedisSet()
class SkillCategoryController(BaseController):
def __init__(self, request):
BaseController.__init__(self, request)
self.skill_category_repo = SkillCategoryRepo()
self.redis_set = RedisSet()
def list_skills_categories(self):
skills_categories = self.skill_category_repo.filter_by(
is_deleted=False)
skills_category_list = [
skills_category.serialize()
for skills_category in skills_categories.items
]
return self.handle_response(
"OK",
payload={
"skills_categories": skills_category_list,
"meta": self.pagination_meta(skills_categories),
},
)
def get_skills_category(self, skills_category_id):
skills_category = self.skill_category_repo.get(skills_category_id)
if skills_category:
return self.handle_response(
"OK", payload={"skills_category": skills_category.serialize()})
return self.handle_response("Invalid or Missing skills_category_id",
status_code=400)
def create_skills_category(self):
name, help_ = self.request_params("name", "help")
skills_category1 = self.skill_category_repo.find_first(name=name)
if not skills_category1:
try:
skills_category = self.skill_category_repo.new_skill_category(
name=name, help_=help_)
return self.handle_response(
"OK",
payload={"skills_category": skills_category.serialize()},
status_code=201,
)
except Exception as e:
return self.handle_response("Error processing: " + str(e),
status_code=400)
return self.handle_response(
"Skills Category with this name already exists", status_code=400)
def update_skills_category(self, update_id):
name, help_, skill_category_id = self.request_params(
"name", "help", "skill_category_id")
if update_id != skill_category_id:
return self.handle_response(
"Invalid or incorrect skills_category_id provided",
status_code=400)
skills_category = self.skill_category_repo.get(skill_category_id)
if skills_category:
updates = {}
if name:
skills_category1 = self.skill_category_repo.find_first(
name=name)
if skills_category1:
return self.handle_response(
"Skills Category with this name already exists",
status_code=400)
updates["name"] = name
if help_:
updates["help"] = help_
skills_category = self.skill_category_repo.update(
skills_category, **updates)
return self.handle_response(
"OK", payload={"skills_category": skills_category.serialize()})
return self.handle_response(
"Invalid or incorrect skills_category_id provided",
status_code=400)
def delete_skills_category(self, skills_category_id):
skills_category = self.skill_category_repo.get(skills_category_id)
if skills_category:
updates = {}
updates["is_deleted"] = True
self.skill_category_repo.update(skills_category, **updates)
return self.handle_response("skills category deleted",
payload={"status": "success"})
return self.handle_response(
"Invalid or incorrect skills_category_id provided",
status_code=404)
def autocomplete(self):
params = self.get_params("q")
rows = []
if params:
for value in self.redis_set.get(params[0]):
if value:
rows.append(value)
return self.handle_response(rows, status_code=200)
class TestCron(BaseTestCase):
def setUp(self):
self.BaseSetUp()
self.redis_set = RedisSet()
def tearDown(self):
self.BaseTearDown()
def test_run_24_hourly_method(self):
end_date = (datetime.now() - timedelta(weeks=1)).date()
new_engagement = VendorEngagementFactory.create(end_date=end_date)
temp_engagement_id = new_engagement.id
Cron(self.app).run_24_hourly()
with self.app.app_context():
engagement = VendorEngagementRepo().get(temp_engagement_id)
self.assertEqual(engagement.status, 0)
def test_job_to_schedule_method_creates_meal_sessions(self):
location = LocationFactory.create(id=1, name="Lagos")
location.save()
with self.app.app_context():
Cron(self.app).run_meal_session_cron()
meal_sessions = MealSessionRepo().fetch_all().items
assert meal_sessions[0].name == "breakfast"
assert meal_sessions[1].name == "lunch"
@patch.object(MealSessionCron, '_get_scheduler_current_date')
@patch.object(MealSessionCron, '_get_location_current_date')
def test_meal_session_cron_creates_meal_session_using_scheduler_date(
self,
mock_location_current_date,
mock_scheduler_current_date,
):
location = LocationFactory.create(id=1, name="Lagos")
location.save()
with self.app.app_context():
mock_scheduler_current_date.return_value = datetime(
year=2019,
month=4,
day=10,
hour=0,
minute=0,
tzinfo=pytz.timezone("Africa/Lagos"))
mock_location_current_date.return_value = datetime(
year=2019,
month=3,
day=10,
hour=11,
minute=0,
tzinfo=pytz.timezone("Africa/Dakar"))
Cron(self.app).run_meal_session_cron()
meal_sessions = MealSessionRepo().fetch_all().items
assert meal_sessions[0].name == "breakfast"
assert meal_sessions[0].date.month == 4
assert meal_sessions[1].name == "lunch"
assert meal_sessions[1].date.month == 4
@patch.object(MealSessionLogic, 'validate_meal_session_times')
@patch.object(MealSessionCron, '_get_scheduler_current_date')
@patch.object(MealSessionCron, '_get_location_current_date')
def test_meal_session_cron_does_not_create_meal_session_if_session_already_exists(
self, mock_location_current_date, mock_scheduler_current_date,
mock_validate_meal_session_times):
LocationFactory.create(id=1, name="Kampala")
with self.app.app_context():
mock_scheduler_current_date.return_value = datetime(
year=2019,
month=4,
day=10,
tzinfo=pytz.timezone("Africa/Lagos"))
mock_location_current_date.return_value = datetime(
year=2019,
month=3,
day=10,
tzinfo=pytz.timezone("Africa/Dakar"))
mock_validate_meal_session_times.return_value = "A meal session already exists"
Cron(self.app).run_meal_session_cron()
meal_sessions = MealSessionRepo().fetch_all().items
assert len(meal_sessions) == 0
def test_run_5_minute_method(self):
role = RoleFactory.create()
location = LocationFactory.create()
user_role = UserRoleFactory.build(role_id=role.id, location=location)
UserRoleRepo().new_user_role(user_role.role_id, user_role.user_id,
user_role.location_id, user_role.email)
Cron(self.app).run_5_minute()
results = self.redis_set.get(user_role.email[0])
self.assertEqual(user_role.email, results[0])
results = self.redis_set.get(user_role.email[0:1])
self.assertEqual(user_role.email, results[0])
results = self.redis_set.get(user_role.email[0:2])
self.assertEqual(user_role.email, results[0])
