def test_get_projects_work_hours_and_percentage_should_return_dictionary_containing_with_work_time_and_time_percent_per_project( self): ReportFactory(author=self.user, project=self.project_1, work_hours=timezone.timedelta(hours=8)) ReportFactory(author=self.user, project=self.project_2, work_hours=timezone.timedelta(hours=4)) ReportFactory(author=self.user, project=self.project_2, work_hours=timezone.timedelta(hours=8)) ReportFactory(project=self.project_1, work_hours=timezone.timedelta(hours=4)) result = ProjectsWorkPercentageMixin( )._get_projects_work_hours_and_percentage(self.user.report_set.all()) self.assertEqual(len(result), 2) self.assertEqual( result, { self.project_1.name: (timezone.timedelta(hours=8), 40.0), self.project_2.name: (timezone.timedelta(hours=12), 60.0), }, )
def setUp(self): super().setUp() self.date_1 = datetime.datetime.now().date() self.date_2 = self.date_1 - datetime.timedelta(days=1) ReportFactory(work_hours=datetime.timedelta(hours=6), date=self.date_1) ReportFactory(work_hours=datetime.timedelta(hours=7), date=self.date_1) ReportFactory(work_hours=datetime.timedelta(hours=5), date=self.date_2)
def test_project_report_list_view_should_display_inactive_members_reports(self): current_date = datetime.datetime.now().date() previous_date = current_date + relativedelta(months=-1) inactive_user = UserFactory(is_active=False) project_report = ReportFactory( author=inactive_user, date=current_date, project=self.project, description="This is for current project." ) other_project_report = ReportFactory( author=inactive_user, date=current_date, description="This is for other project." ) project_report_from_other_month = ReportFactory( author=inactive_user, date=previous_date, project=self.project, description="This is for another month." ) response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertContains(response, project_report.description) self.assertNotContains(response, other_project_report.description) self.assertNotContains(response, project_report_from_other_month.description) response = self.client.get( reverse( "project-report-list", kwargs={"pk": self.project.pk, "year": previous_date.year, "month": previous_date.month}, ) ) self.assertEqual(response.status_code, 200) self.assertNotContains(response, project_report.description) self.assertNotContains(response, other_project_report.description) self.assertContains(response, project_report_from_other_month.description)
def setUp(self): super().setUp() self.user = AdminUserFactory() self.task_activity = TaskActivityTypeFactory() self.project = ProjectFactory() self.project.members.add(self.user) self.client.force_login(self.user) self.report = ReportFactory(author=self.user, project=self.project, task_activity=self.task_activity) self.url = reverse("project-report-detail", args=(self.report.pk, )) self.data = { "date": self.report.date, "description": self.report.description, "project": self.report.project.pk, "author": self.report.author.pk, "task_activity": self.task_activity.pk, "work_hours": self.report.work_hours_str, "current-project-pk": self.report.project.pk, } self.expected_success_message = SuccessPopUpMessages.REPORT_UPDATE_BY_ADMIN.value.format( report_author_email=self.report.author.email, report_date=self.report.date, project_name=self.report.project.name, )
def _generate_user_reports_for_current_and_previous_month_with_uneven_total_hours( self): reports_per_project, remaining_hours = self._strip_hours_between_projects( ) months_and_reported_days = self._get_number_of_reported_days_for_each_month( reports_per_project) for start_date, total_reported_days in months_and_reported_days.items( ): total_reported_days = reports_per_project report_date = start_date for _ in range(total_reported_days): work_hours = timezone.timedelta(hours=self.hours_per_report) for project in self.projects: ReportFactory(project=project, author=self.user, work_hours=work_hours, date=report_date) report_date += relativedelta(days=1) if remaining_hours != 0: ReportFactory( project=self.projects[0], author=self.user, work_hours=timezone.timedelta(hours=remaining_hours), date=report_date, )
def setUp(self): super().setUp() self.author_1 = UserFactory() self.author_2 = UserFactory() ReportFactory(work_hours=datetime.timedelta(hours=6), author=self.author_1) ReportFactory(work_hours=datetime.timedelta(hours=7), author=self.author_2) ReportFactory(work_hours=datetime.timedelta(hours=5), author=self.author_2)
def test_view_should_display_author_reports_only_one_project(self): admin = AdminUserFactory() report_from_project1 = ReportFactory(author=self.user, project=self.project, date=self.report.date) report_from_other_project = ReportFactory(author=self.user) self.client.force_login(admin) response = self.client.get(self.url) self.assertContains(response, self.report.description) self.assertContains(response, report_from_project1.description) self.assertContains(response, report_from_project1.project.name) self.assertNotContains(response, report_from_other_project.description) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, AuthorReportProjectView.template_name)
def test_custom_report_list_view_should_not_display_reports_from_different_month_than_selected(self): current_date = datetime.datetime.now().date() other_report = ReportFactory( date=current_date + relativedelta(months=+1), author=self.user, project=self.report.project ) yet_another_report = ReportFactory( date=current_date + relativedelta(years=-1), author=self.user, project=self.report.project ) response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertNotContains(response, other_report.description) self.assertNotContains(response, yet_another_report.description)
def test_user_is_author_of_current_report_mixin_should_not_limit_view_report_queryset_if_user_is_not_employee( self): user = UserFactory(user_type=CustomUser.UserType.MANAGER.name) ReportFactory(author=user) # Other author report. ReportFactory() assert Report.objects.count() == 2 request = self.request_factory.get("anything") request.user = user response = self.view(request) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.context_data["object_list"]), 2)
def setUp(self): super().setUp() self.task_type = TaskActivityType(pk=1, name="Other") self.task_type.save() self.user = AdminUserFactory() self.project = ProjectFactory() self.project.members.add(self.user) self.client.force_login(self.user) current_date = datetime.datetime.now().date() self.report = ReportFactory( author=self.user, project=self.project, date=current_date, task_activity=self.task_type, work_hours=datetime.timedelta(hours=8), ) self.data = { "date": timezone.now().date(), "description": "Some other description", "project": self.report.project.pk, "author": self.user.pk, "task_activity": self.report.task_activity.pk, "work_hours": "8.00", } self.year = current_date.year self.month = current_date.month self.url = reverse( "project-report-list", kwargs={"pk": self.project.pk, "year": self.year, "month": self.month} )
def test_user_is_manager_of_current_project_or_author_of_current_report_mixin_should_not_limit_view_project_queryset_if_user_is_not_manager( self): user = UserFactory(user_type=CustomUser.UserType.EMPLOYEE.name) report = ReportFactory() report.project.managers.add(user) # Report with project without current user as manager. ReportFactory() assert Report.objects.count() == 2 request = self.request_factory.get("anything") request.user = user response = self.view(request) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.context_data["object_list"]), 2)
def setUp(self): super().setUp() self.user = AdminUserFactory() self.new_user = AdminUserFactory() self.other_project = ProjectFactory() self.project_start_date = timezone.now() + timezone.timedelta(days=-1) self.project = ProjectFactory( name="aaa", start_date=self.project_start_date, stop_date=timezone.now() + timezone.timedelta(days=6) ) self.report = ReportFactory(author=self.user, project=self.project) self.project.members.add(self.user) self.data = {"project": self.project.pk, "author": self.user.pk} self.url_single_user = reverse( "export-data", kwargs={ "pk": self.user.pk, "year": str(self.report.creation_date.year), "month": str(self.report.creation_date.month), }, ) self.url_project = reverse( "export-project-reports", kwargs={ "pk": self.data["project"], "year": str(self.report.creation_date.year), "month": str(self.report.creation_date.month), }, ) self.workbook_for_project = generate_xlsx_for_project(self.project) self.workbook_for_user = generate_xlsx_for_single_user(self.user)
def setUp(self): self.user = UserFactory() self.client.force_login(self.user) self.task_activity = TaskActivityTypeFactory() self.report = ReportFactory( author=self.user, date=datetime.datetime.now().date(), task_activity=self.task_activity, work_hours=datetime.timedelta(hours=8), ) self.report.project.members.add(self.user) self.url = reverse( "join-project", kwargs={ "year": datetime.datetime.now().date().year, "month": datetime.datetime.now().date().month }, ) self.success_url = reverse( "custom-report-list", kwargs={ "year": datetime.datetime.now().date().year, "month": datetime.datetime.now().date().month }, ) self.new_project = ProjectFactory(name="New Project", start_date=datetime.datetime.now())
def test_manager_should_not_get_any_notification_about_missing_reports(self, test_date): with freeze_time("2019-07-05"): ReportFactory(author=self.employee, project=self.project, date="2019-07-05") self.client.force_login(self.manager) with freeze_time(test_date): response = self.client.get(self.url) self._check_response(response, 200, [UserNotificationsText.NO_MORE_NOTIFICATIONS.value])
def test_manager_should_only_get_notifications_about_employees_from_his_projects(self): with freeze_time("2019-07-08"): ReportFactory(date="2019-07-08") self.client.force_login(self.manager) with freeze_time("2019-07-15"): response = self.client.get(self.url) self._check_response(response, 200, [UserNotificationsText.NO_MORE_NOTIFICATIONS.value])
def test_initial_date_should_be_highest_report_date_for_user_for_last_report_date_preference( self): user_preferences = CustomUserPreferences.objects.get(user=self.user) user_preferences.default_report_date = DatePreferences.LAST_REPORT_DATE.name user_preferences.save() highest_date = timezone.now().date() + relativedelta(days=+100) ReportFactory(author=self.user, date=timezone.now().date() + relativedelta(days=+10)) ReportFactory(author=self.user, date=highest_date) ReportFactory(author=self.user, date=timezone.now().date() + relativedelta(days=-100)) response = self.client.get(self.url) initial_date = response.context["form"].initial["date"] self.assertEqual(initial_date, highest_date)
def test_get_project_ordered_by_last_report_creation_date_should_not_include_other_users_reports( self): # Create report from other user in the same project ReportFactory(project=self.project_3) result = list( self.user.get_project_ordered_by_last_report_creation_date()) self.assertEqual(result, [self.project_2, self.project_1, self.project_3])
def test_manager_should_get_notification_about_missing_reports(self, test_date, missing_reports): with freeze_time("2019-07-08"): ReportFactory(author=self.employee, project=self.project, date="2019-07-08") self.client.force_login(self.manager) with freeze_time(test_date): response = self.client.get(self.url) self._check_response(response, 200, [self.employee.email, missing_reports])
def test_project_work_percentage_mixin_should_pass_work_hours_summary_to_report_list_view( self): class TestView(ProjectsWorkPercentageMixin, ListView): model = Report report_1 = ReportFactory() report_2 = ReportFactory() response = TestView.as_view()(self.request) self.assertEqual(response.status_code, 200) self.assertTrue( "projects_work_percentage" in response.context_data.keys()) projects_work_percentage = response.context_data[ "projects_work_percentage"] self.assertTrue(report_1.project.name in projects_work_percentage) self.assertTrue(report_2.project.name in projects_work_percentage)
def test_manager_should_not_get_get_notifications_about_inactive_employees(self): inactive_user = UserFactory(is_active=False) with freeze_time("2019-07-08"): ReportFactory(author=inactive_user, project=self.project, date="2019-07-08") self.client.force_login(self.manager) with freeze_time("2019-07-15"): response = self.client.get(self.url) self._check_response(response, 200, [UserNotificationsText.NO_MORE_NOTIFICATIONS.value])
def create_report(self, user: Any, report_publication_date: timezone.datetime, number_of_reports: int) -> None: ReportFactory( date=report_publication_date, description=FuzzyText(length=random.randrange(20, 100)), author=user, project=self._pick_random_user_project(user), work_hours=self._get_random_work_hours(number_of_reports), task_activity=self.pick_random_task_activity(), )
def test_initial_date_should_be_today_for_always_today_preference( self, report_date): user_preferences = CustomUserPreferences.objects.get(user=self.user) user_preferences.default_report_date = DatePreferences.TODAY.name user_preferences.save() ReportFactory(author=self.user, date=report_date) self._assert_initial_date_equal_today()
def test_custom_report_list_view_should_display_monthly_hour_sum_in_hour_format(self): report_date = timezone.datetime(year=timezone.now().year, month=timezone.now().month, day=1) for i in range(3): ReportFactory( author=self.user, date=report_date + timezone.timedelta(days=i), work_hours=timezone.timedelta(hours=8) ) response = self.client.get(self.url) self.assertContains(response, "32:00") self.assertNotContains(response, str(timezone.timedelta(hours=32)))
def test_author_report_list_view_should_link_to_admin_report_detail_if_user_is_author(self): report = ReportFactory(date=self.current_time) response = self.client.get( reverse( "author-report-list", kwargs={"pk": report.author.pk, "year": self.current_time.year, "month": self.current_time.month}, ) ) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, AuthorReportView.template_name) self.assertContains(response, reverse("admin-report-detail", kwargs={"pk": report.pk}))
def test_initial_date_should_be_date_of_recently_created_report_for_recently_created_report_date_preference( self, report_date): user_preferences = CustomUserPreferences.objects.get(user=self.user) user_preferences.default_report_date = DatePreferences.RECENTLY_CREATED_REPORT_DATE.name user_preferences.save() ReportFactory(author=self.user, date=report_date) response = self.client.get(self.url) initial_date = response.context["form"].initial["date"] self.assertEqual(initial_date, report_date)
def test_manager_should_not_get_any_notifications_if_they_are_disabled_for_project(self): self.project.is_notification_enabled = False self.project.save() with freeze_time("2019-07-08"): ReportFactory(author=self.employee, project=self.project, date="2019-07-08") self.client.force_login(self.manager) with freeze_time("2019-07-15"): response = self.client.get(self.url) self._check_response(response, 200, [UserNotificationsText.NO_MORE_NOTIFICATIONS.value])
def test_custom_report_detail_view_should_return_only_one_report_when_are_more_than_one_managers_in_project( self): manager_1 = ManagerUserFactory() manager_2 = ManagerUserFactory() self.report.project.managers.add(manager_1) self.report.project.managers.add(manager_2) report_1 = ReportFactory(author=manager_1, project=self.report.project) self.client.force_login(manager_1) response = self.client.get( path=reverse("custom-report-detail", args=(report_1.pk, ))) self.assertEqual(response.status_code, 200) self.assertContains(response, report_1.description)
def test_custom_report_detail_view_should_show_data_from_current_report_not_from_latest_report( self): # Latest report ReportFactory(author=self.user) response = self.client.get( path=reverse("custom-report-detail", args=(self.report.pk, ))) self.assertEqual(response.status_code, 200) self.assertEqual( response.context_data["form"].initial["task_activity"], self.report.task_activity) self.assertEqual(response.context_data["form"].initial["project"], self.report.project)
def test_manager_should_be_able_to_update_his_reports_in_project_in_which_he_is_not_manager( self): user_manager = ManagerUserFactory() self.client.force_login(user_manager) report_manager = ReportFactory(author=user_manager, task_activity=self.task_activity) report_manager.project.members.add(user_manager) data = { "date": report_manager.date, "description": "report_manager other description", "project": report_manager.project.pk, "author": report_manager.author.pk, "task_activity": self.task_activity.pk, "work_hours": report_manager.work_hours_str, } response = self.client.post(path=reverse("custom-report-detail", args=(report_manager.pk, )), data=data) report_manager.refresh_from_db() self.assertEqual(response.status_code, 302) self.assertEqual(report_manager.description, data["description"])
def setUp(self): super().setUp() self.employee1 = UserFactory(first_name="Cezar", last_name="Goldstein") self.employee2 = UserFactory(first_name="", last_name="", email="*****@*****.**") self.employee3 = UserFactory(first_name="Abimelek", last_name="Zuckerberg") self.manager = ManagerUserFactory() self.project = ProjectFactory() self.project.members.add(self.employee1) self.project.members.add(self.employee2) self.project.members.add(self.employee3) reports_in_day = 2 # creating reports in desc order number_of_days = 4 self.year = "2019" self.month = "06" for i in range(number_of_days, 0, -1): for _ in range(reports_in_day): ReportFactory(author=self.employee2, project=self.project, date=f"{self.year}-{self.month}-{i}") ReportFactory(author=self.employee3, project=self.project, date=f"{self.year}-{self.month}-{i}") ReportFactory(author=self.employee1, project=self.project, date=f"{self.year}-{self.month}-{i}") self.report_asc = Report.objects.filter(author__id=self.employee1.pk).order_by("date") self.reports_per_user = reports_in_day * number_of_days