added test cases and fixed some issues related to posting of private questions and answers

6 files changed, 180 insertions, 48 deletions

diff --git a/askbot/models/__init__.py b/askbot/models/__init__.py
index f217b816..db9674e2 100644
--- a/askbot/models/__init__.py
+++ b/askbot/models/__init__.py
@@ -1730,14 +1730,15 @@ def user_edit_answer(
                 ):
     if force == False:
         self.assert_can_edit_answer(answer)
+
     answer.apply_edit(
-        edited_at = timestamp,
-        edited_by = self,
-        text = body_text,
-        comment = revision_comment,
-        wiki = wiki,
-        is_private = is_private,
-        by_email = by_email
+        edited_at=timestamp,
+        edited_by=self,
+        text=body_text,
+        comment=revision_comment,
+        wiki=wiki,
+        is_private=is_private,
+        by_email=by_email
     )
 
     answer.thread.invalidate_cached_data()
diff --git a/askbot/models/post.py b/askbot/models/post.py
index 609c4f9e..10b3cdc7 100644
--- a/askbot/models/post.py
+++ b/askbot/models/post.py
@@ -59,6 +59,15 @@ class PostQuerySet(models.query.QuerySet):
     #todo: we may not need this query set class,
     #as all methods on this class seem to want to
     #belong to Thread manager or Query set.
+    def get_for_user(self, user):
+        if askbot_settings.GROUPS_ENABLED:
+            if user is None or user.is_anonymous():
+                groups = [get_global_group()]
+            else:
+                groups = user.get_groups()
+            return self.filter(groups__in = groups).distinct()
+        else:
+            return self
 
     def get_by_text_query(self, search_query):
         """returns a query set of questions,
@@ -156,24 +165,16 @@ class PostManager(BaseQuerySetManager):
     def get_query_set(self):
         return PostQuerySet(self.model)
 
-    def get_questions(self):
-        return self.filter(post_type='question')
+    def get_questions(self, user=None):
+        questions = self.filter(post_type='question')
+        return questions.get_for_user(user)
 
-    def get_answers(self, user = None):
+    def get_answers(self, user=None):
         """returns query set of answer posts,
         optionally filtered to exclude posts of groups
         to which user does not belong"""
         answers = self.filter(post_type='answer')
-
-        if askbot_settings.GROUPS_ENABLED:
-            if user is None or user.is_anonymous():
-                groups = [get_global_group()]
-            else:
-                groups = user.get_groups()
-            answers = answers.filter(groups__in = groups).distinct()
-
-        return answers
-
+        return answers.get_for_user(user)
 
     def get_comments(self):
         return self.filter(post_type='comment')
@@ -1725,9 +1726,10 @@ class Post(models.Model):
         ##it is important to do this before __apply_edit b/c of signals!!!
         if self.is_private() != is_private:
             if is_private:
-                self.make_private(self.author)
+                #todo: make private for author or for the editor?
+                self.thread.make_private(self.author)
             else:
-                self.make_public()
+                self.thread.make_public(recursive=False)
 
         self.__apply_edit(
             edited_at=edited_at,
diff --git a/askbot/models/question.py b/askbot/models/question.py
index ef35f577..6c45f1eb 100644
--- a/askbot/models/question.py
+++ b/askbot/models/question.py
@@ -890,7 +890,8 @@ class Thread(models.Model):
             #if moderated - then author is guaranteed to be the
             #limited visibility enquirer
             published_answer_ids = self.posts.get_answers(
-                                        user=question_post.author#todo: may be > 1
+                                        user=question_post.author
+                                        #todo: may be > 1 user
                                     ).filter(
                                         deleted=False
                                     ).order_by(
@@ -905,9 +906,13 @@ class Thread(models.Model):
             #now put those answers first
             answer_map = dict([(answer.id, answer) for answer in answers])
             for answer_id in published_answer_ids:
-                answer = answer_map[answer_id]
-                answers.remove(answer)
-                answers.insert(0, answer)
+                #note that answer map may not contain answers publised
+                #to the question enquirer, because current user may
+                #not have access to that answer, so we use the .get() method
+                answer = answer_map.get(answer_id, None)
+                if answer:
+                    answers.remove(answer)
+                    answers.insert(0, answer)
 
         return (question_post, answers, post_to_author, published_answer_ids)
 
diff --git a/askbot/tests/question_views_tests.py b/askbot/tests/question_views_tests.py
index d6e64101..b1836f9e 100644
--- a/askbot/tests/question_views_tests.py
+++ b/askbot/tests/question_views_tests.py
@@ -28,7 +28,7 @@ class PrivateQuestionViewsTests(AskbotTestCase):
 
     def test_post_private_question(self):
         data = self.qdata
-        data['post_privately'] = 'true'
+        data['post_privately'] = 'checked'
         response1 = self.client.post(reverse('ask'), data=data)
         response2 = self.client.get(response1['location'])
         dom = BeautifulSoup(response2.content)
@@ -38,13 +38,28 @@ class PrivateQuestionViewsTests(AskbotTestCase):
         self.assertEqual(question.title, self.qdata['title'])
         self.assertFalse(get_global_group() in set(question.groups.all()))
 
+        #private question is not accessible to unauthorized users
+        self.client.logout()
+        response = self.client.get(question._question_post().get_absolute_url())
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response.content, '')
+        #private question link is not shown on the main page
+        #to unauthorized users
+        response = self.client.get(reverse('questions'))
+        self.assertFalse(self.qdata['title'] in response.content)
+        #private question link is not shown on the poster profile
+        #to the unauthorized users
+        response = self.client.get(self.user.get_profile_url())
+        self.assertFalse(self.qdata['title'] in response.content)
+
     def test_publish_private_question(self):
         question = self.post_question(user=self.user, is_private=True)
         title = question.thread.get_title()
         self.assertTrue(const.POST_STATUS['private'] in title)
         data = self.qdata
-        data['post_privately'] = 'false'
+        #data['post_privately'] = 'false'
         data['select_revision'] = 'false'
+        data['text'] = 'edited question text'
         response1 = self.client.post(
             reverse('edit_question', kwargs={'id':question.id}),
             data=data
@@ -53,15 +68,18 @@ class PrivateQuestionViewsTests(AskbotTestCase):
         dom = BeautifulSoup(response2.content)
         title = dom.find('h1').text
         self.assertTrue(get_global_group() in set(question.groups.all()))
-        #todo: fix this fail
         self.assertEqual(title, self.qdata['title'])
 
+        self.client.logout()
+        response = self.client.get(question.get_absolute_url())
+        self.assertTrue('edited question text' in response.content)
+
     def test_privatize_public_question(self):
-        question = self.post_question(user=self.user, is_private=True)
+        question = self.post_question(user=self.user)
         title = question.thread.get_title()
-        self.assertTrue(const.POST_STATUS['private'] in title)
+        self.assertFalse(const.POST_STATUS['private'] in title)
         data = self.qdata
-        data['post_privately'] = 'true'
+        data['post_privately'] = 'checked'
         data['select_revision'] = 'false'
         response1 = self.client.post(
             reverse('edit_question', kwargs={'id':question.id}),
@@ -74,16 +92,116 @@ class PrivateQuestionViewsTests(AskbotTestCase):
         self.assertTrue(const.POST_STATUS['private'] in title)
 
     def test_private_checkbox_is_on_when_editing_private_question(self):
-        pass
+        question = self.post_question(user=self.user, is_private=True)
+        response = self.client.get(
+            reverse('edit_question', kwargs={'id':question.id})
+        )
+        dom = BeautifulSoup(response.content)
+        checkbox = dom.find(
+            'input', attrs={'type': 'checkbox', 'name': 'post_privately'}
+        )
+        self.assertEqual(checkbox['checked'], 'checked')
 
     def test_private_checkbox_is_off_when_editing_public_question(self):
-        pass
+        question = self.post_question(user=self.user)
+        response = self.client.get(
+            reverse('edit_question', kwargs={'id':question.id})
+        )
+        dom = BeautifulSoup(response.content)
+        checkbox = dom.find(
+            'input', attrs={'type': 'checkbox', 'name': 'post_privately'}
+        )
+        self.assertEqual(checkbox.get('checked', False), False)
+
+
+class PrivateAnswerViewsTests(AskbotTestCase):
     
-    def test_private_answer(self):
-        pass
+    def setUp(self):
+        self._backup = askbot_settings.GROUPS_ENABLED
+        askbot_settings.update('GROUPS_ENABLED', True)
+        self.user = self.create_user('user')
+        group = models.Group.objects.create(
+            name='the group', openness=models.Group.OPEN
+        )
+        self.user.join_group(group)
+        self.question = self.post_question(user=self.user)
+        self.client.login(user_id=self.user.id, method='force')
+
+    def tearDown(self):
+        askbot_settings.update('GROUPS_ENABLED', self._backup)
+
+    def test_post_private_answer(self):
+        response1 = self.client.post(
+            reverse('answer', kwargs={'id': self.question.id}),
+            data={'text': 'some answer text', 'post_privately': 'checked'}
+        )
+        answer = self.question.thread.get_answers(user=self.user)[0]
+        self.assertFalse(get_global_group() in set(answer.groups.all()))
+        self.client.logout()
+
+        user2 = self.create_user('user2')
+        self.client.login(user_id=user2.id, method='force')
+        response = self.client.get(self.question.get_absolute_url())
+        self.assertFalse('some answer text' in response.content)
+
+        self.client.logout()
+        response = self.client.get(self.question.get_absolute_url())
+        self.assertFalse('some answer text' in response.content)
+
+    
+    def test_private_checkbox_is_on_when_editing_private_answer(self):
+        answer = self.post_answer(
+            question=self.question, user=self.user, is_private=True
+        )
+        response = self.client.get(
+            reverse('edit_answer', kwargs={'id': answer.id})
+        )
+        dom = BeautifulSoup(response.content)
+        checkbox = dom.find(
+            'input', attrs={'type': 'checkbox', 'name': 'post_privately'}
+        )
+        self.assertEqual(checkbox['checked'], 'checked')
+
+    def test_privaet_checkbox_is_off_when_editing_public_answer(self):
+        answer = self.post_answer(question=self.question, user=self.user)
+        response = self.client.get(
+            reverse('edit_answer', kwargs={'id': answer.id})
+        )
+        dom = BeautifulSoup(response.content)
+        checkbox = dom.find(
+            'input', attrs={'type': 'checkbox', 'name': 'post_privately'}
+        )
+        self.assertEqual(checkbox.get('checked', False), False)
 
     def test_publish_private_answer(self):
-        pass
+        answer = self.post_answer(
+            question=self.question, user=self.user, is_private=True
+        )
+        self.client.post(
+            reverse('edit_answer', kwargs={'id': answer.id}),
+            data={'text': 'edited answer text', 'select_revision': 'false'}
+        )
+        answer = self.reload_object(answer)
+        self.assertTrue(get_global_group() in answer.groups.all())
+        self.client.logout()
+        response = self.client.get(self.question.get_absolute_url())
+        self.assertTrue('edited answer text' in response.content)
+
 
     def test_privatize_public_answer(self):
-        pass
+        answer = self.post_answer(question=self.question, user=self.user)
+        self.client.post(
+            reverse('edit_answer', kwargs={'id': answer.id}),
+            data={
+                'text': 'edited answer text',
+                'post_privately': 'checked',
+                'select_revision': 'false'
+            }
+        )
+        #check that answer is not visible to the "everyone" group
+        answer = self.reload_object(answer)
+        self.assertFalse(get_global_group() in answer.groups.all())
+        #check that countent is not seen by an anonymous user
+        self.client.logout()
+        response = self.client.get(self.question.get_absolute_url())
+        self.assertFalse('edited answer text' in response.content)
diff --git a/askbot/views/users.py b/askbot/views/users.py
index 707f4e14..c22fd294 100644
--- a/askbot/views/users.py
+++ b/askbot/views/users.py
@@ -371,9 +371,15 @@ def user_stats(request, user, context):
     #
     # Questions
     #
-    questions = user.posts.get_questions().filter(**question_filter).\
-                    order_by('-points', '-thread__last_activity_at').\
-                    select_related('thread', 'thread__last_activity_by')[:100]
+    questions = user.posts.get_questions(
+                    user=request.user
+                ).filter(
+                    **question_filter
+                ).order_by(
+                    '-points', '-thread__last_activity_at'
+                ).select_related(
+                    'thread', 'thread__last_activity_by'
+                )[:100]
 
     #added this if to avoid another query if questions is less than 100
     if len(questions) < 100:
diff --git a/askbot/views/writers.py b/askbot/views/writers.py
index 8fcea796..db7a24d2 100644
--- a/askbot/views/writers.py
+++ b/askbot/views/writers.py
@@ -496,13 +496,13 @@ def edit_answer(request, id):
                     if form.has_changed():
                         user = form.get_post_user(request.user)
                         user.edit_answer(
-                                answer = answer,
-                                body_text = form.cleaned_data['text'],
-                                revision_comment = form.cleaned_data['summary'],
-                                wiki = form.cleaned_data.get('wiki', answer.wiki),
-                                is_private = form.cleaned_data.get('is_private', False)
-                                #todo: add wiki field to form
-                            )
+                            answer=answer,
+                            body_text=form.cleaned_data['text'],
+                            revision_comment=form.cleaned_data['summary'],
+                            wiki=form.cleaned_data.get('wiki', answer.wiki),
+                            is_private=form.cleaned_data.get('post_privately', False)
+                            #todo: add wiki field to form
+                        )
                     return HttpResponseRedirect(answer.get_absolute_url())
         else:
             revision_form = forms.RevisionForm(answer, revision)