--- a/.settings/org.eclipse.core.resources.prefs Mon Jan 11 18:24:14 2016 +0100
+++ b/.settings/org.eclipse.core.resources.prefs Tue Jan 26 17:18:04 2016 +0100
@@ -5,5 +5,7 @@
encoding//server/python/django/renkanmanager/migrations/0001_initial.py=utf-8
encoding//server/python/django/renkanmanager/utils.py=utf-8
encoding//server/python/django/renkanmanager/views.py=utf-8
+encoding//server/python2/django/renkanmanager/api/views.py=utf-8
encoding//server/python2/django/renkanmanager/migrations/0002_alter_models_and_populate_revisions.py=utf-8
encoding//server/python2/django/renkanmanager/migrations/0003_auto_20160105_0954.py=utf-8
+encoding//server/python2/django/renkanmanager/utils.py=utf-8
--- a/server/python2/django/renkanmanager/api/views.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/api/views.py Tue Jan 26 17:18:04 2016 +0100
@@ -20,7 +20,7 @@
CanEditWorkspace, CanDeleteWorkspace, CanCreateWorkspace, \
CanDeleteRevision
from renkanmanager.serializers import RenkanSerializer, RevisionSerializer, WorkspaceSerializer
-from renkanmanager.utils import LineNodePlacer, renkan_copier, renkan_deleter
+from renkanmanager.auth import CsrfExemptSessionAuthentication
from rest_framework import permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView
@@ -43,19 +43,26 @@
else:
renkans = Renkan.objects.filter(workspace_guid=workspace_guid)
serializer = RenkanSerializer(renkans, many=True)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
def post(self, request, workspace_guid='', format=None):
create_data = request.data
# We check if the POST request is a copy request, either with ?source="id" query arg or with source_revision_guid present in the data
- source_revision_guid = request.GET.get("source", None) if request.GET.get("source", None) is not None else request.data.get("source_revision_guid", None)
+ source_renkan_guid = request.GET.get("source_renkan_guid", request.data.get("source_renkan_guid", None))
+ source_revision_guid = request.GET.get("source_revision_guid", request.data.get("source_revision_guid", None))
+ if source_renkan_guid is not None:
+ try:
+ source_renkan=Renkan.objects.get(renkan_guid=source_renkan_guid)
+ except Renkan.DoesNotExist:
+ return Response({'detail': 'Source renkan '+source_renkan_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ source_revision_guid = source_renkan.current_revision_guid
if source_revision_guid is not None:
try:
source_revision=Revision.objects.get(revision_guid=source_revision_guid)
except Revision.DoesNotExist:
return Response({'detail': 'Source revision '+source_revision_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
create_data["source_revision_guid"] = source_revision.revision_guid
- create_data["title"] = source_revision.title
+ create_data["title"] = request.data.get("title", source_revision.title)
create_data["content"] = source_revision.content
if workspace_guid:
try:
@@ -66,7 +73,7 @@
serializer = RenkanSerializer(data=create_data)
if serializer.is_valid():
serializer.save(creator=request.user)
- return Response(serializer.data, status=status.HTTP_201_CREATED)
+ return Response(serializer.data, status=status.HTTP_201_CREATED, content_type='application/json')
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -80,6 +87,12 @@
CanEditRenkan,
CanDeleteRenkan,
)
+ authentication_classes = (
+ CsrfExemptSessionAuthentication,
+ )
+ @csrf_exempt
+ def dispatch(self, *args, **kwargs):
+ return super(RenkanDetail, self).dispatch(*args, **kwargs)
def get_object(self, renkan_guid):
return Renkan.objects.get(renkan_guid=renkan_guid)
@@ -91,7 +104,9 @@
return Response({'detail': 'Renkan project '+renkan_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
self.check_object_permissions(request, renkan)
serializer = RenkanSerializer(renkan)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ if {'true': True, 'false': False, "0": False, "1": True}.get(request.GET.get("content_only", "false").lower()):
+ return Response(json.loads(serializer.data["content"]), status=status.HTTP_200_OK, content_type='application/json')
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
def put(self, request, renkan_guid, format=None):
try:
@@ -99,10 +114,16 @@
except Renkan.DoesNotExist:
return Response({'detail': 'Renkan project '+renkan_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
self.check_object_permissions(request, renkan)
- serializer = RenkanSerializer(renkan, data=request.data)
+ if {'true': True, 'false': False, "0": False, "1": True}.get(request.GET.get("content_only", "false").lower()):
+ put_data = {}
+ put_data["content"] = json.dumps(request.data)
+ put_data["title"] = request.data.get("title", "")
+ else:
+ put_data = request.data
+ serializer = RenkanSerializer(renkan, data=put_data)
if serializer.is_valid():
serializer.save(updator=request.user)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, renkan_guid, format=None):
@@ -139,7 +160,7 @@
serializer = WorkspaceSerializer(data=request.data)
if serializer.is_valid():
serializer.save(creator=request.user)
- return Response(serializer.data, status=status.HTTP_201_CREATED)
+ return Response(serializer.data, status=status.HTTP_201_CREATED, content_type='application/json')
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class WorkspaceDetail(APIView):
@@ -162,7 +183,7 @@
return Response({'detail': 'Workspace '+workspace_guid+' does not exist.'}, status=status.HTTP_404_NOT_FOUND)
self.check_object_permissions(request, workspace)
serializer = WorkspaceSerializer(workspace)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
def put(self, request, workspace_guid, format=None):
try:
@@ -173,7 +194,7 @@
serializer = WorkspaceSerializer(workspace, data=request.data)
if serializer.is_valid():
serializer.save()
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, workspace_guid, format=None):
@@ -201,7 +222,7 @@
if not revisions:
return Response({'detail': 'Renkan project '+renkan_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
serializer = RevisionSerializer(revisions.all(), many=True)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
class RevisionDetail(APIView):
"""
@@ -225,7 +246,7 @@
return Response({'detail': 'Revision '+revision_guid+' does not exist'}, status=status.HTTP_404_NOT_FOUND)
self.check_object_permissions(request, revision)
serializer = RevisionSerializer(revision)
- return Response(serializer.data, status=status.HTTP_200_OK)
+ return Response(serializer.data, status=status.HTTP_200_OK, content_type='application/json')
def delete(self, request, renkan_guid, revision_guid, format=None):
revisions = self.get_queryset(renkan_guid)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/server/python2/django/renkanmanager/auth.py Tue Jan 26 17:18:04 2016 +0100
@@ -0,0 +1,10 @@
+from rest_framework.authentication import SessionAuthentication
+
+class CsrfExemptSessionAuthentication(SessionAuthentication):
+ """
+ Session authentication class to use with Renkan client, as it does not provide a csrf token
+ """
+
+
+ def enforce_csrf(self, request):
+ return
\ No newline at end of file
--- a/server/python2/django/renkanmanager/migrations/0002_alter_models_and_populate_revisions.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/migrations/0002_alter_models_and_populate_revisions.py Tue Jan 26 17:18:04 2016 +0100
@@ -38,7 +38,7 @@
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('revision_guid', models.CharField(default=uuid.uuid4, unique=True, max_length=256)),
('parent_renkan_guid', models.CharField(max_length=256)),
- ('title', models.CharField(max_length=1024, null=True)),
+ ('title', models.CharField(max_length=1024, null=True, blank=True)),
('content', models.TextField(null=True, blank=True)),
('creation_date', models.DateTimeField(auto_now_add=True)),
('modification_date', models.DateTimeField(auto_now=True)),
--- a/server/python2/django/renkanmanager/models.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/models.py Tue Jan 26 17:18:04 2016 +0100
@@ -70,7 +70,7 @@
revision_guid = models.CharField(max_length=256, default=uuid.uuid4, unique=True) # typically UUID
parent_renkan_guid = models.CharField(max_length=256)
- title = models.CharField(max_length=1024, null=True)
+ title = models.CharField(max_length=1024, null=True, blank=True)
content = models.TextField(blank=True, null=True)
creator = models.ForeignKey(auth_user_model, blank=True, null=True, related_name="revision_creator")
last_updated_by = models.ForeignKey(auth_user_model, blank=True, null=True, related_name="revision_last_updated_by")
--- a/server/python2/django/renkanmanager/serializers.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/serializers.py Tue Jan 26 17:18:04 2016 +0100
@@ -1,7 +1,8 @@
+import json
import uuid
from guardian.shortcuts import assign_perm
-from models import Renkan, Workspace, Revision
+from renkanmanager.models import Renkan, Workspace, Revision
from rest_framework import serializers
@@ -14,7 +15,7 @@
project_created_by = serializers.StringRelatedField(source="creator")
last_updated_by = serializers.SerializerMethodField("get_current_revision_last_updator")
title = serializers.CharField(required=False)
- content = serializers.CharField(required=False)
+ content = serializers.JSONField(required=False)
creation_date = serializers.ReadOnlyField()
modification_date = serializers.SerializerMethodField("get_current_revision_modification_date")
create_new_revision = serializers.BooleanField(write_only=True, required=False) # only used for updating
@@ -36,8 +37,7 @@
creator = validated_data.get('creator')
renkan = Renkan.objects.create()
initial_revision = Revision.objects.create()
- initial_revision.title = validated_data.get('title', '')
- initial_revision.content = validated_data.get('content', '{}')
+ initial_revision.title = validated_data.get('title', 'Untitled renkan')
initial_revision.parent_renkan_guid = renkan.renkan_guid
initial_revision.creator = creator
initial_revision.last_updated_by = validated_data.get('creator', '')
@@ -45,6 +45,20 @@
renkan.workspace_guid = validated_data.get('workspace_guid', '')
renkan.source_revision_guid = validated_data.get('source_revision_guid', '')
renkan.creator = creator
+ initial_revision.content = validated_data.get('content', json.dumps(
+ {
+ "id": str(renkan.renkan_guid),
+ "title": initial_revision.title,
+ "description": "",
+ "created": str(initial_revision.creation_date),
+ "updated": str(initial_revision.modification_date),
+ "edges": [],
+ "nodes": [],
+ "users": [],
+ "space_id": str(renkan.workspace_guid),
+ "views": []
+ }
+ ))
initial_revision.save()
renkan.save()
assign_perm('view_renkan', creator, renkan)
@@ -59,16 +73,16 @@
Method to update a Renkan object. Creates a new revision if needed
"""
updator = validated_data.get('updator')
+ current_revision = Revision.objects.get(revision_guid=renkan.current_revision_guid)
if validated_data.get("create_new_revision", False):
revision_to_update = Revision.objects.create()
revision_to_update.parent_renkan_guid = renkan.renkan_guid
revision_to_update.creator = updator
renkan.current_revision_guid = revision_to_update.revision_guid
else:
- revision_to_update = Revision.objects.get(revision_guid=renkan.current_revision_guid)
-
- revision_to_update.title = validated_data.get('title', '')
- revision_to_update.content = validated_data.get('content', '{}')
+ revision_to_update = current_revision
+ revision_to_update.title = validated_data.get('title', current_revision.title)
+ revision_to_update.content = validated_data.get('content', current_revision.content)
revision_to_update.last_updated_by = updator
revision_to_update.save()
if not updator.has_perm('view_revision', revision_to_update):
@@ -86,6 +100,23 @@
if self.instance is not None:
raise serializers.ValidationError("You cannot update source_revision_guid")
return value
+
+ def validate_content(self, value):
+
+ try:
+ json.loads(value)
+ except ValueError:
+ raise serializers.ValidationError("Content format is not a JSON-serializable")
+ loaded_json = json.loads(value)
+
+ if (not "nodes" in loaded_json):
+ raise serializers.ValidationError("Content requires a 'nodes' entry")
+ if (not "edges" in loaded_json):
+ raise serializers.ValidationError("Content requires a 'edges' entry")
+ if (not "views" in loaded_json):
+ raise serializers.ValidationError("Content requires a 'views' entry")
+
+ return value
class RevisionSerializer(serializers.Serializer):
@@ -93,7 +124,7 @@
parent_renkan_guid = serializers.ReadOnlyField()
workspace_guid = serializers.SerializerMethodField("get_related_workspace_guid")
title = serializers.ReadOnlyField()
- content = serializers.ReadOnlyField()
+ content = serializers.JSONField(read_only=True)
project_created_by = serializers.SerializerMethodField("get_related_project_creator")
project_creation_date = serializers.SerializerMethodField("get_related_project_creation_date")
revision_created_by = serializers.StringRelatedField(source="creator")
--- a/server/python2/django/renkanmanager/tests/__init__.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/tests/__init__.py Tue Jan 26 17:18:04 2016 +0100
@@ -1,3 +1,3 @@
-from tests_renkan import *
-from tests_workspace import *
-from tests_revision import *
\ No newline at end of file
+from .tests_renkan import *
+from .tests_workspace import *
+from .tests_revision import *
\ No newline at end of file
--- a/server/python2/django/renkanmanager/tests/tests_renkan.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/tests/tests_renkan.py Tue Jan 26 17:18:04 2016 +0100
@@ -12,18 +12,57 @@
class RenkanTests(APITestCase):
def setUp(self):
- User.objects.create_superuser('blop', 'blop@blop.com', 'blop')
- self.user = User.objects.get(username='blop')
- _ = self.client.login(username='blop', password='blop')
- User.objects.create_user('blip', 'blip@blip.com', 'blip')
- self.unauthorized_user = User.objects.get(username='blip')
+ User.objects.create_superuser("blop", "blop@blop.com", "blop")
+ self.user = User.objects.get(username="blop")
+ _ = self.client.login(username="blop", password="blop")
+ User.objects.create_user("blip", "blip@blip.com", "blip")
+ self.unauthorized_user = User.objects.get(username="blip")
# POSTing test workspace
- post_url = reverse('workspace_list')
- test_title = 'bleh_title'
- data = {'title': test_title}
- post_response = self.client.post(post_url, data, format='json')
- self.test_workspace_guid = json.loads(post_response.content).get('workspace_guid')
+ post_url = reverse("workspace_list")
+ test_title = "bleh_title"
+ data = {"title": test_title}
+ post_response = self.client.post(post_url, data, format="json")
+ self.test_workspace_guid = json.loads(post_response.content.decode()).get("workspace_guid")
+ self.first_test_title = "test_title_1"
+ self.first_test_content = json.dumps({
+ "id": "",
+ "title": "test_title_1",
+ "description": "test_description_1",
+ "created": "",
+ "updated": "",
+ "edges": [],
+ "nodes": [],
+ "users": [],
+ "space_id": "",
+ "views": []
+ })
+ self.second_test_title = "test_title_1"
+ self.second_test_content = json.dumps({
+ "id": "",
+ "title": "test_title_2",
+ "description": "test_description_2",
+ "created": "",
+ "updated": "",
+ "edges": [],
+ "nodes": [],
+ "users": [],
+ "space_id": "",
+ "views": []
+ })
+ self.third_test_title = "test_title_1"
+ self.third_test_content = json.dumps({
+ "id": "",
+ "title": "test_title_3",
+ "description": "test_description_3",
+ "created": "",
+ "updated": "",
+ "edges": [],
+ "nodes": [],
+ "users": [],
+ "space_id": "",
+ "views": []
+ })
def test_create_renkan(self):
@@ -31,101 +70,104 @@
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
- test_title = 'bleh_title'
- test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- data = {'title': test_title, 'content': test_content}
+ post_url = reverse("renkan_list")
+ data = {"title": self.first_test_title, "content": self.first_test_content}
- post_response = self.client.post(post_url, data, format='json')
+ post_response = self.client.post(post_url, data, format="json")
self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Renkan.objects.count(), 1)
self.assertEqual(Revision.objects.count(), 1)
# Checking POSTed Renkan data
- post_response_dict = json.loads(post_response.content)
- new_renkan_guid = post_response_dict.get('renkan_guid', '')
+ post_response_dict = json.loads(post_response.content.decode())
+ new_renkan_guid = post_response_dict.get("renkan_guid", "")
new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid)
# GUIDs and username
- self.assertEqual(self.user.username, post_response_dict.get('project_created_by', ''))
- self.assertEqual(self.user.username, post_response_dict.get('last_updated_by', ''))
+ self.assertEqual(self.user.username, post_response_dict.get("project_created_by", ""))
+ self.assertEqual(self.user.username, post_response_dict.get("last_updated_by", ""))
self.assertEqual(self.user.username, new_renkan.creator.username)
# Content and title extracted from revision
- self.assertEqual(new_renkan.title, test_title)
- self.assertEqual(new_renkan.content, test_content)
+ self.assertEqual(new_renkan.title, self.first_test_title)
+ self.assertEqual(new_renkan.content, self.first_test_content)
# Revision count
self.assertEqual(new_renkan.revision_count, 1)
- self.assertEqual(post_response_dict.get('revision_count', ''), 1)
+ self.assertEqual(post_response_dict.get("revision_count", ""), 1)
# Checking POSTed Renkan revision data
- new_renkan_revision_guid = post_response_dict.get('current_revision_guid', '')
+ new_renkan_revision_guid = post_response_dict.get("current_revision_guid", "")
new_renkan_revision = Revision.objects.get(revision_guid = new_renkan_revision_guid)
# GUIDs and username
self.assertEqual(self.user.username, new_renkan_revision.creator.username)
self.assertEqual(self.user.username, new_renkan_revision.last_updated_by.username)
# Title and content
# in the response
- self.assertEqual(post_response_dict.get('title', ''), test_title)
- self.assertEqual(post_response_dict.get('content', ''), test_content)
+ self.assertEqual(post_response_dict.get("title", ""), self.first_test_title)
+ self.assertEqual(post_response_dict.get("content", ""), self.first_test_content)
# in the database
- self.assertEqual(new_renkan_revision.title, test_title)
- self.assertEqual(new_renkan_revision.content, test_content)
+ self.assertEqual(new_renkan_revision.title, self.first_test_title)
+ self.assertEqual(new_renkan_revision.content, self.first_test_content)
# Checking permission
- self.assertTrue(self.user.has_perm('view_renkan', new_renkan))
+ self.assertTrue(self.user.has_perm("view_renkan", new_renkan))
###################################################
# POSTing new Renkan into workspace
###################################################
- post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': self.test_workspace_guid})
- test_title = 'bleh_title_2'
- test_content = json.dumps({'title': 'bleh_title_2', 'some_random_stuff': 'wow_2'})
- data = {'title': test_title, 'content': test_content}
+ post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})
+ data = {"title": self.second_test_title, "content": self.second_test_content}
- post_response = self.client.post(post_url, data, format='json')
+ post_response = self.client.post(post_url, data, format="json")
self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Renkan.objects.count(), 2)
self.assertEqual(Revision.objects.count(), 2)
# Checking POSTed Renkan data
- post_response_dict = json.loads(post_response.content)
- new_renkan_guid = post_response_dict.get('renkan_guid', '')
+ post_response_dict = json.loads(post_response.content.decode())
+ new_renkan_guid = post_response_dict.get("renkan_guid", "")
new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid)
# GUIDs and username
- self.assertEqual(self.test_workspace_guid, post_response_dict.get('workspace_guid', ''))
+ self.assertEqual(self.test_workspace_guid, post_response_dict.get("workspace_guid", ""))
self.assertEqual(self.test_workspace_guid, new_renkan.workspace_guid)
- self.assertEqual(self.user.username, post_response_dict.get('project_created_by', ''))
- self.assertEqual(self.user.username, post_response_dict.get('last_updated_by', ''))
+ self.assertEqual(self.user.username, post_response_dict.get("project_created_by", ""))
+ self.assertEqual(self.user.username, post_response_dict.get("last_updated_by", ""))
self.assertEqual(self.user.username, new_renkan.creator.username)
# Content and title extracted from revision
- self.assertEqual(new_renkan.title, test_title)
- self.assertEqual(new_renkan.content, test_content)
+ self.assertEqual(new_renkan.title, self.second_test_title)
+ self.assertEqual(new_renkan.content, self.second_test_content)
# Revision count
self.assertEqual(new_renkan.revision_count, 1)
- self.assertEqual(post_response_dict.get('revision_count', ''), 1)
+ self.assertEqual(post_response_dict.get("revision_count", ""), 1)
+
+ ###################################################
+ # POSTing new Renkan with no content
+ ###################################################
+ post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})
+ test_title = "bleh_title_2"
+ data = {"title": test_title}
+ post_response = self.client.post(post_url, data, format="json")
+ self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)
+ self.assertEqual(Renkan.objects.count(), 3)
+ self.assertEqual(Revision.objects.count(), 3)
###################################################
# POSTing with wrong workspace_guid
###################################################
- post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': 'bleh-bad-workspace-guid'})
- test_title = 'bleh_title_3'
- test_content = json.dumps({'title': 'bleh_title_3', 'some_random_stuff': 'wow_3'})
- data = {'title': test_title, 'content': test_content}
+ post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": "bleh-bad-workspace-guid"})
+ data = {"title": self.third_test_title, "content": self.third_test_content}
- post_response = self.client.post(post_url, data, format='json')
+ post_response = self.client.post(post_url, data, format="json")
self.assertEqual(post_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try POSTing with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': self.test_workspace_guid})
- test_title = 'shouldnt_work'
- test_content = json.dumps({'title': 'shouldnt_work', 'some_random_stuff': 'test'})
- data = {'title': test_title, 'content': test_content}
- post_response = self.client.post(post_url, data, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})
+ data = {"title": self.third_test_title, "content": self.third_test_content}
+ post_response = self.client.post(post_url, data, format="json")
self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_renkan(self):
@@ -134,43 +176,43 @@
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
+ post_url = reverse("renkan_list")
data = {}
- post_response = self.client.post(post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- new_renkan_guid = post_response_dict.get('renkan_guid', '')
- new_revision_guid = post_response_dict.get('current_revision_guid', '')
+ post_response = self.client.post(post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ new_renkan_guid = post_response_dict.get("renkan_guid", "")
+ new_revision_guid = post_response_dict.get("current_revision_guid", "")
###################################################
# GETting posted Renkan
###################################################
- get_url = reverse('renkan_detail', kwargs={'renkan_guid':new_renkan_guid})
- get_response = self.client.get(get_url, format='json')
+ get_url = reverse("renkan_detail", kwargs={"renkan_guid":new_renkan_guid})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
# Checking GET data
- get_response_dict = json.loads(get_response.content)
- self.assertEqual(new_renkan_guid, get_response_dict.get('renkan_guid', ''))
- self.assertEqual(new_revision_guid, get_response_dict.get('current_revision_guid', ''))
- self.assertEqual(self.user.username, get_response_dict.get('project_created_by', ''))
- self.assertEqual(self.user.username, get_response_dict.get('last_updated_by', ''))
+ get_response_dict = json.loads(get_response.content.decode())
+ self.assertEqual(new_renkan_guid, get_response_dict.get("renkan_guid", ""))
+ self.assertEqual(new_revision_guid, get_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(self.user.username, get_response_dict.get("project_created_by", ""))
+ self.assertEqual(self.user.username, get_response_dict.get("last_updated_by", ""))
###################################################
# GETting with wrong guid
###################################################
- get_url = reverse('renkan_detail', kwargs={'renkan_guid': 'bad-id'})
- get_response = self.client.get(get_url, format='json')
+ get_url = reverse("renkan_detail", kwargs={"renkan_guid": "bad-id"})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try GETting with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- get_url = reverse('renkan_detail', kwargs={'renkan_guid': new_renkan_guid})
- get_response = self.client.get(get_url, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ get_url = reverse("renkan_detail", kwargs={"renkan_guid": new_renkan_guid})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_renkan_list(self):
@@ -179,25 +221,21 @@
# POSTing new Renkans
###################################################
- post_url = reverse('renkan_list')
- first_test_title = 'bleh_title'
- first_test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- second_test_title = 'bleh_title_2'
- second_test_content = json.dumps({'title': 'bleh_title_2', 'some_random_stuff': 'such'})
- first_data = {'title': first_test_title, 'content': first_test_content}
- second_data = {'title': second_test_title, 'content': second_test_content}
- self.client.post(post_url, first_data, format='json')
- self.client.post(post_url, second_data, format='json')
+ post_url = reverse("renkan_list")
+ first_data = {"title": self.first_test_title, "content": self.first_test_content}
+ second_data = {"title": self.second_test_title, "content": self.second_test_content}
+ self.client.post(post_url, first_data, format="json")
+ self.client.post(post_url, second_data, format="json")
###################################################
# GETting posted Renkans
###################################################
get_url = post_url
- get_response = self.client.get(get_url, format='json')
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
- get_response_content = json.loads(get_response.content) # Should be a list
+ get_response_content = json.loads(get_response.content.decode()) # Should be a list
self.assertTrue(isinstance(get_response_content, list))
self.assertEqual(len(get_response_content), 2)
@@ -205,21 +243,19 @@
# POSTing new Renkan into workspace
###################################################
- post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': self.test_workspace_guid})
- third_test_title = 'bleh_title'
- third_test_content = json.dumps({'title': 'bleh_title_3rd', 'some_random_stuff': 'wow much'})
- third_data = {'title': third_test_title, 'content': third_test_content}
- self.client.post(post_url, third_data, format='json')
+ post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})
+ third_data = {"title": self.third_test_title, "content": self.third_test_content}
+ self.client.post(post_url, third_data, format="json")
###################################################
# GETting posted Renkans
###################################################
get_url = post_url
- get_response = self.client.get(get_url, format='json')
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
- get_response_content = json.loads(get_response.content) # Should be a list
+ get_response_content = json.loads(get_response.content.decode()) # Should be a list
self.assertTrue(isinstance(get_response_content, list))
self.assertEqual(len(get_response_content), 1)
@@ -230,123 +266,115 @@
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
+ post_url = reverse("renkan_list")
data = {}
- post_response = self.client.post(post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- renkan_guid = post_response_dict.get('renkan_guid', '')
- revision_guid = post_response_dict.get('current_revision_guid', '')
-
- ###################################################
- # Init PUT data
- ###################################################
- first_put_title = 'edited_title'
- first_put_content = json.dumps({'title': 'edited_title', 'nodes': 1})
- second_put_title = 'edited_title_2'
- second_put_content = json.dumps({'title': 'edited_title_2', 'nodes': 2})
+ post_response = self.client.post(post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ renkan_guid = post_response_dict.get("renkan_guid", "")
+ revision_guid = post_response_dict.get("current_revision_guid", "")
###################################################
# PUTting by updating current revision
###################################################
- put_url = reverse('renkan_detail', kwargs={'renkan_guid': renkan_guid})
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid": renkan_guid})
put_data = {
- 'title' : first_put_title,
- 'content' : first_put_content,
- 'create_new_revision': False
+ "title" : self.first_test_title,
+ "content" : self.first_test_content,
+ "create_new_revision": False
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_200_OK)
- put_response_dict = json.loads(put_response.content)
- # checking we're still on the same revision as the initial one
+ put_response_dict = json.loads(put_response.content.decode())
+ # checking we"re still on the same revision as the initial one
updated_project = Renkan.objects.get(renkan_guid=renkan_guid)
- self.assertEqual(revision_guid, put_response_dict.get('current_revision_guid', ''))
- self.assertEqual(put_response_dict.get('revision_count', ''), 1)
+ self.assertEqual(revision_guid, put_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(put_response_dict.get("revision_count", ""), 1)
self.assertEqual(updated_project.revision_count, 1)
self.assertEqual(revision_guid, updated_project.current_revision_guid)
# checking data was updated
# in the reponse
- self.assertEqual(put_response_dict.get('title', ''), first_put_title)
- self.assertEqual(put_response_dict.get('content', ''), first_put_content)
+ self.assertEqual(put_response_dict.get("title", ""), self.first_test_title)
+ self.assertEqual(put_response_dict.get("content", ""), self.first_test_content)
# in the database
updated_revision = Revision.objects.get(revision_guid=revision_guid)
- self.assertEqual(updated_revision.title, first_put_title)
- self.assertEqual(updated_revision.content, first_put_content)
+ self.assertEqual(updated_revision.title, self.first_test_title)
+ self.assertEqual(updated_revision.content, self.first_test_content)
###################################################
# PUTting by creating a new revision
###################################################
put_data = {
- 'title' : second_put_title,
- 'content' : second_put_content,
- 'create_new_revision': True
+ "title" : self.second_test_title,
+ "content" : self.second_test_content,
+ "create_new_revision": True
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_200_OK)
- put_response_dict = json.loads(put_response.content)
+ put_response_dict = json.loads(put_response.content.decode())
# checking we created a new revision
updated_project = Renkan.objects.get(renkan_guid=renkan_guid)
- created_revision_guid = put_response_dict.get('current_revision_guid', '')
+ created_revision_guid = put_response_dict.get("current_revision_guid", "")
self.assertNotEqual(created_revision_guid, revision_guid)
self.assertEqual(Renkan.objects.count(), 1)
self.assertEqual(Revision.objects.count(), 2)
- self.assertEqual(put_response_dict.get('revision_count', ''), 2)
+ self.assertEqual(put_response_dict.get("revision_count", ""), 2)
self.assertEqual(updated_project.revision_count, 2)
# checking project now points towards new revision
self.assertEqual(updated_project.current_revision_guid, created_revision_guid)
# checking data was updated
# in the reponse
- self.assertEqual(put_response_dict.get('title', ''), second_put_title)
- self.assertEqual(put_response_dict.get('content', ''), second_put_content)
+ self.assertEqual(put_response_dict.get("title", ""), self.second_test_title)
+ self.assertEqual(put_response_dict.get("content", ""), self.second_test_content)
# in the database
updated_revision = Revision.objects.get(revision_guid=created_revision_guid)
- self.assertEqual(updated_revision.title, second_put_title)
- self.assertEqual(updated_revision.content, second_put_content)
+ self.assertEqual(updated_revision.title, self.second_test_title)
+ self.assertEqual(updated_revision.content, self.second_test_content)
###################################################
# try to update source_revision_guid or workspace_guid
###################################################
put_data = {
- 'title' : second_put_title,
- 'content' : second_put_content,
- 'workspace_guid': 'bleh-workspace-guid' # should fail without even checking the id
+ "title" : self.third_test_title,
+ "content" : self.third_test_content,
+ "workspace_guid": "bleh-workspace-guid" # should fail without even checking the id
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_400_BAD_REQUEST)
put_data = {
- 'title' : second_put_title,
- 'content' : second_put_content,
- 'source_revision_guid' : 'bleh-revision-guid' # should fail without even checking the id
+ "title" : self.third_test_title,
+ "content" : self.third_test_content,
+ "source_revision_guid" : "bleh-revision-guid" # should fail without even checking the id
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_400_BAD_REQUEST)
###################################################
# PUTting with wrong guid
###################################################
- put_url = reverse('renkan_detail', kwargs={'renkan_guid': 'bad-id'})
- put_response = self.client.put(put_url, {}, format='json')
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid": "bad-id"})
+ put_response = self.client.put(put_url, {}, format="json")
self.assertEqual(put_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try PUTting with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- put_url = reverse('renkan_detail', kwargs={'renkan_guid': renkan_guid})
+ _ = self.client.login(username="blip", password="blip")
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid": renkan_guid})
put_data = {
- 'title' : 'wont_work',
- 'content' : json.dumps({'title': 'wont_work', 'nodes': 0}),
- 'create_new_revision': False
+ "title" : self.third_test_title,
+ "content" : self.third_test_content,
+ "create_new_revision": False
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_403_FORBIDDEN)
def test_copy_renkan(self):
@@ -355,95 +383,151 @@
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
- test_title = 'bleh_title'
- test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- data = {'title': test_title, 'content': test_content}
- post_response = self.client.post(post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- source_renkan_guid = post_response_dict.get('renkan_guid', '')
- source_revision_guid = post_response_dict.get('current_revision_guid', '')
+ post_url = reverse("renkan_list")
+ data = {"title": self.first_test_title, "content": self.first_test_content}
+ post_response = self.client.post(post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ source_renkan_guid = post_response_dict.get("renkan_guid", "")
+ source_revision_guid = post_response_dict.get("current_revision_guid", "")
###################################################
- # POSTing copy with query arg
+ # POSTing copy with query arg for RENKAN guid
###################################################
- first_copy_data = {}
- first_copy_url = post_url+'?source='+source_revision_guid
- first_copy_response = self.client.post(first_copy_url, first_copy_data, format='json')
- first_copy_response_dict = json.loads(first_copy_response.content)
+ first_copy_data = {"title": "new_title_copy_1"}
+ first_copy_url = post_url+"?source_renkan_guid="+source_renkan_guid
+ first_copy_response = self.client.post(first_copy_url, first_copy_data, format="json")
+ first_copy_response_dict = json.loads(first_copy_response.content.decode())
self.assertEqual(first_copy_response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Renkan.objects.count(), 2)
# Checking data
# in the response
- self.assertNotEqual(first_copy_response_dict.get('renkan_guid'), source_renkan_guid)
- self.assertEqual(first_copy_response_dict.get('source_revision_guid'), source_revision_guid)
- self.assertEqual(first_copy_response_dict.get('title', ''), test_title)
- self.assertEqual(first_copy_response_dict.get('content', ''), test_content)
- self.assertEqual(first_copy_response_dict.get('project_created_by', ''), self.user.username)
- self.assertEqual(first_copy_response_dict.get('last_updated_by', ''), self.user.username)
+ self.assertNotEqual(first_copy_response_dict.get("renkan_guid"), source_renkan_guid)
+ self.assertEqual(first_copy_response_dict.get("source_revision_guid"), source_revision_guid)
+ self.assertEqual(first_copy_response_dict.get("title", ""), "new_title_copy_1")
+ self.assertEqual(first_copy_response_dict.get("content", ""), self.first_test_content)
+ self.assertEqual(first_copy_response_dict.get("project_created_by", ""), self.user.username)
+ self.assertEqual(first_copy_response_dict.get("last_updated_by", ""), self.user.username)
# in the database
- first_copy = Renkan.objects.get(renkan_guid=first_copy_response_dict.get('renkan_guid', ''))
- first_copy_revision = Revision.objects.get(revision_guid=first_copy_response_dict.get('current_revision_guid', ''))
- self.assertEqual(first_copy.title, test_title)
- self.assertEqual(first_copy.content, test_content)
- self.assertEqual(first_copy_revision.title, test_title)
- self.assertEqual(first_copy_revision.content, test_content)
+ first_copy = Renkan.objects.get(renkan_guid=first_copy_response_dict.get("renkan_guid", ""))
+ first_copy_revision = Revision.objects.get(revision_guid=first_copy_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(first_copy.title, "new_title_copy_1")
+ self.assertEqual(first_copy.content, self.first_test_content)
+ self.assertEqual(first_copy_revision.title, "new_title_copy_1")
+ self.assertEqual(first_copy_revision.content, self.first_test_content)
self.assertEqual(first_copy.creator.username, self.user.username)
self.assertEqual(first_copy_revision.creator.username, self.user.username)
self.assertEqual(first_copy_revision.last_updated_by.username, self.user.username)
###################################################
- # POSTing copy with source_revision_guid in data
+ # POSTing copy with source_renkan_guid in data
###################################################
- second_copy_data = {'source_revision_guid': source_revision_guid}
- second_copy_url = post_url+'?source='+source_revision_guid
- second_copy_response = self.client.post(second_copy_url, second_copy_data, format='json')
- second_copy_response_dict = json.loads(second_copy_response.content)
+ second_copy_data = {"source_renkan_guid": source_renkan_guid, "title": "new_title_copy_2"}
+ second_copy_url = post_url
+ second_copy_response = self.client.post(second_copy_url, second_copy_data, format="json")
+ second_copy_response_dict = json.loads(second_copy_response.content.decode())
self.assertEqual(second_copy_response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Renkan.objects.count(), 3)
# Checking data
# in the response
- self.assertNotEqual(second_copy_response_dict.get('renkan_guid'), source_renkan_guid)
- self.assertEqual(first_copy_response_dict.get('source_revision_guid'), source_revision_guid)
- self.assertEqual(second_copy_response_dict.get('title', ''), test_title)
- self.assertEqual(second_copy_response_dict.get('content', ''), test_content)
- self.assertEqual(second_copy_response_dict.get('project_created_by', ''), self.user.username)
- self.assertEqual(second_copy_response_dict.get('last_updated_by', ''), self.user.username)
+ self.assertNotEqual(second_copy_response_dict.get("renkan_guid"), source_renkan_guid)
+ self.assertEqual(second_copy_response_dict.get("source_revision_guid"), source_revision_guid)
+ self.assertEqual(second_copy_response_dict.get("title", ""), "new_title_copy_2")
+ self.assertEqual(second_copy_response_dict.get("content", ""), self.first_test_content)
+ self.assertEqual(second_copy_response_dict.get("project_created_by", ""), self.user.username)
+ self.assertEqual(second_copy_response_dict.get("last_updated_by", ""), self.user.username)
# in the database
- second_copy = Renkan.objects.get(renkan_guid=second_copy_response_dict.get('renkan_guid', ''))
- second_copy_revision = Revision.objects.get(revision_guid=second_copy_response_dict.get('current_revision_guid', ''))
- self.assertEqual(second_copy.title, test_title)
- self.assertEqual(second_copy.content, test_content)
- self.assertEqual(second_copy_revision.title, test_title)
- self.assertEqual(second_copy_revision.content, test_content)
+ second_copy = Renkan.objects.get(renkan_guid=second_copy_response_dict.get("renkan_guid", ""))
+ second_copy_revision = Revision.objects.get(revision_guid=second_copy_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(second_copy.title, "new_title_copy_2")
+ self.assertEqual(second_copy.content, self.first_test_content)
+ self.assertEqual(second_copy_revision.title, "new_title_copy_2")
+ self.assertEqual(second_copy_revision.content, self.first_test_content)
self.assertEqual(second_copy.creator.username, self.user.username)
self.assertEqual(second_copy_revision.creator.username, self.user.username)
self.assertEqual(second_copy_revision.last_updated_by.username, self.user.username)
+ ###################################################
+ # POSTing copy with query arg for REVISION guid
+ ###################################################
+
+ third_copy_data = {"title": "new_title_copy_3"}
+ third_copy_url = post_url+"?source_revision_guid="+source_revision_guid
+ third_copy_response = self.client.post(third_copy_url, third_copy_data, format="json")
+ third_copy_response_dict = json.loads(third_copy_response.content.decode())
+ self.assertEqual(third_copy_response.status_code, status.HTTP_201_CREATED)
+ self.assertEqual(Renkan.objects.count(), 4)
+ # Checking data
+ # in the response
+ self.assertNotEqual(third_copy_response_dict.get("renkan_guid"), source_renkan_guid)
+ self.assertEqual(third_copy_response_dict.get("source_revision_guid"), source_revision_guid)
+ self.assertEqual(third_copy_response_dict.get("title", ""), "new_title_copy_3")
+ self.assertEqual(third_copy_response_dict.get("content", ""), self.first_test_content)
+ self.assertEqual(third_copy_response_dict.get("project_created_by", ""), self.user.username)
+ self.assertEqual(third_copy_response_dict.get("last_updated_by", ""), self.user.username)
+ # in the database
+ third_copy = Renkan.objects.get(renkan_guid=third_copy_response_dict.get("renkan_guid", ""))
+ third_copy_revision = Revision.objects.get(revision_guid=third_copy_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(third_copy.title, "new_title_copy_3")
+ self.assertEqual(third_copy.content, self.first_test_content)
+ self.assertEqual(third_copy_revision.title, "new_title_copy_3")
+ self.assertEqual(third_copy_revision.content, self.first_test_content)
+ self.assertEqual(third_copy.creator.username, self.user.username)
+ self.assertEqual(third_copy_revision.creator.username, self.user.username)
+ self.assertEqual(third_copy_revision.last_updated_by.username, self.user.username)
+
+ ###################################################
+ # POSTing copy with source_revision_guid in data
+ ###################################################
+
+ fourth_copy_data = {"source_revision_guid": source_revision_guid}
+ fourth_copy_url = post_url
+ fourth_copy_response = self.client.post(fourth_copy_url, fourth_copy_data, format="json")
+ fourth_copy_response_dict = json.loads(fourth_copy_response.content.decode())
+ self.assertEqual(fourth_copy_response.status_code, status.HTTP_201_CREATED)
+ self.assertEqual(Renkan.objects.count(), 5)
+ # Checking data
+ # in the response
+ self.assertNotEqual(fourth_copy_response_dict.get("renkan_guid"), source_renkan_guid)
+ self.assertEqual(fourth_copy_response_dict.get("source_revision_guid"), source_revision_guid)
+ self.assertEqual(fourth_copy_response_dict.get("title", ""), self.first_test_title)
+ self.assertEqual(fourth_copy_response_dict.get("content", ""), self.first_test_content)
+ self.assertEqual(fourth_copy_response_dict.get("project_created_by", ""), self.user.username)
+ self.assertEqual(fourth_copy_response_dict.get("last_updated_by", ""), self.user.username)
+ # in the database
+ fourth_copy = Renkan.objects.get(renkan_guid=fourth_copy_response_dict.get("renkan_guid", ""))
+ fourth_copy_revision = Revision.objects.get(revision_guid=fourth_copy_response_dict.get("current_revision_guid", ""))
+ self.assertEqual(fourth_copy.title, self.first_test_title)
+ self.assertEqual(fourth_copy.content, self.first_test_content)
+ self.assertEqual(fourth_copy_revision.title, self.first_test_title)
+ self.assertEqual(fourth_copy_revision.content, self.first_test_content)
+ self.assertEqual(fourth_copy.creator.username, self.user.username)
+ self.assertEqual(fourth_copy_revision.creator.username, self.user.username)
+ self.assertEqual(fourth_copy_revision.last_updated_by.username, self.user.username)
+
###################################################
# try POSTing copy with bad query arg guid and with bad data guid
###################################################
- bad_copy_data = {'source_revision_guid': 'bleh_bad_id'}
+ bad_copy_data = {"source_revision_guid": "bleh_bad_id"}
# with query arg
- qarg_bad_copy_url = post_url+'?source=bleh_bad_id'
- qarg_bad_copy_response = self.client.post(qarg_bad_copy_url, {}, format='json')
+ qarg_bad_copy_url = post_url+"?source=bleh_bad_id"
+ qarg_bad_copy_response = self.client.post(qarg_bad_copy_url, {}, format="json")
self.assertEqual(qarg_bad_copy_response.status_code, status.HTTP_404_NOT_FOUND)
# with data
data_bad_copy_url = post_url
- data_bad_copy_response = self.client.post(data_bad_copy_url, bad_copy_data, format='json')
+ data_bad_copy_response = self.client.post(data_bad_copy_url, bad_copy_data, format="json")
self.assertEqual(data_bad_copy_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try POSTing with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- post_url = reverse('renkan_list')+'?source='+source_revision_guid
- post_response = self.client.post(post_url, {}, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ post_url = reverse("renkan_list")+"?source="+source_revision_guid
+ post_response = self.client.post(post_url, {}, format="json")
self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_renkan(self):
@@ -452,27 +536,25 @@
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
- test_title = 'bleh_title'
- test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- data = {'title': test_title, 'content': test_content}
- post_response = self.client.post(post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- to_delete_renkan_guid = post_response_dict.get('renkan_guid', '')
- to_delete_revision_guid = post_response_dict.get('current_revision_guid', '')
+ post_url = reverse("renkan_list")
+ data = {"title": self.first_test_title, "content": self.first_test_content}
+ post_response = self.client.post(post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ to_delete_renkan_guid = post_response_dict.get("renkan_guid", "")
+ to_delete_revision_guid = post_response_dict.get("current_revision_guid", "")
###################################################
# POSTing copy
###################################################
data = {}
- post_response = self.client.post(post_url+'?source='+to_delete_revision_guid, data, format='json')
- post_response_dict = json.loads(post_response.content)
- copy_renkan_guid = post_response_dict.get('renkan_guid', '')
+ post_response = self.client.post(post_url+"?source="+to_delete_renkan_guid, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ copy_renkan_guid = post_response_dict.get("renkan_guid", "")
# Adding another revision
- put_data = {'title': test_title+'_edited!', 'create_new_revision': True}
- put_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})
- put_response = self.client.put(put_url, put_data, format='json')
+ put_data = {"title": self.first_test_title+"_edited!", "create_new_revision": True}
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(Renkan.objects.count(), 2)
self.assertEqual(Revision.objects.count(), 3)
@@ -480,20 +562,20 @@
# try to DELETE with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- delete_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})
- delete_response = self.client.delete(delete_url, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ delete_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})
+ delete_response = self.client.delete(delete_url, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_403_FORBIDDEN)
# Restoring rightful user
- _ = self.client.login(username='blop', password='blop')
+ _ = self.client.login(username="blop", password="blop")
###################################################
# DELETE initial renkan
###################################################
- delete_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})
- delete_response = self.client.delete(delete_url, format='json')
+ delete_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})
+ delete_response = self.client.delete(delete_url, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Renkan.objects.count(), 1) # Only the copy remains
self.assertEqual(Revision.objects.count(), 1) # Only the copy initial revision remains
@@ -502,21 +584,21 @@
# Try to GET deleted renkan
###################################################
- get_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})
- get_response = self.client.get(get_url, format='json')
+ get_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
- # Check that remaining renkan doesn't have reference to deleted renkan
+ # Check that remaining renkan doesn"t have reference to deleted renkan
###################################################
copy_renkan = Renkan.objects.get(renkan_guid=copy_renkan_guid)
- self.assertEqual(copy_renkan.source_revision_guid, '')
+ self.assertEqual(copy_renkan.source_revision_guid, "")
###################################################
# Try to DELETE renkan with wrong guid
###################################################
- delete_url = reverse('renkan_detail', kwargs={'renkan_guid': 'bad-id'})
- delete_response = self.client.delete(delete_url, format='json')
+ delete_url = reverse("renkan_detail", kwargs={"renkan_guid": "bad-id"})
+ delete_response = self.client.delete(delete_url, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND)
\ No newline at end of file
--- a/server/python2/django/renkanmanager/tests/tests_revision.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/tests/tests_revision.py Tue Jan 26 17:18:04 2016 +0100
@@ -12,22 +12,35 @@
class RevisionTests(APITestCase):
def setUp(self):
- User.objects.create_superuser('blop', 'blop@blop.com', 'blop')
- self.user = User.objects.get(username='blop')
- _ = self.client.login(username='blop', password='blop')
- User.objects.create_user('blip', 'blip@blip.com', 'blip')
- self.unauthorized_user = User.objects.get(username='blip')
+ User.objects.create_superuser("blop", "blop@blop.com", "blop")
+ self.user = User.objects.get(username="blop")
+ _ = self.client.login(username="blop", password="blop")
+ User.objects.create_user("blip", "blip@blip.com", "blip")
+ self.unauthorized_user = User.objects.get(username="blip")
###################################################
# POSTing new Renkan
###################################################
- post_url = reverse('renkan_list')
- self.test_data = {'title': 'test_title', 'content': json.dumps({'mock_data': 'wow'})}
- post_response = self.client.post(post_url, self.test_data, format='json')
- post_response_dict = json.loads(post_response.content)
- self.test_renkan_guid = post_response_dict.get('renkan_guid', '')
- self.test_initial_revision_guid = post_response_dict.get('current_revision_guid', '')
+ post_url = reverse("renkan_list")
+ self.test_title = "test_title_1"
+ self.test_content = json.dumps({
+ "id": "",
+ "title": "test_title_1",
+ "description": "test_description_1",
+ "created": "",
+ "updated": "",
+ "edges": [],
+ "nodes": [],
+ "users": [],
+ "space_id": "",
+ "views": []
+ })
+ self.test_data = {"title": self.test_title, "content": self.test_content}
+ post_response = self.client.post(post_url, self.test_data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ self.test_renkan_guid = post_response_dict.get("renkan_guid", "")
+ self.test_initial_revision_guid = post_response_dict.get("current_revision_guid", "")
def test_get_revision(self):
@@ -35,42 +48,42 @@
# GETting revision
###################################################
- get_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- get_response = self.client.get(get_url, {}, format='json')
+ get_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
# Checking data
- get_response_dict = json.loads(get_response.content)
- self.assertEqual(get_response_dict.get('revision_guid', ''), self.test_initial_revision_guid)
- self.assertEqual(get_response_dict.get('parent_renkan_guid', ''), self.test_renkan_guid)
- self.assertEqual(get_response_dict.get('revision_created_by', ''), self.user.username)
- self.assertEqual(get_response_dict.get('revision_last_updated_by', ''), self.user.username)
- self.assertEqual(get_response_dict.get('title', ''), self.test_data.get('title', ''))
- self.assertEqual(get_response_dict.get('content', ''), self.test_data.get('content', ''))
+ get_response_dict = json.loads(get_response.content.decode())
+ self.assertEqual(get_response_dict.get("revision_guid", ""), self.test_initial_revision_guid)
+ self.assertEqual(get_response_dict.get("parent_renkan_guid", ""), self.test_renkan_guid)
+ self.assertEqual(get_response_dict.get("revision_created_by", ""), self.user.username)
+ self.assertEqual(get_response_dict.get("revision_last_updated_by", ""), self.user.username)
+ self.assertEqual(get_response_dict.get("title", ""), self.test_data.get("title", ""))
+ self.assertEqual(get_response_dict.get("content", ""), self.test_data.get("content", ""))
###################################################
# GETting with wrong renkan guid
###################################################
- get_url = reverse('revision_detail', kwargs={'renkan_guid' : 'bad-renkan-guid', 'revision_guid': self.test_initial_revision_guid})
- get_response = self.client.get(get_url, {}, format='json')
+ get_url = reverse("revision_detail", kwargs={"renkan_guid" : "bad-renkan-guid", "revision_guid": self.test_initial_revision_guid})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# GETting with wrong revision guid
###################################################
- get_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': 'bad-revision-guid'})
- get_response = self.client.get(get_url, {}, format='json')
+ get_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": "bad-revision-guid"})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try GETting with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- get_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- get_response = self.client.get(get_url, {}, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ get_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_revision_list(self):
@@ -79,26 +92,24 @@
# PUTting another revision in test renkan
###################################################
- put_url = reverse('renkan_detail', kwargs={'renkan_guid' : self.test_renkan_guid})
- put_title = 'edited_title'
- put_content = json.dumps({"title": "edited_title", "nodes": 1})
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid" : self.test_renkan_guid})
+ put_title = "edited_title"
put_data = {
- 'title' : put_title,
- 'content' : put_content,
- 'create_new_revision': True
+ "title" : put_title,
+ "create_new_revision": True
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
###################################################
# GETting revision lists
###################################################
- get_url = reverse('revision_list', kwargs={'renkan_guid' : self.test_renkan_guid})
- get_response = self.client.get(get_url, {}, format='json')
+ get_url = reverse("revision_list", kwargs={"renkan_guid" : self.test_renkan_guid})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
# Checking data
- get_response_content = json.loads(get_response.content) # Should be a list
+ get_response_content = json.loads(get_response.content.decode()) # Should be a list
self.assertTrue(isinstance(get_response_content, list))
self.assertEqual(len(get_response_content), 2)
@@ -106,9 +117,9 @@
# GETting with wrong renkan guid
###################################################
- _ = self.client.login(username='blip', password='blip')
- get_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- get_response = self.client.get(get_url, {}, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ get_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ get_response = self.client.get(get_url, {}, format="json")
self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_revision(self):
@@ -116,32 +127,30 @@
###################################################
# Try to DELETE the initial revision (last revision, should 400)
###################################################
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_400_BAD_REQUEST)
###################################################
# PUTting another revision in test renkan
###################################################
- put_url = reverse('renkan_detail', kwargs={'renkan_guid' : self.test_renkan_guid})
- put_title = 'edited_title'
- put_content = json.dumps({"title": "edited_title", "nodes": 1})
+ put_url = reverse("renkan_detail", kwargs={"renkan_guid" : self.test_renkan_guid})
+ put_title = "edited_title"
put_data = {
- 'title' : put_title,
- 'content' : put_content,
- 'create_new_revision': True
+ "title" : put_title,
+ "create_new_revision": True
}
- put_response = self.client.put(put_url, put_data, format='json')
- put_response_dict = json.loads(put_response.content)
- added_revision_guid = put_response_dict.get('current_revision_guid', '')
+ put_response = self.client.put(put_url, put_data, format="json")
+ put_response_dict = json.loads(put_response.content.decode())
+ added_revision_guid = put_response_dict.get("current_revision_guid", "")
###################################################
# Try to DELETE the added revision (current revision, should 400)
###################################################
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': added_revision_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": added_revision_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_400_BAD_REQUEST)
@@ -149,34 +158,34 @@
# try to DELETE with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_403_FORBIDDEN)
# Restoring rightful user
- _ = self.client.login(username='blop', password='blop')
+ _ = self.client.login(username="blop", password="blop")
###################################################
# Try to DELETE the initial revision (should 204 now that we added a revision)
###################################################
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': self.test_initial_revision_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": self.test_initial_revision_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_204_NO_CONTENT)
###################################################
# Try to DELETE with wrong renkan guid
###################################################
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : 'bad-renkan-guid', 'revision_guid': self.test_initial_revision_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : "bad-renkan-guid", "revision_guid": self.test_initial_revision_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# Try to DELETE with wrong revision guid
###################################################
- delete_url = reverse('revision_detail', kwargs={'renkan_guid' : self.test_renkan_guid, 'revision_guid': 'bad-revision-guid'})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("revision_detail", kwargs={"renkan_guid" : self.test_renkan_guid, "revision_guid": "bad-revision-guid"})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND)
\ No newline at end of file
--- a/server/python2/django/renkanmanager/tests/tests_workspace.py Mon Jan 11 18:24:14 2016 +0100
+++ b/server/python2/django/renkanmanager/tests/tests_workspace.py Tue Jan 26 17:18:04 2016 +0100
@@ -10,11 +10,11 @@
class WorkspaceTests(APITestCase):
def setUp(self):
- User.objects.create_superuser('blop', 'blop@blop.com', 'blop')
- self.user = User.objects.get(username='blop')
- _ = self.client.login(username='blop', password='blop')
- User.objects.create_user('blip', 'blip@blip.com', 'blip')
- self.unauthorized_user = User.objects.get(username='blip')
+ User.objects.create_superuser("blop", "blop@blop.com", "blop")
+ self.user = User.objects.get(username="blop")
+ _ = self.client.login(username="blop", password="blop")
+ User.objects.create_user("blip", "blip@blip.com", "blip")
+ self.unauthorized_user = User.objects.get(username="blip")
def test_post_workspace(self):
@@ -22,34 +22,34 @@
# POSTing test Workspace
###################################################
- post_url = reverse('workspace_list')
- test_title = 'bleh_title'
- data = {'title': test_title}
- post_response = self.client.post(post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
+ post_url = reverse("workspace_list")
+ test_title = "bleh_title"
+ data = {"title": test_title}
+ post_response = self.client.post(post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)
# Checking data
# in the response
- self.assertEqual(post_response_dict.get('workspace_created_by'), self.user.username)
- self.assertEqual(post_response_dict.get('title'), test_title)
+ self.assertEqual(post_response_dict.get("workspace_created_by"), self.user.username)
+ self.assertEqual(post_response_dict.get("title"), test_title)
# in the database
- created_workspace_guid = post_response_dict.get('workspace_guid')
+ created_workspace_guid = post_response_dict.get("workspace_guid")
created_workspace = Workspace.objects.get(workspace_guid=created_workspace_guid)
self.assertEqual(created_workspace.creator.username, self.user.username)
self.assertEqual(created_workspace.title, test_title)
# Checking permission
- self.assertTrue(self.user.has_perm('view_workspace', created_workspace))
+ self.assertTrue(self.user.has_perm("view_workspace", created_workspace))
###################################################
# try POSTing with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- post_url = reverse('workspace_list')
- data = {'title': 'wont_work'}
- post_response = self.client.post(post_url, data, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ post_url = reverse("workspace_list")
+ data = {"title": "wont_work"}
+ post_response = self.client.post(post_url, data, format="json")
self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN)
@@ -59,13 +59,13 @@
# POSTing new Workspaces
###################################################
- post_url = reverse('workspace_list')
- first_test_title = 'bleh_title_2'
- second_test_title = 'bleh_title_3'
- first_data = {'title': first_test_title}
- second_data = {'title': second_test_title}
- self.client.post(post_url, first_data, format='json')
- self.client.post(post_url, second_data, format='json')
+ post_url = reverse("workspace_list")
+ first_test_title = "bleh_title_2"
+ second_test_title = "bleh_title_3"
+ first_data = {"title": first_test_title}
+ second_data = {"title": second_test_title}
+ self.client.post(post_url, first_data, format="json")
+ self.client.post(post_url, second_data, format="json")
###################################################
# GETting Workspaces
@@ -76,7 +76,7 @@
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
# Check data
- get_response_content = json.loads(get_response.content) # Should be a list
+ get_response_content = json.loads(get_response.content.decode()) # Should be a list
self.assertTrue(isinstance(get_response_content, list))
self.assertEqual(len(get_response_content), 2)
@@ -86,57 +86,55 @@
# POSTing test Workspace
###################################################
- workspace_post_url = reverse('workspace_list')
- test_title = 'bleh_title'
- data = {'title': test_title}
- post_response = self.client.post(workspace_post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- test_workspace_guid = post_response_dict.get('workspace_guid')
+ workspace_post_url = reverse("workspace_list")
+ test_title = "bleh_title"
+ data = {"title": test_title}
+ post_response = self.client.post(workspace_post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ test_workspace_guid = post_response_dict.get("workspace_guid")
###################################################
# POSTing new Renkans into test Workspace
###################################################
- renkan_post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': test_workspace_guid})
- first_test_title = 'bleh_title'
- first_test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- second_test_title = 'bleh_title_2'
- second_test_content = json.dumps({'title': 'bleh_title_2', 'some_random_stuff': 'such'})
- first_data = {'title': first_test_title, 'content': first_test_content}
- second_data = {'title': second_test_title, 'content': second_test_content}
- self.client.post(renkan_post_url, first_data, format='json')
- self.client.post(renkan_post_url, second_data, format='json')
+ renkan_post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": test_workspace_guid})
+ first_test_title = "bleh_title"
+ second_test_title = "bleh_title_2"
+ first_data = {"title": first_test_title}
+ second_data = {"title": second_test_title}
+ self.client.post(renkan_post_url, first_data, format="json")
+ self.client.post(renkan_post_url, second_data, format="json")
###################################################
# GETting test Workspace
###################################################
- get_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})
- get_response = self.client.get(get_url, format='json')
+ get_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_200_OK)
# Checking GET data
- get_response_dict = json.loads(get_response.content)
- self.assertEqual(test_workspace_guid, get_response_dict.get('workspace_guid', ''))
- self.assertEqual(test_title, get_response_dict.get('title', ''))
- self.assertEqual(self.user.username, get_response_dict.get('workspace_created_by', ''))
- self.assertEqual(2, get_response_dict.get('renkan_count'))
+ get_response_dict = json.loads(get_response.content.decode())
+ self.assertEqual(test_workspace_guid, get_response_dict.get("workspace_guid", ""))
+ self.assertEqual(test_title, get_response_dict.get("title", ""))
+ self.assertEqual(self.user.username, get_response_dict.get("workspace_created_by", ""))
+ self.assertEqual(2, get_response_dict.get("renkan_count"))
###################################################
# GETting wrong workspace_guid
###################################################
- get_url = reverse('workspace_detail', kwargs={'workspace_guid': 'bleh-bad-workspace-id'})
- get_response = self.client.get(get_url, format='json')
+ get_url = reverse("workspace_detail", kwargs={"workspace_guid": "bleh-bad-workspace-id"})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)
###################################################
# try GETting with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- get_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})
- get_response = self.client.get(get_url, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ get_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})
+ get_response = self.client.get(get_url, format="json")
self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_workspace(self):
@@ -145,31 +143,31 @@
# POSTing test Workspace
###################################################
- workspace_post_url = reverse('workspace_list')
- test_title = 'bleh_title'
- data = {'title': test_title}
- post_response = self.client.post(workspace_post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- test_workspace_guid = post_response_dict.get('workspace_guid')
+ workspace_post_url = reverse("workspace_list")
+ test_title = "bleh_title"
+ data = {"title": test_title}
+ post_response = self.client.post(workspace_post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ test_workspace_guid = post_response_dict.get("workspace_guid")
###################################################
# PUTting into test Workspace
###################################################
- put_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})
- edited_title = 'bleh_title_2'
- put_data = {'title': edited_title}
- put_response = self.client.put(put_url, put_data, format='json')
- put_response_dict = json.loads(put_response.content)
+ put_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})
+ edited_title = "bleh_title_2"
+ put_data = {"title": edited_title}
+ put_response = self.client.put(put_url, put_data, format="json")
+ put_response_dict = json.loads(put_response.content.decode())
self.assertEqual(put_response.status_code, status.HTTP_200_OK)
# Checking data
# in the response
- self.assertEqual(put_response_dict.get('workspace_created_by'), self.user.username)
- self.assertEqual(put_response_dict.get('title'), edited_title)
- self.assertEqual(put_response_dict.get('renkan_count'), 0)
+ self.assertEqual(put_response_dict.get("workspace_created_by"), self.user.username)
+ self.assertEqual(put_response_dict.get("title"), edited_title)
+ self.assertEqual(put_response_dict.get("renkan_count"), 0)
# in the database
- edited_workspace_guid = put_response_dict.get('workspace_guid')
+ edited_workspace_guid = put_response_dict.get("workspace_guid")
edited_workspace = Workspace.objects.get(workspace_guid=edited_workspace_guid)
self.assertEqual(edited_workspace.creator.username, self.user.username)
self.assertEqual(edited_workspace.title, edited_title)
@@ -179,12 +177,12 @@
# try PUTting with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- put_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})
+ _ = self.client.login(username="blip", password="blip")
+ put_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})
put_data = {
- 'title' : 'wont_work'
+ "title" : "wont_work"
}
- put_response = self.client.put(put_url, put_data, format='json')
+ put_response = self.client.put(put_url, put_data, format="json")
self.assertEqual(put_response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_workspace(self):
@@ -193,65 +191,64 @@
# POSTing test Workspace
###################################################
- workspace_post_url = reverse('workspace_list')
- test_title = 'bleh_title'
- data = {'title': test_title}
- post_response = self.client.post(workspace_post_url, data, format='json')
- post_response_dict = json.loads(post_response.content)
- to_delete_workspace_guid = post_response_dict.get('workspace_guid')
+ workspace_post_url = reverse("workspace_list")
+ test_title = "bleh_title"
+ data = {"title": test_title}
+ post_response = self.client.post(workspace_post_url, data, format="json")
+ post_response_dict = json.loads(post_response.content.decode())
+ to_delete_workspace_guid = post_response_dict.get("workspace_guid")
###################################################
# POSTing new Renkan into test Workspace
###################################################
- renkan_post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': to_delete_workspace_guid})
- renkan_test_title = 'bleh_title'
- renkan_test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})
- renkan_test_data = {'title': renkan_test_title, 'content': renkan_test_content}
- post_response = self.client.post(renkan_post_url, renkan_test_data, format='json')
- to_delete_renkan_guid = json.loads(post_response.content).get('renkan_guid', '')
+ renkan_post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": to_delete_workspace_guid})
+ renkan_test_title = "bleh_title"
+ renkan_test_data = {"title": renkan_test_title}
+ post_response = self.client.post(renkan_post_url, renkan_test_data, format="json")
+ to_delete_renkan_guid = json.loads(post_response.content.decode()).get("renkan_guid", "")
###################################################
# Try to DELETE test Workspace (should fail, it still contains a Renkan)
###################################################
- delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_400_BAD_REQUEST)
###################################################
# DELETE posted Renkan
###################################################
- delete_renkan_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})
- delete_renkan_response = self.client.delete(delete_renkan_url, format='json')
+ delete_renkan_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})
+ delete_renkan_response = self.client.delete(delete_renkan_url, format="json")
self.assertEqual(delete_renkan_response.status_code, status.HTTP_204_NO_CONTENT)
###################################################
# try to DELETE with unauthorized user
###################################################
- _ = self.client.login(username='blip', password='blip')
- delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ _ = self.client.login(username="blip", password="blip")
+ delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_403_FORBIDDEN)
# Restoring rightful user
- _ = self.client.login(username='blop', password='blop')
+ _ = self.client.login(username="blop", password="blop")
###################################################
# DELETE test Workspace
###################################################
- delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})
- delete_response = self.client.delete(delete_url, {}, format='json')
+ delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})
+ delete_response = self.client.delete(delete_url, {}, format="json")
self.assertEqual(delete_response.status_code, status.HTTP_204_NO_CONTENT)
###################################################
# Try to DELETE workspace with wrong guid
###################################################
- delete_url = reverse('workspace_detail', kwargs={'workspace_guid': 'bad-workspace-guid'})
+ delete_url = reverse("workspace_detail", kwargs={"workspace_guid": "bad-workspace-guid"})
delete_response = self.client.delete(delete_url, format=json)
self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND)
\ No newline at end of file