def test_number_users(self):
"""Test JOB dashboard returns number of users."""
UserFactory.create()
new_users_week()
sql = "select * from dashboard_week_new_users;"
results = db.session.execute(sql)
for row in results:
assert row.day_users == 1
assert str(row.day) in datetime.utcnow().strftime('%Y-%m-%d')
def test_number_users(self):
"""Test JOB dashboard returns number of users."""
UserFactory.create()
dashboard_new_users_week()
sql = "select * from dashboard_week_new_users;"
results = db.session.execute(sql)
for row in results:
assert row.day_users == 1
assert str(row.day) in datetime.utcnow().strftime('%Y-%m-%d')
def test_format_new_users(self):
"""Test format new users works."""
UserFactory.create()
new_users_week()
res = format_new_users()
assert len(res["labels"]) == 1
day = datetime.utcnow().strftime("%Y-%m-%d")
assert res["labels"][0] == day
assert len(res["series"]) == 1
assert res["series"][0][0] == 1, res["series"][0][0]
def test_format_new_users(self):
"""Test format new users works."""
UserFactory.create()
new_users_week()
res = format_new_users()
assert len(res['labels']) == 1
day = datetime.utcnow().strftime('%Y-%m-%d')
assert res['labels'][0] == day
assert len(res['series']) == 1
assert res['series'][0][0] == 1, res['series'][0][0]
def test_format_new_users(self):
"""Test format new users works."""
UserFactory.create()
dashboard_new_users_week()
res = format_new_users()
assert len(res['labels']) == 1
day = datetime.utcnow().strftime('%Y-%m-%d')
assert res['labels'][0] == day
assert len(res['series']) == 1
assert res['series'][0][0] == 1, res['series'][0][0]
def test_returning_users(self):
"""Test JOB dashboard returns number of returning users."""
once_only_user = UserFactory.create()
returning_user = UserFactory.create()
TaskRunFactory.create(user=once_only_user)
TaskRunFactory.create(user=returning_user)
task_run = TaskRunFactory.create(user=returning_user)
day = datetime.utcnow() - timedelta(days=1)
TaskRunFactory.create(user=returning_user, finish_time=day.isoformat())
returning_users_week()
sql = "select * from dashboard_week_returning_users;"
results = db.session.execute(sql).fetchall()
assert results[0].n_days == 2
assert results[0].user_id == task_run.user_id
def test_returning_users(self):
"""Test JOB dashboard returns number of returning users."""
once_only_user = UserFactory.create()
returning_user = UserFactory.create()
TaskRunFactory.create(user=once_only_user)
TaskRunFactory.create(user=returning_user)
task_run = TaskRunFactory.create(user=returning_user)
day = datetime.utcnow() - timedelta(days=1)
TaskRunFactory.create(user=returning_user, finish_time=day.isoformat())
returning_users_week()
sql = "select * from dashboard_week_returning_users;"
results = db.session.execute(sql).fetchall()
assert results[0].n_days == 2
assert results[0].user_id == task_run.user_id
def test_format_returning_users(self):
"""Test format returning users works."""
u = UserFactory.create()
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
day = datetime.utcnow() - timedelta(days=2)
TaskRunFactory.create(user=u, finish_time=day.isoformat())
day = datetime.utcnow() - timedelta(days=1)
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
dashboard_returning_users_week()
res = format_returning_users()
for i in range(1,8):
if i == 1:
day = '%s day' % i
else:
day = "%s days" % i
err = "%s != %s" % (res['labels'][i - 1], day)
assert res['labels'][i - 1] == day, err
if day == '3 days':
assert res['labels'][i - 1] == day, day
assert res['series'][0][i - 1] == 1, res['series'][0][i - 1]
else:
assert res['series'][0][i - 1] == 0, res
def test_format_returning_users(self):
"""Test format returning users works."""
u = UserFactory.create()
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
TaskRunFactory.create(user=u)
day = datetime.utcnow() - timedelta(days=2)
TaskRunFactory.create(user=u, finish_time=day.isoformat())
day = datetime.utcnow() - timedelta(days=1)
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
TaskRunFactory.create(user=u, finish_time=day.isoformat())
returning_users_week()
res = format_returning_users()
for i in range(1, 8):
if i == 1:
day = '%s day' % i
else:
day = "%s days" % i
err = "%s != %s" % (res['labels'][i - 1], day)
assert res['labels'][i - 1] == day, err
if day == '3 days':
assert res['labels'][i - 1] == day, day
assert res['series'][0][i - 1] == 1, res['series'][0][i - 1]
else:
assert res['series'][0][i - 1] == 0, res
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_new_user_method_returns_new_user_object(self):
user = UserFactory.build(slack_id='-Lcel5YdCjsvKOG3zsrV')
role = RoleFactory()
user_role = UserRoleFactory(role_id=role.id)
new_user = self.repo.new_user(user.first_name, user.last_name, user.image_url,
user_id=user.user_id, slack_id=user.slack_id, user_type=user_role)
self.assertIsInstance(new_user, User)
self.assertEqual(str(new_user.slack_id), str(user.slack_id))
self.assertEqual(new_user.first_name, user.first_name)
self.assertEqual(new_user.image_url, user.image_url)
def test_new_user_project_method_returns_new_user_project_object(self):
user = UserFactory.create()
user.save()
user_project = UserProjectFactoryFake.build(user=user, user_id=user.id)
new_user_project = self.repo.new_user_project(
user_id=user.id,
project_name=user_project.project_name,
project_url=user_project.project_url,
project_description=user_project.project_description,
start_date=user_project.start_date,
end_date=user_project.end_date,
is_current=False,
)
self.assertIsInstance(new_user_project, UserProject)
self.assertEqual(str(new_user_project.user_id), str(user.id))
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_new_client_method_returns_new_client_object(self):
user = UserFactory.create()
user.save()
client = ClientFactoryFake.build()
new_client = self.repo.new_client(
institution_name=client.institution_name,
institution_url=client.institution_url,
institution_city=client.institution_city,
institution_country=client.institution_country,
institution_size=client.institution_size,
start_date=client.start_date,
status=client.status,
)
self.assertIsInstance(new_client, Client)
self.assertEqual(str(new_client.institution_name),
str(new_client.institution_name))
def test_new_user_education_method_returns_new_user_education_object(self):
user = UserFactory.create()
user.save()
user_education = UserEducationFactoryFake.build(user=user,
user_id=user.id)
new_user_education = self.repo.new_user_education(
user_id=user.id,
institution_name=user_education.institution_name,
course_name=user_education.course_name,
degree_earned=user_education.degree_earned,
start_date=user_education.start_date,
end_date=user_education.end_date,
accomplishments=user_education.accomplishments,
institution_city=user_education.institution_city,
institution_country=user_education.institution_country,
)
self.assertIsInstance(new_user_education, UserEducation)
self.assertEqual(str(new_user_education.user_id), str(user.id))
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_method_handles_user_creation_with_duplicate_email_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(email="*****@*****.**",
password="******")
mock_request_params.return_value = [
user.email, "Joseph", "Serunjogi", "-LXTuXlk2W4Gskt8KTte",
False
]
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 email '{}' already exists".format(user.email))
def test_new_user_employment_skill_method_returns_new_user_employment_skill_object(
self, ):
user = UserFactory.create()
user.save()
user_employment = UserEmploymentFactory.create()
user_employment.save()
skill = SkillFactory()
skill.save()
user_employment_skill = UserEmploymentSkillFactoryFake.build(
user_employment_id=user_employment.id, skill_id=skill.id)
new_user_employment_skill = self.repo.new_user_employment_skill(
user_employment_id=user_employment_skill.user_employment_id,
skill_id=user_employment_skill.skill_id,
)
self.assertIsInstance(new_user_employment_skill, UserEmploymentSkill)
self.assertEqual(str(new_user_employment_skill.skill_id),
str(skill.id))
def test_list_user_succeeds(self):
with self.app.app_context():
user = UserFactory.create(email="*****@*****.**",
password="******")
user_controller = UserController(self.request_context)
response = user_controller.list_user(email="*****@*****.**")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()['msg'], "OK")
self.assertEqual(response.get_json()['payload']['user']['email'],
user.email)
self.assertEqual(
response.get_json()['payload']['user']['firstName'],
user.first_name)
self.assertEqual(
response.get_json()['payload']['user']['lastName'],
user.last_name)
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_save(self):
user = UserFactory()
user.save()
token = AccountActivationToken(user=user)
token.save()
assert token.token_type == Token.TokenTypes.ACCOUNT_ACTIVATION.value
def setUp(self):
#self.tearDown()
self.user = UserFactory.create(username='******',
email='*****@*****.**',
password=UserFactory.FACTORY_FOR.encrypt_password('password123'))
self.base_url = '/auth/api/auth/'
