# HG changeset patch # User durandn # Date 1453825084 -3600 # Node ID 95536fa18d0d58c620fd72ec026e770fa4dae247 # Parent fb0041aa74d3c42e4c62c73ab7bda7e73b9d1b74 Minor adjustements to properly interact with Renkan client diff -r fb0041aa74d3 -r 95536fa18d0d .settings/org.eclipse.core.resources.prefs --- 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 diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/api/views.py --- 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) diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/auth.py --- /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 diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/migrations/0002_alter_models_and_populate_revisions.py --- 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)), diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/models.py --- 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") diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/serializers.py --- 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") diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/tests/__init__.py --- 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 diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/tests/tests_renkan.py --- 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 diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/tests/tests_revision.py --- 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 diff -r fb0041aa74d3 -r 95536fa18d0d server/python2/django/renkanmanager/tests/tests_workspace.py --- 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