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_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_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_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_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 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 _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_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_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_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_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"
