def test_user_quiz_verifier_view_with_valid_inputs(self):
"""
Testing the user maker quiz view with valid inputs
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_model = self.quiz_adapter.create_and_save_model(
quiz_id=self.quiz_tools.get_quiz_id(user.username, 'test_quiz_name'),
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
session = client.session
session['quiz_complete_model'] = QuizCompleteModel(quiz_model=quiz_model)
session.save()
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
quiz_parameters['quiz_form'] = '<div id="rendered-form" style="padding-top: 40px; display: block;">\r\n ' \
'<form action="#"><div class=""><h1>Header</h1></div></form>\r\n ' \
'<button class="btn btn-default edit-form">Edit</button>\r\n</div>'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_delete_with_invalid_user(self):
"""
Testing quiz delete view
:return:
"""
client = Client()
create_user()
# Creating attacker account which tries to delete other persons quizzes
AuthUser.objects.create_user(username="******", email=context.get('*****@*****.**'),
password=context.get('password'))
client.login(username="******", password=context.get('password'))
# Preparing quiz model to be deleted
quiz = self.quiz_adapter.create_and_save_model(quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = quiz.quiz_id
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
# Testing response status code
response = client.post(reverse('service:user_quiz_delete'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/myquiz/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
def test_user_quiz_delete_with_all_valid_inputs(self):
"""
Testing quiz delete view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
client = prepare_client(client)
# Preparing quiz model to be deleted
quiz = self.quiz_adapter.create_and_save_model(quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = quiz.quiz_id
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
# Testing response status code
response = client.post(reverse('service:user_quiz_delete'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/myquiz/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Assert quiz deleted
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), None)
def test_user_quiz_verifier_view_with_valid_inputs(self):
"""
Testing the user maker quiz view with valid inputs
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_model = self.quiz_adapter.create_and_save_model(
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
session = client.session
session['quiz_complete_model'] = QuizCompleteModel(quiz_model=quiz_model)
session.save()
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
quiz_parameters['quiz_form'] = '<div id="rendered-form" style="padding-top: 40px; display: block;">\r\n ' \
'<form action="#"><div class=""><h1>Header</h1></div></form>\r\n ' \
'<button class="btn btn-default edit-form">Edit</button>\r\n</div>'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_less_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
# <from > instead of <form>
quiz_parameters['quiz_form'] = '<div id="rendered-form" style="padding-top: 40px; display: block;">\r\n ' \
'<form action="#"><div class=""></div></form>\r\n ' \
'<button class="btn btn-default edit-form">Edit</button>\r\n</div>'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_delete_with_all_valid_inputs(self):
"""
Testing quiz delete view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
client = prepare_client(client)
# Preparing quiz model to be deleted
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = quiz.quiz_id
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
# Testing response status code
response = client.post(reverse('service:user_quiz_delete'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/myquiz/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Assert quiz deleted
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), None)
def test_user_myquiz_home_view_with_valid_inputs_with_one_quiz(self):
"""
Testing the user myquiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'),
password=context.get('password'))
# Preparing quiz model to be displayed
self.quiz_adapter.create_and_save_model(
quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
response = client.post(reverse('service:user_myquiz_home'),
context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_myquiz_info_view_with_valid_inputs(self):
"""
Testing the user myquiz info page
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# Preparing mock file for test
with open("".join([settings.BASE_DIR, "/service/tmp", self.quiz_tools.create_filename(quiz)]),
'wb') as mock_file:
mock_file.write(serialize(quiz_complete_model))
mock_file.close()
response = client.post(reverse('service:user_myquiz_info', kwargs={'quiz_id': quiz.quiz_id}),
context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_delete_with_invalid_user(self):
"""
Testing quiz delete view
:return:
"""
client = Client()
create_user()
# Creating attacker account which tries to delete other persons quizzes
AuthUser.objects.create_user(username="******", email=context.get('*****@*****.**'),
password=context.get('password'))
client.login(username="******", password=context.get('password'))
# Preparing quiz model to be deleted
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = quiz.quiz_id
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
# Testing response status code
response = client.post(reverse('service:user_quiz_delete'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/myquiz/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Assert quiz present
self.assertEqual(self.quiz_adapter.exists(quiz.quiz_id), quiz)
def test_user_quiz_maker_view_with_duplicate_name(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_name'] = 'mock_name'
quiz_parameters['quiz_description'] = 'test_quiz_description'
quiz = self.quiz_adapter.create_and_save_model(
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
quiz.delete()
def test_user_quizarena_solve_view_with_valid_inputs(self):
"""
Testing the user quizarena view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# Preparing mock file for test
with open("".join([settings.BASE_DIR, "/service/tmp", self.quiz_tools.create_filename(quiz)]),
'wb') as mock_file:
mock_file.write(serialize(quiz_complete_model))
mock_file.close()
response = client.post(reverse('service:user_quizarena_solve', kwargs={'quiz_id': 'test_id'}), context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quizarena_result_view_with_valid_inputs(self):
"""
Testing the user quizarena view
:return: Asserts
"""
client = Client()
create_user()
client = prepare_client(client)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# Preparing session
session = client.session
session['quiz'] = quiz
session.save()
# Preparing mock file for test
with open("".join([settings.BASE_DIR, "/service/tmp", self.quiz_storage_handler.create_filename(quiz)]),
'wb') as mock_file:
mock_file.write(serialize(quiz_complete_model))
mock_file.close()
response = client.post(reverse('service:user_quizarena_result'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_less_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
# <from > instead of <form>
quiz_parameters['quiz_form'] = '<div id="rendered-form" style="padding-top: 40px; display: block;">\r\n ' \
'<form action="#"><div class=""></div></form>\r\n ' \
'<button class="btn btn-default edit-form">Edit</button>\r\n</div>'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_maker_view_with_duplicate_name(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_name'] = 'test_quiz_name'
quiz_parameters['quiz_description'] = 'test_quiz_description'
quiz = self.quiz_adapter.create_and_save_model(
quiz_id=self.quiz_tools.get_quiz_id(user.username, quiz_parameters['quiz_name']),
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
quiz.delete()
def create_user():
"""
Creates user for client
:return: return logged in client
"""
User.objects.create_user(username=context.get('username'), email=context.get('username'),
password=context.get('password'))
user = authenticate(username=context.get('username'), password=context.get('password'))
return user
def test_user_myquiz_info_view_with_invalid_inputs(self):
"""
Testing the user myquiz info page
:return:
"""
client = Client()
create_user()
# Creating attacker account which tries to delete other persons quizzes
AuthUser.objects.create_user(username="******",
email=context.get('*****@*****.**'),
password=context.get('password'))
client.login(username="******",
password=context.get('password'))
client = prepare_client(client)
# Quiz not yet created
response = client.post(reverse('service:user_myquiz_info',
kwargs={'quiz_id': 'test_id'}),
context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(
quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# Preparing mock file for test
with open(
"".join([
settings.BASE_DIR, "/service/tmp",
self.quiz_tools.create_filename(quiz)
]), 'wb') as mock_file:
mock_file.write(serialize(quiz_complete_model))
mock_file.close()
# User not allowed to modify this
response = client.post(reverse('service:user_myquiz_info',
kwargs={'quiz_id': 'test_id'}),
context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_create_model(self):
"""
Testing the create user method
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'),
password=context.get('password'))
# Empty username should not create model
self.assertRaises(ValueError,
self.user_adapter.create_model,
username="******")
# Valid flow
user = self.user_adapter.create_model(
username=context.get('username'),
first_name=context.get('user_first_name'),
last_name=context.get('user_last_name'),
phone=context.get('user_phone'),
dob=context.get('user_dob'))
self.assertEqual(self.user_adapter.exists(user), None)
user.save()
self.assertEqual(self.user_adapter.exists(context.get('username')),
user)
# Duplicate user should not create model too
self.assertRaises(ValueError,
self.user_adapter.create_model,
username=context.get('username'))
def test_user_quiz_init_view(self):
"""
Testing the user quiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_init'), context)
self.assertEqual(response.status_code, 200)
def test_user_valid(self):
"""
Testing the dashboard view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
client = prepare_client(client)
response = client.post(reverse('service:user_home'), context)
self.assertEqual(response.status_code, 200)
def test_user_quiz_init_view(self):
"""
Testing the user quiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_init'), context)
self.assertEqual(response.status_code, 200)
def test_user_not_authenticated(self):
"""
Testing the dashboard view
:return:
"""
client = Client()
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_home'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/?next=/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_register_check_with_duplicate_id(self):
"""
Checking register check
:return:
"""
client = Client()
create_user()
user = User(username=context.get('username'),
user_first_name=context.get('user_first_name'),
user_last_name=context.get('user_last_name'),
user_phone=context.get('user_phone'),
user_dob=context.get('user_dob'))
user.save()
response = client.post(reverse('service:register_check'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/register/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Test if user is created in models
try:
get_object_or_404(User, username=context.get('username'))
except Http404:
raise Http404
user.delete()
user = authenticate(username=context.get('username'), password=context.get('password'))
self.assertEqual(user.is_active, True)
def test_user_quizarena_result_view_with_invalid_inputs(self):
"""
Testing the user quizarena view
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quizarena_result'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quizarena/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quizarena_result_view_with_invalid_inputs(self):
"""
Testing the user quizarena view
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quizarena_result'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quizarena/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_myquiz_home_view_with_valid_inputs_with_no_quiz(self):
"""
Testing the user myquiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_myquiz_home'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_null_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_null_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_create_model(self):
"""
Testing the create model method
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'),
password=context.get('password'))
# Create and save user
user = self.user_adapter.create_and_save_model(
username=context.get('username'),
first_name=context.get('user_first_name'),
last_name=context.get('user_last_name'),
phone=context.get('user_phone'),
dob=context.get('user_dob'))
# Create and save quiz with the above user as owner.
quiz_model = self.quiz_adapter.create_and_save_model(
quiz_id="quiz_id",
quiz_name="quiz_name",
quiz_description="quiz_description",
quiz_owner=user)
# No tag exists.
self.assertEqual(self.quiz_tag_adapter.exists("test_tag"), None)
# Verify name
self.assertEqual(self.quiz_tag_adapter.verify_tag_name("test?tag"),
None)
self.assertNotEqual(self.quiz_tag_adapter.verify_tag_name("test_tag"),
None)
# Creating tag
test_tag = self.quiz_tag_adapter.create_model("test_tag")
# Should not be able to link the tag to the quiz as it has not been saved yet.
self.assertRaises(ValueError,
self.quiz_tag_adapter.link_quiz,
tag_name=test_tag.tag_name,
quiz_id=quiz_model.quiz_id)
test_tag = self.quiz_tag_adapter.create_and_save_model("test_tag")
# No links yet
self.assertEqual(quiz_model.quiztag_set.count(), 0)
# Linking
self.quiz_tag_adapter.link_quiz(tag_name=test_tag.tag_name,
quiz_id=quiz_model.quiz_id)
self.assertEqual(quiz_model.quiztag_set.count(), 1)
# Checking whether tag linked to the right quiz.
self.assertNotEqual(quiz_model.quiztag_set.all()[0], None)
self.assertEqual(test_tag.tagged_quiz.all()[0], quiz_model)
self.quiz_tag_adapter.unlink_quiz(quiz_id=quiz_model.quiz_id,
tag_name=test_tag.tag_name)
self.assertEqual(self.quiz_tag_adapter.exists(test_tag.tag_name), None)
def test_user_myquiz_home_view_with_valid_inputs_with_no_quiz(self):
"""
Testing the user myquiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'),
password=context.get('password'))
response = client.post(reverse('service:user_myquiz_home'),
context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_myquiz_home_view_with_valid_inputs_with_one_quiz(self):
"""
Testing the user myquiz view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing quiz model to be displayed
self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
response = client.post(reverse('service:user_myquiz_home'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_create_view_with_all_invalid_inputs(self):
"""
Testing create view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = {'answer_key': 'test'}
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_create_view_with_all_invalid_inputs(self):
"""
Testing create view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = {'answer_key': 'test'}
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_maker_view_with_empty_name(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_name'] = ' '
quiz_parameters['quiz_description'] = 'test_quiz_description'
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_both_invalid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = 'garbage'
quiz_parameters['quiz_form'] = 'garbage'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_register_check_with_valid_inputs(self):
"""
Checking the post method and all valid inputs
:return:
"""
client = Client()
response = client.post(reverse('service:register_check'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Test if user is created in models
try:
get_object_or_404(User, username=context.get('username'))
except Http404:
raise Http404
user = authenticate(username=context.get('username'), password=context.get('password'))
self.assertEqual(user.is_active, True)
def test_user_quiz_maker_view_with_empty_name(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_name'] = ' '
quiz_parameters['quiz_description'] = 'test_quiz_description'
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_both_invalid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = 'garbage'
quiz_parameters['quiz_form'] = 'garbage'
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_maker_view_with_valid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = 'test_quiz_id'
quiz_parameters['quiz_name'] = 'test_quiz_name'
quiz_parameters['quiz_description'] = 'test_quiz_description'
quiz_parameters['attempts'] = -1
quiz_parameters['pass_percentage'] = 100
quiz_parameters['start_date_time'] = '02/08/1993 1:42 PM'
quiz_parameters['end_date_time'] = '02/08/1993 2:42 PM'
quiz_parameters['quiz_tags'] = 'test1,test2'
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
def test_user_quiz_maker_view_with_valid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
quiz_parameters = dict(context)
quiz_parameters['quiz_id'] = 'test_quiz_id'
quiz_parameters['quiz_name'] = 'test_quiz_name'
quiz_parameters['quiz_description'] = 'test_quiz_description'
quiz_parameters['attempts'] = -1
quiz_parameters['pass_percentage'] = 100
quiz_parameters['start_date_time'] = '02/08/1993 1:42 PM'
quiz_parameters['end_date_time'] = '02/08/1993 2:42 PM'
quiz_parameters['quiz_tags'] = 'test1,test2'
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
response = client.post(reverse('service:user_quiz_maker'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
def test_user_quiz_verifier_view_with_form_invalid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
quiz_parameters['quiz_form'] = "garbage"
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_login_view_valid_user_without_email(self):
"""
Testing the login view
:return:
"""
modified_context = dict(context)
# Replicating login using facebook which does not have an email id by default.
modified_context['username'] = "******"
User.objects.create_user(username=context.get('username'),
password=context.get('password'))
client = Client()
session = client.session
session['user_profile_model'] = USER_PROFILE_MODEL
session.save()
response = client.post(reverse('service:login'), context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/usersetup/", 302))
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_verifier_view_with_form_invalid_inputs(self):
"""
Testing the user maker quiz view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['quiz_data'] = '<form-template>\r\n\t<fields>\r\n\t\t<field class="header" label="Header" ' \
'type="header" subtype="h1"></field>\r\n\t</fields>\r\n</form-template>'
quiz_parameters['quiz_form'] = "garbage"
# Testing response status code
response = client.post(reverse('service:user_quiz_verifier'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_create_view_with_valid_inputs(self):
"""
Testing create view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = {'answer_key': 'test'}
# Preparing session
quiz_model = mock_quiz_model
# Use the user model created in setUp
mock_quiz_model.quiz_owner = self.mock_user
quiz_complete_model = QuizCompleteModel(quiz_model=quiz_model,
quiz_data="mock_quiz_data",
quiz_form="mock_quiz_form",
answer_key={"key": "value"},
pass_percentage=100,
attempts=1,
tags=list())
client = prepare_client(client)
session = client.session
session['quiz_complete_model'] = quiz_complete_model
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_myquiz_info_view_with_invalid_inputs(self):
"""
Testing the user myquiz info page
:return:
"""
client = Client()
create_user()
# Creating attacker account which tries to delete other persons quizzes
AuthUser.objects.create_user(username="******", email=context.get('*****@*****.**'),
password=context.get('password'))
client.login(username="******", password=context.get('password'))
client = prepare_client(client)
# Quiz not yet created
response = client.post(reverse('service:user_myquiz_info', kwargs={'quiz_id': uuid.uuid4()}),
context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# User not allowed to modify this
response = client.post(reverse('service:user_myquiz_info', kwargs={'quiz_id': quiz.quiz_id}),
context, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_create_view_with_valid_inputs(self):
"""
Testing create view
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = {'answer_key': 'test'}
# Preparing session
quiz_model = mock_quiz_model
# Use the user model created in setUp
mock_quiz_model.quiz_owner = self.mock_user
quiz_complete_model = QuizCompleteModel(quiz_model=quiz_model,
quiz_data="mock_quiz_data",
quiz_form="mock_quiz_form",
answer_key={"key": "value"},
pass_percentage=100,
attempts=1,
tags=list())
client = prepare_client(client)
session = client.session
session['quiz_complete_model'] = quiz_complete_model
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/home/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quizarena_solve_view_with_valid_inputs(self):
"""
Testing the user quizarena view
:return: Asserts
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing quiz model to be displayed
quiz = self.quiz_adapter.create_and_save_model(quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user)
quiz_complete_model = mock_quiz_complete_model
quiz_complete_model.quiz_model = quiz
# Preparing session for attempts check while solving quizzes. Needs user_profile_model
session = client.session
session[USER_PROFILE_MODEL] = mock_user_profile_model
session.save()
# Preparing mock file for test
with open("".join([settings.BASE_DIR, "/service/tmp", self.quiz_storage_handler.create_filename(quiz)]),
'wb') as mock_file:
mock_file.write(serialize(quiz_complete_model))
mock_file.close()
# Attempt the quiz (attempt = 1)
response = client.post(reverse('service:user_quizarena_solve', kwargs={'quiz_id': quiz.quiz_id}), context,
follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
self.assertEqual(response.redirect_chain, redirect_chain)
def test_create_model(self):
"""
Testing the create user method
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'), password=context.get('password'))
# Empty username should not create model
self.assertRaises(ValueError, self.user_adapter.create_model, username="******")
# Valid flow
user = self.user_adapter.create_model(username=context.get('username'),
first_name=context.get('user_first_name'),
last_name=context.get('user_last_name'),
phone=context.get('user_phone'),
dob=context.get('user_dob'))
self.assertEqual(self.user_adapter.exists(user), None)
user.save()
self.assertEqual(self.user_adapter.exists(context.get('username')), user)
# Duplicate user should not create model too
self.assertRaises(ValueError, self.user_adapter.create_model, username=context.get('username'))
def test_create_model(self):
"""
Testing the create quiz model method
:return: Asserts
"""
client = Client()
create_user()
client.login(username=context.get('username'),
password=context.get('password'))
# Empty quiz_id and parameters should not create model
self.assertRaises(ValueError,
self.quiz_adapter.create_model,
quiz_id=" ",
quiz_name=" ",
quiz_description=None,
quiz_owner=None)
# Valid flow
user = self.user_adapter.create_and_save_model(
username=context.get('username'),
first_name=context.get('user_first_name'),
last_name=context.get('user_last_name'),
phone=context.get('user_phone'),
dob=context.get('user_dob'))
self.assertEqual(self.quiz_adapter.exists(quiz_id="quiz_id"), None)
quiz_model = self.quiz_adapter.create_and_save_model(
quiz_id="quiz_id",
quiz_name="quiz_name",
quiz_description="quiz_description",
quiz_owner=user)
self.assertEqual(self.quiz_adapter.exists("quiz_id"), quiz_model)
# Duplicate quiz should not create model too
self.assertRaises(ValueError,
self.quiz_adapter.create_model,
quiz_id='quiz_id',
quiz_name="quiz_name",
quiz_description="quiz_description",
quiz_owner=user)
def test_user_quiz_create_view_with_invalid_error_inputs(self):
"""
Testing create view
Handling exception
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = 'answer_key'
quiz_parameters['csrfmiddlewaretoken'] = 'test'
# Preparing session
quiz = Quiz(
quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session = client.session
session['quiz_data'] = "mock_quiz_data"
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing session
quiz = Quiz(
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session['quiz_form'] = "mock_quiz_form"
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing session
quiz = Quiz(
quiz_id="test_id",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
def test_user_quiz_create_view_with_invalid_error_inputs(self):
"""
Testing create view
Handling exception
:return:
"""
client = Client()
user = create_user()
self.assertEqual(user.is_active, True)
client.login(username=context.get('username'), password=context.get('password'))
# Preparing the context
quiz_parameters = dict(context)
quiz_parameters['answer_key'] = 'answer_key'
quiz_parameters['csrfmiddlewaretoken'] = 'test'
# Preparing session
quiz = Quiz(
quiz_id="test_id",
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session = client.session
session['quiz_data'] = "mock_quiz_data"
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing session
quiz = Quiz(
quiz_name="mock_name",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session['quiz_form'] = "mock_quiz_form"
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
# Preparing session
quiz = Quiz(
quiz_id="test_id",
quiz_description="mock_description",
quiz_owner=self.mock_user
)
session['quiz'] = quiz
session.save()
# Testing response status code
response = client.post(reverse('service:user_quiz_create'), quiz_parameters, follow=True)
self.assertEqual(response.status_code, 200)
# Testing redirection
redirect_chain = list()
redirect_chain.append(("/quiz/init/", 302))
self.assertEqual(response.redirect_chain, redirect_chain)
