1 from django.test import TestCase

     2 from django.test.client import Client

     3 from django.core import management

     4 from datetime import datetime

     5 from cm.activity import *

     6 from cm.models import *

     7 from cm.security import *

     8 

     9 from django.http import HttpRequest, HttpResponse

    10 from django.utils import simplejson

    11 

    12 from cm.api.handlers import *

    13 

    14 #from piston.test import TestCase

    15 from piston.models import Consumer

    16 from piston.handler import BaseHandler

    17 from piston.utils import rc

    18 from piston.resource import Resource

    19 

    20 class FalseRequest(object):

    21     def __init__(self, user):

    22         self.user = user

    23 

    24 class APITest(TestCase):

    25     fixtures = ['roles_generic', 'test_content', ]

    26     

    27     def test_text_get(self):

    28         """

    29         Anonymous api call

    30         """

    31         

    32         resource = Resource(AnonymousTextHandler)

    33         request = HttpRequest()

    34         setattr(request, 'user' , None)

    35         request.method = 'GET'

    36         

    37         # get public text

    38         response = resource(request, key='text_key_4', emitter_format='json')

    39         self.assertEquals(200, response.status_code) # 401: forbidden

    40         response_data = simplejson.loads(response.content)

    41         self.assertEquals(response_data.get('created'), '2009-02-13 04:01:12')

    42         

    43         # error: private text

    44         response = resource(request, key='text_key_3', emitter_format='json')

    45         self.assertEquals(401, response.status_code)

    46 

    47 

    48     def test_text_get_logged_in(self):

    49         """

    50         Logged in as manager api call

    51         """

    52 

    53         resource = Resource(AnonymousTextHandler)

    54         request = HttpRequest()

    55         user = User.objects.get(pk=1)

    56         setattr(request, 'user' , user)

    57         request.method = 'GET'

    58   

    59         response = resource(request, key='text_key_3', emitter_format='json')

    60         self.assertEquals(200, response.status_code)

    61 

    62 

    63     def test_text_create(self):

    64         request = FalseRequest(None) 

    65         nb_anon_texts = get_texts_with_perm(request, 'can_view_text').count()

    66         nb_texts = Text.objects.count()

    67         

    68         resource = Resource(TextListHandler)

    69         

    70         # create one private text 

    71         request = HttpRequest()

    72         user = User.objects.get(pk=1)

    73         setattr(request, 'user' , user)

    74         request.method = 'POST'

    75         setattr(request, 'POST' , {'content':'test content', 'format':"markdown", 'title': 'my title'})

    76         response = resource(request,)

    77 

    78         self.assertEquals(200, response.status_code)

    79         self.assertTrue('key' in simplejson.loads(response.content).keys())

    80 

    81         request = FalseRequest(None) 

    82         self.assertEqual(get_texts_with_perm(request, 'can_view_text').count(), nb_anon_texts) # NO more anon text

    83         

    84         # create one text with anon observer

    85         request = HttpRequest()

    86         user = User.objects.get(pk=1)

    87         setattr(request, 'user' , user)

    88         request.method = 'POST'

    89         setattr(request, 'POST' , {'content':'test content', 'format':"markdown", 'title': 'my title', 'anon_role' : 4})

    90         response = resource(request,)

    91 

    92         self.assertEquals(200, response.status_code)

    93         self.assertTrue('key' in simplejson.loads(response.content).keys())

    94         

    95         self.assertEquals(nb_texts + 2, Text.objects.count()) # 2 more texts should have been created

    96 

    97         request = FalseRequest(None) 

    98         self.assertEqual(get_texts_with_perm(request, 'can_view_text').count(), nb_anon_texts + 1) # one more anon accessible text available

    99         

   100     def test_list_text_get(self):

   101         """

   102         List texts anon

   103         """

   104         resource = Resource(AnonymousTextListHandler)

   105         request = HttpRequest()

   106         setattr(request, 'user' , None)

   107         request.method = 'GET'

   108   

   109         response = resource(request, emitter_format='json')

   110         self.assertEquals(200, response.status_code)

   111         self.assertEquals(2, len(simplejson.loads(response.content)))

   112 

   113     def test_list_text_logged_in(self):

   114         """

   115         List texts manager

   116         """

   117         resource = Resource(AnonymousTextListHandler)

   118         request = HttpRequest()

   119         user = User.objects.get(pk=1)

   120         setattr(request, 'user' , user)

   121         request.method = 'GET'

   122   

   123         response = resource(request, emitter_format='json')

   124         self.assertEquals(200, response.status_code)

   125         self.assertEquals(5, len(simplejson.loads(response.content)))

   126 

   127     def test_delete_text_logged_in_works(self):

   128         """

   129         Delete text

   130         """

   131         nb_texts = Text.objects.count()

   132         

   133         resource = Resource(TextDeleteHandler)

   134         request = HttpRequest()

   135         user = User.objects.get(pk=1)

   136         setattr(request, 'user' , user)

   137         request.method = 'POST'

   138         setattr(request, 'POST' , {'key':'text_key_3'})

   139         setattr(request, 'flash' , {})

   140   

   141         response = resource(request, emitter_format='json')

   142         self.assertEquals(204, response.status_code)

   143 

   144         # one text deleted

   145         self.assertEquals(nb_texts - 1, Text.objects.count())

   146         

   147     def test_delete_text_logged_in_fail(self):

   148         """

   149         Delete text (and fail: insufficient rights)

   150         """

   151         nb_texts = Text.objects.count()

   152 

   153         resource = Resource(TextDeleteHandler)

   154         request = HttpRequest()

   155         user = User.objects.get(pk=3)

   156         setattr(request, 'user' , user)

   157         request.method = 'POST'

   158         setattr(request, 'POST' , {'key':'text_key_3'})

   159         setattr(request, 'flash' , {})

   160   

   161         response = resource(request, emitter_format='json')

   162         self.assertEquals(401, response.status_code)

   163         

   164         # no text deleted

   165         self.assertEquals(nb_texts, Text.objects.count())

   166 

   167 

   168     def test_pre_edit(self):

   169         """

   170         Pre edit text: should return number of comments to remove

   171         """

   172         resource = Resource(TextPreEditHandler)

   173         request = HttpRequest()

   174         user = User.objects.get(pk=1) 

   175         setattr(request, 'user' , user)

   176         request.method = 'POST'

   177         setattr(request, 'POST' , {'new_format' : 'markdown', 'new_content' : u'ggg'})

   178         setattr(request, 'flash' , {})

   179     

   180         response = resource(request, key='text_key_2', emitter_format='json')

   181         self.assertEquals(response.content, '{"nb_removed": 3}')

   182 

   183     def xtest_edit(self):

   184         """

   185         Edit text

   186         """

   187         resource = Resource(TextEditHandler)

   188         request = HttpRequest()

   189         setattr(request,'session',None)

   190         user = User.objects.get(pk=1) 

   191         setattr(request, 'user' , user)

   192         request.method = 'POST'

   193         setattr(request, 'POST' , {'new_format' : 'markdown', 'new_content' : u'ggg'})

   194         setattr(request, 'flash' , {})

   195     

   196         response = resource(request, key='text_key_2', emitter_format='json')

   197 

   198         self.assertEquals(Text.objects.get(pk=2).last_text_version.content , u'ggg')

   199 

   200     

   201     def test_setuser(self):

   202         """

   203         Set username/email for commenting

   204         """

   205         from django.test.client import Client

   206         c = Client()

   207         response = c.post('/setuser/', {'username': 'my_username', 'email': 'my_email'})