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)
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)
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)
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)
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)
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)
def test_status(): c = Client() res = c.get('/search/status/') json_ok(res) res = c.head('/search/status/') eq_(res.status_code, 200)
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
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)
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)
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)
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
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)
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)
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")
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_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
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
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
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 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 )
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)
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)
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)
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)
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)
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)
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"
def test_view(self): c = Client() c.login(username='******', password='******') response = c.head('/playlists/') self.assertEqual(response.status_code, 200)
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)
def test_view(self): c = Client() c.login(username='******', password='******') response = c.head('/songs/albums/test_value') self.assertEqual(response.status_code, 200)
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))
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'])
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)