Python tests.NGReportFactory类代码示例

 def test_get_last_ten_weeks_reports(self):
     user = UserFactory.create()
     # Add 4 reports more than a day apart
     for i in range(8, 0, -2):
         NGReportFactory.create(user=user, report_date=(now().date() - timedelta(days=i)))
     # Get the reports added in the last 10 weeks
     eq_(count_user_ng_reports(user, period=10), 4)

    def test_longest_streak(self, mocked_date):
        """Update current and longest streak counters when the fourth
        report out of five is deleted.
        """

        mocked_date.return_value = datetime.date(2011, 01, 29)
        user = UserFactory.create()
        up = user.userprofile
        start_date = datetime.date(2011, 01, 01)
        end_date = datetime.date(2011, 01, 29)
        # Create 5 reports
        for i in range(0, 5):
            NGReportFactory.create(
                user=user,
                report_date=end_date - datetime.timedelta(weeks=i))

        eq_(up.current_streak_start, start_date)
        eq_(up.longest_streak_start, start_date)
        eq_(up.longest_streak_end, end_date)

        # Delete the report that the user submitted on 22-01-2012
        NGReport.objects.filter(
            user=user,
            report_date=datetime.date(2011, 01, 22)).delete()

        user = User.objects.get(pk=user.id)
        up = user.userprofile
        eq_(up.current_streak_start, end_date)
        eq_(up.longest_streak_start, start_date)
        eq_(up.longest_streak_end, datetime.date(2011, 01, 15))

 def test_get_last_report_future(self):
     past_date = now().date() - timedelta(weeks=5)
     future_date = now().date() + timedelta(weeks=2)
     user = UserFactory.create(groups=["Rep"])
     NGReportFactory.create(user=user, report_date=past_date)
     NGReportFactory.create(user=user, report_date=future_date)
     eq_(get_last_report(user).report_date, past_date)

 def test_current_streak(self):
     user = UserFactory.create()
     # Add a report every 22 hours for the last 4 days (5 reports)
     for i in range(0, 4):
         NGReportFactory.create(user=user,
                                report_date=(now().date() -
                                             timedelta(days=i)))
     eq_(count_user_ng_reports(user, current_streak=True), 4)

    def test_current_streak_counter_with_past_reports(self):
        past_day = now().date() - datetime.timedelta(days=30)

        user = UserFactory.create()
        for i in range(0, 5):
            NGReportFactory.create(user=user, report_date=past_day - datetime.timedelta(days=i))

        ok_(not user.userprofile.current_streak_start)

    def test_no_current_streak(self):
        user = UserFactory.create(groups=['Rep'])
        for i in range(4):
            report_date = date(2011, 01, 01) + timedelta(weeks=i)
            NGReportFactory.create(user=user, report_date=report_date)

        calculate_longest_streaks()
        eq_(user.userprofile.longest_streak_start, date(2011, 01, 01))
        eq_(user.userprofile.longest_streak_end, date(2011, 01, 22))

    def test_with_report_filled(self):
        mentor = UserFactory.create(groups=["Mentor"])
        today = now().date()
        rep = UserFactory.create(groups=["Rep"], userprofile__mentor=mentor)
        NGReportFactory.create(user=rep, report_date=today - timedelta(weeks=2))

        with patch("remo.reports.utils.send_remo_mail") as mail_mock:
            send_second_report_notification()
        ok_(not mail_mock.called)

    def test_current_longest_streak(self):
        today = now().date()
        user = UserFactory.create()

        for i in range(0, 2):
            NGReportFactory.create(user=user, report_date=today - datetime.timedelta(days=i))

        eq_(user.userprofile.current_streak_start, today - datetime.timedelta(days=1))
        eq_(user.userprofile.longest_streak_start, today - datetime.timedelta(days=1))
        eq_(user.userprofile.longest_streak_end, today)

    def test_base(self):
        past_day = get_date(-8)
        user = UserFactory.create(groups=['Rep'])
        NGReportFactory.create(user=user, report_date=past_day)
        user.userprofile.current_streak_start = past_day
        user.userprofile.save()

        zero_current_streak()
        user = User.objects.get(pk=user.id)

        ok_(not user.userprofile.current_streak_start)

 def test_rep_functional_area_list(self):
     user = UserFactory.create(groups=['Rep'])
     functional_area = FunctionalAreaFactory.create()
     report = NGReportFactory.create(user=user,
                                     functional_areas=[functional_area])
     NGReportFactory.create(functional_areas=[functional_area])
     url = reverse('list_ng_reports_rep_functional_area',
                   kwargs={'functional_area_slug': functional_area.slug,
                           'rep': user.userprofile.display_name})
     response = self.get(url=url)
     eq_(set(response.context['reports'].object_list), set([report]))

    def test_longest_streak(self):
        user = UserFactory.create()
        past_day = now().date() - timedelta(days=30)
        # Add 7 continuous reports somewhere in the past
        for i in range(0, 7):
            NGReportFactory.create(user=user, report_date=(past_day - timedelta(days=i)))

        # Add a report, one each day for the last 4 days (6 reports)
        for i in range(0, 3):
            NGReportFactory.create(user=user, report_date=(now().date() - timedelta(days=i)))
        eq_(count_user_ng_reports(user, longest_streak=True), 7)

    def test_with_no_report_filled_and_one_notification(self):
        mentor = UserFactory.create(groups=['Mentor'])
        today = datetime.utcnow().date()
        rep = UserFactory.create(
            groups=['Rep'], userprofile__mentor=mentor,
            userprofile__last_report_notification=today - timedelta(weeks=1))
        NGReportFactory.create(user=rep,
                               report_date=today - timedelta(weeks=2))

        with patch('remo.reports.tasks.send_mail') as send_mail_mock:
            send_ng_report_notification()
        ok_(not send_mail_mock.called)

    def test_user_new_future_activity(self):
        report_notification = now().date() - datetime.timedelta(weeks=3)
        new_report_date = now().date() + datetime.timedelta(weeks=6)

        rep = UserFactory.create(
            groups=['Rep'],
            userprofile__first_report_notification=report_notification
        )
        NGReportFactory.create(user=rep, report_date=new_report_date)

        user = User.objects.get(pk=rep.id)
        eq_(user.userprofile.first_report_notification, report_notification)

    def test_with_user_unavailable(self):
        mentor = UserFactory.create(groups=["Mentor"])
        today = now().date()
        rep = UserFactory.create(
            groups=["Rep"], userprofile__mentor=mentor, userprofile__date_joined_program=get_date(days=-100)
        )
        UserStatusFactory.create(user=rep)
        NGReportFactory.create(user=rep, report_date=today - timedelta(weeks=5))

        with patch("remo.reports.utils.send_remo_mail") as mail_mock:
            send_first_report_notification()

        ok_(not mail_mock.called)

    def test_base(self):
        mentor_1 = UserFactory.create(groups=['Mentor'])
        NGReportFactory.create_batch(2, mentor=mentor_1)
        NGReport.objects.update(created_on=date(2014, 1, 1))
        UserFactory.create(groups=['Mentor'])

        with patch('remo.reports.tasks.datetime') as datetime_mock:
            datetime_mock.utcnow().date.return_value = datetime(2014, 1, 1)
            with patch('remo.reports.tasks.send_mail') as send_mail_mock:
                with patch('remo.reports.tasks.DIGEST_SUBJECT', '{date}'):
                    send_report_digest()

        send_mail_mock.assert_called_with(
            'Wed 01 Jan 2014', mockany, settings.FROM_EMAIL, [mentor_1.email])