def setUp(self) -> None: ProjectFactory(start_date=timezone.now(), suspended=True) ProjectFactory( start_date=timezone.now() - timezone.timedelta(days=2), stop_date=timezone.now() - timezone.timedelta(days=1), ) ProjectFactory(start_date=timezone.now())
class RemoveUserFromProjectTests(TestCase): def setUp(self) -> None: self.number_of_reports = 6 self.project = ProjectFactory(name="Test project") self.user = UserFactory() self.project.members.add(self.user) self._generate_user_reports() def test_that_removing_user_from_project_should_not_delete_user_reports_made_for_project( self): user_reports = Report.objects.filter(author=self.user, project=self.project) self.assertIn(self.user, self.project.members.all()) self._check_number_of_reports(user_reports) self.project.members.remove(self.user) self.project.refresh_from_db() self.assertNotIn(self.user, self.project.members.all()) self._check_number_of_reports(user_reports) def _generate_user_reports(self): for _report_number in range(self.number_of_reports): ReportFactory(author=self.user, project=self.project) def _check_number_of_reports(self, user_reports): self.assertEqual(user_reports.count(), self.number_of_reports) self.assertEqual(Report.objects.all().count(), self.number_of_reports)
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 setUp(self): self.admin = AdminUserFactory() self.employee = UserFactory() self.manager = ManagerUserFactory() self.project = ProjectFactory() self.project.managers.add(self.admin) self.project.managers.add(self.manager) self.project.members.add(self.employee) self.url = reverse("custom-users-notifications")
def setUp(self): super().setUp() self.project = ProjectFactory() self.url = reverse("custom-project-update", kwargs={"pk": self.project.pk}) self.data = { "name": "New Example Project Name", "start_date": self.project.start_date, "managers": [self.user.pk], "members": [self.user.pk], }
def setUp(self): self.user = ManagerUserFactory() project_1 = ProjectFactory() project_1.members.add(self.user) project_2 = ProjectFactory() project_2.managers.add(self.user) self.projects = [project_1, project_2] self.current_time = timezone.now() self.hours_per_report = 4 self.total_hours = 160 self._generate_user_reports_for_current_and_previous_month_with_uneven_total_hours( ) self.expected_work_hours_stats = self._get_total_hours_per_project_and_percentage_from_month( )
def test_custom_report_detail_view_should_not_update_report_if_author_is_not_a_member_of_selected_project( self): other_project = ProjectFactory() other_project.save() old_description = self.data["description"] self.data["description"] = "Some other description" old_project = self.data["project"] self.data["project"] = other_project.pk response = self.client.post(path=self.url, data=self.data) self.report.refresh_from_db() self.assertEqual(response.status_code, 200) self.assertIsNotNone(response.context_data["form"].errors) self.assertEqual(old_description, self.report.description) self.assertEqual(old_project, self.report.project.pk)
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 test_view_should_not_display_reports_for_any_other_managers(self): user = ManagerUserFactory() other_project = ProjectFactory() other_project.managers.add(user) self.client.force_login(user) response = self.client.get(self.url) self.assertEqual(response.status_code, 404)
def test_user_is_manager_of_current_project_mixin_should_not_limit_view_project_queryset_if_user_is_not_manager( self): user = UserFactory(user_type=CustomUser.UserType.EMPLOYEE.name) manager_project = ProjectFactory() manager_project.managers.add(user) # Project without current user as manager. ProjectFactory() assert Project.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 test_that_add_users_to_projects_function_should_add_number_of_users_to_projects_from_specified_range( self): projects_list = [] users_list = [] for _project_number in range(3): projects_list.append( ProjectFactory(start_date=timezone.now(), suspended=True)) for _user_number in range(15): users_list.append( UserFactory(user_type=CustomUser.UserType.EMPLOYEE.name)) max_number_of_users_to_add = 6 GenerateTestDataCommand().add_users_to_projects( users_list, projects_list, CustomUser.UserType.EMPLOYEE.name, ProjectType.SUSPENDED.name, max_number_of_users_to_add, ) self.assertTrue(Project.objects.all()[0].members.count() in range( 0, max_number_of_users_to_add + 1)) self.assertTrue(Project.objects.all()[1].members.count() in range( 0, max_number_of_users_to_add + 1)) self.assertTrue(Project.objects.all()[2].members.count() in range( 0, max_number_of_users_to_add + 1))
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 setUp(self): super().setUp() self.user_admin = AdminUserFactory() self.client.force_login(self.user_admin) self.project = ProjectFactory() self.task_activity = TaskActivityTypeFactory() self.url = reverse("task-activities")
def _generate_test_projects(number_of_projects_to_fill_database, project_type): project_list = [] for _ in range(number_of_projects_to_fill_database): if project_type == ProjectType.SUSPENDED.name: project = ProjectFactory(suspended=True) elif project_type == ProjectType.ACTIVE.name: project = ProjectFactory() elif project_type == ProjectType.COMPLETED.name: project = ProjectFactory(stop_date=timezone.now() - relativedelta(days=1)) else: raise UnsupportedProjectTypeException project_list.append(project) return project_list
def test_custom_report_detail_view_should_contains_in_project_field_all_project_related_with_user( self): other_user_project = ProjectFactory() other_user_project.members.add(self.user) response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertCountEqual( self.user.projects.all(), response.context_data["form"].fields["project"].queryset)
def test_filter_completed_projects_should_return_all_projects_with_stop_date_less_than_current_date( self): project_not_completed = ProjectFactory() self.project.stop_date = timezone.now() - timezone.timedelta(days=1) self.project.save() completed_projects = Project.objects.filter_completed() self.assertIn(self.project, completed_projects) self.assertNotIn(project_not_completed, completed_projects)
def test_projects_list_view_for_manager_should_show_only_projects_in_which_he_is_manager( self): manager_user = UserFactory(user_type=CustomUser.UserType.MANAGER.name) manager_project = ProjectFactory() manager_project.managers.add(manager_user) self.client.force_login(manager_user) response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertContains(response, manager_project.name) self.assertNotContains(response, self.project.name)
def test_custom_report_detail_view_should_contains_chosen_project_even_user_is_no_longer_in_project( self): other_user_project = ProjectFactory() other_user_project.members.add(self.user) self.user.projects.remove(self.report.project) response = self.client.get(self.url) self.assertIn(self.report.project, response.context_data["form"].fields["project"].queryset)
def setUp(self): super().setUp() self.user_admin = AdminUserFactory() self.client.force_login(self.user_admin) self.active_task_activity = TaskActivityTypeFactory() self.not_active_task_activity = TaskActivityTypeFactory( is_active=False) self.project = ProjectFactory() self.url = reverse( "disable-task-activity", kwargs={"task_activity_pk": self.active_task_activity.pk})
def test_create_report_form_view_should_contain_only_active_projects_related_to_user( self): other_project = ProjectFactory() response = self.client.get(self.url) project_choices = response.context["form"].fields["project"].queryset self.assertEqual(response.status_code, 200) self.assertIn(self.report.project, project_choices) self.assertNotIn(other_project, project_choices) self.assertIn(self.report.project, Project.objects.filter_active())
def setUp(self): super().setUp() self.project_1 = ProjectFactory( name="aaa", start_date=timezone.now() + timezone.timedelta(days=1), stop_date=timezone.now() + timezone.timedelta(days=6), ) self.project_2 = ProjectFactory( name="abc", start_date=timezone.now() + timezone.timedelta(days=2), stop_date=timezone.now() + timezone.timedelta(days=5), ) self.project_3 = ProjectFactory( name="cca", start_date=timezone.now() + timezone.timedelta(days=3), stop_date=timezone.now() + timezone.timedelta(days=4), ) self.project_1.members.add(UserFactory()) self.project_2.members.add(UserFactory(), UserFactory(), UserFactory()) self.project_3.members.add(UserFactory(), UserFactory()) self.url = reverse("custom-projects-list")
def test_that_remove_all_random_user_projects_function_should_remove_all_user_projects( self, user_type): projects = [ ProjectFactory(start_date=timezone.now()) for _project in range(3) ] user = UserFactory(user_type=user_type) for project in projects: project.members.add(user) GenerateTestDataCommand().remove_all_random_user_projects(user_type) self.assertEqual(user.projects.count(), 0)
def setUp(self): super().setUp() self.user = UserFactory() self.project_1 = ProjectFactory() self.project_2 = ProjectFactory() self.project_3 = ProjectFactory() self.project_1_report_1 = ReportFactory(author=self.user, project=self.project_1) self.project_2_report_1 = ReportFactory(author=self.user, project=self.project_2) self.project_3_report_1 = ReportFactory(author=self.user, project=self.project_3) self.project_3_report_2 = ReportFactory(author=self.user, project=self.project_3) self.project_1_report_2 = ReportFactory(author=self.user, project=self.project_1) self.project_2_report_2 = ReportFactory(author=self.user, project=self.project_2) self.user.projects.add(self.project_1, self.project_2, self.project_3)
def setUp(self): super().setUp() self.user = UserFactory() self.project = ProjectFactory() self.project.members.add(self.user) current_date = timezone.now() self.report = ReportFactory(author=self.user, project=self.project, date=current_date) self.url = reverse( "author-report-project-list", kwargs={ "pk": self.project.pk, "user_pk": self.user.pk, "year": current_date.year, "month": current_date.month, }, )
def setUp(self): super().setUp() self.admin = AdminUserFactory() self.user = UserFactory() self.task_activity = TaskActivityTypeFactory() self.project = ProjectFactory() self.project.members.add(self.user) self.client.force_login(self.admin) self.report = ReportFactory(author=self.user, project=self.project, task_activity=self.task_activity) self.url = reverse("admin-report-detail", kwargs={"pk": self.report.pk}) self.data = { "date": timezone.now().date(), "description": "Some other description", "project": self.report.project.pk, "author": self.user.pk, "task_activity": self.task_activity.pk, "work_hours": "8:00", "current-project-pk": self.report.project.pk, }
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
def setUp(self): super().setUp() self.project = ProjectFactory() self.url = reverse("custom-projects-list")
def setUp(self): super().setUp() self.project = ProjectFactory() self.url = reverse("custom-project-detail", kwargs={"pk": self.project.pk})
class ProjectUpdateViewTestCase(ProjectBaseTests): def setUp(self): super().setUp() self.project = ProjectFactory() self.url = reverse("custom-project-update", kwargs={"pk": self.project.pk}) self.data = { "name": "New Example Project Name", "start_date": self.project.start_date, "managers": [self.user.pk], "members": [self.user.pk], } def test_project_update_view_should_display_update_template(self): response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertContains(response, self.project.name) self.assertTemplateUsed(response, ProjectUpdateView.template_name) def test_project_update_view_should_return_404_status_code_on_get_if_project_does_not_exist( self): response = self.client.get( reverse("custom-project-update", kwargs={"pk": self.project.pk + 1})) self.assertEqual(response.status_code, 404) def test_project_create_view_should_exclude_inactive_users_from_members_field( self): inactive_user = UserFactory(is_active=False) response = self.client.get(self.url) form = response.context_data["form"] self.assertTrue(inactive_user not in form.fields["members"].queryset) def test_project_update_view_should_update_project_on_post(self): response = self.client.post(self.url, self.data) self.assertEqual(response.status_code, 302) self.project.refresh_from_db() self.assertEqual(self.project.name, self.data["name"]) def test_project_update_view_should_update_project_on_post_if_data_is_invalid( self): del self.data["name"] response = self.client.post(self.url, self.data) self.assertEqual(response.status_code, 200) self.project.refresh_from_db() self.assertFormError(response, "form", "name", "This field is required.") def test_project_update_view_should_not_update_managers_if_user_is_manager( self): assert self.project.managers.count() == 0 user_manager = UserFactory(user_type=CustomUser.UserType.MANAGER.name) self.client.force_login(user=user_manager) self.data["managers"] = [self.user.pk, user_manager.pk] response = self.client.post(self.url, self.data) self.assertEqual(response.status_code, 404) self.project.refresh_from_db() self.assertEqual(self.project.managers.count(), 0) def test_project_update_view_should_display_all_aggregated_managers_on_get( self): self.project.managers.add(self.user) other_manager = ManagerUserFactory() response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertIn(self.user, response.context_data["form"].initial["managers"]) self.assertNotIn(other_manager, response.context_data["form"].initial["managers"]) self.assertContains(response, self.user) self.assertContains(response, other_manager)