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)

    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('workspace_guid')

    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) # 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)

    94         test_workspace_guid = post_response_dict.get('workspace_guid')

    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         first_test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})

   103         second_test_title = 'bleh_title_2'

   104         second_test_content = json.dumps({'title': 'bleh_title_2', 'some_random_stuff': 'such'})

   105         first_data = {'title': first_test_title, 'content': first_test_content}

   106         second_data = {'title': second_test_title, 'content': second_test_content}

   107         self.client.post(renkan_post_url, first_data, format='json')

   108         self.client.post(renkan_post_url, second_data, format='json')

   109         

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

   111         # GETting test Workspace

   112         ###################################################

   113         

   114         get_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})

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

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

   117         

   118         # Checking GET data

   119         get_response_dict = json.loads(get_response.content)

   120         self.assertEqual(test_workspace_guid, get_response_dict.get('workspace_guid', ''))

   121         self.assertEqual(test_title, get_response_dict.get('title', ''))

   122         self.assertEqual(self.user.username, get_response_dict.get('workspace_created_by', ''))

   123         self.assertEqual(2, get_response_dict.get('renkan_count'))

   124         

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

   126         # GETting wrong workspace_guid

   127         ###################################################

   128         

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

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

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

   132         

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

   134         # try GETting with unauthorized user 

   135         ###################################################

   136         

   137         _ = self.client.login(username='blip', password='blip')

   138         get_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})

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

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

   141         

   142     def test_update_workspace(self):

   143         

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

   145         # POSTing test Workspace

   146         ###################################################

   147         

   148         workspace_post_url = reverse('workspace_list')

   149         test_title = 'bleh_title'

   150         data = {'title': test_title}

   151         post_response = self.client.post(workspace_post_url, data, format='json')

   152         post_response_dict = json.loads(post_response.content)

   153         test_workspace_guid = post_response_dict.get('workspace_guid')

   154         

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

   156         # PUTting into test Workspace

   157         ###################################################

   158         

   159         put_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})

   160         edited_title = 'bleh_title_2'

   161         put_data = {'title': edited_title}

   162         put_response = self.client.put(put_url, put_data, format='json')

   163         put_response_dict = json.loads(put_response.content)

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

   165         

   166         # Checking data

   167         #    in the response

   168         self.assertEqual(put_response_dict.get('workspace_created_by'), self.user.username)

   169         self.assertEqual(put_response_dict.get('title'), edited_title)

   170         self.assertEqual(put_response_dict.get('renkan_count'), 0)

   171         #    in the database

   172         edited_workspace_guid = put_response_dict.get('workspace_guid')

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

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

   175         self.assertEqual(edited_workspace.title, edited_title)

   176         self.assertEqual(edited_workspace.renkan_count, 0)

   177         

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

   179         # try PUTting with unauthorized user 

   180         ###################################################

   181         

   182         _ = self.client.login(username='blip', password='blip')

   183         put_url = reverse('workspace_detail', kwargs={'workspace_guid': test_workspace_guid})

   184         put_data = {

   185             'title' : 'wont_work'

   186         }

   187         put_response = self.client.put(put_url, put_data, format='json')

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

   189         

   190     def test_delete_workspace(self):

   191         

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

   193         # POSTing test Workspace

   194         ###################################################

   195         

   196         workspace_post_url = reverse('workspace_list')

   197         test_title = 'bleh_title'

   198         data = {'title': test_title}

   199         post_response = self.client.post(workspace_post_url, data, format='json')

   200         post_response_dict = json.loads(post_response.content)

   201         to_delete_workspace_guid = post_response_dict.get('workspace_guid')

   202         

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

   204         # POSTing new Renkan into test Workspace

   205         ###################################################

   206         

   207         renkan_post_url = reverse('renkan_list_workspace', kwargs={'workspace_guid': to_delete_workspace_guid})

   208         renkan_test_title = 'bleh_title'

   209         renkan_test_content = json.dumps({'title': 'bleh_title', 'some_random_stuff': 'wow'})

   210         renkan_test_data = {'title': renkan_test_title, 'content': renkan_test_content}

   211         post_response = self.client.post(renkan_post_url, renkan_test_data, format='json')

   212         to_delete_renkan_guid = json.loads(post_response.content).get('renkan_guid', '')

   213         

   214         ###################################################

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

   216         ###################################################

   217         

   218         delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})

   219         delete_response = self.client.delete(delete_url, {}, format='json')

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

   221         

   222         ###################################################

   223         # DELETE posted Renkan

   224         ###################################################

   225         

   226         delete_renkan_url = reverse('renkan_detail', kwargs={'renkan_guid':to_delete_renkan_guid})

   227         delete_renkan_response = self.client.delete(delete_renkan_url, format='json')

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

   229         

   230         ###################################################

   231         # try to DELETE with unauthorized user 

   232         ###################################################

   233         

   234         _ = self.client.login(username='blip', password='blip')

   235         delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})

   236         delete_response = self.client.delete(delete_url, {}, format='json')

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

   238         

   239         # Restoring rightful user

   240         _ = self.client.login(username='blop', password='blop')

   241         

   242         ###################################################

   243         # DELETE test Workspace 

   244         ###################################################

   245         

   246         delete_url = reverse('workspace_detail', kwargs={'workspace_guid':to_delete_workspace_guid})

   247         delete_response = self.client.delete(delete_url, {}, format='json')

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

   249         

   250         ###################################################

   251         # Try to DELETE workspace with wrong guid

   252         ###################################################

   253         

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

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

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

   257