def test_task_list(client, data): url = reverse('tasks-list') response = client.get(url) tasks_data = json.loads(response.content.decode('utf-8')) assert len(tasks_data) == 2 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) tasks_data = json.loads(response.content.decode('utf-8')) assert len(tasks_data) == 2 assert response.status_code == 200 client.login(data.project_member_with_perms) response = client.get(url) tasks_data = json.loads(response.content.decode('utf-8')) assert len(tasks_data) == 4 assert response.status_code == 200 client.login(data.project_owner) response = client.get(url) tasks_data = json.loads(response.content.decode('utf-8')) assert len(tasks_data) == 4 assert response.status_code == 200
def test_projects_user_order(client): user = f.UserFactory.create(is_superuser=True) project_1 = f.create_project() role_1 = f.RoleFactory(project=project_1) f.MembershipFactory(user=user, project=project_1, is_owner=True, role=role_1, user_order=2) project_2 = f.create_project() role_2 = f.RoleFactory(project=project_2) f.MembershipFactory(user=user, project=project_2, is_owner=True, role=role_2, user_order=1) client.login(user) #Testing default id order url = reverse("projects-list") url = "%s?member=%s" % (url, user.id) response = client.json.get(url) response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert(response_content[0]["id"] == project_1.id) #Testing user order url = reverse("projects-list") url = "%s?member=%s&order_by=memberships__user_order" % (url, user.id) response = client.json.get(url) response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert(response_content[0]["id"] == project_2.id)
def test_project_list_with_discover_mode_enabled(client, data): url = "{}?{}".format(reverse('projects-list'), "discover_mode=true") response = client.get(url) projects_data = json.loads(response.content.decode('utf-8')) assert len(projects_data) == 2 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) projects_data = json.loads(response.content.decode('utf-8')) assert len(projects_data) == 2 assert response.status_code == 200 client.login(data.project_member_with_perms) response = client.get(url) projects_data = json.loads(response.content.decode('utf-8')) assert len(projects_data) == 2 assert response.status_code == 200 client.login(data.project_owner) response = client.get(url) projects_data = json.loads(response.content.decode('utf-8')) assert len(projects_data) == 2 assert response.status_code == 200
def test_user_list(client, data): url = reverse("users-list") response = client.get(url) users_data = json.loads(response.content.decode("utf-8")) assert len(users_data) == 0 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) users_data = json.loads(response.content.decode("utf-8")) assert len(users_data) == 1 assert response.status_code == 200 client.login(data.other_user) response = client.get(url) users_data = json.loads(response.content.decode("utf-8")) assert len(users_data) == 1 assert response.status_code == 200 client.login(data.superuser) response = client.get(url) users_data = json.loads(response.content.decode("utf-8")) assert len(users_data) == 3 assert response.status_code == 200
def test_wiki_link_list(client, data): url = reverse('wiki-links-list') response = client.get(url) wiki_links_data = json.loads(response.content.decode('utf-8')) assert len(wiki_links_data) == 2 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) wiki_links_data = json.loads(response.content.decode('utf-8')) assert len(wiki_links_data) == 2 assert response.status_code == 200 client.login(data.project_member_with_perms) response = client.get(url) wiki_links_data = json.loads(response.content.decode('utf-8')) assert len(wiki_links_data) == 3 assert response.status_code == 200 client.login(data.project_owner) response = client.get(url) wiki_links_data = json.loads(response.content.decode('utf-8')) assert len(wiki_links_data) == 3 assert response.status_code == 200
def test_projects_user_order(client): user = f.UserFactory.create(is_superuser=True) project_1 = f.create_project() role_1 = f.RoleFactory(project=project_1) f.MembershipFactory(user=user, project=project_1, is_owner=True, role=role_1, user_order=2) project_2 = f.create_project() role_2 = f.RoleFactory(project=project_2) f.MembershipFactory(user=user, project=project_2, is_owner=True, role=role_2, user_order=1) client.login(user) #Testing default id order url = reverse("projects-list") url = "%s?member=%s" % (url, user.id) response = client.json.get(url) response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert (response_content[0]["id"] == project_1.id) #Testing user order url = reverse("projects-list") url = "%s?member=%s&order_by=memberships__user_order" % (url, user.id) response = client.json.get(url) response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 200 assert (response_content[0]["id"] == project_2.id)
def test_epic_related_userstories_list(client, data): url = reverse('epics-related-userstories-list', args=[data.public_epic.pk]) response = client.get(url) related_uss_data = json.loads(response.content.decode('utf-8')) assert len(related_uss_data) == 1 assert response.status_code == 200 client.login(data.registered_user) url = reverse('epics-related-userstories-list', args=[data.private_epic1.pk]) response = client.get(url) related_uss_data = json.loads(response.content.decode('utf-8')) assert len(related_uss_data) == 1 assert response.status_code == 200 client.login(data.project_member_with_perms) url = reverse('epics-related-userstories-list', args=[data.private_epic2.pk]) response = client.get(url) related_uss_data = json.loads(response.content.decode('utf-8')) assert len(related_uss_data) == 1 assert response.status_code == 200 client.login(data.project_owner) url = reverse('epics-related-userstories-list', args=[data.blocked_epic.pk]) response = client.get(url) related_uss_data = json.loads(response.content.decode('utf-8')) assert len(related_uss_data) == 1 assert response.status_code == 200
def test_resolver_list(client, data): url = reverse("resolver-list") users = [ None, data.registered_user, data.project_member_without_perms, data.project_member_with_perms, data.project_owner, ] results = helper_test_http_method(client, "get", "{}?project=public".format(url), None, users) assert results == [200, 200, 200, 200, 200] results = helper_test_http_method(client, "get", "{}?project=private1".format(url), None, users) assert results == [200, 200, 200, 200, 200] results = helper_test_http_method(client, "get", "{}?project=private2".format(url), None, users) assert results == [401, 403, 403, 200, 200] client.login(data.other_user) response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url)) assert json.loads(response.content.decode("utf-8")) == {"project": data.private_project2.pk} client.login(data.project_owner) response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url)) assert json.loads(response.content.decode("utf-8")) == { "project": data.private_project2.pk, "us": 1, "task": 1, "issue": 1, "milestone": data.milestone.pk, }
def test_task_list(client, data): url = reverse("tasks-list") response = client.get(url) tasks_data = json.loads(response.content.decode("utf-8")) assert len(tasks_data) == 2 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) tasks_data = json.loads(response.content.decode("utf-8")) assert len(tasks_data) == 2 assert response.status_code == 200 client.login(data.project_member_with_perms) response = client.get(url) tasks_data = json.loads(response.content.decode("utf-8")) assert len(tasks_data) == 3 assert response.status_code == 200 client.login(data.project_owner) response = client.get(url) tasks_data = json.loads(response.content.decode("utf-8")) assert len(tasks_data) == 3 assert response.status_code == 200
def test_user_list(client, data): url = reverse('users-list') response = client.get(url) users_data = json.loads(response.content.decode('utf-8')) assert len(users_data) == 0 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) users_data = json.loads(response.content.decode('utf-8')) assert len(users_data) == 1 assert response.status_code == 200 client.login(data.other_user) response = client.get(url) users_data = json.loads(response.content.decode('utf-8')) assert len(users_data) == 1 assert response.status_code == 200 client.login(data.superuser) response = client.get(url) users_data = json.loads(response.content.decode('utf-8')) assert len(users_data) == 3 assert response.status_code == 200
def test_resolver_list(client, data): url = reverse('resolver-list') users = [ None, data.registered_user, data.project_member_without_perms, data.project_member_with_perms, data.project_owner ] results = helper_test_http_method(client, 'get', "{}?project=public".format(url), None, users) assert results == [200, 200, 200, 200, 200] results = helper_test_http_method(client, 'get', "{}?project=private1".format(url), None, users) assert results == [200, 200, 200, 200, 200] results = helper_test_http_method(client, 'get', "{}?project=private2".format(url), None, users) assert results == [401, 403, 403, 200, 200] client.login(data.other_user) response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url)) assert json.loads(response.content.decode('utf-8')) == {"project": data.private_project2.pk} client.login(data.project_owner) response = client.get("{}?project=private2&us=1&task=2&issue=3&milestone=4".format(url)) assert json.loads(response.content.decode('utf-8')) == {"project": data.private_project2.pk, "us": 1, "task": 1, "issue": 1, "milestone": data.milestone.pk}
def test_invalid_issue_import_with_bad_choices(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory(project=project, user=user, is_owner=True) project.default_issue_type = f.IssueTypeFactory.create(project=project) project.default_issue_status = f.IssueStatusFactory.create(project=project) project.default_severity = f.SeverityFactory.create(project=project) project.default_priority = f.PriorityFactory.create(project=project) project.save() client.login(user) url = reverse("importer-issue", args=[project.pk]) data = { "subject": "Imported issue", "description": "Imported issue", "status": "Not valid" } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data) == 1 url = reverse("importer-issue", args=[project.pk]) data = { "subject": "Imported issue", "description": "Imported issue", "priority": "Not valid" } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data) == 1 url = reverse("importer-issue", args=[project.pk]) data = { "subject": "Imported issue", "description": "Imported issue", "severity": "Not valid" } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data) == 1 url = reverse("importer-issue", args=[project.pk]) data = { "subject": "Imported issue", "description": "Imported issue", "type": "Not valid" } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data) == 1
def test_valid_wiki_link_import(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory(project=project, user=user, is_owner=True) client.login(user) url = reverse("importer-wiki-link", args=[project.pk]) data = { "title": "Imported wiki_link", "href": "imported-wiki-link", } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 json.loads(response.content.decode("utf-8"))
def test_valid_concurrent_save_for_task_different_fields(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory.create(project=project, user=user, is_owner=True) client.login(user) mock_path = "taiga.projects.tasks.api.TaskViewSet.pre_conditions_on_save" with patch(mock_path): url = reverse("tasks-list") data = { "subject": "test", "project": project.id, "status": f.TaskStatusFactory.create(project=project).id } response = client.json.post(url, json.dumps(data)) assert response.status_code == 201 task_id = json.loads(response.content)["id"] url = reverse("tasks-detail", args=(task_id, )) data = {"version": 1, "subject": "test 1"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200 data = {"version": 1, "description": "test 2"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200
def handle(self, *args, **options): dump_file_path = options["dump_file"] owner_email = options["owner_email"] overwrite = options["overwrite"] data = json.loads(open(dump_file_path, 'r').read()) try: with transaction.atomic(): if overwrite: receivers_back = signals.post_delete.receivers signals.post_delete.receivers = [] try: proj = Project.objects.get(slug=data.get("slug", "not a slug")) proj.tasks.all().delete() proj.user_stories.all().delete() proj.issues.all().delete() proj.memberships.all().delete() proj.roles.all().delete() proj.delete() except Project.DoesNotExist: pass signals.post_delete.receivers = receivers_back user = User.objects.get(email=owner_email) services.store_project_from_dict(data, user) except err.TaigaImportError as e: if e.project: e.project.delete_related_content() e.project.delete() print("ERROR:", end=" ") print(e.message) print(json.dumps(e.errors, indent=4))
def test_valid_concurrent_save_for_issue_different_versions(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) membership = f.MembershipFactory.create(project=project, user=user, is_owner=True) client.login(user) mock_path = "taiga.projects.issues.api.IssueViewSet.pre_conditions_on_save" with patch(mock_path) as m: url = reverse("issues-list") data = {"subject": "test", "project": project.id, "status": f.IssueStatusFactory.create(project=project).id, "severity": f.SeverityFactory.create(project=project).id, "type": f.IssueTypeFactory.create(project=project).id, "priority": f.PriorityFactory.create(project=project).id} response = client.json.post(url, json.dumps(data)) assert response.status_code == 201, response.content issue_id = json.loads(response.content)["id"] url = reverse("issues-detail", args=(issue_id,)) data = {"version":1, "subject": "test 1"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200 data = {"version":2, "subject": "test 2"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200
def test_valid_concurrent_save_for_wiki_page_different_versions(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory.create(project=project, user=user, is_owner=True) client.login(user) mock_path = "taiga.projects.wiki.api.WikiViewSet.pre_conditions_on_save" with patch(mock_path): url = reverse("wiki-list") data = {"project": project.id, "slug": "test"} response = client.json.post(url, json.dumps(data)) assert response.status_code == 201, response.content wiki_id = json.loads(response.content)["id"] url = reverse("wiki-detail", args=(wiki_id, )) data = {"version": 1, "content": "test 1"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200 data = {"version": 2, "content": "test 2"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200
def _reorder_if_needed( self, obj, old_order_key, order_key, order_attr, project, user_story=None, status=None, milestone=None, ): # Executes the extra ordering if there is a difference in the ordering keys if old_order_key != order_key: extra_orders = json.loads(self.request.META.get("HTTP_SET_ORDERS", "{}")) data = [{"task_id": obj.id, "order": getattr(obj, order_attr)}] for id, order in extra_orders.items(): data.append({"task_id": int(id), "order": order}) return services.update_tasks_order_in_bulk( data, order_attr, project, user_story=user_story, status=status, milestone=milestone, ) return {}
def test_import_epic_with_user_stories(client): project = f.ProjectFactory() project.default_points = f.PointsFactory.create(project=project) project.default_issue_type = f.IssueTypeFactory.create(project=project) project.default_issue_status = f.IssueStatusFactory.create(project=project) project.default_epic_status = f.EpicStatusFactory.create(project=project) project.default_us_status = f.UserStoryStatusFactory.create(project=project) project.default_task_status = f.TaskStatusFactory.create(project=project) project.default_priority = f.PriorityFactory.create(project=project) project.default_severity = f.SeverityFactory.create(project=project) epic = f.EpicFactory.create(subject="test epic export", project=project, status=project.default_epic_status) user_story = f.UserStoryFactory.create(project=project, status=project.default_us_status, milestone=None) f.RelatedUserStory.create(epic=epic, user_story=user_story, order=55) output = io.BytesIO() render_project(user_story.project, output) project_data = json.loads(output.getvalue()) epic.project.delete() project = store_project_from_dict(project_data) assert project.epics.count() == 1 assert project.epics.first().ref == epic.ref assert project.epics.first().user_stories.count() == 1 related_userstory = project.epics.first().relateduserstory_set.first() assert related_userstory.user_story.ref == user_story.ref assert related_userstory.order == 55 assert related_userstory.epic.ref == epic.ref
def test_valid_project_import_with_membership_uuid_rewrite(client): user = f.UserFactory.create() client.login(user) url = reverse("importer-list") data = { "name": "Imported project", "description": "Imported project", "memberships": [{ "email": "*****@*****.**", "role": "Role", "token": "123", }], "roles": [{ "name": "Role" }] } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 response_data = json.loads(response.content.decode("utf-8")) assert Membership.objects.filter(email="*****@*****.**", token="123").count() == 0
def test_invalid_concurrent_save_for_us(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) membership = f.MembershipFactory.create(project=project, user=user, is_owner=True) userstory = f.UserStoryFactory.create(version=10, project=project) client.login(user) mock_path = "taiga.projects.userstories.api.UserStoryViewSet.pre_conditions_on_save" with patch(mock_path) as m: url = reverse("userstories-list") data = {"subject": "test", "project": project.id, "status": f.UserStoryStatusFactory.create(project=project).id} response = client.json.post(url, json.dumps(data)) assert response.status_code == 201 userstory_id = json.loads(response.content)["id"] url = reverse("userstories-detail", args=(userstory_id,)) data = {"version":1, "subject": "test 1"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 200 data = {"version":1, "subject": "test 2"} response = client.patch(url, json.dumps(data), content_type="application/json") assert response.status_code == 400
def handle(self, *args, **options): data = json.loads(open(args[0], 'r').read()) try: with transaction.atomic(): if options["overwrite"]: receivers_back = signals.post_delete.receivers signals.post_delete.receivers = [] try: proj = Project.objects.get(slug=data.get("slug", "not a slug")) proj.tasks.all().delete() proj.user_stories.all().delete() proj.issues.all().delete() proj.memberships.all().delete() proj.roles.all().delete() proj.delete() except Project.DoesNotExist: pass signals.post_delete.receivers = receivers_back user = User.objects.get(email=args[1]) dict_to_project(data, user) except TaigaImportError as e: print("ERROR:", end=" ") print(e.message) print(get_errors())
def test_valid_project_import_without_extra_data(client): user = f.UserFactory.create() client.login(user) url = reverse("importer-list") data = { "name": "Imported project", "description": "Imported project", } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 response_data = json.loads(response.content.decode("utf-8")) must_empty_children = [ "issues", "user_stories", "roles", "us_statuses", "wiki_pages", "priorities", "severities", "milestones", "points", "issue_types", "task_statuses", "memberships", "issue_statuses", "wiki_links", ] assert all(map(lambda x: len(response_data[x]) == 0, must_empty_children)) assert response_data["owner"] == user.email
def test_valid_task_import_with_extra_data(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory(project=project, user=user, is_owner=True) project.default_task_status = f.TaskStatusFactory.create(project=project) project.save() client.login(user) url = reverse("importer-task", args=[project.pk]) data = { "subject": "Imported task", "description": "Imported task", "attachments": [{ "owner": user.email, "attached_file": { "name": "imported attachment", "data": base64.b64encode(b"TEST").decode("utf-8") } }] } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data["attachments"]) == 1 assert response_data["owner"] == user.email assert response_data["ref"] is not None
def test_export_user_story_finish_date(client): user_story = f.UserStoryFactory.create(finish_date="2014-10-22") output = io.StringIO() render_project(user_story.project, output) project_data = json.loads(output.getvalue()) finish_date = project_data["user_stories"][0]["finish_date"] assert finish_date == "2014-10-22T00:00:00+0000"
def test_valid_wiki_page_import_with_extra_data(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory(project=project, user=user, is_owner=True) client.login(user) url = reverse("importer-wiki-page", args=[project.pk]) data = { "slug": "imported-wiki-page", "content": "Imported wiki_page", "attachments": [{ "owner": user.email, "attached_file": { "name": "imported attachment", "data": base64.b64encode(b"TEST").decode("utf-8") } }] } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data["attachments"]) == 1 assert response_data["owner"] == user.email
def test_invalid_project_import_with_extra_data(client): user = f.UserFactory.create() client.login(user) url = reverse("importer-list") data = { "name": "Imported project", "description": "Imported project", "roles": [{ "permissions": [], "name": "Test" }], "us_statuses": [{}], "severities": [{}], "priorities": [{}], "points": [{}], "issue_types": [{}], "task_statuses": [{}], "issue_statuses": [{}], } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert len(response_data) == 7 assert Project.objects.filter(slug="imported-project").count() == 0
def test_valid_milestone_import(client): user = f.UserFactory.create() project = f.ProjectFactory.create(owner=user) f.MembershipFactory(project=project, user=user, is_owner=True) client.login(user) url = reverse("importer-milestone", args=[project.pk]) data = { "name": "Imported milestone", "estimated_start": "2014-10-10", "estimated_finish": "2014-10-20", } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 json.loads(response.content.decode("utf-8"))
def test_import_epic_with_user_stories(client): project = f.ProjectFactory() project.default_points = f.PointsFactory.create(project=project) project.default_issue_type = f.IssueTypeFactory.create(project=project) project.default_issue_status = f.IssueStatusFactory.create(project=project) project.default_epic_status = f.EpicStatusFactory.create(project=project) project.default_us_status = f.UserStoryStatusFactory.create( project=project) project.default_task_status = f.TaskStatusFactory.create(project=project) project.default_priority = f.PriorityFactory.create(project=project) project.default_severity = f.SeverityFactory.create(project=project) epic = f.EpicFactory.create(subject="test epic export", project=project, status=project.default_epic_status) user_story = f.UserStoryFactory.create(project=project, status=project.default_us_status, milestone=None) f.RelatedUserStory.create(epic=epic, user_story=user_story, order=55) output = io.BytesIO() render_project(user_story.project, output) project_data = json.loads(output.getvalue()) epic.project.delete() project = store_project_from_dict(project_data) assert project.epics.count() == 1 assert project.epics.first().ref == epic.ref assert project.epics.first().user_stories.count() == 1 related_userstory = project.epics.first().relateduserstory_set.first() assert related_userstory.user_story.ref == user_story.ref assert related_userstory.order == 55 assert related_userstory.epic.ref == epic.ref
def test_export_issue_finish_date(client): issue = f.IssueFactory.create(finished_date="2014-10-22") output = io.StringIO() render_project(issue.project, output) project_data = json.loads(output.getvalue()) finish_date = project_data["issues"][0]["finished_date"] assert finish_date == "2014-10-22T00:00:00+0000"
def handle(self, *args, **options): dump_file_path = options["dump_file"] owner_email = options["owner_email"] overwrite = options["overwrite"] data = json.loads(open(dump_file_path, 'r').read()) try: with transaction.atomic(): if overwrite: receivers_back = signals.post_delete.receivers signals.post_delete.receivers = [] try: proj = Project.objects.get( slug=data.get("slug", "not a slug")) proj.tasks.all().delete() proj.user_stories.all().delete() proj.issues.all().delete() proj.memberships.all().delete() proj.roles.all().delete() proj.delete() except Project.DoesNotExist: pass signals.post_delete.receivers = receivers_back user = User.objects.get(email=owner_email) services.store_project_from_dict(data, user) except err.TaigaImportError as e: if e.project: e.project.delete_related_content() e.project.delete() print("ERROR:", end=" ") print(e.message) print(json.dumps(e.errors, indent=4))
def handle(self, *args, **options): data = json.loads(open(args[0], 'r').read()) try: with transaction.atomic(): if options["overwrite"]: receivers_back = signals.post_delete.receivers signals.post_delete.receivers = [] try: proj = Project.objects.get( slug=data.get("slug", "not a slug")) proj.tasks.all().delete() proj.user_stories.all().delete() proj.issues.all().delete() proj.memberships.all().delete() proj.roles.all().delete() proj.delete() except Project.DoesNotExist: pass signals.post_delete.receivers = receivers_back user = User.objects.get(email=args[1]) dict_to_project(data, user) except TaigaImportError as e: print("ERROR:", end=" ") print(e.message) print(get_errors())
def test_retrieve_notify_policies_by_anonymous_user(client): project = f.ProjectFactory.create() policy = services.get_notify_policy(project, project.owner) url = reverse("notifications-detail", args=[policy.pk]) response = client.get(url, content_type="application/json") assert response.status_code == 404, response.status_code assert json.loads(response.content.decode("utf-8"))["_error_message"] == "No NotifyPolicy matches the given query.", response.content
def test_leave_project_valid_membership_only_owner(client): user = f.UserFactory.create() project = f.ProjectFactory.create() role = f.RoleFactory.create(project=project, permissions=["view_project"]) f.MembershipFactory.create(project=project, user=user, role=role, is_owner=True) client.login(user) url = reverse("projects-leave", args=(project.id,)) response = client.post(url) assert response.status_code == 403 assert json.loads(response.content)["_error_message"] == "You can't leave the project if there are no more owners"
def test_delete_membership_only_owner(client): user = f.UserFactory.create() project = f.ProjectFactory.create() role = f.RoleFactory.create(project=project, permissions=["view_project"]) membership = f.MembershipFactory.create(project=project, user=user, role=role, is_owner=True) client.login(user) url = reverse("memberships-detail", args=(membership.id,)) response = client.delete(url) assert response.status_code == 400 assert json.loads(response.content)["_error_message"] == "At least one of the user must be an active admin"
def test_bad_signature(client): project = f.ProjectFactory() url = reverse("github-hook-list") url = "%s?project=%s" % (url, project.id) data = {} response = client.post(url, json.dumps(data), HTTP_X_HUB_SIGNATURE="sha1=badbadbad", content_type="application/json") response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 400 assert "Bad signature" in response_content["_error_message"]
def test_webhook_action_test_transform_to_json(client, data): url = reverse('webhooks-test', kwargs={"pk": data.webhook1.pk}) response = Mock(status_code=200, headers={}, text="ok") response.elapsed.total_seconds.return_value = 100 with patch("taiga.webhooks.tasks.requests.Session.send", return_value=response) as session_send_mock: client.login(data.project_owner) response = client.json.post(url) assert response.status_code == 200 assert json.loads(response.data["response_data"]) == {"content": "ok"}
def _reorder_if_needed(self, obj, old_order_key, order_key): # Executes the extra ordering if there is a difference in the ordering keys if old_order_key == order_key: return {} extra_orders = json.loads(self.request.META.get("HTTP_SET_ORDERS", "{}")) data = [{"us_id": obj.user_story.id, "order": getattr(obj, "order")}] for id, order in extra_orders.items(): data.append({"us_id": int(id), "order": order}) return services.update_epic_related_userstories_order_in_bulk(data, epic=obj.epic)
def test_list_contacts_private_projects(client): project = f.ProjectFactory.create() user_1 = f.UserFactory.create() user_2 = f.UserFactory.create() role = f.RoleFactory(project=project, permissions=["view_project"]) membership_1 = f.MembershipFactory.create(project=project, user=user_1, role=role) membership_2 = f.MembershipFactory.create(project=project, user=user_2, role=role) url = reverse('users-contacts', kwargs={"pk": user_1.pk}) response = client.get(url, content_type="application/json") assert response.status_code == 200 response_content = json.loads(response.content.decode("utf-8")) assert len(response_content) == 0 client.login(user_1) response = client.get(url, content_type="application/json") assert response.status_code == 200 response_content = json.loads(response.content.decode("utf-8")) assert len(response_content) == 1 assert response_content[0]["id"] == user_2.id
def test_retrieve_notify_policies_by_anonymous_user(client): project = f.ProjectFactory.create() policy = services.get_notify_policy(project, project.owner) url = reverse("notifications-detail", args=[policy.pk]) response = client.get(url, content_type="application/json") assert response.status_code == 404, response.status_code assert json.loads( response.content.decode("utf-8") )["_error_message"] == "No NotifyPolicy matches the given query.", response.content
def test_bad_signature(client): project=f.ProjectFactory() url = reverse("github-hook-list") url = "%s?project=%s"%(url, project.id) data = {} response = client.post(url, json.dumps(data), HTTP_X_HUB_SIGNATURE="sha1=badbadbad", content_type="application/json") response_content = json.loads(response.content.decode("utf-8")) assert response.status_code == 400 assert "Bad signature" in response_content["_error_message"]
def test_export_epic_with_user_stories(client): epic = f.EpicFactory.create(subject="test epic export") user_story = f.UserStoryFactory.create(project=epic.project) f.RelatedUserStory.create(epic=epic, user_story=user_story) output = io.BytesIO() render_project(user_story.project, output) project_data = json.loads(output.getvalue()) assert project_data["epics"][0]["subject"] == "test epic export" assert len(project_data["epics"]) == 1 assert project_data["epics"][0]["related_user_stories"][0]["user_story"] == user_story.ref assert len(project_data["epics"][0]["related_user_stories"]) == 1
def test_webhooklogs_list(client, data): url = reverse('webhooklogs-list') response = client.get(url) webhooklogs_data = json.loads(response.content.decode('utf-8')) assert len(webhooklogs_data) == 0 assert response.status_code == 200 client.login(data.registered_user) response = client.get(url) webhooklogs_data = json.loads(response.content.decode('utf-8')) assert len(webhooklogs_data) == 0 assert response.status_code == 200 client.login(data.project_owner) response = client.get(url) webhooklogs_data = json.loads(response.content.decode('utf-8')) assert len(webhooklogs_data) == 2 assert response.status_code == 200
def test_valid_project_import_with_extra_data(client): user = f.UserFactory.create() client.login(user) url = reverse("importer-list") data = { "name": "Imported project", "description": "Imported project", "roles": [{ "permissions": [], "name": "Test" }], "us_statuses": [{ "name": "Test" }], "severities": [{ "name": "Test" }], "priorities": [{ "name": "Test" }], "points": [{ "name": "Test" }], "issue_types": [{ "name": "Test" }], "task_statuses": [{ "name": "Test" }], "issue_statuses": [{ "name": "Test" }], } response = client.post(url, json.dumps(data), content_type="application/json") assert response.status_code == 201 response_data = json.loads(response.content.decode("utf-8")) must_empty_children = [ "issues", "user_stories", "wiki_pages", "milestones", "wiki_links", ] must_one_instance_children = [ "roles", "us_statuses", "severities", "priorities", "points", "issue_types", "task_statuses", "issue_statuses", "memberships", ] assert all(map(lambda x: len(response_data[x]) == 0, must_empty_children)) # Allwais is created at least the owner membership assert all(map(lambda x: len(response_data[x]) == 1, must_one_instance_children)) assert response_data["owner"] == user.email
def test_invalid_dump_import(client): user = f.UserFactory.create() client.login(user) url = reverse("importer-load-dump") data = ContentFile(b"test") data.name = "test" response = client.post(url, {'dump': data}) assert response.status_code == 400 response_data = json.loads(response.content.decode("utf-8")) assert response_data["_error_message"] == "Invalid dump format"