1 from django.core.urlresolvers import reverse

     2 from rest_framework.test import APITestCase

     3 from rest_framework import status

     4 from renkanmanager.models import Renkan, Workspace

     5 from django.contrib.auth import get_user_model

     6 import json

     7 

     8 User = get_user_model()

     9 

    10 class WorkspaceTests(APITestCase):

    11     

    12     def setUp(self):

    13         User.objects.create_superuser("blop", "blop@blop.com", "blop")

    14         self.user = User.objects.get(username="blop")

    15         _ = self.client.login(username="blop", password="blop")

    16         User.objects.create_user("blip", "blip@blip.com", "blip")

    17         self.unauthorized_user = User.objects.get(username="blip")

    18     

    19     def test_post_workspace(self):

    20         

    21         ###################################################

    22         # POSTing test Workspace

    23         ###################################################

    24         

    25         post_url = reverse("workspace_list")

    26         test_title = "bleh_title"

    27         data = {"title": test_title}

    28         post_response = self.client.post(post_url, data, format="json")

    29         post_response_dict = json.loads(post_response.content.decode())

    30         self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)

    31         

    32         # Checking data

    33         #    in the response

    34         self.assertEqual(post_response_dict.get("workspace_created_by"), self.user.username)

    35         self.assertEqual(post_response_dict.get("title"), test_title)

    36         #    in the database

    37         created_workspace_guid = post_response_dict.get("id")

    38         created_workspace = Workspace.objects.get(workspace_guid=created_workspace_guid)

    39         self.assertEqual(created_workspace.creator.username, self.user.username)

    40         self.assertEqual(created_workspace.title, test_title)

    41         

    42         # Checking permission

    43         self.assertTrue(self.user.has_perm("view_workspace", created_workspace))

    44         

    45         ###################################################

    46         # try POSTing with unauthorized user 

    47         ###################################################

    48         

    49         _ = self.client.login(username="blip", password="blip")

    50         post_url = reverse("workspace_list")

    51         data = {"title": "wont_work"}

    52         post_response = self.client.post(post_url, data, format="json")

    53         self.assertEqual(post_response.status_code, status.HTTP_403_FORBIDDEN)

    54         

    55      

    56     def test_get_workspace_list(self):

    57         

    58         ###################################################

    59         # POSTing new Workspaces

    60         ###################################################

    61         

    62         post_url = reverse("workspace_list")

    63         first_test_title = "bleh_title_2"

    64         second_test_title = "bleh_title_3"

    65         first_data = {"title": first_test_title}

    66         second_data = {"title": second_test_title}

    67         self.client.post(post_url, first_data, format="json")

    68         self.client.post(post_url, second_data, format="json")

    69         

    70         ###################################################

    71         # GETting Workspaces

    72         ###################################################

    73         

    74         get_url = post_url

    75         get_response = self.client.get(get_url, format=json)

    76         self.assertEqual(get_response.status_code, status.HTTP_200_OK)

    77         

    78         # Check data

    79         get_response_content = json.loads(get_response.content.decode()) # Should be a list

    80         self.assertTrue(isinstance(get_response_content, list))

    81         self.assertEqual(len(get_response_content), 2)

    82     

    83     def test_get_workspace(self):

    84         

    85         ###################################################

    86         # POSTing test Workspace

    87         ###################################################

    88         

    89         workspace_post_url = reverse("workspace_list")

    90         test_title = "bleh_title"

    91         data = {"title": test_title}

    92         post_response = self.client.post(workspace_post_url, data, format="json")

    93         post_response_dict = json.loads(post_response.content.decode())

    94         test_workspace_guid = post_response_dict.get("id")

    95         

    96         ###################################################

    97         # POSTing new Renkans into test Workspace

    98         ###################################################

    99         

   100         renkan_post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": test_workspace_guid})

   101         first_test_title = "bleh_title"

   102         second_test_title = "bleh_title_2"

   103         first_data = {"title": first_test_title}

   104         second_data = {"title": second_test_title}

   105         self.client.post(renkan_post_url, first_data, format="json")

   106         self.client.post(renkan_post_url, second_data, format="json")

   107         

   108         ###################################################

   109         # GETting test Workspace

   110         ###################################################

   111         

   112         get_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})

   113         get_response = self.client.get(get_url, format="json")

   114         self.assertEqual(get_response.status_code, status.HTTP_200_OK)

   115         

   116         # Checking GET data

   117         get_response_dict = json.loads(get_response.content.decode())

   118         self.assertEqual(test_workspace_guid, get_response_dict.get("id", ""))

   119         self.assertEqual(test_title, get_response_dict.get("title", ""))

   120         self.assertEqual(self.user.username, get_response_dict.get("workspace_created_by", ""))

   121         self.assertEqual(2, get_response_dict.get("renkan_count"))

   122         

   123         ###################################################

   124         # GETting wrong workspace_guid

   125         ###################################################

   126         

   127         get_url = reverse("workspace_detail", kwargs={"workspace_guid": "bleh-bad-workspace-id"})

   128         get_response = self.client.get(get_url, format="json")

   129         self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)

   130         

   131         ###################################################

   132         # try GETting with unauthorized user 

   133         ###################################################

   134         

   135         _ = self.client.login(username="blip", password="blip")

   136         get_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})

   137         get_response = self.client.get(get_url, format="json")

   138         self.assertEqual(get_response.status_code, status.HTTP_403_FORBIDDEN)

   139         

   140     def test_update_workspace(self):

   141         

   142         ###################################################

   143         # POSTing test Workspace

   144         ###################################################

   145         

   146         workspace_post_url = reverse("workspace_list")

   147         test_title = "bleh_title"

   148         data = {"title": test_title}

   149         post_response = self.client.post(workspace_post_url, data, format="json")

   150         post_response_dict = json.loads(post_response.content.decode())

   151         test_workspace_guid = post_response_dict.get("id")

   152         

   153         ###################################################

   154         # PUTting into test Workspace

   155         ###################################################

   156         

   157         put_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})

   158         edited_title = "bleh_title_2"

   159         put_data = {"title": edited_title}

   160         put_response = self.client.put(put_url, put_data, format="json")

   161         put_response_dict = json.loads(put_response.content.decode())

   162         self.assertEqual(put_response.status_code, status.HTTP_200_OK)

   163         

   164         # Checking data

   165         #    in the response

   166         self.assertEqual(put_response_dict.get("workspace_created_by"), self.user.username)

   167         self.assertEqual(put_response_dict.get("title"), edited_title)

   168         self.assertEqual(put_response_dict.get("renkan_count"), 0)

   169         #    in the database

   170         edited_workspace_guid = put_response_dict.get("id")

   171         edited_workspace = Workspace.objects.get(workspace_guid=edited_workspace_guid)

   172         self.assertEqual(edited_workspace.creator.username, self.user.username)

   173         self.assertEqual(edited_workspace.title, edited_title)

   174         self.assertEqual(edited_workspace.renkan_count, 0)

   175         

   176         ###################################################

   177         # try PUTting with unauthorized user 

   178         ###################################################

   179         

   180         _ = self.client.login(username="blip", password="blip")

   181         put_url = reverse("workspace_detail", kwargs={"workspace_guid": test_workspace_guid})

   182         put_data = {

   183             "title" : "wont_work"

   184         }

   185         put_response = self.client.put(put_url, put_data, format="json")

   186         self.assertEqual(put_response.status_code, status.HTTP_403_FORBIDDEN)

   187         

   188     def test_delete_workspace(self):

   189         

   190         ###################################################

   191         # POSTing test Workspace

   192         ###################################################

   193         

   194         workspace_post_url = reverse("workspace_list")

   195         test_title = "bleh_title"

   196         data = {"title": test_title}

   197         post_response = self.client.post(workspace_post_url, data, format="json")

   198         post_response_dict = json.loads(post_response.content.decode())

   199         to_delete_workspace_guid = post_response_dict.get("id", "")

   200         

   201         ###################################################

   202         # POSTing new Renkan into test Workspace

   203         ###################################################

   204         

   205         renkan_post_url = reverse("renkan_list_workspace", kwargs={"workspace_guid": to_delete_workspace_guid})

   206         renkan_test_title = "bleh_title"

   207         renkan_test_data = {"title": renkan_test_title}

   208         post_response = self.client.post(renkan_post_url, renkan_test_data, format="json")

   209         to_delete_renkan_guid = json.loads(post_response.content.decode()).get("id", "")

   210         

   211         ###################################################

   212         # Try to DELETE test Workspace (should fail, it still contains a Renkan)

   213         ###################################################

   214         

   215         delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})

   216         delete_response = self.client.delete(delete_url, {}, format="json")

   217         self.assertEqual(delete_response.status_code, status.HTTP_400_BAD_REQUEST)

   218         

   219         ###################################################

   220         # DELETE posted Renkan

   221         ###################################################

   222         

   223         delete_renkan_url = reverse("renkan_detail", kwargs={"renkan_guid":to_delete_renkan_guid})

   224         delete_renkan_response = self.client.delete(delete_renkan_url, format="json")

   225         self.assertEqual(delete_renkan_response.status_code, status.HTTP_204_NO_CONTENT)

   226         

   227         ###################################################

   228         # try to DELETE with unauthorized user 

   229         ###################################################

   230         

   231         _ = self.client.login(username="blip", password="blip")

   232         delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})

   233         delete_response = self.client.delete(delete_url, {}, format="json")

   234         self.assertEqual(delete_response.status_code, status.HTTP_403_FORBIDDEN)

   235         

   236         # Restoring rightful user

   237         _ = self.client.login(username="blop", password="blop")

   238         

   239         ###################################################

   240         # DELETE test Workspace 

   241         ###################################################

   242         

   243         delete_url = reverse("workspace_detail", kwargs={"workspace_guid":to_delete_workspace_guid})

   244         delete_response = self.client.delete(delete_url, {}, format="json")

   245         self.assertEqual(delete_response.status_code, status.HTTP_204_NO_CONTENT)

   246         

   247         ###################################################

   248         # Try to DELETE workspace with wrong guid

   249         ###################################################

   250         

   251         delete_url = reverse("workspace_detail", kwargs={"workspace_guid": "bad-workspace-guid"})

   252         delete_response = self.client.delete(delete_url, format=json)

   253         self.assertEqual(delete_response.status_code, status.HTTP_404_NOT_FOUND)

   254