cleaning up tests for all CBV based version

diff --git a/quiz/templates/quiz/quiz_detail.html b/quiz/templates/quiz/quiz_detail.html
index e20f5006b4e16b6080c80cdf225993e976de5f7d..b63034165f43c301075dc0359ce6d7e83dc4ff79 100644 (file)
--- a/quiz/templates/quiz/quiz_detail.html
+++ b/quiz/templates/quiz/quiz_detail.html
@@ -10,5 +10,9 @@
   <h4>You will only get one attempt at this quiz.</h4>
 {% endif %}
 <p>{{ quiz.description }}</p>
-<p><a href="{% url 'quiz.views.quiz_take' quiz_name=quiz.url %}">Start quiz</a></p>
+<p>
+  <a href="{% url 'quiz_question' quiz_name=quiz.url %}">
+       Start quiz
+  </a>
+</p>
 {% endblock %}

diff --git a/quiz/tests.py b/quiz/tests.py
index eb7963e66fb04a3fe764ebff8693f5fa13e3818c..2ceddaaf912c934852f1fb4e9bd0605619c342a2 100644 (file)
--- a/quiz/tests.py
+++ b/quiz/tests.py
@@ -9,7 +9,7 @@ from django.template import Template, Context
 from django.utils.importlib import import_module
 
 from .models import Category, Quiz, Progress, Sitting
-from .views import quiz_take, anon_session_score
+from .views import anon_session_score, QuizTake
 from multichoice.models import MCQuestion, Answer
 from true_false.models import TF_Question
 
@@ -302,19 +302,19 @@ class TestNonQuestionViews(TestCase):
         request = HttpRequest()
         engine = import_module(settings.SESSION_ENGINE)
         request.session = engine.SessionStore(None)
-        score, possible = anon_session_score(request)
+        score, possible = anon_session_score(request.session)
         self.assertEqual((score, possible), (0, 0))
 
-        score, possible = anon_session_score(request, 1, 0)
+        score, possible = anon_session_score(request.session, 1, 0)
         self.assertEqual((score, possible), (0, 0))
 
-        score, possible = anon_session_score(request, 1, 1)
+        score, possible = anon_session_score(request.session, 1, 1)
         self.assertEqual((score, possible), (1, 1))
 
-        score, possible = anon_session_score(request, -0.5, 1)
+        score, possible = anon_session_score(request.session, -0.5, 1)
         self.assertEqual((score, possible), (0.5, 2))
 
-        score, possible = anon_session_score(request)
+        score, possible = anon_session_score(request.session)
         self.assertEqual((score, possible), (0.5, 2))
 
 
@@ -350,7 +350,6 @@ class TestQuestionViewsAnon(TestCase):
     def test_quiz_take_anon_view_only(self):
         found = resolve('/q/tq1/take/')
 
-        self.assertEqual(found.func, quiz_take)
         self.assertEqual(found.kwargs, {'quiz_name': 'tq1'})
         self.assertEqual(found.url_name, 'quiz_question')
 
@@ -363,9 +362,7 @@ class TestQuestionViewsAnon(TestCase):
         self.assertEqual(response.context['quiz'].id, self.quiz1.id)
         self.assertEqual(response.context['question'].content,
                          self.question1.content)
-        self.assertEqual(response.context['question_type'],
-                         {self.question1.__class__.__name__: True})
-        self.assertEqual(response.context['previous'], False)
+        self.assertNotIn('previous', response.context)
         self.assertTemplateUsed('question.html')
 
         session = self.client.session
@@ -381,33 +378,30 @@ class TestQuestionViewsAnon(TestCase):
         # show first question
         response = self.client.get('/q/tq1/take/')
         self.assertNotContains(response, 'previous question')
-        first_question = response.context['question']
-
         # submit first answer
-        response = self.client.get('/q/tq1/take/',
-                                   {'guess': '123',
-                                    'question_id':
-                                    self.client.session['1_q_list'][0]})
+        response = self.client.post('/q/tq1/take/',
+                                    {'answers': '123',
+                                     'question_id':
+                                     self.client.session['1_q_list'][0]})
 
-        self.assertContains(response, 'previous question', status_code=200)
+        self.assertContains(response, 'previous', status_code=200)
         self.assertContains(response, 'incorrect')
         self.assertContains(response, 'Explanation:')
         self.assertContains(response, 'squeek')
         self.assertEqual(self.client.session['1_q_list'], [2])
         self.assertEqual(self.client.session['session_score'], 0)
         self.assertEqual(self.client.session['session_score_possible'], 1)
-        self.assertEqual(response.context['previous'],
-                         {'previous_answer': '123',
-                          'previous_outcome': False,
-                          'previous_question': first_question})
+        self.assertEqual(response.context['previous']['question_type'],
+                         {self.question1.__class__.__name__: True})
+        self.assertIn(self.answer1, response.context['previous']['answers'])
         self.assertTemplateUsed('question.html')
         second_question = response.context['question']
 
         # submit second and final answer of quiz, show final result page
-        response = self.client.get('/q/tq1/take/',
-                                   {'guess': '456',
-                                    'question_id':
-                                    self.client.session['1_q_list'][0]})
+        response = self.client.post('/q/tq1/take/',
+                                    {'answers': '456',
+                                     'question_id':
+                                     self.client.session['1_q_list'][0]})
 
         self.assertContains(response, 'previous question', status_code=200)
         self.assertNotContains(response, 'incorrect')
@@ -419,10 +413,12 @@ class TestQuestionViewsAnon(TestCase):
         self.assertEqual(response.context['percent'], 50)
         self.assertEqual(response.context['session'], 1)
         self.assertEqual(response.context['possible'], 2)
-        self.assertEqual(response.context['previous'],
-                         {'previous_answer': '456',
-                          'previous_outcome': True,
-                          'previous_question': second_question})
+        self.assertEqual(response.context['previous']['previous_answer'],
+                         '456')
+        self.assertEqual(response.context['previous']['previous_outcome'],
+                         True)
+        self.assertEqual(response.context['previous']['previous_question'],
+                         second_question)
         self.assertTemplateUsed('result.html')
 
         # quiz restarts
@@ -430,10 +426,10 @@ class TestQuestionViewsAnon(TestCase):
         self.assertNotContains(response, 'previous question')
 
         # session score continues to increase
-        response = self.client.get('/q/tq1/take/',
-                                   {'guess': '123',
-                                    'question_id':
-                                    self.client.session['1_q_list'][0]})
+        response = self.client.post('/q/tq1/take/',
+                                    {'answers': '123',
+                                     'question_id':
+                                     self.client.session['1_q_list'][0]})
         self.assertEqual(self.client.session['session_score'], 1)
         self.assertEqual(self.client.session['session_score_possible'], 3)
 
@@ -509,9 +505,7 @@ class TestQuestionViewsUser(TestCase):
         self.assertEqual(response.context['quiz'].id, self.quiz1.id)
         self.assertEqual(response.context['question'].content,
                          self.question1.content)
-        self.assertEqual(response.context['question_type'],
-                         {self.question1.__class__.__name__: True})
-        self.assertEqual(response.context['previous'], False)
+        self.assertNotIn('previous', response.context)
         self.assertTemplateUsed('question.html')
 
         response = self.client.get('/q/tq1/take/')
@@ -538,10 +532,10 @@ class TestQuestionViewsUser(TestCase):
         next_question = Sitting.objects.get(quiz=self.quiz1)\
                                        .get_first_question()
 
-        response = self.client.get('/q/tq1/take/',
-                                   {'guess': '123',
-                                    'question_id':
-                                    next_question.id})
+        response = self.client.post('/q/tq1/take/',
+                                    {'answers': '123',
+                                     'question_id':
+                                     next_question.id})
 
         sitting = Sitting.objects.get(quiz=self.quiz1)
         progress_count = Progress.objects.count()
@@ -560,9 +554,9 @@ class TestQuestionViewsUser(TestCase):
                          self.question2.content)
         self.assertTemplateUsed('question.html')
 
-        response = self.client.get('/q/tq1/take/',
-                                   {'guess': '456',
-                                    'question_id': 2})
+        response = self.client.post('/q/tq1/take/',
+                                    {'answers': '456',
+                                     'question_id': 2})
 
         self.assertEqual(Sitting.objects.count(), 0)
         self.assertTemplateUsed('result.html')
@@ -570,16 +564,14 @@ class TestQuestionViewsUser(TestCase):
 
     def test_quiz_take_user_answer_end(self):
         self.client.login(username='jacob', password='top_secret')
-        response = self.client.get('/q/tq2/take/',
-                                   {'guess': '123',
-                                    'question_id': 1})
-
+        response = self.client.post('/q/tq2/take/',
+                                    {'answers': '123',
+                                     'question_id': 1})
         self.assertNotContains(response, 'previous question')
-        self.assertEqual(response.context['previous'], False)
 
-        response = self.client.get('/q/tq2/take/',
-                                   {'guess': 'T',
-                                    'question_id': 3})
+        response = self.client.post('/q/tq2/take/',
+                                    {'answers': True,
+                                     'question_id': 3})
 
         self.assertEqual(response.context['score'], 1)
         self.assertEqual(response.context['max_score'], 2)
@@ -603,12 +595,12 @@ class TestQuestionViewsUser(TestCase):
         self.quiz2.single_attempt = True
         self.quiz2.save()
         self.client.login(username='jacob', password='top_secret')
-        response = self.client.get('/q/tq2/take/',
-                                   {'guess': '123',
-                                    'question_id': 1})
-        response = self.client.get('/q/tq2/take/',
-                                   {'guess': 'T',
-                                    'question_id': 3})
+        response = self.client.post('/q/tq2/take/',
+                                    {'answers': '123',
+                                     'question_id': 1})
+        response = self.client.post('/q/tq2/take/',
+                                    {'answers': True,
+                                     'question_id': 3})
 
         # quiz complete, trying it again
         response = self.client.get('/q/tq2/take/')

diff --git a/quiz/urls.py b/quiz/urls.py
index c3438847fbda5dc4d382c9ab27d22cd58c280933..ba1557907cbcd371431ee833b0e064215615fe36 100644 (file)
--- a/quiz/urls.py
+++ b/quiz/urls.py
@@ -4,7 +4,7 @@ from .views import QuizListView, CategoriesListView,\
     ViewQuizListByCategory, QuizUserProgressView, QuizDetailView, QuizTake
 
 
-urlpatterns = patterns('quiz.views',
+urlpatterns = patterns('',
 
                        url(regex=r'^$',
                            view=QuizListView.as_view(),

diff --git a/quiz/views.py b/quiz/views.py
index 577da90c9e994681dc1566cf18262f42c0c2a1e1..f5e22e1a4eedc9e0bf9009fe26803f1bce4ea005 100644 (file)
--- a/quiz/views.py
+++ b/quiz/views.py
@@ -27,20 +27,24 @@ class ViewQuizListByCategory(ListView):
     model = Quiz
     template_name = 'view_quiz_category.html'
 
+    def dispatch(self, request, *args, **kwargs):
+        self.category = get_object_or_404(Category,
+                                          category=
+                                          self.kwargs['category_name'])
+
+        return super(ViewQuizListByCategory, self).\
+            dispatch(request, *args, **kwargs)
+
     def get_context_data(self, **kwargs):
         context = super(ViewQuizListByCategory, self)\
             .get_context_data(**kwargs)
 
-        category = get_object_or_404(Category,
-                                     category=self.kwargs['category_name'])
-        context['category'] = category
+        context['category'] = self.category
         return context
 
     def get_queryset(self):
-        category = get_object_or_404(Category,
-                                     category=self.kwargs['category_name'])
         queryset = super(ViewQuizListByCategory, self).get_queryset()
-        return queryset.filter(category=category)
+        return queryset.filter(category=self.category)
 
 
 class QuizUserProgressView(TemplateView):
@@ -53,11 +57,9 @@ class QuizUserProgressView(TemplateView):
 
     def get_context_data(self, **kwargs):
         context = super(QuizUserProgressView, self).get_context_data(**kwargs)
-
-        progress = get_object_or_404(Progress, user=self.request.user)
+        progress, c = Progress.objects.get_or_create(user=self.request.user)
         context['cat_scores'] = progress.list_all_cat_scores()
         context['exams'] = progress.show_exams()
-
         return context
 
 
@@ -71,16 +73,20 @@ class QuizTake(FormView):
         if request.user.is_authenticated() is True:
             self.sitting = user_sitting(self.request, self.quiz)
         else:
-            anon_load_sitting(self.request, self.quiz)
+            self.sitting = anon_load_sitting(self.request, self.quiz)
+
+        if self.sitting is False:
+            return render(request, 'single_complete.html')
 
-        return super(QuizTake, self).dispatch(request, *args, **kwargs)
+        return super(QuizTake, self).dispatch(self.request, *args, **kwargs)
 
     def get_form_kwargs(self):
+        kwargs = super(QuizTake, self).get_form_kwargs()
         if self.request.user.is_authenticated() is True:
             self.question = self.sitting.get_first_question()
         else:
             self.question = anon_next_question(self)
-        kwargs = super(QuizTake, self).get_form_kwargs()
+
         return dict(kwargs, question=self.question)
 
     def form_valid(self, form):
@@ -95,11 +101,13 @@ class QuizTake(FormView):
                 return final_result_anon(self.request,
                                          self.quiz, self.previous)
 
+        self.request.POST = ''
         return super(QuizTake, self).get(self, self.request)
 
     def get_context_data(self, **kwargs):
         context = super(QuizTake, self).get_context_data(**kwargs)
         context['question'] = self.question
+        context['quiz'] = self.quiz
         if hasattr(self, 'previous'):
             context['previous'] = self.previous
         return context
@@ -107,26 +115,22 @@ class QuizTake(FormView):
 
 def user_sitting(request, quiz):
     if quiz.single_attempt is True and\
-       Sitting.objects.filter(user=request.user,
-                              quiz=quiz,
-                              complete=True)\
-                      .count() > 0:
-
-        return render(request, 'single_complete.html')
+        Sitting.objects.filter(user=request.user,
+                               quiz=quiz,
+                               complete=True)\
+                       .count() > 0:
+        return False
 
     try:
         sitting = Sitting.objects.get(user=request.user,
                                       quiz=quiz,
                                       complete=False)
-
     except Sitting.DoesNotExist:
         sitting = Sitting.objects.new_sitting(request.user, quiz)
-
     except Sitting.MultipleObjectsReturned:
         sitting = Sitting.objects.filter(user=request.user,
                                          quiz=quiz,
                                          complete=False)[0]
-
     finally:
         return sitting
 
@@ -191,7 +195,7 @@ def final_result_user(request, sitting, quiz, previous):
 
 def anon_load_sitting(request, quiz):
     if quiz.single_attempt is True:
-        return render(request, 'single_complete.html')
+        return False
 
     if quiz.anon_q_list() in request.session:
         return request.session[quiz.anon_q_list()]
@@ -229,9 +233,9 @@ def form_valid_anon(self, form):
 
     if is_correct is True:
         self.request.session[self.quiz.anon_score_id()] += 1
-        anon_session_score(self.request, 1, 1)
+        anon_session_score(self.request.session, 1, 1)
     else:
-        anon_session_score(self.request, 0, 1)
+        anon_session_score(self.request.session, 0, 1)
 
     if self.quiz.answers_at_end is not True:
         self.previous = {'previous_answer': guess,
@@ -246,7 +250,7 @@ def form_valid_anon(self, form):
         (self.request.session[self.quiz.anon_q_list()][1:])
 
 
-def anon_session_score(request, to_add=0, possible=0):
+def anon_session_score(session, to_add=0, possible=0):
     """
     Returns the session score for non-signed in users.
     If number passed in then add this to the running total and
@@ -258,19 +262,17 @@ def anon_session_score(request, to_add=0, possible=0):
         x, y = anon_session_score() will return the session score
                                     without modification
     """
-    if "session_score" not in request.session:
-        request.session["session_score"] = 0
-        request.session["session_score_possible"] = 0
+    if "session_score" not in session:
+        session["session_score"] = 0
+        session["session_score_possible"] = 0
 
     if possible > 0:
-        request.session["session_score"] = (request.session["session_score"] +
-                                            to_add)
+        session["session_score"] = session["session_score"] + to_add
 
-        request.session["session_score_possible"] = \
-            (request.session["session_score_possible"] + possible)
+        session["session_score_possible"] =\
+            session["session_score_possible"] + possible
 
-    return request.session["session_score"], \
-        request.session["session_score_possible"]
+    return session["session_score"], session["session_score_possible"]
 
 
 def final_result_anon(request, quiz, previous):
@@ -280,7 +282,7 @@ def final_result_anon(request, quiz, previous):
     if score is 0:
         score = "0"
 
-    session_score, session_possible = anon_session_score(request)
+    session_score, session_possible = anon_session_score(request.session)
     del request.session[quiz.anon_q_list()]
 
     if quiz.answers_at_end is False:

diff --git a/true_false/models.py b/true_false/models.py
index fee27347467da973e4909caf011e35dc723c5314..8f594cae5e1b9e9b5b8cd28e5d0a9acad485fda5 100644 (file)
--- a/true_false/models.py
+++ b/true_false/models.py
@@ -23,9 +23,9 @@ class TF_Question(Question):
             return False
 
     def get_answers(self):
-        return [{'correct': self.check_if_correct('T'),
+        return [{'correct': self.check_if_correct("True"),
                  'content': 'True'},
-                {'correct': self.check_if_correct('F'),
+                {'correct': self.check_if_correct("False"),
                  'content': 'False'}]
 
     def get_answers_list(self):

diff --git a/true_false/tests.py b/true_false/tests.py
index 377371373a11c6e09675675b5ec8d3d22c71891d..ca08bba197e8ea2d12e64f251262067b7d6daa04 100644 (file)
--- a/true_false/tests.py
+++ b/true_false/tests.py
@@ -14,14 +14,14 @@ class TestTrueFalseQuestionModel(TestCase):
 
     def test_true_q(self):
         self.assertEqual(self.red.correct, True)
-        self.assertEqual(self.red.check_if_correct("T"), True)
-        self.assertEqual(self.red.check_if_correct("F"), False)
+        self.assertEqual(self.red.check_if_correct("True"), True)
+        self.assertEqual(self.red.check_if_correct("False"), False)
         self.assertEqual(self.red.check_if_correct("4"), False)
 
     def test_false_q(self):
         self.assertEqual(self.blue.correct, False)
-        self.assertEqual(self.blue.check_if_correct("T"), False)
-        self.assertEqual(self.blue.check_if_correct("F"), True)
+        self.assertEqual(self.blue.check_if_correct("True"), False)
+        self.assertEqual(self.blue.check_if_correct("False"), True)
 
     def test_get_answers(self):
         self.assertEqual(self.red.get_answers(),