taiga
/
taiga-back
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Delete the rest of django test

remotes/origin/enhancement/email-actions
David Barragán Merino 2014-06-15 11:18:16 +02:00
parent c6ec50bb1e
commit 2c8524e146
24 changed files with 3 additions and 5183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
settings/common.py
View File

@ -300,8 +300,6 @@ TEST_RUNNER="django.test.runner.DiscoverRunner"
# Test conditions # Test conditions
if "test" in sys.argv: if "test" in sys.argv:
if "settings" not in ",".join(sys.argv): print ("\033[1;91mNo django tests.\033[0m")
print ("\033[1;91mNot settings specified.\033[0m") print ("Try: \033[1;33mpy.test\033[0m")
print ("Try: \033[1;33mpython manage.py test --settings="
"settings.testing -v2 taiga\033[0m")
sys.exit(0) sys.exit(0)

4
settings/testing.py
View File

@ -18,7 +18,3 @@ from .development import *
SKIP_SOUTH_TESTS = True SKIP_SOUTH_TESTS = True
SOUTH_TESTS_MIGRATE = False SOUTH_TESTS_MIGRATE = False
INSTALLED_APPS += [
"taiga.projects.mixins.tests.blocked.foo",
]

63
taiga/events/tests.py
View File

@ -1,63 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django import test
from django.test.client import RequestFactory
from django.http import HttpResponse
from taiga.projects.tests import create_project
from taiga.projects.issues.tests import create_issue
from taiga.users.tests import create_user
from . import middleware as mw
from . import changes as ch
class SessionIDMiddlewareTests(test.TestCase):
# fixtures = ["initial_domains.json"]
def setUp(self):
self.factory = RequestFactory()
def test_process_session_id_01(self):
request = self.factory.get("/")
mw_instance = mw.SessionIDMiddleware()
mw_instance.process_request(request)
self.assertEqual(mw.get_current_session_id(), None)
def test_process_session_id_02(self):
request = self.factory.get("/", HTTP_X_SESSION_ID="foobar")
mw_instance = mw.SessionIDMiddleware()
mw_instance.process_request(request)
self.assertEqual(mw.get_current_session_id(), "foobar")
from unittest.mock import MagicMock
from unittest.mock import patch
class ChangesTest(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def test_emit_change_for_model(self):
user = create_user(1) # Project owner
project = create_project(1, user)
issue = create_issue(1, user, project)
with patch("taiga.events.backends.get_events_backend") as mock_instance:
ch.emit_change_event_for_model(issue, "sessionid")
self.assertTrue(mock_instance.return_value.emit_event.called)

207
taiga/projects/history/tests.py
View File

@ -1,207 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django import test
from django.core.urlresolvers import reverse
from django.core.files.uploadedfile import SimpleUploadedFile
from django.contrib.contenttypes.models import ContentType
from django.db.models.loading import get_model
from taiga.users.tests import create_user
from taiga.projects.tests import create_project
from taiga.projects.userstories.tests import create_userstory
from . import services as history
from . import models
class HistoryApiViewsTest(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.project1 = create_project(1, self.user1)
def test_resolve_urls(self):
self.assertEqual(reverse("userstory-history-detail", args=[1]), "/api/v1/history/userstory/1")
def test_list_history_entries(self):
userstory1 = create_userstory(1, self.user1, self.project1)
userstory1.subject = "test1"
userstory1.save()
history.take_snapshot(userstory1)
userstory1.subject = "test2"
userstory1.save()
history.take_snapshot(userstory1)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
url = reverse("userstory-history-detail", args=[userstory1.pk])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
class HistoryServicesTest(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.project1 = create_project(1, self.user1)
# def test_freeze_userstory(self):
# userstory1 = create_userstory(1, self.user1, self.project1)
# fobj = history.freeze_model_instance(userstory1)
# self.assertEqual(fobj.key, "userstories.userstory:{}".format(userstory1.id))
# self.assertIn("status", fobj.snapshot)
def test_freeze_wrong_object(self):
some_object = object()
with self.assertRaises(Exception):
history.freeze_model_instance(some_object)
def test_diff(self):
userstory1 = create_userstory(1, self.user1, self.project1)
userstory1.subject = "test1"
userstory1.save()
fobj1 = history.freeze_model_instance(userstory1)
userstory1.subject = "test2"
userstory1.save()
fobj2 = history.freeze_model_instance(userstory1)
fdiff = history.make_diff(fobj1, fobj2)
self.assertEqual(fdiff.diff, {"subject": ('test1', 'test2')})
def test_snapshot(self):
userstory1 = create_userstory(1, self.user1, self.project1)
userstory1.subject = "test1"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test2"
userstory1.save()
self.assertEqual(hentry.key, "userstories.userstory:{}".format(userstory1.id))
self.assertEqual(models.HistoryEntry.objects.count(), 1)
history.take_snapshot(userstory1)
self.assertEqual(models.HistoryEntry.objects.count(), 2)
def test_comment(self):
userstory1 = create_userstory(1, self.user1, self.project1)
self.assertEqual(models.HistoryEntry.objects.count(), 0)
hentry = history.take_snapshot(userstory1, comment="Sample comment")
self.assertEqual(models.HistoryEntry.objects.count(), 1)
self.assertEqual(hentry.comment, "Sample comment")
def test_userstory_points(self):
userstory1 = create_userstory(1, self.user1, self.project1)
hentry = history.take_snapshot(userstory1)
self.assertEqual({}, hentry.values_diff)
rpmodel_cls = get_model("userstories", "RolePoints")
pmodel_cls = get_model("projects", "Points")
rolepoints = rpmodel_cls.objects.filter(user_story=userstory1)[0]
points = pmodel_cls.objects.get(project=userstory1.project, value=15)
rolepoints.points = points
rolepoints.save()
hentry = history.take_snapshot(userstory1)
self.assertIn("points", hentry.values_diff)
self.assertIn("UX", hentry.values_diff["points"])
self.assertEqual(hentry.values_diff["points"]["UX"], ["?", "15"])
def test_userstory_attachments(self):
userstory1 = create_userstory(1, self.user1, self.project1)
hentry = history.take_snapshot(userstory1)
self.assertEqual({}, hentry.values_diff)
# Create attachment file
attachment_modelcls = get_model("attachments", "Attachment")
content_type = ContentType.objects.get_for_model(userstory1.__class__)
temporary_file = SimpleUploadedFile("text.txt", b"sample content")
attachment = attachment_modelcls.objects.create(project=userstory1.project,
content_type=content_type,
content_object=userstory1,
object_id=userstory1.id,
owner=self.user1,
attached_file=temporary_file)
hentry = history.take_snapshot(userstory1)
self.assertIn("attachments", hentry.values_diff)
def test_values(self):
userstory1 = create_userstory(1, self.user1, self.project1)
userstory1.subject = "test1"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test2"
userstory1.assigned_to = self.user1
userstory1.save()
hentry = history.take_snapshot(userstory1)
self.assertIn("users", hentry.values)
self.assertEqual(len(hentry.values), 1)
self.assertIn("assigned_to", hentry.values_diff)
self.assertEqual(hentry.values_diff["assigned_to"], [None, "Foo1 Bar1"])
def test_partial_snapshots(self):
userstory1 = create_userstory(1, self.user1, self.project1)
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test1"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test2"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test3"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test4"
userstory1.save()
hentry = history.take_snapshot(userstory1)
userstory1.subject = "test5"
userstory1.save()
hentry = history.take_snapshot(userstory1)
self.assertEqual(models.HistoryEntry.objects.count(), 6)
self.assertEqual(models.HistoryEntry.objects.filter(is_snapshot=True).count(), 1)
self.assertEqual(models.HistoryEntry.objects.filter(is_snapshot=False).count(), 5)

37
taiga/projects/issues/tests/__init__.py
View File

@ -1,37 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_issue(id, owner, project, milestone=None, save=True):
model = get_model("issues", "Issue")
instance = model(
subject="Issue {0}".format(id),
description="The issue description.",
project=project,
milestone=milestone,
status=project.issue_statuses.all()[0],
severity=project.severities.all()[0],
priority=project.priorities.all()[0],
type=project.issue_types.all()[0],
owner=owner
)
if save:
instance.save()
return instance

965
taiga/projects/issues/tests/tests_api.py
View File

@ -1,965 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core import mail
from django.core.urlresolvers import reverse
from taiga.users.tests import create_user
from taiga.projects.tests import create_project, add_membership
from taiga.projects.milestones.tests import create_milestone
from taiga.projects.issues.models import Issue
from . import create_issue
class IssuesTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.user2 = create_user(2) # Owner
self.user3 = create_user(3) # Membership
self.user4 = create_user(4) # No Membership
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user2)
add_membership(self.project1, self.user3)
self.milestone1 = create_milestone(1, self.user2, self.project1)
self.issue1 = create_issue(1, self.user2, self.project1, self.milestone1)
self.issue2 = create_issue(2, self.user2, self.project1, self.milestone1)
self.issue3 = create_issue(3, self.user2, self.project1)
self.project2 = create_project(2, self.user4)
self.milestone2 = create_milestone(2, self.user4, self.project2)
self.issue4 = create_issue(4, self.user4, self.project2)
mail.outbox = []
def test_list_issues_by_anon(self):
response = self.client.get(reverse("issues-list"))
self.assertEqual(response.status_code, 401)
def test_list_issues_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-list"))
self.assertEqual(response.status_code, 200)
issues_list = response.data
self.assertEqual(len(issues_list), 3)
self.client.logout()
def test_list_issues_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-list"))
self.assertEqual(response.status_code, 200)
issues_list = response.data
self.assertEqual(len(issues_list), 3)
self.client.logout()
def test_list_issues_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-list"))
self.assertEqual(response.status_code, 200)
issues_list = response.data
self.assertEqual(len(issues_list), 3)
self.client.logout()
def test_list_issues_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-list"))
self.assertEqual(response.status_code, 200)
issues_list = response.data
self.assertEqual(len(issues_list), 1)
self.client.logout()
def test_view_issue_by_anon(self):
response = self.client.get(reverse("issues-detail", args=(self.issue1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_issue_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-detail", args=(self.issue1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_issue_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-detail", args=(self.issue1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_issue_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-detail", args=(self.issue1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_issue_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("issues-detail", args=(self.issue1.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_issue_by_anon(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Issue.objects.all().count(), 4)
def test_create_issue_by_project_owner(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Issue.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_project(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project2.id,
"status": self.project2.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_milestone(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_status(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project2.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_severity(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project2.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_priority(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project2.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_project_owner_with_wron_type(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project2.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Issue.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_issue_by_membership_with_wron_project(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project2.id,
"status": self.project2.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership_with_wron_milestone(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership_with_wron_status(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project2.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership_with_wron_severity(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project2.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership_with_wron_priority(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project2.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_membership_with_wron_type(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project2.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_create_issue_by_no_membership(self):
data = {
"subject": "Test Issue",
"description": "A Test Issue example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.issue_statuses.all()[1].id,
"severity": self.project1.severities.all()[1].id,
"priority": self.project1.priorities.all()[1].id,
"type": self.project1.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("issues-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_anon(self):
data = {
"subject": "Edited test issue",
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.issue1.subject)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Issue.objects.all().count(), 4)
def test_edit_issue_by_project_owner(self):
data = {
"subject": "Modified issue subject",
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.issue1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_status(self):
data = {
"status": self.project2.issue_statuses.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_severity(self):
data = {
"severity": self.project2.severities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_priority(self):
data = {
"priority": self.project2.priorities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_project_owner_with_wron_type(self):
data = {
"type": self.project2.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner(self):
data = {
"subject": "Modified issue subject",
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.issue1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_issue_by_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner_with_wron_status(self):
data = {
"status": self.project2.issue_statuses.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner_with_wron_severity(self):
data = {
"severity": self.project2.severities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner_with_wron_priority(self):
data = {
"priority": self.project2.priorities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_owner_with_wron_type(self):
data = {
"type": self.project2.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership(self):
data = {
"subject": "Modified issue subject",
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.issue1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Issue.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_issue_by_membership_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership_with_wron_status(self):
data = {
"status": self.project2.issue_statuses.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership_with_wron_severity(self):
data = {
"severity": self.project2.severities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership_with_wron_priority(self):
data = {
"priority": self.project2.priorities.all()[1].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_membership_with_wron_type(self):
data = {
"type": self.project2.issue_types.all()[0].id
}
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_edit_issue_by_no_membership(self):
data = {
"subject": "Modified issue subject",
}
self.assertEqual(Issue.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.issue1.subject)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.patch(
reverse("issues-detail", args=(self.issue1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()
def test_delete_issue_by_ano(self):
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.delete(
reverse("issues-detail", args=(self.issue1.id,))
)
self.assertEqual(response.status_code, 401)
self.assertEqual(Issue.objects.all().count(), 4)
def test_delete_issue_by_project_owner(self):
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(
reverse("issues-detail", args=(self.issue1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Issue.objects.all().count(), 3)
self.client.logout()
def test_delete_issue_by_owner(self):
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(
reverse("issues-detail", args=(self.issue1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Issue.objects.all().count(), 3)
self.client.logout()
def test_delete_issue_by_membership(self):
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(
reverse("issues-detail", args=(self.issue1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Issue.objects.all().count(), 3)
self.client.logout()
def test_delete_issue_by_no_membership(self):
self.assertEqual(Issue.objects.all().count(), 4)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.delete(
reverse("issues-detail", args=(self.issue1.id,))
)
self.assertEqual(response.status_code, 404)
self.assertEqual(Issue.objects.all().count(), 4)
self.client.logout()

31
taiga/projects/milestones/tests/__init__.py
View File

@ -1,31 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_milestone(id, owner, project, save=True):
model = get_model("milestones", "Milestone")
instance = model(
name="Milestone {0}".format(id),
project=project,
owner=owner
)
if save:
instance.save()
return instance

422
taiga/projects/milestones/tests/tests_api.py
View File

@ -1,422 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core import mail
from django.core.urlresolvers import reverse
from taiga.users.tests import create_user
from taiga.projects.tests import create_project, add_membership
from taiga.projects.milestones.models import Milestone
from . import create_milestone
class MilestonesTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json",]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user4 = create_user(4)
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user2)
add_membership(self.project1, self.user3)
self.project2 = create_project(2, self.user4)
self.milestone1 = create_milestone(1, self.user2, self.project1)
self.milestone2 = create_milestone(2, self.user2, self.project1)
def test_list_milestones_by_anon(self):
response = self.client.get(reverse("milestones-list"))
self.assertEqual(response.status_code, 401)
def test_list_milestones_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-list"))
self.assertEqual(response.status_code, 200)
milestones_list = response.data
self.assertEqual(len(milestones_list), 2)
self.client.logout()
def test_list_milestones_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-list"))
self.assertEqual(response.status_code, 200)
milestones_list = response.data
self.assertEqual(len(milestones_list), 2)
self.client.logout()
def test_list_milestones_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-list"))
self.assertEqual(response.status_code, 200)
milestones_list = response.data
self.assertEqual(len(milestones_list), 2)
self.client.logout()
def test_list_milestones_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-list"))
self.assertEqual(response.status_code, 200)
milestones_list = response.data
self.assertEqual(len(milestones_list), 0)
self.client.logout()
def test_view_milestone_by_anon(self):
response = self.client.get(reverse("milestones-detail", args=(self.milestone1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_milestone_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-detail", args=(self.milestone1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_milestone_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-detail", args=(self.milestone1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_milestone_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-detail", args=(self.milestone1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_milestone_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("milestones-detail", args=(self.milestone1.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_milestone_by_anon(self):
data = {
"name": "Test Milestone",
"project": self.project1.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.post(
reverse("milestones-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Milestone.objects.all().count(), 2)
def test_create_milestone_by_project_owner(self):
data = {
"name": "Test Milestone",
"project": self.project1.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("milestones-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Milestone.objects.all().count(), 3)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_milestone_by_membership(self):
data = {
"name": "Test Milestone",
"project": self.project1.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("milestones-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Milestone.objects.all().count(), 3)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_milestone_by_membership_with_wron_project(self):
data = {
"name": "Test Milestone",
"project": self.project2.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("milestones-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_create_milestone_by_no_membership(self):
data = {
"name": "Test Milestone",
"project": self.project1.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("milestones-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_edit_milestone_by_anon(self):
data = {
"name": "Edited test milestone",
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertNotEqual(data["name"], self.milestone1.name)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Milestone.objects.all().count(), 2)
def test_edit_milestone_by_project_owner(self):
data = {
"name": "Modified milestone name",
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertNotEqual(data["name"], self.milestone1.name)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["name"], response.data["name"])
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_milestone_by_project_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_edit_milestone_by_owner(self):
data = {
"name": "Modified milestone name",
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertNotEqual(data["name"], self.milestone1.name)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["name"], response.data["name"])
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_milestone_by_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_edit_milestone_by_membership(self):
data = {
"name": "Modified milestone name",
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertNotEqual(data["name"], self.milestone1.name)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["name"], response.data["name"])
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_milestone_by_membership_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_edit_milestone_by_no_membership(self):
data = {
"name": "Modified milestone name",
}
self.assertEqual(Milestone.objects.all().count(), 2)
self.assertNotEqual(data["name"], self.milestone1.name)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.patch(
reverse("milestones-detail", args=(self.milestone1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()
def test_delete_milestone_by_ano(self):
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.delete(
reverse("milestones-detail", args=(self.milestone1.id,))
)
self.assertEqual(response.status_code, 401)
self.assertEqual(Milestone.objects.all().count(), 2)
def test_delete_milestone_by_project_owner(self):
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(
reverse("milestones-detail", args=(self.milestone1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Milestone.objects.all().count(), 1)
self.client.logout()
def test_delete_milestone_by_owner(self):
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(
reverse("milestones-detail", args=(self.milestone1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Milestone.objects.all().count(), 1)
self.client.logout()
def test_delete_milestone_by_membership(self):
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(
reverse("milestones-detail", args=(self.milestone1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Milestone.objects.all().count(), 1)
self.client.logout()
def test_delete_milestone_by_no_membership(self):
self.assertEqual(Milestone.objects.all().count(), 2)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.delete(
reverse("milestones-detail", args=(self.milestone1.id,))
)
self.assertEqual(response.status_code, 404)
self.assertEqual(Milestone.objects.all().count(), 2)
self.client.logout()

1
taiga/projects/mixins/tests/__init__.py
View File

@ -1 +0,0 @@

0
taiga/projects/mixins/tests/blocked/foo/__init__.py
View File

21
taiga/projects/mixins/tests/blocked/foo/models.py
View File

@ -1,21 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from taiga.projects.mixins.blocked import BlockedMixin
class BlockedFoo(BlockedMixin):
pass

78
taiga/projects/mixins/tests/blocked/tests_models.py
View File

@ -1,78 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django import test
from .foo.models import BlockedFoo
class BlockedMixinModelTestCase(test.TestCase):
def test_block_item_without_note(self):
obj = BlockedFoo.objects.create()
self.assertEqual(BlockedFoo.objects.all().count(), 1)
self.assertFalse(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
obj.is_blocked = True
obj.save()
self.assertTrue(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
def test_block_item_with_note(self):
obj = BlockedFoo.objects.create()
self.assertEqual(BlockedFoo.objects.all().count(), 1)
self.assertFalse(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
obj.is_blocked = True
obj.blocked_note = "Test note"
obj.save()
self.assertTrue(obj.is_blocked)
self.assertEqual(obj.blocked_note, "Test note")
def test_unblock_item_withou_note(self):
obj = BlockedFoo.objects.create(is_blocked=True)
self.assertEqual(BlockedFoo.objects.all().count(), 1)
self.assertTrue(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
obj.is_blocked = False
obj.save()
self.assertFalse(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
def test_unblock_item_with_note(self):
obj = BlockedFoo.objects.create(is_blocked=True, blocked_note="Test note")
self.assertEqual(BlockedFoo.objects.all().count(), 1)
self.assertTrue(obj.is_blocked)
self.assertEqual(obj.blocked_note, "Test note")
obj.is_blocked = False
obj.save()
self.assertFalse(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")
def test_unblock_item_with_new_note(self):
obj = BlockedFoo.objects.create(is_blocked=True, blocked_note="Test note")
self.assertEqual(BlockedFoo.objects.all().count(), 1)
self.assertTrue(obj.is_blocked)
self.assertEqual(obj.blocked_note, "Test note")
obj.is_blocked = False
obj.blocked_note = "New test note "
obj.save()
self.assertFalse(obj.is_blocked)
self.assertEqual(obj.blocked_note, "")

36
taiga/projects/tasks/tests/__init__.py
View File

@ -1,36 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_task(id, owner, project, milestone=None, user_story=None, save=True):
model = get_model("tasks", "Task")
instance = model(
subject="Task {0}".format(id),
description="The Task description.",
project=project,
milestone=milestone,
user_story=user_story,
status=project.task_statuses.all()[0],
owner=owner
)
if save:
instance.save()
return instance

777
taiga/projects/tasks/tests/tests_api.py
View File

@ -1,777 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core import mail
from django.core.urlresolvers import reverse
from taiga.users.tests import create_user
from taiga.projects.tests import create_project, add_membership
from taiga.projects.milestones.tests import create_milestone
from taiga.projects.userstories.tests import create_userstory
from taiga.projects.tasks.models import Task
from . import create_task
class TasksTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.user2 = create_user(2) # Owner
self.user3 = create_user(3) # Membership
self.user4 = create_user(4) # No Membership
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user2)
add_membership(self.project1, self.user3)
self.milestone1 = create_milestone(1, self.user2, self.project1)
self.userstory1 = create_userstory(1, self.user2, self.project1, self.milestone1)
self.userstory2 = create_userstory(2, self.user2, self.project1, self.milestone1)
self.userstory3 = create_userstory(3, self.user2, self.project1)
self.task1 = create_task(1, self.user2, self.project1, None, self.userstory1)
self.task2 = create_task(2, self.user3, self.project1, None, self.userstory1)
self.task3 = create_task(3, self.user2, self.project1, None, self.userstory2)
self.task4 = create_task(4, self.user3, self.project1, self.milestone1)
self.project2 = create_project(2, self.user4)
self.milestone2 = create_milestone(2, self.user4, self.project2)
self.userstory4 = create_userstory(4, self.user4, self.project2)
self.task5 = create_task(5, self.user4, self.project2, self.milestone2)
def test_list_tasks_by_anon(self):
response = self.client.get(reverse("tasks-list"))
self.assertEqual(response.status_code, 401)
def test_list_tasks_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-list"), HTTP_X_DISABLE_PAGINATION=True)
self.assertEqual(response.status_code, 200)
tasks_list = response.data
self.assertEqual(len(tasks_list), 4)
response = self.client.get(reverse("tasks-list"), {"page": 2},
HTTP_X_DISABLE_PAGINATION=True)
self.assertEqual(response.status_code, 200)
tasks_list = response.data
self.assertEqual(len(tasks_list), 4)
self.client.logout()
def test_list_tasks_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-list"))
self.assertEqual(response.status_code, 200)
tasks_list = response.data
self.assertEqual(len(tasks_list), 4)
self.client.logout()
def test_list_tasks_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-list"))
self.assertEqual(response.status_code, 200)
tasks_list = response.data
self.assertEqual(len(tasks_list), 4)
self.client.logout()
def test_list_tasks_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-list"))
self.assertEqual(response.status_code, 200)
tasks_list = response.data
self.assertEqual(len(tasks_list), 1)
self.client.logout()
def test_view_task_by_anon(self):
response = self.client.get(reverse("tasks-detail", args=(self.task1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_task_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-detail", args=(self.task1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_task_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-detail", args=(self.task1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_task_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("tasks-detail", args=(self.task1.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_task_by_anon(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Task.objects.all().count(), 5)
def test_create_task_by_project_owner(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Task.objects.all().count(), 6)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_task_by_project_owner_with_wron_project(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project2.id,
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_project_owner_with_wron_milestone(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_project_owner_with_wron_userstory(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"user_story": self.userstory4.id,
"status": self.project1.task_statuses.all()[1].id,
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_project_owner_with_wron_status(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_membership(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Task.objects.all().count(), 6)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_task_by_membership_with_wron_project(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project2.id,
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_membership_with_wron_milestone(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_membership_with_wron_userstory(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"user_story": self.userstory4.id,
"status": self.project1.task_statuses.all()[1].id,
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_membership_with_wron_status(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_create_task_by_no_membership(self):
data = {
"subject": "Test Task",
"description": "A Test Task example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("tasks-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_anon(self):
data = {
"subject": "Edited test task",
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertNotEqual(data["subject"], self.task1.subject)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Task.objects.all().count(), 5)
def test_edit_task_by_project_owner(self):
data = {
"subject": "Modified task subject",
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertNotEqual(data["subject"], self.task1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_task_by_project_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_project_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["milestone"], self.milestone1.id)
self.assertEqual(Task.objects.all().count(), 5)
data = {
"milestone": self.milestone2.id,
"user_story": None
}
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_project_owner_with_wron_userstory(self):
data = {
"user_story": self.userstory4.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_project_owner_with_wron_status(self):
data = {
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_owner(self):
data = {
"subject": "Modified task subject",
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertNotEqual(data["subject"], self.task1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_task_by_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["milestone"], self.milestone1.id)
self.assertEqual(Task.objects.all().count(), 5)
data = {
"milestone": self.milestone2.id,
"user_story": None
}
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_owner_with_wron_userstory(self):
data = {
"user_story": self.userstory4.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_owner_with_wron_status(self):
data = {
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_membership(self):
data = {
"subject": "Modified task subject",
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertNotEqual(data["subject"], self.task1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(Task.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_task_by_membership_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_membership_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["milestone"], self.milestone1.id)
self.assertEqual(Task.objects.all().count(), 5)
data = {
"milestone": self.milestone2.id,
"user_story": None
}
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_membership_with_wron_userstory(self):
data = {
"user_story": self.userstory4.id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_membership_with_wron_status(self):
data = {
"status": self.project2.task_statuses.all()[1].id
}
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_edit_task_by_no_membership(self):
data = {
"subject": "Modified task subject",
}
self.assertEqual(Task.objects.all().count(), 5)
self.assertNotEqual(data["subject"], self.task1.subject)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.patch(
reverse("tasks-detail", args=(self.task1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()
def test_delete_task_by_ano(self):
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.delete(
reverse("tasks-detail", args=(self.task1.id,))
)
self.assertEqual(response.status_code, 401)
self.assertEqual(Task.objects.all().count(), 5)
def test_delete_task_by_project_owner(self):
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(
reverse("tasks-detail", args=(self.task1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Task.objects.all().count(), 4)
self.client.logout()
def test_delete_task_by_owner(self):
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(
reverse("tasks-detail", args=(self.task1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Task.objects.all().count(), 4)
self.client.logout()
def test_delete_task_by_membership(self):
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(
reverse("tasks-detail", args=(self.task1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Task.objects.all().count(), 4)
self.client.logout()
def test_delete_task_by_no_membership(self):
self.assertEqual(Task.objects.all().count(), 5)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.delete(
reverse("tasks-detail", args=(self.task1.id,))
)
self.assertEqual(response.status_code, 404)
self.assertEqual(Task.objects.all().count(), 5)
self.client.logout()

47
taiga/projects/tests/__init__.py
View File

@ -1,47 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
from taiga.domains import get_active_domain
def create_project(id, owner, save=True):
model = get_model("projects", "Project")
instance = model(
name="Project {0}".format(id),
description="This is a test project",
owner=owner,
total_story_points=id,
domain=get_active_domain()
)
if save:
instance.save()
return instance
def add_membership(project, user, role_slug="back"):
model = get_model("users", "Role")
role = model.objects.get(slug=role_slug, project=project)
model = get_model("projects", "Membership")
instance = model.objects.create(
project=project,
user=user,
role=role
)
return instance

845
taiga/projects/tests/tests_api.py
View File

@ -1,845 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core.urlresolvers import reverse
from django.core import mail
from django.db.models import get_model
from taiga.users.tests import create_user
from taiga.projects.models import Project, Membership, ProjectTemplate
from taiga.domains.models import Domain
from . import create_project
from . import add_membership
class ProfileTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1, is_superuser=True)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.project1 = create_project(1, self.user1)
self.project2 = create_project(2, self.user1)
self.project3 = create_project(3, self.user2)
add_membership(self.project1, self.user3, "back")
add_membership(self.project3, self.user3, "back")
add_membership(self.project3, self.user2, "back")
def test_list_users(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("users-list"))
self.assertEqual(response.status_code, 200)
users_list = response.data
self.assertEqual(len(users_list), 1)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("users-list"))
self.assertEqual(response.status_code, 200)
users_list = response.data
self.assertEqual(len(users_list), 3)
def test_update_users(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.patch(
reverse("users-detail", args=[self.user2.pk]),
content_type="application/json",
data=json.dumps(data))
self.assertEqual(response.status_code, 404)
def test_update_users_self(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.patch(
reverse("users-detail", args=[self.user3.pk]),
content_type="application/json",
data=json.dumps(data))
self.assertEqual(response.status_code, 200)
def test_update_users_superuser(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.patch(
reverse("users-detail", args=[self.user3.pk]),
content_type="application/json",
data=json.dumps(data))
self.assertEqual(response.status_code, 200)
def test_delete_users(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.delete(
reverse("users-detail", args=[self.user2.pk]))
self.assertEqual(response.status_code, 404)
def test_delete_users_self(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.delete(
reverse("users-detail", args=[self.user3.pk]))
self.assertEqual(response.status_code, 204)
def test_delete_users_superuser(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
data = {"full_name": "Foo Bar"}
response = self.client.delete(
reverse("users-detail", args=[self.user3.pk]))
self.assertEqual(response.status_code, 204)
def test_password_recovery(self):
url = reverse("users-password-recovery")
data = {"username": self.user1.username}
response = self.client.post(url, data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(len(mail.outbox), 1)
self.assertNotEqual(len(mail.outbox[0].body), 0)
def test_users_change_password_from_recovery(self):
self.user1.token = "1111-1111-1111-1111"
self.user1.save()
url = reverse("users-change-password-from-recovery")
data = {"token": self.user1.token, "password": "111111"}
response = self.client.post(url, data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 204)
user = get_model("users", "User").objects.get(pk=self.user1.pk)
self.assertTrue(user.check_password("111111"))
def test_users_change_password(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
url = reverse("users-change-password")
data = {"password": "111111"}
response = self.client.post(url, data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 204)
user = get_model("users", "User").objects.get(pk=self.user1.pk)
self.assertTrue(user.check_password("111111"))
class ProjectsTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user3 = create_user(4)
self.project1 = create_project(1, self.user1)
self.project2 = create_project(2, self.user1)
self.project3 = create_project(3, self.user2)
self.project4 = create_project(4, self.user2)
add_membership(self.project1, self.user3, "back")
add_membership(self.project3, self.user3, "back")
self.dev_role1 = get_model("users", "Role").objects.get(slug="back", project=self.project1)
self.dev_role2 = get_model("users", "Role").objects.get(slug="back", project=self.project2)
self.dev_role3 = get_model("users", "Role").objects.get(slug="back", project=self.project3)
self.dev_role4 = get_model("users", "Role").objects.get(slug="back", project=self.project4)
def test_send_invitations_01(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
url = reverse("memberships-list")
data = {"role": self.dev_role4.id,
"email": "pepe@pepe.com",
"project": self.project4.id}
response = self.client.post(url, data=json.dumps(data), content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(self.project4.memberships.count(), 2)
self.assertEqual(len(mail.outbox), 1)
self.assertNotEqual(len(mail.outbox[0].body), 0)
def test_send_invitations_02(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
url = reverse("memberships-list")
data = {"role": self.dev_role4.id,
"email": "pepe@pepe.com",
"project": self.project4.id}
response = self.client.post(url, data=json.dumps(data), content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(self.project4.memberships.count(), 2)
self.assertEqual(len(mail.outbox), 1)
self.assertNotEqual(len(mail.outbox[0].body), 0)
response = self.client.post(url, data=json.dumps(data), content_type="application/json")
self.assertEqual(self.project4.memberships.count(), 2)
self.assertEqual(response.status_code, 400)
self.assertEqual(len(mail.outbox), 1)
self.assertNotEqual(len(mail.outbox[0].body), 0)
def test_send_invitations_03(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
url = reverse("memberships-list")
data = {"role": self.dev_role3.id,
"email": self.user3.email,
"project": self.project3.id}
response = self.client.post(url, data=json.dumps(data), content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(len(mail.outbox), 0)
def test_list_projects_by_anon(self):
response = self.client.get(reverse("projects-list"))
self.assertEqual(response.status_code, 401)
def test_list_projects_by_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-list"))
self.assertEqual(response.status_code, 200)
projects_list = response.data
self.assertEqual(len(projects_list), 2)
self.client.logout()
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-list"))
self.assertEqual(response.status_code, 200)
projects_list = response.data
self.assertEqual(len(projects_list), 2)
self.client.logout()
def test_list_projects_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-list"))
self.assertEqual(response.status_code, 200)
projects_list = response.data
self.assertEqual(len(projects_list), 2)
self.client.logout()
def test_view_project_by_anon(self):
response = self.client.get(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_project_by_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("projects-detail", args=(self.project2.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_project_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("projects-detail", args=(self.project3.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_project_by_not_membership(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("projects-detail", args=(self.project3.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_project_by_anon(self):
data = {
"name": "Test Project",
"description": "A new Test Project",
"total_story_points": 10
}
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.post(
reverse("projects-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Project.objects.all().count(), 4)
def test_create_project_by_auth(self):
data = {
"name": "Test Project",
"description": "A new Test Project",
"total_story_points": 10
}
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(reverse("projects-list"), json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Project.objects.all().count(), 5)
self.client.logout()
def test_edit_project_by_anon(self):
data = {
"description": "Edited project description",
}
self.assertEqual(Project.objects.all().count(), 4)
self.assertNotEqual(data["description"], self.project1.description)
response = self.client.patch(
reverse("projects-detail", args=(self.project1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(Project.objects.all().count(), 4)
def test_edit_project_by_owner(self):
data = {
"description": "Modified project description",
}
self.assertEqual(Project.objects.all().count(), 4)
self.assertNotEqual(data["description"], self.project1.description)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("projects-detail", args=(self.project1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["description"], response.data["description"])
self.assertEqual(Project.objects.all().count(), 4)
self.client.logout()
def test_edit_project_by_membership(self):
data = {
"description": "Edited project description",
}
self.assertEqual(Project.objects.all().count(), 4)
self.assertNotEqual(data["description"], self.project1.description)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("projects-detail", args=(self.project1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["description"], response.data["description"])
self.assertEqual(Project.objects.all().count(), 4)
self.client.logout()
def test_edit_project_by_not_membership(self):
data = {
"description": "Edited project description",
}
self.assertEqual(Project.objects.all().count(), 4)
self.assertNotEqual(data["description"], self.project1.description)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("projects-detail", args=(self.project1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(Project.objects.all().count(), 4)
self.client.logout()
def test_delete_project_by_anon(self):
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.delete(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 401)
self.assertEqual(Project.objects.all().count(), 4)
def test_delete_project_by_owner(self):
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 204)
self.assertEqual(Project.objects.all().count(), 3)
self.client.logout()
def test_delete_project_by_membership(self):
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(reverse("projects-detail", args=(self.project1.id,)))
self.assertEqual(response.status_code, 403)
self.assertEqual(Project.objects.all().count(), 4)
self.client.logout()
def test_delete_project_by_not_membership(self):
self.assertEqual(Project.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(reverse("projects-detail", args=(self.project3.id,)))
self.assertEqual(response.status_code, 404)
self.assertEqual(Project.objects.all().count(), 4)
self.client.logout()
class ProjectTemplatesTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.domain = Domain.objects.all()[0]
self.domain.owner = self.user1
def test_list_project_templates_by_anon(self):
response = self.client.get(reverse("project-templates-list"))
self.assertEqual(response.status_code, 401)
def test_list_project_templates_by_domain_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("project-templates-list"))
self.assertEqual(response.status_code, 200)
projects_list = response.data
self.assertEqual(len(projects_list), 2)
self.client.logout()
def test_list_projects_by_not_domain_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("project-templates-list"))
self.assertEqual(response.status_code, 403)
def test_view_project_template_by_anon(self):
response = self.client.get(reverse("project-templates-detail", args=(1,)))
self.assertEqual(response.status_code, 401)
def test_view_project_template_by_domain_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("project-templates-detail", args=(1,)))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("project-templates-detail", args=(2,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_project_template_by_not_domain_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("project-templates-detail", args=(1,)))
self.assertEqual(response.status_code, 403)
response = self.client.get(reverse("project-templates-detail", args=(2,)))
self.assertEqual(response.status_code, 403)
self.client.logout()
def test_create_project_template_by_anon(self):
data = {
"name": "Test Project Template",
"slug": "test-project-template",
"description": "A new Test Project Template",
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.post(
reverse("project-templates-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
data = {
"name": "Test Project Template 2",
"slug": "test-project-template-2",
"description": "A new Test Project Template",
"domain": 100,
}
response = self.client.post(
reverse("project-templates-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
def test_create_project_template_by_domain_owner(self):
data = {
"name": "Test Project Template",
"slug": "test-project-template",
"description": "A new Test Project Template",
"default_owner_role": "test",
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(reverse("project-templates-list"), json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
data = {
"name": "Test Project Template 2",
"slug": "test-project-template-2",
"description": "A new Test Project Template",
"default_owner_role": "test",
"domain": 100,
}
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(reverse("project-templates-list"), json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(ProjectTemplate.objects.all().count(), 4)
template = ProjectTemplate.objects.order_by('-created_date')[0]
self.assertEqual(template.domain.id, 1)
self.client.logout()
ProjectTemplate.objects.order_by("created_date")[0].delete()
ProjectTemplate.objects.order_by("created_date")[1].delete()
def test_create_project_template_by_not_domain_owner(self):
data = {
"name": "Test Project Template",
"slug": "test-project-template",
"description": "A new Test Project Template",
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("project-templates-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
data = {
"name": "Test Project Template 2",
"slug": "test-project-template-2",
"description": "A new Test Project Template",
"domain": 100
}
response = self.client.post(
reverse("project-templates-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
self.client.logout()
def test_edit_project_template_by_anon(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
data = {"description": "A new Test Project Template", }
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.patch(
reverse("project-templates-detail", args=(1,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
response = self.client.patch(
reverse("project-templates-detail", args=(template.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
template.delete()
def test_edit_project_template_by_domain_owner(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
data = {"description": "A new Test Project Template", }
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.patch(
reverse("project-templates-detail", args=(1,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
response = self.client.patch(
reverse("project-templates-detail", args=(template.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
template.delete()
self.client.logout()
def test_edit_project_template_by_not_domain_owner(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
data = {"description": "A new Test Project Template", }
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.patch(
reverse("project-templates-detail", args=(1,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
response = self.client.patch(
reverse("project-templates-detail", args=(template.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
template.delete()
self.client.logout()
def test_delete_project_template_by_anon(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.delete(reverse("projects-detail", args=(1,)))
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.delete(reverse("projects-detail", args=(template.id,)))
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
template.delete()
def test_delete_project_template_by_domain_owner(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(reverse("project-templates-detail", args=(1,)))
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.delete(reverse("project-templates-detail", args=(template.id,)))
self.assertEqual(response.status_code, 204)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
template.delete()
self.client.logout()
def test_delete_project_template_by_not_domain_owner(self):
template = ProjectTemplate.objects.create(
name="Test Project Template with domain",
slug="test-project-template-with-domain",
description="A new Test Project Template with domain",
domain_id=1
)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(reverse("project-templates-detail", args=(1,)))
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
response = self.client.delete(reverse("project-templates-detail", args=(template.id,)))
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
template.delete()
self.client.logout()
def test_create_project_template_from_project_by_anon(self):
data = {
"project_id": 1,
"template_name": "Test",
"template_description": "Test"
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 401)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
def test_create_project_template_from_project_by_domain_owner(self):
project = create_project(1, self.user1)
data = {
"project_id": project.id,
"template_description": "Test"
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 400)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
data = {
"template_name": "Test",
"template_description": "Test"
}
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 400)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
data = {
"project_id": project.id,
"template_name": "Test",
"template_description": "Test"
}
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 201)
self.assertEqual(ProjectTemplate.objects.all().count(), 3)
ProjectTemplate.objects.get(slug="test").delete()
self.client.logout()
def test_create_project_template_from_project_by_not_domain_owner(self):
data = {
"project_id": 1,
"template_name": "Test",
"template_description": "Test"
}
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
response = self.client.post(reverse("project-templates-create-from-project"), data)
self.assertEqual(response.status_code, 403)
self.assertEqual(ProjectTemplate.objects.all().count(), 2)
self.client.logout()

77
taiga/projects/tests/tests_model.py
View File

@ -1,77 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core.urlresolvers import reverse
from django.core import mail
from django.db.models import get_model
from django.conf import settings
from taiga.users.tests import create_user
from taiga.projects.models import Project, Membership, ProjectTemplate, Role
from taiga.domains.models import Domain
from . import create_project
from . import add_membership
class ProjectTemplateModelTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user = create_user(1)
self.domain = Domain.objects.all()[0]
self.template = ProjectTemplate.objects.get(slug="scrum")
def test_apply_to_not_saved_project(self):
not_saved_project = Project()
self.assertRaises(Exception, self.template.apply_to_project, (not_saved_project,))
def test_apply_to_saved_project(self):
# Post-save apply the default template
project = Project.objects.create(name="Test", slug="test", owner=self.user)
self.assertEqual(project.creation_template.slug, settings.DEFAULT_PROJECT_TEMPLATE)
self.assertEqual(project.memberships.filter(user=self.user).count(), 1)
def test_load_data_from_project_with_invalid_object(self):
self.assertRaises(Exception, self.template.load_data_from_project, (None,))
def test_load_data_from_project_not_defaults(self):
project = Project.objects.create(name="Test", slug="test", owner=self.user)
project.default_points = None
project.default_us_status = None
project.default_task_status = None
project.default_issue_status = None
project.default_issue_type = None
project.default_priority = None
project.default_severity = None
membership = project.memberships.get(user=self.user)
membership.role = Role.objects.get(slug="ux")
membership.save()
template = ProjectTemplate()
template.load_data_from_project(project)
self.assertIsNone(template.default_options["points"])
self.assertIsNone(template.default_options["us_status"])
self.assertIsNone(template.default_options["task_status"])
self.assertIsNone(template.default_options["issue_status"])
self.assertIsNone(template.default_options["issue_type"])
self.assertIsNone(template.default_options["priority"])
self.assertIsNone(template.default_options["severity"])
self.assertEqual(template.default_owner_role, "ux")

220
taiga/projects/tests/tests_notifications.py
View File

@ -1,220 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core.urlresolvers import reverse
from django.core import mail
from django.db.models import get_model
from taiga.users.tests import create_user
from taiga.projects.models import Project, Membership
from taiga.projects.issues.tests import create_issue
from taiga.projects.tasks.tests import create_task
from . import create_project
from . import add_membership
class AllProjectEventsNotificationsTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user4 = create_user(4)
self.user5 = create_user(5)
self.user1.notify_level = "all_owned_projects"
self.user1.save()
self.user2.notify_level = "all_owned_projects"
self.user2.save()
self.user3.notify_level = "all_owned_projects"
self.user3.save()
self.user4.notify_level = "all_owned_projects"
self.user4.save()
self.user5.notify_level = "all_owned_projects"
self.user5.save()
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user1, "back")
add_membership(self.project1, self.user2, "back")
add_membership(self.project1, self.user3, "back")
add_membership(self.project1, self.user4, "back")
add_membership(self.project1, self.user5, "back")
def test_issue(self):
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user2, self.user3, self.user4, self.user5]
self.assertEqual(notified,set(expected_notified))
issue.delete()
def test_issue_with_owner_notification(self):
self.user1.notify_changes_by_me = True
self.user1.save()
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user1, self.user2, self.user3, self.user4, self.user5]
self.assertEqual(notified,set(expected_notified))
issue.delete()
self.user1.notify_changes_by_me = False
self.user1.save()
class OnlyAssigendNotificationsTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user4 = create_user(4)
self.user5 = create_user(5)
self.user1.notify_level = "only_assigned"
self.user1.save()
self.user2.notify_level = "only_assigned"
self.user2.save()
self.user3.notify_level = "only_assigned"
self.user3.save()
self.user4.notify_level = "only_assigned"
self.user4.save()
self.user5.notify_level = "only_assigned"
self.user5.save()
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user1, "back")
add_membership(self.project1, self.user2, "back")
add_membership(self.project1, self.user3, "back")
add_membership(self.project1, self.user4, "back")
add_membership(self.project1, self.user5, "back")
def test_issue(self):
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = []
self.assertEqual(notified,set(expected_notified))
issue.assigned_to = self.user1
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = []
self.assertEqual(notified,set(expected_notified))
issue.assigned_to = self.user2
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user2]
self.assertEqual(notified,set(expected_notified))
issue.delete()
def test_issue_with_owner_notification(self):
self.user1.notify_changes_by_me = True
self.user1.save()
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user1]
self.assertEqual(notified,set(expected_notified))
issue.assigned_to = self.user1
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user1]
self.assertEqual(notified,set(expected_notified))
issue.assigned_to = self.user2
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user1, self.user2]
self.assertEqual(notified,set(expected_notified))
issue.delete()
self.user1.notify_changes_by_me = False
self.user1.save()
class OnlyOwnerNotificationsTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user4 = create_user(4)
self.user5 = create_user(5)
self.user1.notify_level = "only_owner"
self.user1.save()
self.user2.notify_level = "only_owner"
self.user2.save()
self.user3.notify_level = "only_owner"
self.user3.save()
self.user4.notify_level = "only_owner"
self.user4.save()
self.user5.notify_level = "only_owner"
self.user5.save()
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user1, "back")
add_membership(self.project1, self.user2, "back")
add_membership(self.project1, self.user3, "back")
add_membership(self.project1, self.user4, "back")
add_membership(self.project1, self.user5, "back")
def test_issue(self):
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user2)
expected_notified = [self.user1]
self.assertEqual(notified,set(expected_notified))
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = []
self.assertEqual(notified,set(expected_notified))
issue.owner = self.user2
notified = issue.get_watchers_to_notify(self.user2)
expected_notified = []
self.assertEqual(notified,set(expected_notified))
issue.delete()
def test_issue_with_owner_notification(self):
self.user1.notify_changes_by_me = True
self.user1.save()
issue = create_issue(1, self.user1, self.project1)
notified = issue.get_watchers_to_notify(self.user2)
expected_notified = [self.user1]
self.assertEqual(notified,set(expected_notified))
notified = issue.get_watchers_to_notify(self.user1)
expected_notified = [self.user1]
self.assertEqual(notified,set(expected_notified))
issue.owner = self.user2
notified = issue.get_watchers_to_notify(self.user2)
expected_notified = []
self.assertEqual(notified,set(expected_notified))
issue.delete()
self.user1.notify_changes_by_me = False
self.user1.save()

35
taiga/projects/userstories/tests/__init__.py
View File

@ -1,35 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_userstory(id, owner, project, milestone=None, save=True):
model = get_model("userstories", "UserStory")
instance = model(
subject="User Story {0}".format(id),
description="The US description.",
project=project,
milestone=milestone,
status=project.us_statuses.all()[0],
owner=owner
)
if save:
instance.save()
return instance

746
taiga/projects/userstories/tests/tests_api.py
View File

@ -1,746 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django import test
from django.core import mail
from django.core.urlresolvers import reverse
from taiga.users.tests import create_user
from taiga.projects.tests import create_project, add_membership
from taiga.projects.milestones.tests import create_milestone
from taiga.projects.userstories.models import UserStory
from taiga.projects.issues.tests import create_issue
from . import create_userstory
import json
class UserStoriesTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.user2 = create_user(2) # Owner
self.user3 = create_user(3) # Membership
self.user4 = create_user(4) # No Membership
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user2)
add_membership(self.project1, self.user3)
self.milestone1 = create_milestone(1, self.user2, self.project1)
self.userstory1 = create_userstory(1, self.user2, self.project1, self.milestone1)
self.userstory2 = create_userstory(2, self.user2, self.project1, self.milestone1)
self.userstory3 = create_userstory(3, self.user2, self.project1)
self.project2 = create_project(2, self.user4)
self.milestone2 = create_milestone(2, self.user4, self.project2)
self.userstory4 = create_userstory(4, self.user4, self.project2)
mail.outbox = []
def test_list_userstories_by_anon(self):
response = self.client.get(reverse("userstories-list"))
self.assertEqual(response.status_code, 401)
def test_list_userstories_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-list"))
self.assertEqual(response.status_code, 200)
userstories_list = response.data
self.assertEqual(len(userstories_list), 3)
self.client.logout()
def test_list_userstories_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-list"))
self.assertEqual(response.status_code, 200)
userstories_list = response.data
self.assertEqual(len(userstories_list), 3)
self.client.logout()
def test_list_userstories_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-list"))
self.assertEqual(response.status_code, 200)
userstories_list = response.data
self.assertEqual(len(userstories_list), 3)
self.client.logout()
def test_list_userstories_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-list"))
self.assertEqual(response.status_code, 200)
userstories_list = response.data
self.assertEqual(len(userstories_list), 1)
self.client.logout()
def test_view_userstory_by_anon(self):
response = self.client.get(reverse("userstories-detail", args=(self.userstory1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_userstory_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-detail", args=(self.userstory1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_userstory_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-detail", args=(self.userstory1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_userstory_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-detail", args=(self.userstory1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_userstory_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("userstories-detail", args=(self.userstory1.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_userstory_by_anon(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(UserStory.objects.all().count(), 4)
def test_create_userstory_by_project_owner(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(UserStory.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_userstory_by_project_owner_with_wron_project(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project2.id,
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_project_owner_with_wron_milestone(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_project_owner_with_wron_status(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_membership(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(UserStory.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_userstory_by_membership_with_wron_project(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project2.id,
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_membership_with_wron_milestone(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone2.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_membership_with_wron_status(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_create_userstory_by_no_membership(self):
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_anon(self):
data = {
"subject": "Edited test userstory",
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.userstory1.subject)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(UserStory.objects.all().count(), 4)
def test_edit_userstory_by_project_owner(self):
data = {
"subject": "Modified userstory subject",
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.userstory1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_userstory_by_project_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_project_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_project_owner_with_wron_status(self):
data = {
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_owner(self):
data = {
"subject": "Modified userstory subject",
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.userstory1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_userstory_by_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_owner_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_owner_with_wron_status(self):
data = {
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_membership(self):
data = {
"subject": "Modified userstory subject",
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.userstory1.subject)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["subject"], response.data["subject"])
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_userstory_by_membership_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_membership_with_wron_milestone(self):
data = {
"milestone": self.milestone2.id,
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_membership_with_wron_status(self):
data = {
"status": self.project2.us_statuses.all()[1].id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_edit_userstory_by_no_membership(self):
data = {
"subject": "Modified userstory subject",
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertNotEqual(data["subject"], self.userstory1.subject)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.patch(
reverse("userstories-detail", args=(self.userstory1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
def test_delete_userstory_by_ano(self):
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.delete(
reverse("userstories-detail", args=(self.userstory1.id,))
)
self.assertEqual(response.status_code, 401)
self.assertEqual(UserStory.objects.all().count(), 4)
def test_delete_userstory_by_project_owner(self):
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(
reverse("userstories-detail", args=(self.userstory1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(UserStory.objects.all().count(), 3)
self.client.logout()
def test_delete_userstory_by_owner(self):
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(
reverse("userstories-detail", args=(self.userstory1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(UserStory.objects.all().count(), 3)
self.client.logout()
def test_delete_userstory_by_membership(self):
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(
reverse("userstories-detail", args=(self.userstory1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(UserStory.objects.all().count(), 3)
self.client.logout()
def test_delete_userstory_by_no_membership(self):
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.delete(
reverse("userstories-detail", args=(self.userstory1.id,))
)
self.assertEqual(response.status_code, 404)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()
##########################################
def test_create_userstory_from_issue_by_anon(self):
issue = create_issue(1, self.user2, self.project1, self.milestone1)
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id,
"generated_from_issue": issue.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(UserStory.objects.all().count(), 4)
def test_create_userstory_from_issue_by_project_owner(self):
issue = create_issue(1, self.user2, self.project1, self.milestone1)
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id,
"generated_from_issue": issue.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(UserStory.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(response.data["origin_issue"]["subject"], issue.subject)
self.client.logout()
def test_create_userstory_from_issue_by_membership(self):
issue = create_issue(1, self.user2, self.project1, self.milestone1)
data = {
"subject": "Test UserStory creation from issue",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id,
"generated_from_issue": issue.id,
"issue_comment": "This is a test example",
"generated_from_issue": issue.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(UserStory.objects.all().count(), 5)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(response.data["origin_issue"]["subject"], issue.subject)
self.client.logout()
def test_create_userstory_from_issue_by_no_membership(self):
issue = create_issue(1, self.user2, self.project1, self.milestone1)
data = {
"subject": "Test UserStory",
"description": "A Test UserStory example description",
"project": self.project1.id,
"milestone": self.milestone1.id,
"status": self.project1.us_statuses.all()[1].id,
"generated_from_issue": issue.id
}
self.assertEqual(UserStory.objects.all().count(), 4)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("userstories-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(UserStory.objects.all().count(), 4)
self.client.logout()

61
taiga/projects/userstories/tests/tests_services.py
View File

@ -1,61 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from taiga.users.tests import create_user
from taiga.projects.tests import create_project
from .. import services
from .. import models
from . import create_userstory
class UserStoriesServiceTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1) # Project owner
self.project1 = create_project(1, self.user1)
def test_bulk_insert(self):
model = models.UserStory
self.assertEqual(model.objects.count(), 0)
service = services.UserStoriesService()
service.bulk_insert(self.project1, self.user1, "kk1\nkk2\n")
self.assertEqual(model.objects.count(), 2)
def test_bulk_order_update(self):
userstory1 = create_userstory(1, self.user1, self.project1)
userstory2 = create_userstory(2, self.user1, self.project1)
data = [
[userstory1.id, 20],
[userstory2.id, 30],
]
service = services.UserStoriesService()
service.bulk_update_order(self.project1, self.user1, data)
model = models.UserStory
userstory1 = model.objects.get(pk=userstory1.id)
userstory2 = model.objects.get(pk=userstory2.id)
self.assertEqual(userstory1.order, 20)
self.assertEqual(userstory2.order, 30)

32
taiga/projects/wiki/tests/__init__.py
View File

@ -1,32 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_wiki_page(id, owner, project, save=True):
model = get_model("wiki", "WikiPage")
instance = model(
slug="wikipage-{0}".format(id),
content="WikiPage {0}".format(id),
project=project,
owner=owner
)
if save:
instance.save()
return instance

426
taiga/projects/wiki/tests/tests_api.py
View File

@ -1,426 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from django import test
from django.core import mail
from django.core.urlresolvers import reverse
from taiga.users.tests import create_user
from taiga.projects.tests import create_project, add_membership
from taiga.projects.wiki.models import WikiPage
from . import create_wiki_page
class WikiPagesTestCase(test.TestCase):
fixtures = ["initial_domains.json", "initial_project_templates.json"]
def setUp(self):
self.user1 = create_user(1)
self.user2 = create_user(2)
self.user3 = create_user(3)
self.user4 = create_user(4)
self.project1 = create_project(1, self.user1)
add_membership(self.project1, self.user2)
add_membership(self.project1, self.user3)
self.project2 = create_project(2, self.user4)
self.wiki_page1 = create_wiki_page(1, self.user2, self.project1)
self.wiki_page2 = create_wiki_page(2, self.user2, self.project1)
def test_list_wiki_pages_by_anon(self):
response = self.client.get(reverse("wiki-list"))
self.assertEqual(response.status_code, 401)
def test_list_wiki_pages_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-list"))
self.assertEqual(response.status_code, 200)
wiki_pages_list = response.data
self.assertEqual(len(wiki_pages_list), 2)
self.client.logout()
def test_list_wiki_pages_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-list"))
self.assertEqual(response.status_code, 200)
wiki_pages_list = response.data
self.assertEqual(len(wiki_pages_list), 2)
self.client.logout()
def test_list_wiki_pages_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-list"))
self.assertEqual(response.status_code, 200)
wiki_pages_list = response.data
self.assertEqual(len(wiki_pages_list), 2)
self.client.logout()
def test_list_wiki_pages_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-list"))
self.assertEqual(response.status_code, 200)
wiki_pages_list = response.data
self.assertEqual(len(wiki_pages_list), 0)
self.client.logout()
def test_view_wiki_page_by_anon(self):
response = self.client.get(reverse("wiki-detail", args=(self.wiki_page1.id,)))
self.assertEqual(response.status_code, 401)
def test_view_wiki_page_by_project_owner(self):
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-detail", args=(self.wiki_page1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_wiki_page_by_owner(self):
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-detail", args=(self.wiki_page1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_wiki_page_by_membership(self):
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-detail", args=(self.wiki_page1.id,)))
self.assertEqual(response.status_code, 200)
self.client.logout()
def test_view_wiki_page_by_no_membership(self):
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.get(reverse("wiki-detail", args=(self.wiki_page1.id,)))
self.assertEqual(response.status_code, 404)
self.client.logout()
def test_create_wiki_page_by_anon(self):
data = {
"slug": "test-wiki-page",
"content": "Test WikiPage",
"project": self.project1.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.post(
reverse("wiki-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(WikiPage.objects.all().count(), 2)
def test_create_wiki_page_by_project_owner(self):
data = {
"slug": "test-wiki-page",
"content": "Test WikiPage",
"project": self.project1.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.post(
reverse("wiki-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(WikiPage.objects.all().count(), 3)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_wiki_page_by_membership(self):
data = {
"slug": "test-wiki-page",
"content": "Test WikiPage",
"project": self.project1.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("wiki-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
self.assertEqual(WikiPage.objects.all().count(), 3)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_create_wiki_page_by_membership_with_wron_project(self):
data = {
"slug": "test-wiki-page",
"content": "Test WikiPage",
"project": self.project2.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.post(
reverse("wiki-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_create_wiki_page_by_no_membership(self):
data = {
"slug": "test-wiki-page",
"content": "Test WikiPage",
"project": self.project1.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.post(
reverse("wiki-list"),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_edit_wiki_page_by_anon(self):
data = {
"content": "Edited test wiki_page",
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertNotEqual(data["content"], self.wiki_page1.content)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 401)
self.assertEqual(WikiPage.objects.all().count(), 2)
def test_edit_wiki_page_by_project_owner(self):
data = {
"content": "Edited test wiki_page",
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertNotEqual(data["content"], self.wiki_page1.content)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["content"], response.data["content"])
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_wiki_page_by_project_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_edit_wiki_page_by_owner(self):
data = {
"content": "Edited test wiki_page",
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertNotEqual(data["content"], self.wiki_page1.content)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["content"], response.data["content"])
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_wiki_page_by_owner_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_edit_wiki_page_by_membership(self):
data = {
"content": "Edited test wiki_page",
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertNotEqual(data["content"], self.wiki_page1.content)
self.assertEqual(len(mail.outbox), 0)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 200)
self.assertEqual(data["content"], response.data["content"])
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertEqual(len(mail.outbox), 2)
self.client.logout()
def test_edit_wiki_page_by_membership_with_wron_project(self):
data = {
"project": self.project2.id
}
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 403)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_edit_wiki_page_by_no_membership(self):
data = {
"content": "Edited test wiki_page",
}
self.assertEqual(WikiPage.objects.all().count(), 2)
self.assertNotEqual(data["content"], self.wiki_page1.content)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.patch(
reverse("wiki-detail", args=(self.wiki_page1.id,)),
json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 404)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()
def test_delete_wiki_page_by_ano(self):
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.delete(
reverse("wiki-detail", args=(self.wiki_page1.id,))
)
self.assertEqual(response.status_code, 401)
self.assertEqual(WikiPage.objects.all().count(), 2)
def test_delete_wiki_page_by_project_owner(self):
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user1.username,
password=self.user1.username)
self.assertTrue(response)
response = self.client.delete(
reverse("wiki-detail", args=(self.wiki_page1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(WikiPage.objects.all().count(), 1)
self.client.logout()
def test_delete_wiki_page_by_owner(self):
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user2.username,
password=self.user2.username)
self.assertTrue(response)
response = self.client.delete(
reverse("wiki-detail", args=(self.wiki_page1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(WikiPage.objects.all().count(), 1)
self.client.logout()
def test_delete_wiki_page_by_membership(self):
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user3.username,
password=self.user3.username)
self.assertTrue(response)
response = self.client.delete(
reverse("wiki-detail", args=(self.wiki_page1.id,))
)
self.assertEqual(response.status_code, 204)
self.assertEqual(WikiPage.objects.all().count(), 1)
self.client.logout()
def test_delete_wiki_page_by_no_membership(self):
self.assertEqual(WikiPage.objects.all().count(), 2)
response = self.client.login(username=self.user4.username,
password=self.user4.username)
self.assertTrue(response)
response = self.client.delete(
reverse("wiki-detail", args=(self.wiki_page1.id,))
)
self.assertEqual(response.status_code, 404)
self.assertEqual(WikiPage.objects.all().count(), 2)
self.client.logout()

47
taiga/users/tests/__init__.py
View File

@ -1,47 +0,0 @@
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.db.models.loading import get_model
def create_user(id, save=True, is_superuser=False):
model = get_model("users", "User")
domain_member_model = get_model("domains", "DomainMember")
domain_model = get_model("domains", "Domain")
instance = model(
username="user{0}".format(id),
email="user{0}@taiga.io".format(id),
full_name="Foo{0} Bar{0}".format(id)
)
instance.set_password(instance.username)
if is_superuser:
instance.is_staff = True
instance.is_superuser = True
instance.save()
domain = domain_model.objects.get(pk=1)
dm = domain_member_model.objects.create(user=instance,
email=instance.email,
domain=domain)
if id == 1:
dm.is_owner = True
dm.is_staff = True
dm.save()
return instance