Beispiel #1
0
    def test_requires_get_or_post(self):
        client = Client(enforce_csrf_checks=True)
        with override_settings(DEBUG=False):
            self.assertEquals(client.get(self.str_uri).status_code, 403)
            self.assertEquals(client.post(self.str_uri).status_code, 403)
            self.assertEquals(client.head(self.str_uri).status_code, 405)
            self.assertEquals(client.options(self.str_uri).status_code, 405)
            self.assertEquals(client.put(self.str_uri).status_code, 405)
            self.assertEquals(client.delete(self.str_uri).status_code, 405)

            self.assertEquals(client.get(self.str_class_uri).status_code, 403)
            self.assertEquals(client.post(self.str_class_uri).status_code, 403)
            self.assertEquals(client.head(self.str_class_uri).status_code, 405)
            self.assertEquals(client.put(self.str_class_uri).status_code, 405)
            self.assertEquals(client.delete(self.str_class_uri).status_code, 405)

        with override_settings(DEBUG=True):
            self.assertEquals(client.get(self.str_uri).status_code, 200)
            self.assertEquals(client.post(self.str_uri).status_code, 200)
            self.assertEquals(client.head(self.str_uri).status_code, 200)
            self.assertEquals(client.options(self.str_uri).status_code, 200)
            self.assertEquals(client.put(self.str_uri).status_code, 200)
            self.assertEquals(client.delete(self.str_uri).status_code, 200)

            self.assertEquals(client.get(self.str_class_uri).status_code, 200)
            self.assertEquals(client.post(self.str_class_uri).status_code, 200)
            self.assertEquals(client.head(self.str_class_uri).status_code, 200)
Beispiel #2
0
class ViewPermDecoratorCase(TestCase):
    
    def setUp(self):
        self.client=Client(enforce_csrf_checks=True)
        self.passwd=''.join(random.sample(string.ascii_letters,10))
        self.superuser=User.objects.create_superuser(
            username='******',
            email='*****@*****.**',
            password=self.passwd)
        self.normaluser=User.objects.create_user(
            username='******',
            email='*****@*****.**',
            password=self.passwd)
        self.anonuser=AnonymousUser()
        
    def test_all_methods(self):
        methods=('GET','POST','HEAD','PUT','DELETE','OPTIONS','TRACE','PATCH')
        self.assertTrue(self.client.login(username='******',password=self.passwd))
        self.assertEqual(self.client.get('/test',follow=True).status_code,200)
        self.assertEqual(self.client.post('/test',follow=True).status_code,200)
        self.assertEqual(self.client.head('/test',follow=True).status_code,200)
        self.assertEqual(self.client.put('/test',follow=True).status_code,200)
        self.assertEqual(self.client.delete('/test',follow=True).status_code,200)
        self.assertEqual(self.client.options('/test',follow=True).status_code,200)
        self.assertEqual(self.client.patch('/test',follow=True).status_code,200)
        self.assertTrue(self.client.login(username='******',password=self.passwd))
        self.assertEqual(self.client.get('/test',follow=True).status_code,403)
        self.assertEqual(self.client.post('/test',follow=True).status_code,403)
        self.assertEqual(self.client.head('/test',follow=True).status_code,403)
        self.assertEqual(self.client.put('/test',follow=True).status_code,403)
        self.assertEqual(self.client.delete('/test',follow=True).status_code,403)
        self.assertEqual(self.client.options('/test',follow=True).status_code,403)
        self.assertEqual(self.client.patch('/test',follow=True).status_code,403)
Beispiel #3
0
    def test_requires_get_or_post(self):
        client = Client(enforce_csrf_checks=True)
        with override_settings(DEBUG=False):
            self.assertEquals(client.get(self.str_uri).status_code, 403)
            self.assertEquals(client.post(self.str_uri).status_code, 403)
            self.assertEquals(client.head(self.str_uri).status_code, 405)
            self.assertEquals(client.options(self.str_uri).status_code, 405)
            self.assertEquals(client.put(self.str_uri).status_code, 405)
            self.assertEquals(client.delete(self.str_uri).status_code, 405)

            self.assertEquals(client.get(self.str_class_uri).status_code, 403)
            self.assertEquals(client.post(self.str_class_uri).status_code, 403)
            self.assertEquals(client.head(self.str_class_uri).status_code, 405)
            self.assertEquals(client.put(self.str_class_uri).status_code, 405)
            self.assertEquals(
                client.delete(self.str_class_uri).status_code, 405)

        with override_settings(DEBUG=True):
            self.assertEquals(client.get(self.str_uri).status_code, 200)
            self.assertEquals(client.post(self.str_uri).status_code, 200)
            self.assertEquals(client.head(self.str_uri).status_code, 200)
            self.assertEquals(client.options(self.str_uri).status_code, 200)
            self.assertEquals(client.put(self.str_uri).status_code, 200)
            self.assertEquals(client.delete(self.str_uri).status_code, 200)

            self.assertEquals(client.get(self.str_class_uri).status_code, 200)
            self.assertEquals(client.post(self.str_class_uri).status_code, 200)
            self.assertEquals(client.head(self.str_class_uri).status_code, 200)
Beispiel #4
0
class MonitorViewTestCase(TestCase):

    def setUp(self):
        company = Company(
            id=1,
            zipcode="79008",
            logo="http://test.test",
            name="testcompany",
            mail="*****@*****.**",
            phone="+380901234567",
        )
        company.save()

        project = AdviserProject(
            id=1,
            id_company=company,
            name="project1",
            description="test",
            project_template="test",
        )
        project.save()

        Player.objects.create(
            id=1,
            name="player1",
            description="player description",
            mac_address="11:2a:bb:q1:ss:77",
            status=False,
            project=project  
        )

        Player.objects.create(
            id=2,
            name="player2",
            description="player description",
            mac_address="22:21:dd:ac:ff:22",
            status=False
        )

        self.client = Client()

    def test_get_rendered_monitor(self):
        url = reverse('monitor')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)   
        
    def test_get_monitor(self):
        url = reverse('monitor_view', args=["11:2a:bb:q1:ss:77"])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        
    def test_head_monitor(self):
        url = reverse('monitor_view', args=["11:2a:bb:q1:ss:77"])
        response = self.client.head(url)
        self.assertEqual(response.status_code, 200)
    
    def test_head_monitor_without_project(self):
        url = reverse('monitor_view', args=["22:21:dd:ac:ff:22"])
        response = self.client.head(url)
        self.assertEqual(response.status_code, 204)
Beispiel #5
0
class MonitorViewTestCase(TestCase):
    def setUp(self):
        company = Company(
            id=1,
            zipcode="79008",
            logo="http://test.test",
            name="testcompany",
            mail="*****@*****.**",
            phone="+380901234567",
        )
        company.save()

        project = AdviserProject(
            id=1,
            id_company=company,
            name="project1",
            description="test",
            project_template="test",
        )
        project.save()

        Player.objects.create(id=1,
                              name="player1",
                              description="player description",
                              mac_address="11:2a:bb:q1:ss:77",
                              status=False,
                              project=project)

        Player.objects.create(id=2,
                              name="player2",
                              description="player description",
                              mac_address="22:21:dd:ac:ff:22",
                              status=False)

        self.client = Client()

    def test_get_rendered_monitor(self):
        url = reverse('monitor')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_get_monitor(self):
        url = reverse('monitor_view', args=["11:2a:bb:q1:ss:77"])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_head_monitor(self):
        url = reverse('monitor_view', args=["11:2a:bb:q1:ss:77"])
        response = self.client.head(url)
        self.assertEqual(response.status_code, 200)

    def test_head_monitor_without_project(self):
        url = reverse('monitor_view', args=["22:21:dd:ac:ff:22"])
        response = self.client.head(url)
        self.assertEqual(response.status_code, 204)
Beispiel #6
0
class RequestsPageTests(TestCase):

    def setUp(self):
        self.client = Client()
        self.link_home = reverse('home')
        self.link_admin = reverse('admin:index')
        self.link_requests = reverse('requests')

    def test_home_link(self):
        '''Page contains the link to the 'home' page
        '''
        response = self.client.get(self.link_requests)
        soup = bss.BeautifulSoupSelect(response.content)
        self.assertTrue(soup('a[href="%s"]' % self.link_home))

    def test_amount_ordering_reverse(self):
        '''View contains no more than last 10 requests and has the proper ordering
           (all params by default: reverse=1, priority=0)
        '''
        for _ in range(10):
            self.client.head(self.link_home)
        response = self.client.get(self.link_requests)
        soup = bss.BeautifulSoupSelect(response.content)
        self.assertEquals(10, len(soup('ul#requests li')))
        self.assertIn(self.link_requests, soup('ul#requests li')[0].text)

    def test_amount_ordering_chronological(self):
        '''View contains no more than last 10 requests and has the proper ordering
           (all params by default: reverse=0, priority=1)
        '''
        for _ in range(10):
            self.client.post(self.link_requests)
        response = self.client.get(self.link_admin)
        response = self.client.get(self.link_requests,
                                   {'priority': 1, 'reverse': 0})
        soup = bss.BeautifulSoupSelect(response.content)
        self.assertEquals(10, len(soup('ul#requests li')))
        self.assertIn(self.link_requests,
                      soup('ul#requests li')[8].text)
        self.assertIn(self.link_admin,
                      soup('ul#requests li')[9].text)

    def test_form_contains(self):
        '''view form contains latest request_id
        '''
        response = self.client.get(self.link_requests)
        soup = bss.BeautifulSoupSelect(response.content)
        self.assertEquals(200, response.status_code)
        self.assertEquals(
            1,
            int(soup('form#requests_form input#last')[0]['value']))
    def test_csrf_client_head_works(self):
        # Create a CSRF client
        csrf_client = Client(enforce_csrf_checks=True)

        # make a HEAD request
        r = csrf_client.head("/ping/%s/" % self.check.code)
        self.assertEqual(r.status_code, 200)
Beispiel #8
0
def test_status():
    c = Client()
    res = c.get('/search/status/')
    json_ok(res)

    res = c.head('/search/status/')
    eq_(res.status_code, 200)
Beispiel #9
0
class GlobalTestCase (TestCase):
    def setUp (self):
        self.client = Client()

    def test_views (self):
        self.assertTrue (True)  # tmp disabled
        return

        """Check that all views from website.urls returns http success"""
        for obj in urls.urlpatterns:
            if isinstance (obj, urlresolvers.RegexURLPattern):
                if obj.name and 'password_reset' in obj.name: continue
                assert obj.regex.pattern[-1] == '$'
                # @todo don't just blindly chop of first and last char
                #       replace first '^' with '/'
                #       chop last if '$'
                url = '/' + obj.regex.pattern[1:-1] # drop first and last char (regex anchors)
                if url.startswith ('/edit/'): continue  # non-public views
                res = self.client.head (url)
                if obj.callback.__name__ == 'RedirectView':
                    self.assertEqual (res.status_code, 301)
                else:
                    self.assertEqual (res.status_code, 200)

            elif isinstance (obj, urlresolvers.RegexURLResolver):
                # @todo recurse on o.url_patterns, but skip if o.namespace == 'admin'
                pass
Beispiel #10
0
 def test_that_the_csrf_head_works(self):
     """
     This test asserts that the csrf_client works
     """
     csrf_client = Client(enforce_csrf_checks=True)
     response = csrf_client.head(reverse("hc-ping", args=[self.check.code]))
     self.assertEqual(response.status_code, 200)
Beispiel #11
0
 def test_edit_admin_operation_not_allowed(self):
     """
     Invalid operation head
     """
     c = Client()
     c.login(username="******", password="******")        
     response = c.head("/administrator/edit/")
     self.assertEquals(response.status_code, 403)
Beispiel #12
0
 def test_edit_pass_operation_not_allowed(self):
     """
     Invalid operation head
     """
     c = Client()
     c.login(username="******", password="******")
     response = c.head("/employee/updatePassword/emp1/")
     self.assertEquals(response.status_code, 400)
Beispiel #13
0
    def test_head_works(self):
        check = Check()
        check.save()

        csrf_client = Client(enforce_csrf_checks=True)
        r = csrf_client.head("/ping/%s/" % check.code)
        assert r.status_code == 200
        assert Ping.objects.count() == 1
Beispiel #14
0
    def test_head_works(self):
        check = Check()
        check.save()

        csrf_client = Client(enforce_csrf_checks=True)
        r = csrf_client.head("/ping/%s/" % check.code)
        assert r.status_code == 200
        assert Ping.objects.count() == 1
Beispiel #15
0
 def test_edit_employees_operation_not_allowed(self):
     """
         Invalid operation head
         """
     c = Client()
     c.login(username="******", password="******")
     response = c.head(reverse("company_edit"))
     self.assertEquals(response.status_code, 403)
Beispiel #16
0
 def test_token(self):
     # prepare client
     client = Client(enforce_csrf_checks=True)
     # normal case
     response = client.get('/api/token/')
     self.assertEqual(response.status_code, 204)
     # wrong type of request
     response = client.head('/api/token/')
     self.assertEqual(response.status_code, 405)
Beispiel #17
0
    def test_head(self):
        client = Client()

        resource_id = self.do_post(client)

        response = client.head(f"/upload/{resource_id}")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response["Upload-Offset"], "0")
        self.assertEqual(response["Upload-Length"], "0")
Beispiel #18
0
 def test_requires_get_or_post(self):
     c = Client(enforce_csrf_checks=True)
     with override_settings(DEBUG=False):
         for uri in self.uris:
             self._assertStatusCode(c.get(uri).status_code, 403, uri)
             self._assertStatusCode(c.post(uri).status_code, 403, uri)
             self._assertStatusCode(c.head(uri).status_code, 405, uri)
             self._assertStatusCode(c.options(uri).status_code, 405, uri)
             self._assertStatusCode(c.put(uri).status_code, 405, uri)
             self._assertStatusCode(c.delete(uri).status_code, 405, uri)
 def test_requires_get_or_post(self):
     c = Client(enforce_csrf_checks=True)
     with override_settings(DEBUG=False):
         for uri in self.uris:
             self._assertStatusCode(c.get(uri).status_code, 403, uri)
             self._assertStatusCode(c.post(uri).status_code, 403, uri)
             self._assertStatusCode(c.head(uri).status_code, 405, uri)
             self._assertStatusCode(c.options(uri).status_code, 405, uri)
             self._assertStatusCode(c.put(uri).status_code, 405, uri)
             self._assertStatusCode(c.delete(uri).status_code, 405, uri)
Beispiel #20
0
def test_get():
    client = Client()
    get_response = client.get('/ssi/tests.method-get/')
    assert get_response.status_code == 200
    assert get_response.content == b'She\'s coming in twelve-thirty flight'

    post_response = client.post('/ssi/tests.method-get/')
    assert post_response.status_code == 405

    head_response = client.head('/ssi/tests.method-get/')
    assert head_response.status_code == 405
Beispiel #21
0
def test_cbv():
    client = Client()
    get_response = client.get('/ssi/tests.simple_cbv/')
    assert get_response.status_code == 200
    assert get_response.content == b'There\'s nothing that a hundred men or more could ever do'

    head_response = client.head('/ssi/tests.simple_cbv/')
    assert head_response.status_code == 200

    post_response = client.post('/ssi/tests.simple_cbv/')
    assert post_response.status_code == 405
Beispiel #22
0
def test_head_ok(wa_audio):
    catcha = wa_audio
    x = CRUD.create_anno(catcha)
    c = Consumer._default_manager.create()
    payload = make_jwt_payload(apikey=c.consumer)
    token = make_encoded_token(c.secret_key, payload)

    client = Client()  # check if middleware works
    response = client.head(reverse('crud_api', kwargs={'anno_id': x.anno_id}),
                           HTTP_AUTHORIZATION='token ' + token)

    assert response.status_code == 200
    assert len(response.content) == 0
Beispiel #23
0
 def test_all_return_statuses_when_debug_true(self):
     c = Client(enforce_csrf_checks=True)
     with override_settings(DEBUG=True):
         for uri in self.uris:
             self._assertStatusCode(c.get(uri).status_code, 200, uri)
             self._assertStatusCode(c.post(uri).status_code, 200, uri)
             self._assertStatusCode(c.head(uri).status_code, 200, uri)
             self._assertStatusCode(c.options(uri).status_code, 200, uri)
             if uri.endswith('class_view/'):
                 self._assertStatusCode(c.put(uri).status_code, 405, uri)
                 self._assertStatusCode(c.delete(uri).status_code, 405, uri)
             else:
                 self._assertStatusCode(c.put(uri).status_code, 200, uri)
                 self._assertStatusCode(c.delete(uri).status_code, 200, uri)
 def test_all_return_statuses_when_debug_true(self):
     c = Client(enforce_csrf_checks=True)
     with override_settings(DEBUG=True):
         for uri in self.uris:
             self._assertStatusCode(c.get(uri).status_code, 200, uri)
             self._assertStatusCode(c.post(uri).status_code, 200, uri)
             self._assertStatusCode(c.head(uri).status_code, 200, uri)
             self._assertStatusCode(c.options(uri).status_code, 200, uri)
             if uri.endswith('class_view/'):
                 self._assertStatusCode(c.put(uri).status_code, 405, uri)
                 self._assertStatusCode(c.delete(uri).status_code, 405, uri)
             else:
                 self._assertStatusCode(c.put(uri).status_code, 200, uri)
                 self._assertStatusCode(c.delete(uri).status_code, 200, uri)
Beispiel #25
0
 def send_head(self, user_string="user_1", do_auth=True, enforce_csrf_checks=False, *args, **kwargs):
     """
     Send a HEAD request to the configured URL endpoint on behalf of the given user.
     :param user_string: The user to send the request as.
     :param do_auth: Whether or not to log the user in if the view requires authentication.
     :param enforce_csrf_checks: Whether or not to enforce CSRF checks in the HTTP client.
     :param args: Positional arguments for client.head.
     :param kwargs: Keyword arguments for client.head.
     :return: The HTTP response.
     """
     client = Client(enforce_csrf_checks=enforce_csrf_checks)
     if self.requires_auth and do_auth:
         user = SaFaker.get_user(user_string)
         client.force_login(user)
     return client.head(
         self.get_url_path(user=user_string),
         *args,
         **kwargs
     )
Beispiel #26
0
class RootViewTestCase(CorvidTestCase):
    def setUp(self):
        super().setUpTheme()
        self.client = Client()

    def tearDown(self):
        super().tearDownTheme()

    def test_not_logged_in_redirect(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/login/', response.url)

    def test_logged_in_go_to_home(self):
        self.assertTrue(
            self.client.login(username=self.admin_user.username,
                              password=self.admin_password))
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/home/', response.url)

    def test_other_response_types_500(self):
        self.assertTrue(
            self.client.login(username=self.admin_user.username,
                              password=self.admin_password))
        response = self.client.post('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.put('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.head('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.delete('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.patch('/')
        self.assertEqual(response.status_code, 500)
Beispiel #27
0
class RootViewTestCase(CorvidTestCase):

    def setUp(self):
        super().setUpTheme()
        self.client = Client()

    def tearDown(self):
        super().tearDownTheme()

    def test_not_logged_in_redirect(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/login/', response.url)

    def test_logged_in_go_to_home(self):
        self.assertTrue(self.client.login(username=self.admin_user.username,
                                          password=self.admin_password))
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/home/', response.url)

    def test_other_response_types_500(self):
        self.assertTrue(self.client.login(username=self.admin_user.username,
                                          password=self.admin_password))
        response = self.client.post('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.put('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.head('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.delete('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.patch('/')
        self.assertEqual(response.status_code, 500)
Beispiel #28
0
class DashboardViewTests(TestCase):
    URL = "app/dashboard"

    # TODO: something about self.user is broken
    # Can't get models with it as attr
    def setUp(self):
        self.c = Client()
        self.factory = RequestFactory()
        self.user = User.objects.create_user(
            username="******", email="*****@*****.**", password="******"
        )

    def test_invalid_method(self):
        """ Test some invalid HTTP methods """
        error_code = 404
        response = self.c.put(self.URL)
        assert response.status_code == error_code
        response = self.c.head(self.URL)
        assert response.status_code == error_code

    def test_get_method(self):
        """ Test GET method with authenticated user """
        # Setup
        ldb = github_leaderboard.app.models.Leaderboard()
        ldb.name = "test_leaderboard"
        ldb.owner = self.user
        request = self.factory.get(self.URL)
        request.user = self.user

        # https://stackoverflow.com/questions/11938164/why-dont-my-django-unittests-know-that-messagemiddleware-is-installed
        setattr(request, "session", "session")
        messages = FallbackStorage(request)
        setattr(request, "_messages", messages)

        # Get Response
        response = views.dashboard(request)
        assert response.status_code == 200
class ChallengeTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(username="******",
                        email="*****@*****.**",
                        challenge="randomstring",
                        encrypted_challenge="encryptedrandomstring")

    def test_get_challenge_invalid_parameters(self):
        response = self.client.get("/challenge/")
        self.assertEqual(response.status_code, 400)

    def test_get_challenge_invalid_username(self):
        response = self.client.get("/challenge/", {"username":"******"})
        self.assertEqual(response.status_code, 404)

    def test_get_challenge_valid_username(self):
        response = self.client.get("/challenge/", {"username":"******"})
        self.assertEqual(response.status_code, 200)

    def test_get_challenge_valid_json(self):
        response = self.client.get("/challenge/", {"username":"******", 'format':'json'})
        try:
            json.loads(response.content)
        except ValueError:
            self.fail("Bad JSON format")

    def test_get_challenge_invalid_format(self):
        response = self.client.get("/challenge/", {"username":"******", 'format':'invalidformat'})
        self.assertEqual(response.status_code, 400)


    def test_get_challenge_valid_encrypted_challenge(self):
        response = self.client.get("/challenge/", {"username":"******", 'format':'json'})
        try:
            challenge_json = json.loads(response.content)
            self.assertEqual("encrypted_challenge" in challenge_json, True)
            self.assertEqual(challenge_json["encrypted_challenge"], "encryptedrandomstring")
        except ValueError:
            self.fail("Bad JSON format")

    def test_post_challenge_invalid_parameters(self):
        response = self.client.post("/challenge/")
        self.assertEqual(response.status_code, 400)
        response = self.client.post("/challenge/", {"username":"******"})
        self.assertEqual(response.status_code, 400)
        response = self.client.post("/challenge/", {"challenge":"randomstring"})
        self.assertEqual(response.status_code, 400)

    def test_post_challenge_valid_parameters(self):
        response = self.client.post("/challenge/", {"username":"******", "challenge":"randomstring"})
        self.assertEqual(response.status_code, 200)

    def test_get_challenge_valid_json(self):
        response = self.client.post("/challenge/", {"username":"******", "challenge":"randomstring", 'format':'json'})
        try:
            rsa_json = json.loads(response.content)
            self.assertEqual("rsa_public" in rsa_json, True)
        except ValueError:
            self.fail("Bad JSON format")

    def test_post_challenge_invalid_format(self):
        response = self.client.post("/challenge/", {"username":"******", "challenge":"randomstring", "format":"invalidformat"})
        self.assertEqual(response.status_code, 400)

    def test_post_challenge_invalid_credentials(self):
        response = self.client.post("/challenge/", {"username":"******", "challenge":"invalidchallenge"})
        self.assertEqual(response.status_code, 403)

    def test_challenge_invalid_methods(self):
        response = self.client.head("/challenge/")
        self.assertEqual(response.status_code, 405)
        response = self.client.options("/challenge/", {})
        self.assertEqual(response.status_code, 405)
        response = self.client.put("/challenge/", {})
        self.assertEqual(response.status_code, 405)
        response = self.client.delete("/challenge/", {})
        self.assertEqual(response.status_code, 405)        
Beispiel #30
0
 def test_head_works(self):
     csrf_client = Client(enforce_csrf_checks=True)
     r = csrf_client.head("/ping/%s/" % self.check.code)
     self.assertEqual(r.status_code, 200)
     self.assertEqual(Ping.objects.count(), 1)
class ChallengeTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username="******",
            email="*****@*****.**",
            challenge="randomstring",
            encrypted_challenge="encryptedrandomstring")

    def test_get_challenge_invalid_parameters(self):
        response = self.client.get("/challenge/")
        self.assertEqual(response.status_code, 400)

    def test_get_challenge_invalid_username(self):
        response = self.client.get("/challenge/",
                                   {"username": "******"})
        self.assertEqual(response.status_code, 404)

    def test_get_challenge_valid_username(self):
        response = self.client.get("/challenge/", {"username": "******"})
        self.assertEqual(response.status_code, 200)

    def test_get_challenge_valid_json(self):
        response = self.client.get("/challenge/", {
            "username": "******",
            'format': 'json'
        })
        try:
            json.loads(response.content)
        except ValueError:
            self.fail("Bad JSON format")

    def test_get_challenge_invalid_format(self):
        response = self.client.get("/challenge/", {
            "username": "******",
            'format': 'invalidformat'
        })
        self.assertEqual(response.status_code, 400)

    def test_get_challenge_valid_encrypted_challenge(self):
        response = self.client.get("/challenge/", {
            "username": "******",
            'format': 'json'
        })
        try:
            challenge_json = json.loads(response.content)
            self.assertEqual("encrypted_challenge" in challenge_json, True)
            self.assertEqual(challenge_json["encrypted_challenge"],
                             "encryptedrandomstring")
        except ValueError:
            self.fail("Bad JSON format")

    def test_post_challenge_invalid_parameters(self):
        response = self.client.post("/challenge/")
        self.assertEqual(response.status_code, 400)
        response = self.client.post("/challenge/", {"username": "******"})
        self.assertEqual(response.status_code, 400)
        response = self.client.post("/challenge/",
                                    {"challenge": "randomstring"})
        self.assertEqual(response.status_code, 400)

    def test_post_challenge_valid_parameters(self):
        response = self.client.post("/challenge/", {
            "username": "******",
            "challenge": "randomstring"
        })
        self.assertEqual(response.status_code, 200)

    def test_get_challenge_valid_json(self):
        response = self.client.post("/challenge/", {
            "username": "******",
            "challenge": "randomstring",
            'format': 'json'
        })
        try:
            rsa_json = json.loads(response.content)
            self.assertEqual("rsa_public" in rsa_json, True)
        except ValueError:
            self.fail("Bad JSON format")

    def test_post_challenge_invalid_format(self):
        response = self.client.post(
            "/challenge/", {
                "username": "******",
                "challenge": "randomstring",
                "format": "invalidformat"
            })
        self.assertEqual(response.status_code, 400)

    def test_post_challenge_invalid_credentials(self):
        response = self.client.post("/challenge/", {
            "username": "******",
            "challenge": "invalidchallenge"
        })
        self.assertEqual(response.status_code, 403)

    def test_challenge_invalid_methods(self):
        response = self.client.head("/challenge/")
        self.assertEqual(response.status_code, 405)
        response = self.client.options("/challenge/", {})
        self.assertEqual(response.status_code, 405)
        response = self.client.put("/challenge/", {})
        self.assertEqual(response.status_code, 405)
        response = self.client.delete("/challenge/", {})
        self.assertEqual(response.status_code, 405)
Beispiel #32
0
 def test_head_works(self):
     csrf_client = Client(enforce_csrf_checks=True)
     r = csrf_client.head("/ping/%s/" % self.check.code)
     self.assertEqual(r.status_code, 200)
     self.assertEqual(Ping.objects.count(), 1)
Beispiel #33
0
class SimpleTestCaseClass(SimpleTestCase):
    pass  # Need to fix test cases as per new changes

    def setUp(self):
        # Every test needs a client.
        self.client = Client()

    def test_post_invalid_json_post(self):
        # Expected response HTTP_400_BAD_REQUEST
        response = self.client.post(path='/datacube_accuracy_api/',
                                    data='{incorrect-json-$#%$#%#$%}',
                                    content_type='application/json')
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)

    @mock.patch('datacube_accuracy_api.utils.validate_request_data',
                side_effect=mock_for_validate_request_data)
    @mock.patch('datacube_accuracy_api.utils.process_request',
                side_effect=mock_for_process_request)
    def test_post_with_valid_json_check(self, fun1, fun2):
        # Expected response HTTP_200_OK
        response = self.client.post(path='/datacube_accuracy_api/',
                                    data='{"start_time":"2016-01-01T00:00",'
                                    '"end_time":"2016-01-02T00:00"}',
                                    content_type='application/json')
        self.assertEquals(response.status_code, status.HTTP_200_OK)

    @mock.patch('datacube_accuracy_api.utils.validate_request_data',
                side_effect=mock_for_validate_request_data)
    @mock.patch('datacube_accuracy_api.utils.process_request',
                side_effect=mock_for_process_request)
    def test_post_with_valid_json_reprocess(self, fun1, fun2):
        # Expected response HTTP_201_CREATED
        response = self.client.post(path='/datacube_accuracy_api/',
                                    data='{"action":"generate"}',
                                    content_type='application/json')

        self.assertEquals(response.status_code, status.HTTP_200_OK)

    def test_get_methods(self):
        # Expected response HTTP_405_METHOD_NOT_ALLOWED
        response = self.client.get(path='/datacube_accuracy_api/')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_put_methods(self):
        # Expected response HTTP_405_METHOD_NOT_ALLOWED
        response = self.client.put(path='/datacube_accuracy_api/')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_delete_methods(self):
        # Expected response HTTP_405_METHOD_NOT_ALLOWED
        response = self.client.delete(path='/datacube_accuracy_api/')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_head_methods(self):
        # Expected response HTTP_405_METHOD_NOT_ALLOWED
        response = self.client.head(path='/datacube_accuracy_api/')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_post_with_valid_json_delete(self):
        # Expected response status.HTTP_405_METHOD_NOT_ALLOWED
        response = self.client.post(path='/datacube_accuracy_api/',
                                    data='{"start_time":"2016-01-01T00:00",'
                                    '"end_time":"2016-01-02T00:00",'
                                    '"action":"delete",'
                                    '"cube":"min15",'
                                    '"environment":"nst",'
                                    '"url_dimension":"yes"}',
                                    content_type='application/json')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_validate_request_data_incorrect_start_date(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="invalid",  # invalid start format
                end_time="2016-01-02T00:00",
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        """
        # self.assertRaises(ValueError, utils.validate_request_data(request))
        try:
            utils.validate_request_data(request)
            self.assertFalse(True)
        except ValueError:
            self.assertTrue(True)
        """
        with self.assertRaisesMessage(
                ValueError,
                "Incorrect start_time format in request body. Please provide \'%Y-%m-%dT%H:%M\'"
        ):
            utils.validate_request_data(request)

    def test_validate_request_data_incorrect_start_minute(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:11",  # invalid minute format
                end_time="2016-01-02T00:00",
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        with self.assertRaisesMessage(
                ValueError,
                "Incorrect start_time. Minute should start from 00 or 15 or 30 or 45"
        ):
            utils.validate_request_data(request)

    def test_validate_request_data_incorrect_end_date(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:00",
                end_time="33/33/33",  # invalid date format
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        with self.assertRaisesMessage(
                ValueError,
                "Incorrect end_time format in request body. Please provide \'%Y-%m-%dT%H:%M\'"
        ):
            utils.validate_request_data(request)

    def test_validate_request_data_incorrect_end_minute(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:00",
                end_time="2016-01-02T00:11",  # invalid minute format
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        with self.assertRaisesMessage(
                ValueError,
                "Incorrect end_time. Minute should start from 00 or 15 or 30 or 45"
        ):
            utils.validate_request_data(request)

    def test_validate_request_data_incorrect_date_range(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-02T00:00",
                end_time="2016-01-01T00:00",
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        with self.assertRaisesMessage(
                ValueError,
                "start_time:2016-01-02T00:00 is greater than end_time:2016-01-01T00:00"
                " in request body"):
            utils.validate_request_data(request)

    def test_validate_request_data_incorrect_cube(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:00",
                end_time="2016-01-02T00:00",
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube="some incorrect value",
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        with self.assertRaisesMessage(ValueError,
                                      "Incorrect 'cube' : " + "some incorrect value" + " value. Should be either " \
                                      + utils.CUBE_MIN_15 + "/" + utils.CUBE_DAILY + "/" + utils.CUBE_WEEKLY):
            utils.validate_request_data(request)

    def test_validate_request_data(self):
        request = RequestFactory().post(
            path="/datacube_accuracy_api/",
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:00",
                end_time="2016-01-02T00:00",
                action=utils.ACTION_CHECK,
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        # overriding data attribute as mismatch between WSGIRequest and Django request in APIViews
        request.data = request.POST
        try:
            utils.validate_request_data(request)
        except ValueError:
            self.assertTrue(False)

    def test_process_request_invalid_action(self):
        response = self.client.post(
            path='/datacube_accuracy_api/',
            data=format_request_body(
                provider="blah-blah",
                start_time="2016-01-01T00:00",
                end_time="2016-01-02T00:00",
                action="Some Invalid Action",
                environment=utils.ENVIRONMENT_NEXT_STAGING,
                cube=utils.CUBE_DAILY,
                url_dimension=utils.URL_DIMENSION_YES))
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)

    def test_read_file_with_expected_results_test(self):
        dir = os.path.dirname(__file__)
        filename = os.path.join(dir, './resources/test_file.csv')
        print filename
        list_from_file = utils.read_file(filename)
        list_expected = dict()
        list_expected['2016-01-01 03:00:00'] = 'not_completed'
        list_expected['2016-01-01 02:45:00'] = 'not_completed'
        list_expected['2016-01-01 08:15:00'] = 'not_completed'
        list_expected['2016-01-01 04:00:00'] = 'completed'

        self.assertEquals(
            len(set(list_from_file.items()) & set(list_expected.items())),
            len(list_from_file))
    def test_csrf_client_head_works(self):
        csrf_client = Client(enforce_csrf_checks=True)
        response = csrf_client.head("/ping/%s/" % self.check.code)

        self.assertEqual(response.status_code, 200)
Beispiel #35
0
class RegisterTestCase(TestCase):
    def setUp(self):
        self.client = Client()

    def test_success_register(self):
        response = self.client.post(
            r'/account/register', {
                'username': '******',
                'email': '*****@*****.**',
                'password': '******',
                'password2': '1234',
                'first_name': 'john',
                'last_name': 'doe',
            })
        self.assertEquals(response.status_code, status.HTTP_200_OK)

    def test_user_already_exists(self):
        self.client.post(
            r'/account/register', {
                'username': '******',
                'email': '*****@*****.**',
                'password': '******',
                'password2': '1234',
                'first_name': 'john',
                'last_name': 'doe',
            })
        response = self.client.post(
            r'/account/register', {
                'username': '******',
                'email': '*****@*****.**',
                'password': '******',
                'password2': '1234',
                'first_name': 'john',
                'last_name': 'doe',
            })
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertJSONEqual(str(response.content, encoding='utf-8'),
                             {'username': ['User john_doe1 already exists']})

    def test_invalid_email(self):
        response = self.client.post(
            r'/account/register', {
                'username': '******',
                'email': 'not_valid_email',
                'password': '******',
                'password2': '1234',
                'first_name': 'john',
                'last_name': 'doe',
            })
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertJSONEqual(str(response.content, encoding='utf-8'),
                             {'email': ['Enter a valid email address.']})

    def test_different_passwords(self):
        response = self.client.post(
            r'/account/register', {
                'username': '******',
                'email': 'not_valid_email',
                'password': '******',
                'password2': '12345',
                'first_name': 'john',
                'last_name': 'doe',
            })
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertJSONEqual(str(response.content, encoding='utf-8'),
                             {'email': ['Enter a valid email address.']})

    def test_empty_fields(self):
        response = self.client.post(r'/account/register')
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertJSONEqual(
            str(response.content, encoding='utf-8'), {
                'email': ['This field is required.'],
                'first_name': ['This field is required.'],
                'last_name': ['This field is required.'],
                'password': ['This field is required.'],
                'password2': ['This field is required.'],
                'username': ['This field is required.'],
            })

    def test_only_post_allowed(self):
        response = self.client.get('/account/register')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)
        response = self.client.delete('/account/register')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)
        response = self.client.put('/account/register')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)
        response = self.client.head('/account/register')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)
        response = self.client.options('/account/register')
        self.assertEquals(response.status_code, status.HTTP_401_UNAUTHORIZED)
        response = self.client.trace('/account/register')
        self.assertEquals(response.status_code,
                          status.HTTP_405_METHOD_NOT_ALLOWED)
Beispiel #36
0
class DropServerTestCase(TestCase):
    def setUp(self):
        """Pre-test activities."""
        self.app = Client()
        self.drop = Drop(drop_id="abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", message=b"Hello World")
        self.dropfoo = Drop(drop_id="abcdefghijklmnopqrstuvwxyzabcdefghijklmnfoo", message=b"Bar")
        self.dropfoo.created_at = datetime.datetime(year=2016, month=1, day=1, tzinfo=pytz.UTC)
        self.drop.save()
        self.dropfoo.save()

    #######GET
    def test_get_message_from_invalid_drop_id(self):
        response = self.app.get("/invalid")
        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "Invalid drop id" == err(response.content)

    def test_get_messages(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo")
        assert response.status_code == status.HTTP_200_OK
        assert response["Content-Type"].startswith("multipart/mixed; boundary=")
        assert "Hello World" in response.content.decode()
        assert response.content.decode().count("Hello World") == 1
        assert "Bar" not in response.content.decode()

    def test_get_messsages_contains_headers(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnfoo")
        assert response["Last-Modified"] == "Fri, 01 Jan 2016 00:00:00 GMT"
        assert "X-Qabel-Latest" in response

    def test_get_messages_empty_drop(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklempty")
        assert response.status_code == status.HTTP_204_NO_CONTENT
        assert response.content == b""

    def test_get_messages_posted_since(self):
        dt = datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(minutes=1)
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt, usegmt=True)
        )

        assert response.status_code == status.HTTP_200_OK
        body = response.content.decode()
        assert "Hello World" in body
        assert "Bar" not in body

    def test_get_messages_posted_since_invalid(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE="warghabl")

        assert response.status_code == status.HTTP_200_OK
        body = response.content.decode()
        assert "Hello World" in body
        assert "Bar" not in body

    def test_get_messages_posted_since_qabel(self):
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            HTTP_X_QABEL_NEW_SINCE=str(utc_timestamp(self.dropfoo.created_at)),
        )

        assert response.status_code == status.HTTP_200_OK
        body = response.content.decode()
        assert "Hello World" in body
        assert "Bar" not in body

    def test_get_messages_posted_since_qabel_invalid(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_X_QABEL_NEW_SINCE="warghabl")

        assert response.status_code == status.HTTP_200_OK
        body = response.content.decode()
        assert "Hello World" in body
        assert "Bar" not in body

    def test_get_qabel_round_trip(self):
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo")
        assert response.status_code == status.HTTP_200_OK
        latest = response["X-Qabel-Latest"]
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_X_QABEL_NEW_SINCE=latest)
        assert response.status_code == status.HTTP_304_NOT_MODIFIED

    def test_get_messages_posted_since_gmt1(self):
        dt = datetime.datetime.now(tz=pytz.timezone("Europe/Berlin")) - datetime.timedelta(minutes=1)
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt)
        )

        assert response.status_code == status.HTTP_200_OK
        assert "Hello World" in response.content.decode()

    def test_get_no_messages_posted_since(self):
        dt = datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(minutes=1)
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt, usegmt=True)
        )
        assert response.status_code == status.HTTP_304_NOT_MODIFIED
        assert response.content == b""

    def test_get_no_messages_posted_since_qabel(self):
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            HTTP_X_QABEL_NEW_SINCE=str(utc_timestamp(self.drop.created_at) + 1),
        )
        assert response.status_code == status.HTTP_304_NOT_MODIFIED
        assert response.content == b""

    def test_get_no_messages_posted_since_gmt1(self):
        dt = datetime.datetime.now(tz=pytz.timezone("Europe/Berlin")) + datetime.timedelta(minutes=1)
        response = self.app.get(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt)
        )
        assert response.status_code == status.HTTP_304_NOT_MODIFIED
        assert response.content == b""

    ######HEAD
    def test_head_message_from_invalid_drop_id(self):
        response = self.app.head("/invalid")
        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert response.content == b""

    def test_head_messages(self):
        response = self.app.head("/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo")
        assert response.status_code == status.HTTP_200_OK
        assert response.content == b""

    def test_head_messages_empty_drop(self):
        response = self.app.head("/abcdefghijklmnopqrstuvwxyzabcdefghijklempty")
        assert response.status_code == status.HTTP_204_NO_CONTENT
        assert response.content == b""

    def test_head_messages_posted_since(self):
        dt = datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(minutes=1)
        print(format_datetime(dt, usegmt=True))
        response = self.app.head(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt, usegmt=True)
        )

        assert response.status_code == status.HTTP_200_OK
        assert response.content == b""

    def test_head_messages_posted_since_qabel(self):
        response = self.app.head(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            HTTP_X_QABEL_NEW_SINCE=str(utc_timestamp(self.dropfoo.created_at)),
        )
        assert response.status_code == status.HTTP_200_OK
        assert response.content == b""

    def test_head_no_messages_posted_since(self):
        dt = datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(minutes=1)
        response = self.app.head(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo", HTTP_IF_MODIFIED_SINCE=format_datetime(dt, usegmt=True)
        )
        assert response.status_code == status.HTTP_304_NOT_MODIFIED
        assert response.content == b""

    def test_head_no_messages_posted_since_etag(self):
        response = self.app.head(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            HTTP_X_QABEL_NEW_SINCE=str(utc_timestamp(self.drop.created_at) + 1),
        )
        assert response.status_code == status.HTTP_304_NOT_MODIFIED
        assert response.content == b""

    #######POST
    def test_post_empty_message(self):
        response = self.app.post(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            data=b"",
            content_type="application/octet-stream",
            HTTP_AUTHORIZATION="Client Qabel",
        )
        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert err(response.content) == "No message provided"

    def test_post_to_invalid_drop_id(self):
        response = self.app.post(
            "/fail", data=b"Yay", content_type="application/octet-stream", HTTP_AUTHORIZATION="Client Qabel"
        )
        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert err(response.content) == "Invalid drop id"

    def test_post_message_is_too_long(self):
        too_long = settings.MESSAGE_SIZE_LIMIT + 1
        response = self.app.post(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmnopo",
            data=too_long * b"x",
            content_type="application/octet-stream",
            HTTP_AUTHORIZATION="Client Qabel",
        )
        assert response.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE
        assert err(response.content) == "Message too large"

    def test_post_message(self):
        response = self.app.post(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmpost",
            data=b"Yay",
            content_type="application/octet-stream",
            HTTP_AUTHORIZATION="Client Qabel",
        )
        assert response.status_code == status.HTTP_200_OK
        assert response.content == b""
        response = self.app.get("/abcdefghijklmnopqrstuvwxyzabcdefghijklmpost")
        assert "Yay" in response.content.decode()

    def test_post_message_without_headers(self):
        response = self.app.post(
            "/abcdefghijklmnopqrstuvwxyzabcdefghijklmpost", data=b"Yay", content_type="application/octet-stream"
        )
        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert err(response.content) == "Bad authorization"
Beispiel #37
0
 def test_view(self):
     c = Client()
     c.login(username='******', password='******')
     response = c.head('/playlists/')
     self.assertEqual(response.status_code, 200)
Beispiel #38
0
class APIViews(TestCase):
    def setUp(self):
        self.c = Client()
        self.article_url = urls.reverse("article", kwargs={"msid": 12345})

    def test_article_protocol_dne(self):
        "a request for an article that does not exist returns 404, not found"
        resp = self.c.get(urls.reverse("article", kwargs={"msid": 42}))
        self.assertEqual(resp.status_code, 404)

    def test_article_protocol_dne_head(self):
        "a HEAD request for an article that does not exist returns 404, not found"
        resp = self.c.head(urls.reverse("article", kwargs={"msid": 42}))
        self.assertEqual(resp.status_code, 404)

    def test_article_protocol(self):
        "a request for an article that exists returns a 200 successful request with correct content-type"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        logic.add_result(json.load(open(fixture, "r")))
        resp = self.c.get(self.article_url)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["Content-Type"], settings.ELIFE_CONTENT_TYPE)

    def test_article_protocol_head(self):
        "a HEAD request for an article that exists returns, 200 successful request"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        logic.add_result(json.load(open(fixture, "r")))
        resp = self.c.head(self.article_url)
        self.assertEqual(resp.status_code, 200)

    def test_article_protocol_elife_ctype(self):
        "a request for an article with a custom elife content type, gets the same content type in the response"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        logic.add_result(json.load(open(fixture, "r")))
        resp = self.c.get(self.article_url,
                          HTTP_ACCEPT=settings.ELIFE_CONTENT_TYPE)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["Content-Type"], settings.ELIFE_CONTENT_TYPE)

    def test_article_protocol_data(self):
        "a request for article data returns a valid response"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        logic.add_result(json.load(open(fixture, "r")))
        resp = self.c.get(self.article_url).json()
        for row in resp["items"]:
            self.assertTrue(
                utils.has_only_keys(row, logic.PROTOCOL_DATA_KEYS.values()))

    def test_article_protocol_post(self):
        "a POST request with article data returns a successful response"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        post_body = json.load(open(fixture, "r"))["data"]  # just rows
        # https://docs.djangoproject.com/en/2.2/topics/testing/tools/#django.test.Client.post
        resp = self.c.post(self.article_url,
                           post_body,
                           content_type="application/json")
        self.assertEqual(resp.status_code, 200)

    def test_article_protocol_post_wonky_encoding(self):
        "a POST request with good article data but a slightly wonky content_type still makes it through"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        post_body = json.load(open(fixture, "r"))["data"]
        resp = self.c.post(
            self.article_url,
            json.dumps(post_body),
            content_type="  Application/JSON;text/xml   ",
        )
        self.assertEqual(resp.status_code, 200)

    def test_article_protocol_post_wonky_encoding_2(self):
        "a POST request with good article data but a slightly wonky content_type still makes it through"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        post_body = json.load(open(fixture, "r"))["data"]
        # (space in-between mime and parameters)
        resp = self.c.post(
            self.article_url,
            json.dumps(post_body),
            content_type="application/vnd.elife.bioprotocol+json; version=1",
        )
        self.assertEqual(resp.status_code, 200)

    def test_article_protocol_post_bad_encoding(self):
        "a POST request with good data but a bad content-encoding header returns a failed response"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        post_body = json.load(open(fixture, "r"))["data"]
        resp = self.c.post(self.article_url,
                           json.dumps(post_body),
                           content_type="text/plain")
        self.assertEqual(resp.status_code, 406)

    def test_article_protocol_post_bad_data(self):
        "a POST request with bad data returns a failed response"
        resp = self.c.post(self.article_url,
                           "foo",
                           content_type="application/json")
        self.assertEqual(resp.status_code, 400)

    def test_article_protocol_post_no_data(self):
        "a POST request with invalid data returns a failed response"
        post_body = []
        resp = self.c.post(self.article_url,
                           post_body,
                           content_type="application/json")
        self.assertEqual(resp.status_code, 400)

    def test_article_protocol_post_invalid_data(self):
        "a POST request with invalid data returns a failed response"
        post_body = [{"foo": "bar"}]
        resp = self.c.post(self.article_url,
                           post_body,
                           content_type="application/json")
        self.assertEqual(resp.status_code, 400)
        expected_response = {"msid": 12345, "successful": 0, "failed": 1}
        self.assertEqual(resp.json(), expected_response)

    def test_article_protocol_post_mixed_invalid_data(self):
        "a POST request with some invalid and some valid data returns a failed response"
        fixture = join(FIXTURE_DIR, "bp-post-to-elife.json")
        post_body = json.load(open(fixture, "r"))["data"]
        post_body[0]["foo"] = "bar"  # extra key
        resp = self.c.post(self.article_url,
                           post_body,
                           content_type="application/json")
        self.assertEqual(resp.status_code, 400)
        expected_response = {"msid": 12345, "successful": 5, "failed": 1}
        self.assertEqual(resp.json(), expected_response)
Beispiel #39
0
 def test_view(self):
     c = Client()
     c.login(username='******', password='******')
     response = c.head('/songs/albums/test_value')
     self.assertEqual(response.status_code, 200)
Beispiel #40
0
def test_site_url():
    module_path(__name__, '')
    # mount(urlconf=__name__) # mount all registered apis
    mount(only_me=True)  # mount all registered apis

    _dump_urls()

    # --- hey ---
    wrp = (hey)
    assert wrp.url == None
    assert wrp.site_url == 'hey/'

    assert (index).site_url == '/'

    # test auto-binding
    url = (t1).site_url
    assert url == 't1/'

    from django.test import Client
    client = Client()

    response = client.post(
        '/t1/', {'a': 2},
        content_type='application/json')  # body: application/json
    assert response.status_code == 200
    r = APIResult(response)
    assert r.error == None
    assert r.result == 2

    response = client.post('/t1/', {'a': 3})  # from body: multipart/form-data
    assert response.status_code == 200
    r = APIResult(response)
    assert r.error == None
    assert r.result == 3

    response = client.post('/t1/?a=4')  # from query-string
    assert response.status_code == 200
    r = APIResult(response)
    assert r.error == None
    assert r.result == 4

    client.cookies['a'] = 5
    response = client.post('/t1/')  # from cookie
    assert response.status_code == 200
    r = APIResult(response)
    assert r.error == None
    assert r.result == 5

    if False:  #todo: setup testing env properly
        client.cookies.pop('a')
        client.session['a'] = 6
        response = client.post('/t1/')  # from session
        assert response.status_code == 200
        r = APIResult(response)
        assert r.error == None
        assert r.result == 6

    # api-binding
    url = (hello).site_url
    assert url == 'hello(?:/a/(?P<a>[0-9]+))?/'

    response = client.get('/hello/')
    assert response.status_code == 200

    r = APIResult(response)
    assert r.error == None
    assert r.result == 1

    response = client.get('/hello/a/2/')
    r = APIResult(response)
    assert r.error == None
    assert r.result == 2

    # method
    response = client.get('/get-only1/')
    r = APIResult(response)
    assert r.error == None

    response = client.get('/get-only2/')
    r = APIResult(response)
    assert r.error == None

    response = client.post('/get-only2/')
    assert response.status_code == 405  # not allowed

    # read
    response = client.head('/read-only/')
    assert response.status_code == 200  # allowed
    response = client.get('/read-only/')
    assert response.status_code == 200  # allowed

    response = client.post('/read-only/')
    assert response.status_code == 405  # not allowed
    response = client.put('/read-only/')
    assert response.status_code == 405  # not allowed
    response = client.patch('/read-only/')
    assert response.status_code == 405  # not allowed

    # write
    response = client.head('/write-only/')
    assert response.status_code == 405  # not allowed
    response = client.get('/write-only/')
    assert response.status_code == 405  # not allowed

    response = client.post('/write-only/')
    assert response.status_code == 200  # allowed
    response = client.put('/write-only/')
    assert response.status_code == 200  # allowed
    response = client.patch('/write-only/')
    assert response.status_code == 200  # allowed

    # django compatibility test
    response = client.head('/get-only/')
    assert response.status_code == 405  # not allowed
    response = client.get('/get-only/')
    assert response.status_code == 200  # allowed

    response = client.post('/get-only/')
    assert response.status_code == 405  # not allowed
    response = client.put('/get-only/')
    assert response.status_code == 405  # not allowed
    response = client.patch('/get-only/')
    assert response.status_code == 405  # not allowed

    assert get_wrapper(get_only).site_url == 'get-only/'

    # test method-based dispatch
    response = client.get('/name/')
    assert response.status_code == 200
    assert response.json()['result'] == 'Ruby'

    response = client.put('/name/?name=Janet')
    assert response.status_code == 200
    assert response.json()['result'] == 'Ruby'  # last name

    response = client.get('/name/')
    assert response.status_code == 200
    assert response.json()['result'] == 'Janet'

    # test class-based api
    assert Monitor().status.site_url == 'monitor/status/'
    assert Monitor.settings.site_url == 'monitor/settings/'
    assert Monitor.ping.site_url == 'monitor/ping/'

    r = APIResult(client.get('/monitor/status/'))
    assert r.status_code == 200
    assert r.result == 10

    r = APIResult(client.get('/monitor/settings/'))
    assert r.status_code == 200
    assert r.result == Monitor.MAX_CONNECTIONS

    r = APIResult(client.get('/monitor/ping/'))
    assert r.status_code == 200
    assert r.result == 'OK'

    # param url processing
    r = APIResult(client.get('/get-info/block-no/1/'))
    assert r.status_code == 200
    assert r.result == 1
class TwilioViewTestCase(TestCase):
    fixtures = ['django_twilio.json']
    urls = 'django_twilio.tests.urls'

    def setUp(self):
        self.client = Client(enforce_csrf_checks=True)
        self.factory = RequestFactory(enforce_csrf_checks=True)

        # Test URIs.
        self.uri = 'http://testserver/tests/decorators'
        self.str_uri = '/tests/decorators/str_view/'
        self.verb_uri = '/tests/decorators/verb_view/'
        self.response_uri = '/tests/decorators/response_view/'

        # Guarantee a value for the required configuration settings after each
        # test case.
        django_twilio_settings.TWILIO_ACCOUNT_SID = 'xxx'
        django_twilio_settings.TWILIO_AUTH_TOKEN = 'xxx'

        # Pre-calculate Twilio signatures for our test views.
        self.response_signature = encodestring(new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/response_view/' % self.uri, sha1).digest()).strip()
        self.str_signature = encodestring(new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/' % self.uri, sha1).digest()).strip()
        self.str_signature_with_from_field_normal_caller = encodestring(new(
                django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/From+12222222222' % self.uri,
                sha1).digest()).strip()
        self.str_signature_with_from_field_blacklisted_caller = encodestring(
                new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/From+13333333333' % self.uri,
                sha1).digest()).strip()
        self.verb_signature = encodestring(new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/verb_view/' % self.uri, sha1).digest()).strip()

    def test_is_csrf_exempt(self):
        self.assertTrue(self.client.post(self.str_uri).csrf_exempt)

    def test_requires_post(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.get(self.str_uri).status_code, 405)
        self.assertEquals(self.client.head(self.str_uri).status_code, 405)
        self.assertEquals(self.client.options(self.str_uri).status_code, 405)
        self.assertEquals(self.client.put(self.str_uri).status_code, 405)
        self.assertEquals(self.client.delete(self.str_uri).status_code, 405)
        settings.DEBUG = True
        self.assertEquals(self.client.get(self.str_uri).status_code, 200)
        self.assertEquals(self.client.head(self.str_uri).status_code, 200)
        self.assertEquals(self.client.options(self.str_uri).status_code, 200)
        self.assertEquals(self.client.put(self.str_uri).status_code, 200)
        self.assertEquals(self.client.delete(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_allows_post(self):
        request = self.factory.post(self.str_uri, HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertEquals(str_view(request).status_code, 200)

    def test_decorator_preserves_metadata(self):
        self.assertEqual(str_view.__name__, 'str_view')

    def test_missing_settings_return_forbidden(self):
        del django_twilio_settings.TWILIO_ACCOUNT_SID
        del django_twilio_settings.TWILIO_AUTH_TOKEN
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.post(self.str_uri).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(self.client.post(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_missing_signature_returns_forbidden(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.post(self.str_uri).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(self.client.post(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_incorrect_signature_returns_forbidden(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        request = self.factory.post(self.str_uri, HTTP_X_TWILIO_SIGNATURE='fakesignature')
        self.assertEquals(str_view(request).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(str_view(request).status_code, 200)
        settings.DEBUG = debug_orig

    def test_no_from_field(self):
        request = self.factory.post(self.str_uri,
                HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertEquals(str_view(request).status_code, 200)

    def test_from_field_no_caller(self):
        request = self.factory.post(self.str_uri, {'From': '+12222222222'},
                HTTP_X_TWILIO_SIGNATURE=self.str_signature_with_from_field_normal_caller)
        self.assertEquals(str_view(request).status_code, 200)

    def test_blacklist_works(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        request = self.factory.post(self.str_uri, {'From': '+13333333333'},
                HTTP_X_TWILIO_SIGNATURE=self.str_signature_with_from_field_blacklisted_caller)
        response = str_view(request)
        r = Response()
        r.reject()
        self.assertEquals(response.content, str(r))
        settings.DEBUG = True
        request = self.factory.post(self.str_uri, {'From': '+13333333333'},
                HTTP_X_TWILIO_SIGNATURE=self.str_signature_with_from_field_blacklisted_caller)
        response = str_view(request)
        r = Response()
        r.reject()
        self.assertEquals(response.content, str(r))
        settings.DEBUG = debug_orig

    def test_decorator_modifies_str(self):
        request = self.factory.post(self.str_uri,
                HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertTrue(isinstance(str_view(request), HttpResponse))

    def test_decorator_modifies_verb(self):
        request = self.factory.post(self.verb_uri, HTTP_X_TWILIO_SIGNATURE=self.verb_signature)
        self.assertTrue(isinstance(verb_view(request), HttpResponse))

    def test_decorator_preserves_httpresponse(self):
        request = self.factory.post(self.response_uri, HTTP_X_TWILIO_SIGNATURE=self.response_signature)
        self.assertTrue(isinstance(response_view(request), HttpResponse))
Beispiel #42
0
class TestServiceProxy(unittest.TestCase):
    def setUp(self):
        self.client = Client()

    @mock.patch.object(VimDriverUtils, 'get_session')
    @mock.patch.object(VimDriverUtils, 'get_token_cache')
    @mock.patch.object(VimDriverUtils, 'get_vim_info')
    def test_get_token(self, mock_get_vim_info, mock_get_token_cache,
                       mock_get_session):
        mock_session_specs = ["head"]
        mock_session = mock.Mock(name='mock_session', spec=mock_session_specs)
        mock_get_servers_response_obj = mock.Mock(spec=MockResponse)
        mock_get_servers_response_obj.status_code = 200
        mock_get_servers_response_obj.content = MOCK_GET_SERVERS_RESPONSE
        mock_get_servers_response_obj.json.return_value = MOCK_GET_SERVERS_RESPONSE
        mock_session.head.return_value = mock_get_servers_response_obj

        mock_get_vim_info.return_value = MOCK_VIM_INFO
        mock_get_session.return_value = mock_session
        mock_get_token_cache.return_value = (
            json.dumps(MOCK_AUTH_STATE),
            json.dumps(MOCK_INTERNAL_METADATA_CATALOG))
        response = self.client.head(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers",
            {},
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_200_OK, response.status_code)

    def test_unauthorized_access(self):
        response = self.client.get(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers"
        )
        self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)

    @mock.patch.object(VimDriverUtils, 'get_vim_info')
    def test_expired_auth_token(self, mock_get_vim_info):
        mock_get_vim_info.return_value = MOCK_VIM_INFO

        response = self.client.get(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers",
            {},
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_403_FORBIDDEN, response.status_code)

    @mock.patch.object(VimDriverUtils, 'get_token_cache')
    @mock.patch.object(VimDriverUtils, 'get_vim_info')
    def test_request_without_servicetype(self, mock_get_vim_info,
                                         mock_get_token_cache):
        mock_get_vim_info.return_value = MOCK_VIM_INFO
        mock_get_token_cache.return_value = (json.dumps(MOCK_AUTH_STATE), {})
        servicetype = "compute"
        url_part1 = "/api/multicloud-starlingx/v0/starlingx_RegionOne/"
        url_part3 = "/v2.1/fcca3cc49d5e42caae15459e27103efc/servers"
        url = (url_part1 + servicetype + url_part3)
        response = self.client.get(url, {}, HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)

        metadata_catalog = copy.deepcopy(MOCK_INTERNAL_METADATA_CATALOG)
        metadata_catalog[servicetype] = None
        mock_get_token_cache.return_value = (json.dumps(MOCK_AUTH_STATE),
                                             json.dumps(metadata_catalog))

        response = self.client.get(url, {}, HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)

        metadata_catalog = copy.deepcopy(MOCK_INTERNAL_METADATA_CATALOG)
        metadata_catalog[servicetype]['prefix'] = None
        metadata_catalog[servicetype]['proxy_prefix'] = None
        mock_get_token_cache.return_value = (json.dumps(MOCK_AUTH_STATE),
                                             json.dumps(metadata_catalog))

        response = self.client.get(url, {}, HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)

    @mock.patch.object(VimDriverUtils, 'get_vim_info')
    @mock.patch.object(VimDriverUtils, 'get_session')
    @mock.patch.object(VimDriverUtils, 'get_auth_state')
    @mock.patch.object(VimDriverUtils, 'update_token_cache')
    @mock.patch.object(VimDriverUtils, 'get_token_cache')
    def test_crud_resources(self, mock_get_token_cache,
                            mock_update_token_cache, mock_get_auth_state,
                            mock_get_session, mock_get_vim_info):
        '''
        Test service proxy API: GET

        :param mock_get_token_cache:
        :param mock_update_token_cache:
        :param mock_get_auth_state:
        :param mock_get_session:
        :param mock_get_vim_info:
        :return:
        '''

        # mock VimDriverUtils APIs
        mock_session_specs = ["get", "post", "put", "patch", "delete"]

        mock_get_servers_response_obj = mock.Mock(spec=MockResponse)
        mock_get_servers_response_obj.status_code = 200
        mock_get_servers_response_obj.content = MOCK_GET_SERVERS_RESPONSE
        mock_get_servers_response_obj.json.return_value = MOCK_GET_SERVERS_RESPONSE

        mock_post_server_response_obj = mock.Mock(spec=MockResponse)
        mock_post_server_response_obj.status_code = 202
        mock_post_server_response_obj.content = MOCK_POST_SERVER_RESPONSE
        mock_post_server_response_obj.json.return_value = MOCK_POST_SERVER_RESPONSE

        mock_patch_server_response_obj = mock.Mock(spec=MockResponse)
        mock_patch_server_response_obj.status_code = 202
        mock_patch_server_response_obj.content = MOCK_PATCH_IMAGE_REQUEST
        mock_patch_server_response_obj.json.return_value = MOCK_PATCH_IMAGE_REQUEST

        mock_delete_server_response_obj = mock.Mock(spec=MockResponse)
        mock_delete_server_response_obj.status_code = 204

        mock_session = mock.Mock(name='mock_session', spec=mock_session_specs)
        mock_session.get.return_value = mock_get_servers_response_obj
        mock_session.post.return_value = mock_post_server_response_obj
        mock_session.patch.return_value = mock_patch_server_response_obj
        mock_session.delete.return_value = mock_delete_server_response_obj

        mock_get_vim_info.return_value = MOCK_VIM_INFO
        mock_get_session.return_value = mock_session
        mock_get_auth_state.return_value = json.dumps(MOCK_AUTH_STATE)
        mock_update_token_cache.return_value = MOCK_TOKEN_ID
        mock_get_token_cache.return_value = (
            json.dumps(MOCK_AUTH_STATE),
            json.dumps(MOCK_INTERNAL_METADATA_CATALOG))

        # Create resource
        response = self.client.post(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers",
            MOCK_POST_SERVER_REQUEST,
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)

        self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
        context = response.json()
        self.assertEqual(MOCK_TOKEN_ID, response['X-Subject-Token'])
        self.assertIsNotNone(context['server'])

        # Retrieve resource
        response = self.client.get(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers",
            {},
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_200_OK, response.status_code)
        context = response.json()

        self.assertEqual(MOCK_TOKEN_ID, response['X-Subject-Token'])
        self.assertIsNotNone(context['servers'])

        # Update resource
        response = self.client.get(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers",
            {},
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)
        self.assertEqual(status.HTTP_200_OK, response.status_code)
        context = response.json()

        self.assertEqual(MOCK_TOKEN_ID, response['X-Subject-Token'])
        self.assertIsNotNone(context['servers'])

        # simulate client to make the request
        response = self.client.delete(
            "/api/multicloud-starlingx/v0/starlingx_RegionOne/compute/v2.1/fcca3cc49d5e42caae15459e27103efc/servers/324dfb7d-f4a9-419a-9a19-237df04b443b",
            HTTP_X_AUTH_TOKEN=MOCK_TOKEN_ID)

        self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
        self.assertEqual(MOCK_TOKEN_ID, response['X-Subject-Token'])
Beispiel #43
0
class TwilioViewTestCase(TestCase):
    fixtures = ['django_twilio.json']
    urls = 'django_twilio.tests.urls'

    def setUp(self):
        self.client = Client(enforce_csrf_checks=True)
        self.factory = RequestFactory(enforce_csrf_checks=True)

        # Test URIs.
        self.uri = 'http://testserver/tests/decorators'
        self.str_uri = '/tests/decorators/str_view/'
        self.verb_uri = '/tests/decorators/verb_view/'
        self.response_uri = '/tests/decorators/response_view/'

        # Guarantee a value for the required configuration settings after each
        # test case.
        django_twilio_settings.TWILIO_ACCOUNT_SID = 'xxx'
        django_twilio_settings.TWILIO_AUTH_TOKEN = 'xxx'

        # Pre-calculate Twilio signatures for our test views.
        self.response_signature = encodestring(
            new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/response_view/' % self.uri, sha1).digest()).strip()
        self.str_signature = encodestring(
            new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/' % self.uri, sha1).digest()).strip()
        self.sig_with_from_field_normal_caller = encodestring(
            new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/From+12222222222' % self.uri,
                sha1).digest()).strip()
        self.sig_with_from_field_blacklisted_caller = encodestring(
            new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/str_view/From+13333333333' % self.uri,
                sha1).digest()).strip()
        self.verb_signature = encodestring(
            new(django_twilio_settings.TWILIO_AUTH_TOKEN,
                '%s/verb_view/' % self.uri, sha1).digest()).strip()

    def test_requires_post(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.get(self.str_uri).status_code, 405)
        self.assertEquals(self.client.head(self.str_uri).status_code, 405)
        self.assertEquals(self.client.options(self.str_uri).status_code, 405)
        self.assertEquals(self.client.put(self.str_uri).status_code, 405)
        self.assertEquals(self.client.delete(self.str_uri).status_code, 405)
        settings.DEBUG = True
        self.assertEquals(self.client.get(self.str_uri).status_code, 200)
        self.assertEquals(self.client.head(self.str_uri).status_code, 200)
        self.assertEquals(self.client.options(self.str_uri).status_code, 200)
        self.assertEquals(self.client.put(self.str_uri).status_code, 200)
        self.assertEquals(self.client.delete(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_allows_post(self):
        request = self.factory.post(self.str_uri,
                                    HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertEquals(str_view(request).status_code, 200)

    def test_decorator_preserves_metadata(self):
        self.assertEqual(str_view.__name__, 'str_view')

    def test_missing_settings_return_forbidden(self):
        del django_twilio_settings.TWILIO_ACCOUNT_SID
        del django_twilio_settings.TWILIO_AUTH_TOKEN
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.post(self.str_uri).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(self.client.post(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_missing_signature_returns_forbidden(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        self.assertEquals(self.client.post(self.str_uri).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(self.client.post(self.str_uri).status_code, 200)
        settings.DEBUG = debug_orig

    def test_incorrect_signature_returns_forbidden(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        request = self.factory.post(self.str_uri,
                                    HTTP_X_TWILIO_SIGNATURE='fakesignature')
        self.assertEquals(str_view(request).status_code, 403)
        settings.DEBUG = True
        self.assertEquals(str_view(request).status_code, 200)
        settings.DEBUG = debug_orig

    def test_no_from_field(self):
        request = self.factory.post(self.str_uri,
                                    HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertEquals(str_view(request).status_code, 200)

    def test_from_field_no_caller(self):
        request = self.factory.post(
            self.str_uri, {'From': '+12222222222'},
            HTTP_X_TWILIO_SIGNATURE=self.sig_with_from_field_normal_caller)
        self.assertEquals(str_view(request).status_code, 200)

    def test_blacklist_works(self):
        debug_orig = settings.DEBUG
        settings.DEBUG = False
        request = self.factory.post(self.str_uri, {'From': '+13333333333'},
                                    HTTP_X_TWILIO_SIGNATURE=self.
                                    sig_with_from_field_blacklisted_caller)
        response = str_view(request)
        r = Response()
        r.reject()
        self.assertEquals(response.content, str(r))
        settings.DEBUG = True
        request = self.factory.post(self.str_uri, {'From': '+13333333333'},
                                    HTTP_X_TWILIO_SIGNATURE=self.
                                    sig_with_from_field_blacklisted_caller)
        response = str_view(request)
        r = Response()
        r.reject()
        self.assertEquals(response.content, str(r))
        settings.DEBUG = debug_orig

    def test_decorator_modifies_str(self):
        request = self.factory.post(self.str_uri,
                                    HTTP_X_TWILIO_SIGNATURE=self.str_signature)
        self.assertTrue(isinstance(str_view(request), HttpResponse))

    def test_decorator_modifies_verb(self):
        request = self.factory.post(
            self.verb_uri, HTTP_X_TWILIO_SIGNATURE=self.verb_signature)
        self.assertTrue(isinstance(verb_view(request), HttpResponse))

    def test_decorator_preserves_httpresponse(self):
        request = self.factory.post(
            self.response_uri, HTTP_X_TWILIO_SIGNATURE=self.response_signature)
        self.assertTrue(isinstance(response_view(request), HttpResponse))

    def test_override_forgery_protection_off_debug_off(self):
        with override_settings(DJANGO_TWILIO_FORGERY_PROTECTION=False,
                               DEBUG=False):
            request = self.factory.post(self.str_uri)
            self.assertEquals(str_view(request).status_code, 200)

    def test_override_forgery_protection_off_debug_on(self):
        with override_settings(DJANGO_TWILIO_FORGERY_PROTECTION=False,
                               DEBUG=True):
            request = self.factory.post(self.str_uri)
            self.assertEquals(str_view(request).status_code, 200)

    def test_override_forgery_protection_on_debug_off(self):
        with override_settings(DJANGO_TWILIO_FORGERY_PROTECTION=True,
                               DEBUG=False):
            request = self.factory.post(self.str_uri)
            self.assertEquals(str_view(request).status_code, 403)

    def test_override_forgery_protection_on_debug_on(self):
        with override_settings(DJANGO_TWILIO_FORGERY_PROTECTION=True,
                               DEBUG=True):
            request = self.factory.post(self.str_uri)
            self.assertEquals(str_view(request).status_code, 403)