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])

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

        rep_subject = "[Reminder] Please share your recent activities"

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

        eq_(mail_mock.call_count, 1)
        expected_call_list = [call(rep_subject, [rep.email], message=mockany)]
        eq_(mail_mock.call_args_list, expected_call_list)

    def test_different_current_longest_streak(self):
        today = now().date()
        past_day = now().date() - datetime.timedelta(days=30)
        user = UserFactory.create()
        # longest streak
        for i in range(0, 3):
            NGReportFactory.create(user=user, report_date=past_day - datetime.timedelta(days=i))

        # current streak
        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, past_day - datetime.timedelta(days=2))
        eq_(user.userprofile.longest_streak_end, past_day)

    def test_old_report_redirect(self):
        """Test old report url redirects to list of reports for that month."""
        user = UserFactory.create(groups=['Rep'])
        report_date = datetime.date(2011, 01, 05)
        NGReportFactory.create_batch(3, user=user, report_date=report_date)

        display_name = user.userprofile.display_name
        url = reverse('reports_ng_view_report',
                      kwargs={'display_name': display_name,
                              'month': 'January',
                              'year': 2011})
        response = self.get(url, follow=True)
        redirect_url = '/reports/rep/%s/?year=2011&month=January'
        self.assertRedirects(response, redirect_url % display_name)
        eq_(response.context['number_of_reports'], 3)

 def test_as_admin(self, redirect_mock):
     user = UserFactory.create(groups=['Admin'])
     report = NGReportFactory.create()
     report_comment = NGReportCommentFactory.create(report=report)
     self.post(user=user, url=report_comment.get_absolute_delete_url())
     ok_(not NGReportComment.objects.filter(pk=report_comment.id).exists())
     redirect_mock.assert_called_with(report.get_absolute_url())

 def test_get_remo_url(self):
     report = NGReportFactory.create()
     url = '/api/beta/activities/%s' % report.id
     request = RequestFactory().get(url)
     data = ActivitiesDetailedSerializer(
         report, context={'request': request}).data
     ok_(report.get_absolute_url() in data['remo_url'])