Exemple #1
0
    def test_mod_two_cant_see_rejected_responses(self):
        self.client.force_login(BypassStaffModerationUserFactory())
        response = ResponseFactory(approved=False, author=UserFactory(username="******"))
        ModerationFactory(
            response=response,
            addressing_the_issue=False,
            personal=False,
            positive_in_tone=False,
            moderator=UserFactory(username="******"),
        )
        ModerationFactory(
            response=response,
            addressing_the_issue=False,
            personal=False,
            positive_in_tone=False,
            moderator=UserFactory(username="******"),
        )
        ModerationFactory(
            response=response,
            addressing_the_issue=False,
            personal=False,
            positive_in_tone=False,
            moderator=UserFactory(username="******"),
        )

        result = self.client.get("/api/response/")
        self.assertEqual(result.status_code, 200)
        self.assertEqual(len(result.json()["results"]), 0)
 def test_current_count(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory.create_batch(
         response=response, positive_in_tone=True, size=11
     )
     ModerationFactory.create_batch(
         response=response, positive_in_tone=False, size=5
     )
     self.assertEquals(self.user.profile.profile_stats["current_count"], 16)
    def test_required_moderations(self):
        user1 = UserFactory(username="******")
        user2 = UserFactory(username="******")

        ModerationFactory(response=ResponseFactory(), moderator=user1)
        ModerationFactory(response=ResponseFactory(), moderator=user1)
        ModerationFactory(response=ResponseFactory(), moderator=user2)

        result = Command().active_contributors(required_responses=0,
                                               required_moderations=2,
                                               period=timedelta(hours=1))
        self.assertEqual(result, 1)
Exemple #4
0
    def setUp(self):
        self.user = UserFactory()
        self.user.set_password('password')
        self.user.save()

        response = ResponseFactory(author=self.user)
        ModerationFactory.create_batch(response=response,
                                       positive_in_tone=True,
                                       size=11)

        # Login
        self.client.login(username=self.user.username, password='******')
    def test_cant_see_reject_responses(self):
        response = ResponseFactory(approved=False, author=UserFactory(username="******"))
        ModerationFactory(response=response, addressing_the_issue=False, personal=False, positive_in_tone=False,
                          moderator=UserFactory(username="******"))
        ModerationFactory(response=response, addressing_the_issue=False, personal=False, positive_in_tone=False,
                          moderator=UserFactory(username="******"))
        ModerationFactory(response=response, addressing_the_issue=False, personal=False, positive_in_tone=False,
                          moderator=UserFactory(username="******"))

        result = self.client.get('/api/response/')
        self.assertEqual(result.status_code, 200)
        self.assertEqual(len(result.json()['results']), 0)
 def test_third_moderation(self):
     self.assertEqual(self.user.profile.karma_points, 0)
     response = ResponseFactory(approved=False, author=UserFactory(username="******"))
     ModerationFactory(response=response)
     ModerationFactory(response=response)
     self.assertEqual(response.moderation_count(), 2)
     result = self.client.post(
         reverse("create_moderation", kwargs={"response_pk": response.pk}),
         data=dict(positive_in_tone=True, addressing_the_issue=True, personal=True),
     )
     self.assertEqual(result.status_code, 201)
     self.user.profile.refresh_from_db()
     self.assertEqual(self.user.profile.karma_points, 3)
     self.assertEqual(response.author.profile.karma_points, 1)
    def test_mod_two_can_see_approved_responses(self):
        self.client.force_login(BypassStaffModerationUserFactory())
        response = ResponseFactory(approved=False, author=UserFactory(username="******"))
        ModerationFactory(response=response, moderator=UserFactory(username="******"))
        ModerationFactory(response=response, moderator=UserFactory(username="******"))
        ModerationFactory(response=response, moderator=UserFactory(username="******"))
        response.refresh_from_db()
        self.assertTrue(response.is_community_approved())

        ResponseFactory(approved=True, author=UserFactory(username="******"))
        ResponseFactory(approved=True, staff_approved=True, author=UserFactory(username="******"))
        result = self.client.get('/api/response/')
        self.assertEqual(result.status_code, 200)
        self.assertEqual(len(result.json()['results']), 2)
 def test_previous_count(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory.create_batch(
         response=response,
         positive_in_tone=True,
         size=11,
         submitted_at=now() - timedelta(days=10),
     )
     ModerationFactory.create_batch(
         response=response,
         positive_in_tone=False,
         size=5,
         submitted_at=now() - timedelta(days=11),
     )
     self.assertEquals(self.user.profile.profile_stats["previous_count"], 16)
    def test_is_staff_approved_after_moderation_by_mod_two(self):
        response = ResponseFactory(approved=False, author=UserFactory(username="******"))
        ModerationFactory(response=response, positive_in_tone=True)
        ModerationFactory(response=response, positive_in_tone=True)

        self.client.force_login(BypassStaffModerationUserFactory())
        result = self.client.post(
            reverse("create_moderation", kwargs={"response_pk": response.pk}),
            data=dict(positive_in_tone=True, addressing_the_issue=True, personal=True),
        )

        self.assertEqual(result.status_code, 201)

        response.refresh_from_db()
        self.assertTrue(response.approved)
        self.assertTrue(response.staff_approved)
    def test_moderations_outside_period(self):
        ModerationFactory(response=ResponseFactory(),
                          submitted_at=timezone.now() - timedelta(hours=2))

        result = Command().active_contributors(required_responses=0,
                                               required_moderations=1,
                                               period=timedelta(hours=1))
        self.assertEqual(result, 0)
Exemple #11
0
    def test_is_rejected_after_negative_moderations(self,
                                                    mock_reply_to_review):
        response = ResponseFactory(approved=False,
                                   author=UserFactory(username="******"))
        # TODO: I don't think these ModerationFactories should be required - once a review has a moderation
        # failing on all three counts, it won't meet the approved criteria and should be immediately rejected, no?
        ModerationFactory(response=response)
        ModerationFactory(response=response)

        result = self.client.post(
            reverse("create_moderation", kwargs={"response_pk": response.pk}),
            data=dict(positive_in_tone=False,
                      addressing_the_issue=False,
                      personal=False),
        )

        response.refresh_from_db()
        self.assertEqual(result.status_code, 201)
        self.assertTrue(response.rejected)
Exemple #12
0
    def test_third_approval(self):
        user = BypassCommunityModerationUserFactory()
        self.client.force_login(user)
        self.assertEqual(user.profile.karma_points, 0)

        author = UserFactory(username="******")
        response = ResponseFactory(approved=False, author=author)
        ModerationFactory(response=response)
        ModerationFactory(response=response)

        result = self.client.post(
            reverse('approve', kwargs={"response_pk": response.pk}))
        self.assertEqual(result.status_code, 200)

        user.profile.refresh_from_db()
        author.profile.refresh_from_db()

        self.assertEqual(user.profile.karma_points, 3)
        self.assertEqual(author.profile.karma_points, 1)
 def test_personal_change(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory.create_batch(
         response=response,
         personal=True,
         size=10,
         submitted_at=now() - timedelta(days=10),
     )
     ModerationFactory.create_batch(response=response, personal=True, size=5)
     ModerationFactory.create_batch(response=response, personal=False, size=5)
     self.assertEquals(self.user.profile.profile_stats["personal_change"], -0.5)
    def test_addressing_the_issue_change(self):
        response = ResponseFactory(author=self.user)
        ModerationFactory.create_batch(
            response=response, addressing_the_issue=True, size=11
        )
        ModerationFactory.create_batch(
            response=response, addressing_the_issue=False, size=5
        )

        ModerationFactory.create_batch(
            response=response,
            addressing_the_issue=True,
            size=10,
            submitted_at=now() - timedelta(days=10),
        )
        self.assertEquals(
            self.user.profile.profile_stats["addressing_the_issue_change"], 0.1
        )
 def test_positive_in_tone_count(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory(response=response, positive_in_tone=True)
     self.assertEquals(self.user.profile.profile_stats["positive_in_tone_count"], 1)
 def test_personal_count(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory(response=response, personal=True)
     self.assertEquals(self.user.profile.profile_stats["personal_count"], 1)
 def test_addressing_the_issue_count(self):
     response = ResponseFactory(author=self.user)
     ModerationFactory(response=response, addressing_the_issue=True)
     self.assertEquals(
         self.user.profile.profile_stats["addressing_the_issue_count"], 1
     )