def test_user_list(client, data):
url = reverse('users-list')
response = client.get(url)
users_data = json.loads(response.content.decode('utf-8'))
assert len(users_data) == 0
assert response.status_code == 200
client.login(data.registered_user)
response = client.get(url)
users_data = json.loads(response.content.decode('utf-8'))
assert len(users_data) == 1
assert response.status_code == 200
client.login(data.other_user)
response = client.get(url)
users_data = json.loads(response.content.decode('utf-8'))
assert len(users_data) == 1
assert response.status_code == 200
client.login(data.superuser)
response = client.get(url)
users_data = json.loads(response.content.decode('utf-8'))
assert len(users_data) == 3
assert response.status_code == 200
def test_project_list_with_discover_mode_enabled(client, data):
url = "{}?{}".format(reverse('projects-list'), "discover_mode=true")
response = client.get(url)
projects_data = json.loads(response.content.decode('utf-8'))
assert len(projects_data) == 2
assert response.status_code == 200
client.login(data.registered_user)
response = client.get(url)
projects_data = json.loads(response.content.decode('utf-8'))
assert len(projects_data) == 2
assert response.status_code == 200
client.login(data.project_member_with_perms)
response = client.get(url)
projects_data = json.loads(response.content.decode('utf-8'))
assert len(projects_data) == 2
assert response.status_code == 200
client.login(data.project_owner)
response = client.get(url)
projects_data = json.loads(response.content.decode('utf-8'))
assert len(projects_data) == 2
assert response.status_code == 200
def test_issue_list(client, data):
url = reverse('issues-list')
response = client.get(url)
issues_data = json.loads(response.content.decode('utf-8'))
assert len(issues_data) == 2
assert response.status_code == 200
client.login(data.registered_user)
response = client.get(url)
issues_data = json.loads(response.content.decode('utf-8'))
assert len(issues_data) == 2
assert response.status_code == 200
client.login(data.project_member_with_perms)
response = client.get(url)
issues_data = json.loads(response.content.decode('utf-8'))
assert len(issues_data) == 4
assert response.status_code == 200
client.login(data.project_owner)
response = client.get(url)
issues_data = json.loads(response.content.decode('utf-8'))
assert len(issues_data) == 4
assert response.status_code == 200
def test_epic_related_userstories_list(client, data):
url = reverse('epics-related-userstories-list', args=[data.public_epic.pk])
response = client.get(url)
related_uss_data = json.loads(response.content.decode('utf-8'))
assert len(related_uss_data) == 1
assert response.status_code == 200
client.login(data.registered_user)
url = reverse('epics-related-userstories-list',
args=[data.private_epic1.pk])
response = client.get(url)
related_uss_data = json.loads(response.content.decode('utf-8'))
assert len(related_uss_data) == 1
assert response.status_code == 200
client.login(data.project_member_with_perms)
url = reverse('epics-related-userstories-list',
args=[data.private_epic2.pk])
response = client.get(url)
related_uss_data = json.loads(response.content.decode('utf-8'))
assert len(related_uss_data) == 1
assert response.status_code == 200
client.login(data.project_owner)
url = reverse('epics-related-userstories-list',
args=[data.blocked_epic.pk])
response = client.get(url)
related_uss_data = json.loads(response.content.decode('utf-8'))
assert len(related_uss_data) == 1
assert response.status_code == 200
def test_import_epic_with_user_stories(client):
project = f.ProjectFactory()
project.default_points = f.PointsFactory.create(project=project)
project.default_issue_type = f.IssueTypeFactory.create(project=project)
project.default_issue_status = f.IssueStatusFactory.create(project=project)
project.default_epic_status = f.EpicStatusFactory.create(project=project)
project.default_us_status = f.UserStoryStatusFactory.create(
project=project)
project.default_task_status = f.TaskStatusFactory.create(project=project)
project.default_priority = f.PriorityFactory.create(project=project)
project.default_severity = f.SeverityFactory.create(project=project)
epic = f.EpicFactory.create(subject="test epic export",
project=project,
status=project.default_epic_status)
user_story = f.UserStoryFactory.create(project=project,
status=project.default_us_status,
milestone=None)
f.RelatedUserStory.create(epic=epic, user_story=user_story, order=55)
output = io.BytesIO()
render_project(user_story.project, output)
project_data = json.loads(output.getvalue())
epic.project.delete()
project = store_project_from_dict(project_data)
assert project.epics.count() == 1
assert project.epics.first().ref == epic.ref
assert project.epics.first().user_stories.count() == 1
related_userstory = project.epics.first().relateduserstory_set.first()
assert related_userstory.user_story.ref == user_story.ref
assert related_userstory.order == 55
assert related_userstory.epic.ref == epic.ref
def test_export_issue_finish_date(client):
issue = f.IssueFactory.create(finished_date="2014-10-22T00:00:00+0000")
output = io.BytesIO()
render_project(issue.project, output)
project_data = json.loads(output.getvalue())
finish_date = project_data["issues"][0]["finished_date"]
assert finish_date == "2014-10-22T00:00:00+0000"
def test_export_user_story_finish_date(client):
user_story = f.UserStoryFactory.create(
finish_date="2014-10-22T00:00:00+0000")
output = io.BytesIO()
render_project(user_story.project, output)
project_data = json.loads(output.getvalue())
finish_date = project_data["user_stories"][0]["finish_date"]
assert finish_date == "2014-10-22T00:00:00+0000"
def test_webhook_action_test_transform_to_json(client, data):
url = reverse('webhooks-test', kwargs={"pk": data.webhook1.pk})
response = Mock(status_code=200, headers={}, text="ok")
response.elapsed.total_seconds.return_value = 100
with patch("tuesmon.webhooks.tasks.requests.Session.send", return_value=response), \
patch("tuesmon.base.utils.urls.validate_private_url", return_value=True):
client.login(data.project_owner)
response = client.json.post(url)
assert response.status_code == 200
assert json.loads(response.data["response_data"]) == {"content": "ok"}
def test_webhooklogs_list(client, data):
url = reverse('webhooklogs-list')
response = client.get(url)
webhooklogs_data = json.loads(response.content.decode('utf-8'))
assert len(webhooklogs_data) == 0
assert response.status_code == 200
client.login(data.registered_user)
response = client.get(url)
webhooklogs_data = json.loads(response.content.decode('utf-8'))
assert len(webhooklogs_data) == 0
assert response.status_code == 200
client.login(data.project_owner)
response = client.get(url)
webhooklogs_data = json.loads(response.content.decode('utf-8'))
assert len(webhooklogs_data) == 2
assert response.status_code == 200
def _reorder_if_needed(self, obj, old_order_key, order_key):
# Executes the extra ordering if there is a difference in the ordering keys
if old_order_key == order_key:
return {}
extra_orders = json.loads(
self.request.META.get("HTTP_SET_ORDERS", "{}"))
data = [{"us_id": obj.user_story.id, "order": getattr(obj, "order")}]
for id, order in extra_orders.items():
data.append({"us_id": int(id), "order": order})
return services.update_epic_related_userstories_order_in_bulk(
data, epic=obj.epic)
def test_export_epic_with_user_stories(client):
epic = f.EpicFactory.create(subject="test epic export")
user_story = f.UserStoryFactory.create(project=epic.project)
f.RelatedUserStory.create(epic=epic, user_story=user_story)
output = io.BytesIO()
render_project(user_story.project, output)
project_data = json.loads(output.getvalue())
assert project_data["epics"][0]["subject"] == "test epic export"
assert len(project_data["epics"]) == 1
assert project_data["epics"][0]["related_user_stories"][0][
"user_story"] == user_story.ref
assert len(project_data["epics"][0]["related_user_stories"]) == 1
def _reorder_if_needed(self,
obj,
old_order_key,
order_key,
order_attr,
project,
status=None,
milestone=None):
# Executes the extra ordering if there is a difference in the ordering keys
if old_order_key != order_key:
extra_orders = json.loads(
self.request.META.get("HTTP_SET_ORDERS", "{}"))
data = [{"us_id": obj.id, "order": getattr(obj, order_attr)}]
for id, order in extra_orders.items():
data.append({"us_id": int(id), "order": order})
return services.update_userstories_order_in_bulk(
data, order_attr, project, status=status, milestone=milestone)
return {}
def test_update_epic_order(client):
user = f.UserFactory.create()
project = f.ProjectFactory.create(owner=user)
epic_1 = f.EpicFactory.create(project=project, epics_order=1, status=project.default_us_status)
epic_2 = f.EpicFactory.create(project=project, epics_order=2, status=project.default_us_status)
epic_3 = f.EpicFactory.create(project=project, epics_order=3, status=project.default_us_status)
f.MembershipFactory.create(project=project, user=user, is_admin=True)
url = reverse('epics-detail', kwargs={"pk": epic_1.pk})
data = {
"epics_order": 2,
"version": epic_1.version
}
client.login(user)
response = client.json.patch(url, json.dumps(data))
assert json.loads(response.get("tuesmon-info-order-updated")) == {
str(epic_1.id): 2,
str(epic_2.id): 3,
str(epic_3.id): 4
}
def handle(self, *args, **options):
dump_file_path = options["dump_file"]
owner_email = options["owner_email"]
overwrite = options["overwrite"]
data = json.loads(open(dump_file_path, 'r').read())
try:
if overwrite:
receivers_back = signals.post_delete.receivers
signals.post_delete.receivers = []
try:
proj = Project.objects.get(
slug=data.get("slug", "not a slug"))
proj.tasks.all().delete()
proj.user_stories.all().delete()
proj.issues.all().delete()
proj.memberships.all().delete()
proj.roles.all().delete()
proj.delete()
except Project.DoesNotExist:
pass
signals.post_delete.receivers = receivers_back
else:
slug = data.get('slug', None)
if slug is not None and Project.objects.filter(
slug=slug).exists():
del data['slug']
user = User.objects.get(email=owner_email)
services.store_project_from_dict(data, user)
except err.TuesmonImportError as e:
if e.project:
e.project.delete_related_content()
e.project.delete()
print("ERROR:", end=" ")
print(e.message)
print(json.dumps(e.errors, indent=4))
def _get_payload(self, request):
try:
payload = json.loads(request.body.decode("utf-8"))
except ValueError:
raise exc.BadRequest(_("The payload is not a valid json"))
return payload
def from_native(self, obj):
if isinstance(obj, dict):
return obj
return json.loads(obj)
def _get_event_name(self, request):
payload = json.loads(request.body.decode("utf-8"))
return payload.get('object_kind', 'push') if payload is not None else 'empty'