def test_all_proficiencies_dict(self):
""" Test that proficiencies dict getter assembles properly from character attributes """
p_skill = G(Skill, name='Proficient Skill')
e_skill = G(Skill, name='Expert Skill')
skill_proficiency = G(SkillProficiency,
skill=p_skill,
proficiency_level='P')
skill_expertise = G(SkillProficiency,
skill=e_skill,
proficiency_level='E')
character = G(Character,
skills=[skill_proficiency.id, skill_expertise.id])
character.proficient_heavy_armor = True
character.proficient_languages = 'Common,Dwarvish'
character.proficient_other = 'Other Proficiency A,Other Proficiency B'
result = character.all_proficiencies_dict
self.assertIn('armor', result)
self.assertIn('weapons', result)
self.assertIn('tools', result)
self.assertIn('skills', result)
self.assertIn('other', result)
self.assertIn('languages', result)
self.assertIn('Proficient Skill', result['skills'])
self.assertIn('Expert Skill', result['skills'])
self.assertIn('Heavy Armor', result['armor'])
self.assertIn('Common', result['languages'])
self.assertIn('Dwarvish', result['languages'])
self.assertIn('Other Proficiency A', result['other'])
self.assertIn('Other Proficiency B', result['other'])
self.assertNotIn('Light Armor', result['armor'])
self.assertNotIn('Elvish', result['languages'])
def test_random_model_creation(self):
EXAMPLE_COUNT = 20
for modeladmin in admin.site._registry.values():
if modeladmin.model._meta.managed:
for _ in range(EXAMPLE_COUNT):
G(modeladmin.model, fill_nullable_fields=True)
G(modeladmin.model, fill_nullable_fields=False)
def test_doctor_search_via_name(self, doctor, client):
self._login(doctor.user, client)
response = client.get('/doctor/dashboard/search/')
assert response.status_code == 200, 'Search view should return 200 OK response for doctor'
assert len(
response.context_data.get('object_list')
) == 0, 'There should not be any results without the query url param'
user_1 = G(User, first_name='Dummy', last_name='Name')
student_1 = G(Student, user=user_1)
user_2 = G(User, first_name='Foo', last_name='Bar')
student_2 = G(Student, user=user_2)
# testing with first_name
search_query = 'dummy'
response = client.get(f'/doctor/dashboard/search/?q={search_query}')
search_results = response.context_data.get('object_list')
assert len(search_results) == 1, 'There should be exactly one result'
assert search_results[
0] == student_1, '"student_2" should be returned as only the search result'
# testing with wrong query
search_query = 'hello'
response = client.get(f'/doctor/dashboard/search/?q={search_query}')
search_results = response.context_data.get('object_list')
assert len(search_results) == 0, 'There should not any search result'
# testing with last_name
search_query = 'bar'
response = client.get(f'/doctor/dashboard/search/?q={search_query}')
search_results = response.context_data.get('object_list')
assert len(search_results) == 1, 'There should be exactly one result'
assert search_results[
0] == student_2, '"student_2" should be returned as only the search result'
def test_is_magic(self):
""" Test that the is_magic property properly determines if an item is magic """
mundane_armor = G(Armor, rarity='M')
magic_armor = G(Armor, rarity='C')
self.assertTrue(magic_armor.is_magic)
self.assertFalse(mundane_armor.is_magic)
def test_has_child(self):
""" Test that the has_child property correctly determines when an
ancestry has a child ancestry """
ancestry_no_children = G(Ancestry)
ancestry_has_children = G(Ancestry)
G(SubAncestry, parent=ancestry_has_children)
self.assertTrue(ancestry_has_children.has_child)
self.assertFalse(ancestry_no_children.has_child)
def test_doctor_dashboard_list_of_patient(self, doctor, client):
self._login(doctor.user, client)
response = client.get('/doctor/dashboard/list-of-patients/')
assert response.status_code == 200, 'List of patients view should return 200 OK response for doctor'
visit_histories = response.context_data['object_list']
assert len(visit_histories) == 0, 'No visit histories are present.'
# creating dummy students
user_1 = G(User)
student_1 = G(Student, user=user_1)
user_2 = G(User)
student_2 = G(Student, user=user_2)
# creating dummy doctor
user_3 = G(User)
doctor_1 = G(Doctor, user=user_3)
# creating visit histories
vh_1 = G(VisitHistory, student=student_1, doctor=doctor)
vh_2 = G(VisitHistory, student=student_2, doctor=doctor)
vh_3 = G(VisitHistory, student=student_2, doctor=doctor_1)
# testing
response = client.get('/doctor/dashboard/list-of-patients/')
visit_histories = response.context_data['object_list']
assert len(
visit_histories
) == 2, 'There should be two visit histories the logged in doctor'
def test_staff_should_not_be_able_to_access_doc_dashboard(self, client):
user = G(User, is_staff=True)
self._login(user, client)
response = client.get('/doctor/dashboard/')
assert response.status_code == 403, 'Staff members are not allowed to access doctor dashboard'
client.logout()
admin = G(User, is_staff=True, is_superuser=True)
self._login(admin, client)
response = client.get('/doctor/dashboard/')
assert response.status_code == 403, 'Admin members are not allowed to access doctor dashboard'
def setUp(self):
self.ranged_longbow = G(WeaponProperty, name='ranged (150/600)')
self.ranged_thrown = G(WeaponProperty, name='ranged (20/60)')
self.finesse = G(WeaponProperty, name='finesse')
self.thrown = G(WeaponProperty, name='thrown')
self.versatile = G(WeaponProperty, name='versatile (d10)')
self.handaxe = G(Weapon, properties=[self.thrown.id, self.ranged_thrown.id])
self.dagger = G(Weapon, properties=[self.finesse.id, self.thrown.id, self.ranged_thrown.id])
self.longbow = G(Weapon, properties=[self.ranged_longbow.id])
self.rapier = G(Weapon, properties=[self.finesse.id])
self.longsword = G(Weapon, properties=[self.versatile.id])
def test_datetimefield_model(db):
obj = G(DateTimeFieldModel)
value = obj.field
obj.field = obj.field + timedelta(days=1, hours=3)
obj.save()
assert obj.get_field_history()[0].value == value
def test_stud_dashboard_history(self, student, doctor, client):
self._login(student.user, client)
visit_1 = G(VisitHistory, student=student, doctor=doctor)
visit_2 = G(VisitHistory, student=student, doctor=doctor)
response = client.get('/student/dashboard/')
assert response.status_code == 200, 'Response should be 200 OK for student dashboard'
visits = response.context_data.get('visits')
assert len(
visits) == 2, 'Two Visits should be present in the context data'
assert visits[
0].doctor.pk == doctor.pk, 'Doctor pk should be the same as created.'
assert visits[
1].doctor.pk == doctor.pk, 'Doctor pk should be the same as created.'
def test_reset_password_successful(self):
""" Testcase for successfully reseting user's password. """
user = G(AUTH_USER)
# Generating token for given user.
token = TokenGenerator.generate_token(
user,
exp=datetime.datetime.utcnow()
+ datetime.timedelta(
hours=commons_constant.EMAIL_VERIFICATION_EXPIRATION_TIME_HR
)
)
url = self.get_url()
data = {
'new_password': '******',
'token': token
}
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(
response.data.get(commons_constant.RESPONSE_MSG),
commons_constant.PASS_UPDATE_SUCC
)
def test_verify_valid_token(self):
""" Testcase to verify the email of the user. """
user = G(AUTH_USER)
# checking currentlty is_email_verified is False.
self.assertEqual(user.is_email_verified, False)
# Generating token for email verification.
token = TokenGenerator.generate_token(
user,
exp=datetime.datetime.utcnow()
+ datetime.timedelta(
hours=commons_constant.EMAIL_VERIFICATION_EXPIRATION_TIME_HR
)
)
url = self.get_url(token)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(
response.data.get(commons_constant.RESPONSE_TOKEN),
Token.objects.get(user=user).key
)
self.assertEqual(AUTH_USER.objects.get(
id=user.id).is_email_verified, True)
def test_fetching_user_profile(self):
""" Testcase for fetching user's profile data. """
user = G(AUTH_USER)
# Without Authenticating
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(len(response.data), 1)
self.assertEqual(
response.data.get('detail'),
'Authentication credentials were not provided.'
)
# After Authenticating.
self.client.force_authenticate(user=user)
expected_response = {
'id': user.id,
'email': user.email,
'first_name': user.first_name,
'last_name': user.last_name,
'dob': user.dob,
'phone': user.phone,
'profile_image': 'http://testserver' + user.profile_image.url,
'is_email_verified': user.is_email_verified,
'token': user.auth_token.key
}
response = self.client.get(f'{self.url}')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(dict(response.data), expected_response)
def test_accessing_other_user_data(self):
""" Testcase for accessing other user's details. """
user1 = G(AUTH_USER)
user2 = G(AUTH_USER)
self.client.force_authenticate(user=user1)
# deleting user2 details by user1
response = self.client.delete(f'{self.url}{user2.id}/')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = get_user_data()
# updating user2 details by user1
response = self.client.put(f'{self.url}{user2.id}/', data=data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_user_updation(self):
""" Testcase for updation of user.
This should not update the user's password, email and
is_email_verified status.
"""
user = G(AUTH_USER)
self.client.force_authenticate(user=user)
data = get_user_data(is_email_verified=True)
expected_response = {
'id': user.id,
'first_name': data['first_name'],
'last_name': data['last_name'],
'email': user.email,
'dob': user.dob,
'phone': user.phone,
'profile_image': f'http://testserver{user.profile_image.url}',
'is_email_verified': user.is_email_verified,
'token': user.auth_token.key
}
response = self.client.put(f'{self.url}{user.id}/', data=data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(dict(response.data), expected_response)
self.assertNotEqual(user.password, make_password(data['password']))
self.assertTrue(not user.is_email_verified)
def test_single_history_on_multiple_changes(db):
obj = G(MultipleFieldModel, first_field="value", second_field="value")
obj.first_field = "new_value"
obj.second_field = "new_value"
obj.save()
assert FieldsHistory.objects.count() == 1
def test_verification_with_invalid_token(self):
""" Testcase to verify the email of the user with invalid token. """
user = G(AUTH_USER)
# checking currentlty is_email_verified is False.
self.assertEqual(user.is_email_verified, False)
# Generating token for email verification.
token = TokenGenerator.generate_token(
user,
exp=datetime.datetime.utcnow()
+ datetime.timedelta(
hours=commons_constant.EMAIL_VERIFICATION_EXPIRATION_TIME_HR
)
)[:-1]
url = self.get_url(token)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data.get(commons_constant.RESPONSE_TOKEN)[0].__str__(),
commons_constant.INVALID_TOKEN
)
def test_integer_model(db):
obj = G(IntegerFieldModel)
value = obj.field
obj.field = obj.field + 1
obj.save()
assert obj.get_field_history()[0].value == value
def test_proficiency_bonus(self):
""" Test that proficiency bonus calculation is equal to CEIL(LEVEL / 4) + 1"""
char_class_1 = G(CharacterClass)
class_1_and_level = G(ClassAndLevel,
character_class=char_class_1,
level=5)
char_class_2 = G(CharacterClass)
class_2_and_level = G(ClassAndLevel,
character_class=char_class_2,
level=3)
character = G(
Character,
class_levels=[class_1_and_level.id, class_2_and_level.id])
self.assertEqual(character.proficiency_bonus, 3, \
msg="Total level is 8, proficiency should be 3")
char_class_3 = G(CharacterClass)
class_3_and_level = G(ClassAndLevel,
character_class=char_class_3,
level=1)
character.class_levels.add(class_3_and_level)
self.assertEqual(character.proficiency_bonus, 4, \
msg="Total level is now 9, proficiency should bump by 1")
def test_update(self, client: FuncWebTest, admin_url):
transaction = G(Transaction, amount=20)
client.get_literal_url(admin_url(Transaction, "change",
transaction.pk))
client.fill_by_name({"amount": "40"})
client.submit("[name='_save']")
transaction.refresh_from_db()
assert transaction.amount == 40
def setUp(self):
# Initialize client
self.client = APIClient()
# Initialize different POV users
user_model = get_user_model()
self.superuser = user_model.objects.create_superuser('superuser',
password='******')
self.owner = user_model.objects.create_user('owner', password='******')
self.editor = user_model.objects.create_user('editor', password='******')
self.some_user = user_model.objects.create_user('some_user',
password='******')
# create some test users
G(Character, PRIVATE_COUNT, owner=self.owner, \
authorized_editors=[self.editor.id], is_private=True)
G(Character, PUBLIC_COUNT, owner=self.owner, \
authorized_editors=[self.editor.id], is_private=False)
def test_no_history_only_on_tracked_fields_change(db):
obj = G(OneOfManyTrackedFieldModel, tracked="value", not_tracked="value")
obj.not_tracked = "new_value"
obj.save()
assert not FieldsHistory.objects.exists()
obj.tracked = "new_value"
obj.save()
assert FieldsHistory.objects.count() == 1
def test_initiative(self):
""" Test that initiative modifier is calculated accounting for
dexterity, jack of all trades, and miscellaneous bonuses """
char_class_1 = G(CharacterClass)
class_1_and_level = G(ClassAndLevel,
character_class=char_class_1,
level=5)
character = G(Character, class_levels=[class_1_and_level.id])
self.assertEqual(character.initiative, 0)
character.dexterity = 14
self.assertEqual(character.initiative, 2)
character.jack_of_all_trades = True
self.assertEqual(character.initiative, 3)
character.misc_initiative_bonus = 5
self.assertEqual(character.initiative, 8)
def test_history_on_field_change_save(db, model):
obj = G(model)
new_obj = N(model)
assert new_obj.field != obj.field
obj.field = new_obj.field
assert not FieldsHistory.objects.exists()
obj.save()
assert FieldsHistory.objects.count() == 1
def test_appointment_list_view_response(self, doctor, student, client):
self._login(doctor.user, client)
response = client.get('/doctor/dashboard/appointments/')
assert response.status_code == 200, 'Doctor should be able to view all its appointments'
assert len(response.context_data['object_list']
) == 0, 'There are no appointments currently'
# creating another dummy doctor
user_1 = G(User)
doctor_1 = G(Doctor, user=user_1)
# creating appointments
appointment_1 = G(Appointment, doctor=doctor, student=student)
appointment_2 = G(Appointment, doctor=doctor_1, student=student)
response = client.get('/doctor/dashboard/appointments/')
assert len(
response.context_data['object_list']
) == 1, 'There are exactly one appointment for the logged in doctor'
def test_ability_modifier_getters(self):
""" Test that ability modifiers are calculated correctly """
character = G(Character)
self.assertEqual(character.strength_modifier, 0)
character.strength += 4
self.assertEqual(character.strength_modifier, 2)
character.strength -= 8
self.assertEqual(character.strength_modifier, -2)
def setUp(self):
# Initialize client
self.client = APIClient()
# Initialize different POV users
user_model = get_user_model()
self.superuser = user_model.objects.create_superuser('superuser',
password='******')
self.owner = user_model.objects.create_user('owner', password='******')
self.editor = user_model.objects.create_user('editor', password='******')
self.other_user = user_model.objects.create_user('other_user',
password='******')
self.inactive_user = user_model.objects.create_user('inactive_user', \
password='******', is_active=False)
self.skill = G(Skill,
owner=self.owner,
authorized_editors=[self.editor.id])
self.private_character = G(Character, is_private=True, \
owner=self.owner, authorized_editors=[self.editor.id])
def test_successful_logout(self):
""" Testcase for successful logout. """
user = G(AUTH_USER)
self.client.force_authenticate(user=user)
response = self.client.delete(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Token.objects.filter(user=user).count(), 0)
def test_login_page_with_authenticated_user(self, client):
user = G(User)
client.force_login(user)
response = client.get('/login/')
assert response.status_code == 302, 'Logged in user should get redirected on accessing login page'
assert response.has_header(
'location'
) == True, 'Redirection url should be present in response header'
assert response.get(
'location'
) == '/', 'Location header must contain redirection url which is homepage in this case.'
def test_appointment_cancelled(self, doctor, student, client):
self._login(doctor.user, client)
appointment = G(Appointment, student=student, doctor=doctor)
response = client.get(f'/appointments/update/{appointment.pk}/cancel/')
assert response.status_code == 302, 'Updation of appointment should return redirect response'
assert response.get(
'location'
) == '/doctor/dashboard/appointments/', 'Updation of appointment should return to appointment list view of doctor'
appointment.refresh_from_db()
assert appointment.is_cancelled == True, 'Appointment should be cancelled'
assert appointment.is_confirmed == False, 'Appointment should not be confirmed'