def setUp(self):
self.course_id = 'edX/toy/2012_Fall'
self.student_role = RoleFactory(name='Student',
course_id=self.course_id)
self.moderator_role = RoleFactory(name='Moderator',
course_id=self.course_id)
self.community_ta_role = RoleFactory(name='Community TA',
course_id=self.course_id)
self.student1 = UserFactory(username='******',
email='*****@*****.**')
self.student1_enrollment = CourseEnrollmentFactory(user=self.student1)
self.student_role.users.add(self.student1)
self.student2 = UserFactory(username='******',
email='*****@*****.**')
self.student2_enrollment = CourseEnrollmentFactory(user=self.student2)
self.moderator = UserFactory(username='******',
email='*****@*****.**',
is_staff=True)
self.moderator_enrollment = CourseEnrollmentFactory(
user=self.moderator)
self.moderator_role.users.add(self.moderator)
self.community_ta1 = UserFactory(username='******',
email='*****@*****.**')
self.community_ta_role.users.add(self.community_ta1)
self.community_ta2 = UserFactory(username='******',
email='*****@*****.**')
self.community_ta_role.users.add(self.community_ta2)
def test_create_user_endpoint_succeeds(self):
create_user_role('create_user')
user = UserFactory.create(user_id="user_id_2", is_deleted=True)
role = RoleFactory(name='test_role')
location = LocationFactory.create()
headers = self.headers()
headers.update({'X-Location': location.id})
user_data = dict(
firstName=user.first_name,
lastName=user.last_name,
roleId=role.id
)
response = self.client().post(
self.make_url("/users/"),
headers=headers,
data=self.encode_to_json_string(user_data))
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_json['msg'], "OK")
self.assertEqual(response_json['payload']['user']['firstName'], user.first_name)
self.assertEqual(response_json['payload']['user']['lastName'], user.last_name)
self.assertEqual(response_json['payload']['user']['userRoles'][0]['name'], role.name)
self.assertEqual(response_json['payload']['user']['userRoles'][0]['help'], role.help)
def test_create_user_endpoint_succeeds1(self):
location = LocationFactory()
create_user_role("create_user", "admin")
user = UserFactoryFake.build()
role1 = RoleFactory()
user_data = dict(
first_name=user.first_name,
last_name=user.last_name,
role_id=role1.id,
email=user.email,
gender=user.gender,
date_of_birth=str(user.date_of_birth),
location_id=location.id,
password=user.password,
)
headers = self.headers()
headers.update({"X-Location": location.id})
response = self.client().post(
self.make_url("/users/"),
headers=headers,
data=self.encode_to_json_string(user_data),
)
response_json = self.decode_from_json_string(response.data.decode("utf-8"))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_json["msg"], "OK")
self.assertEqual(
response_json["payload"]["user"]["first_name"], user.first_name
)
self.assertEqual(response_json["payload"]["user"]["last_name"], user.last_name)
def test_list_user_succeeds(
self,
mock_user_repo_find_first,
):
with self.app.app_context():
role = RoleFactory()
UserRoleFactory(user_id=self.mock_user.id, role_id=role.id)
PermissionFactory.create(keyword="view_users", role=role)
mock_user_repo_find_first.return_value = self.mock_user
user_controller = UserController(self.request_context)
response = user_controller.list_user(id=self.mock_user.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()["msg"], "OK")
self.assertEqual(
response.get_json()["payload"]["user"]["first_name"],
self.mock_user.first_name,
)
self.assertEqual(
response.get_json()["payload"]["user"]["last_name"],
self.mock_user.last_name,
)
def test_update_user_endpoint_with_invalid_role_fails(self):
create_user_role("update_user", "admin")
role = RoleFactory()
user = UserFactory()
user.save()
UserRoleFactory(user_id=user.id, role=role)
user_data = dict(
first_name="Andela",
last_name="Eats",
role_id=100,
gender="male",
date_of_birth="2020-10-01",
employment_date="2020-10-01",
)
response = self.client().patch(
self.make_url(f"/users/{user.id}"),
headers=self.headers(),
data=self.encode_to_json_string(user_data),
)
response_json = self.decode_from_json_string(response.data.decode("utf-8"))
self.assertEqual(response.status_code, 400)
self.assertEqual(response_json["msg"], "Role with id 100 doesnot exist")
def test_create_user_method_handles_user_creation_with_non_existent_role_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory()
role = RoleFactory(name="test_role")
UserRoleFactory(role_id=role.id, user_id=user.id)
non_existent_role_id = 100
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
"*****@*****.**",
non_existent_role_id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()["msg"],
"Role with userTypeId(roleId) {} does not exist".format(
non_existent_role_id),
)
def test_update_user_endpoint_with_invalid_role_fails(self):
create_user_role('update_user')
role = RoleFactory()
user_role = UserRoleFactory(role=role)
user = UserFactory(user_type=user_role)
user.save()
user_data = dict(firstName="Andela", lastName="Eats", roleId=100)
response = self.client().patch(self.make_url(f'/users/{user.id}'), headers=self.headers(),
data=self.encode_to_json_string(user_data))
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 400)
self.assertEqual(response_json['msg'], 'Role with id 100 doesnot exist')
def test_list_user_succeeds(self):
with self.app.app_context():
role = RoleFactory()
user_role = UserRoleFactory(role_id=role.id)
user = UserFactory(slack_id="-LXTuXlk2W4Gskt8KTte", user_type_id=user_role.id)
user_controller = UserController(self.request_context)
response = user_controller.list_user(slack_id=user.slack_id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()['msg'], "OK")
self.assertEqual(response.get_json()['payload']['user']['slackId'], user.slack_id)
self.assertEqual(response.get_json()['payload']['user']['firstName'], user.first_name)
self.assertEqual(response.get_json()['payload']['user']['lastName'], user.last_name)
def test_autocomplete_endpoint(self):
role = RoleFactory()
user_role = UserRoleFactory(role_id=role.id)
user = UserFactory(slack_id='-LMnsyxrsj_TEYEAHCBk',
user_type_id=user_role.id)
create_user_role('view_user_roles')
response = self.client().get(self.make_url('/roles/autocomplete'),
query_string={'q': user_role.email[0]},
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
payload = response_json
self.assertEqual(response.status_code, 200)
self.assertTrue(user_role.email in payload['msg'])
def test_get_user_role_endpoint(self):
new_role, user_id = create_user_role('view_user_roles')
new_role.save()
role = RoleFactory()
user_role = UserRoleFactory(role=role)
user = UserFactory(user_type_id=user_role.id)
response = self.client().get(
self.make_url(f'/roles/user/{user_role.user_id}'),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assert200(response)
self.assertEqual(response_json['msg'], 'OK')
self.assertEqual(response_json['payload']['user_role'][0]['id'],
user_role.id)
def test_list_user_endpoint(self):
role = RoleFactory()
user_role = UserRoleFactory(role_id=role.id)
user = UserFactory(slack_id='-LMnsyxrsj_TEYEAHCBk',
user_type_id=user_role.id)
create_user_role('view_users')
response = self.client().get(self.make_url(f'/users/{user.slack_id}/'),
headers=self.headers())
response_json = self.decode_from_json_string(
response.data.decode('utf-8'))
self.assertEqual(response_json['msg'], 'OK')
self.assertEqual(response_json['payload']['user']['firstName'],
user.first_name)
self.assertEqual(response_json['payload']['user']['lastName'],
user.last_name)
def test_create_user_method_handles_user_creation_with_duplicate_user_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(user_id="-LXTuXlk2W4Gskt8KTte")
role = RoleFactory(name='test_role')
UserRoleFactory(role_id=role.id, user_id=user.id)
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, user.user_id, role.id
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()['msg'],
"User with userId '{}' already exists".format(user.user_id))
def test_create_user_succeeds(self, mock_request_params,
mock_get_location):
location = LocationFactory()
role = RoleFactory(name='test_role')
with self.app.app_context():
mock_get_location.return_value = location.id
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, "-LXTuXlk2W4Gskt8KTte",
role.id
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
# Assert
assert result.status_code == 201
assert result.get_json()['msg'] == 'OK'
def test_create_user_endpoint_succeeds1(self):
location = LocationFactory()
create_user_role('create_user')
user = UserFactory.build()
user.save()
role = RoleFactory()
user_data = dict(firstName=user.first_name, lastName=user.last_name, roleId=role.id)
headers = self.headers()
headers.update({'X-Location': location.id})
response = self.client().post(self.make_url("/users/"), headers=headers,
data=self.encode_to_json_string(user_data))
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_json['msg'], 'OK')
self.assertEqual(response_json['payload']['user']['firstName'], user.first_name)
self.assertEqual(response_json['payload']['user']['lastName'], user.last_name)
def test_create_user_endpoint_succeeds(self):
create_user_role("create_user", "admin")
user = UserFactoryFake.build(id=500, is_deleted=True)
role = RoleFactory(name="test_role")
location = LocationFactory.create()
headers = self.headers()
headers.update({"X-Location": location.id})
user_data = dict(
first_name=user.first_name,
last_name=user.last_name,
role_id=role.id,
gender=user.gender,
date_of_birth=str(user.date_of_birth),
employment_date=str(user.employment_date),
password=user.password,
email=user.email,
location_id=user.location_id,
)
response = self.client().post(
self.make_url("/users/"),
headers=headers,
data=self.encode_to_json_string(user_data),
)
response_json = self.decode_from_json_string(response.data.decode("utf-8"))
print(response_json)
self.assertEqual(response.status_code, 201)
self.assertEqual(response_json["msg"], "OK")
self.assertEqual(
response_json["payload"]["user"]["first_name"], user.first_name
)
self.assertEqual(response_json["payload"]["user"]["last_name"], user.last_name)
self.assertEqual(
response_json["payload"]["user"]["user_roles"][0]["name"], role.name
)
self.assertEqual(
response_json["payload"]["user"]["user_roles"][0]["help"], role.help
)
def test_update_user_endpoint_succeeds(self):
create_user_role('update_user')
role = RoleFactory()
user_role = UserRoleFactory(role=role)
user_role.save()
user = UserFactory(user_type=user_role)
user.save()
user_data = dict(firstName="Andela", lastName="Eats", roleId=role.id)
response = self.client().patch(
self.make_url(f'/users/{user.id}'),
headers=self.headers(),
data=self.encode_to_json_string(user_data)
)
response_json = self.decode_from_json_string(response.data.decode('utf-8'))
self.assertEqual(response.status_code, 200)
self.assertEqual(response_json['msg'], 'OK')
self.assertEqual(response_json['payload']['user']['firstName'], user.first_name)
self.assertEqual(response_json['payload']['user']['lastName'], user.last_name)
def test_create_user_fails_for_existing_user(
self,
mock_user_role_repo_new_user_role,
# mock_user_repo_new_user,
mock_user_repo_exists,
mock_role_repo_find_first,
mock_request_params,
mock_get_location,
):
location = LocationFactory()
role = RoleFactory(name="test_role")
with self.app.app_context():
mock_get_location.return_value = location.id
mock_role_repo_find_first.return_value = self.mock_role
mock_user_repo_exists.return_value = self.mock_user2
# mock_user_repo_new_user.return_value = None
mock_user_role_repo_new_user_role.return_value = self.mock_user_role
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
self.mock_user2.email,
role.id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
print(result)
print(result.get_json())
# Assert
assert result.status_code == 400
assert (
result.get_json()["msg"] ==
f"User with email '{self.mock_user2.email}' already exists")
def test_create_user_method_handles_user_creation_with_non_existent_role_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(user_id="-LXTuXlk2W4Gskt8KTte")
role = RoleFactory(name='test_role')
UserRoleFactory(role_id=role.id, user_id=user.id)
non_existent_role_id = 100
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, user.user_id,
non_existent_role_id
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()['msg'],
"Role with userTypeId(roleId) {} does not exist".format(
non_existent_role_id))
def test_create_user_succeeds(
self,
mock_user_role_repo_new_user_role,
mock_user_repo_new_user,
mock_user_repo_exists,
mock_role_repo_find_first,
mock_request_params,
mock_get_location,
):
location = LocationFactory()
role = RoleFactory(name="test_role")
with self.app.app_context():
mock_get_location.return_value = location.id
mock_role_repo_find_first.return_value = self.mock_role
mock_user_repo_exists.return_value = None
mock_user_repo_new_user.return_value = self.mock_user2
mock_user_role_repo_new_user_role.return_value = self.mock_user_role
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
"*****@*****.**",
role.id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
# Assert
assert result.status_code == 201
assert result.get_json()["msg"] == "OK"
