def test_validation(self): app = TestApp(main({})) app.get('/service', status=400) res = app.post('/service', params='buh', status=400) self.assertTrue(b'Not a json body' in res.body) res = app.post('/service', params=json.dumps('buh')) self.assertEqual(res.body, json.dumps({ 'body': '"buh"' }).encode('ascii')) app.get('/service?paid=yup') # valid = foo is one res = app.get('/service?foo=1&paid=yup') self.assertEqual(res.json['foo'], 1) # invalid value for foo res = app.get('/service?foo=buh&paid=yup', status=400) # check that json is returned errors = Errors.from_json(res.body) self.assertEqual(len(errors), 1)
def test_validation(self): app = TestApp(main({})) app.get('/service', status=400) res = app.post('/service', params='buh', status=400) self.assertTrue('Not a json body' in res.body) res = app.post('/service', params=json.dumps('buh')) self.assertEqual(res.body, json.dumps({'body': '"buh"'})) app.get('/service?paid=yup') # valid = foo is one res = app.get('/service?foo=1&paid=yup') self.assertEqual(res.json['foo'], 1) # invalid value for foo res = app.get('/service?foo=buh&paid=yup', status=400) # check that json is returned errors = Errors.from_json(res.body) self.assertEqual(len(errors), 1) # the "apidocs" registry entry contains all the needed information # to build up documentation # in this case, this means the function is registered and the argument # of the service are defined (e.g "validator" is set) apidocs = app.app.registry.settings['apidocs'] self.assertTrue(_json in apidocs[('/service', 'POST')]['validators'])
def test_multiple_querystrings(self): app = TestApp(main({})) # it is possible to have more than one value with the same name in the # querystring self.assertEquals(b'{"field": ["5"]}', app.get("/foobaz?field=5").body) self.assertEquals(b'{"field": ["5", "2"]}', app.get("/foobaz?field=5&field=2").body)
def test_accept_issue_113_text_application_json(self): app = TestApp(main({})) res = app.get('/service3', headers={'Accept': 'application/json'}, status=200) self.assertEquals(res.content_type, "application/json")
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... res = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types self.assertTrue('application/json' in res.json) self.assertTrue('text/json' in res.json) app.get('/service2', headers={'Accept': 'application/*'}, status=200) # it should also work with multiple Accept headers app.get('/service2', headers={'Accept': 'audio/*, application/*'}, status=200) # test that using a callable to define what's accepted works as well res = app.get('/service3', headers={'Accept': 'audio/*'}, status=406) self.assertTrue('text/json' in res.json) app.get('/service3', headers={'Accept': 'text/*'}, status=200) # if we are not asking for a particular content-type, everything # should work just fine app.get('/service2', status=200)
def test_validation(self): app = TestApp(main({})) app.get('/service', status=400) res = app.post('/service', params='buh', status=400) self.assertTrue('Not a json body' in res.body) res = app.post('/service', params=json.dumps('buh')) self.assertEqual(res.body, json.dumps({'body': '"buh"'})) app.get('/service?paid=yup') # valid = foo is one res = app.get('/service?foo=1&paid=yup') self.assertEqual(res.json['foo'], 1) # invalid value for foo res = app.get('/service?foo=buh&paid=yup', status=400) # check that json is returned errors = Errors.from_json(res.body) self.assertEqual(len(errors), 1) # let's see the docstring ! apidocs = app.app.registry.settings['apidocs'] post_doc = apidocs[('/service', 'POST')]['docstring'] self.assertEqual(post_doc, 'The request body should be a JSON object.')
def test_content_type_correct(self): # tests that the Content-Type request header satisfies the requirement app = TestApp(main({})) # requesting with one of the allowed Content-Type headers should work, # even when having a charset parameter as suffix response = app.put("/service5", headers={"Content-Type": "text/plain; charset=utf-8"}) self.assertEqual(response.json, "some response")
def post(self, settings={}, headers={}): app = TestApp(main({}, **settings)) return app.post_json('/foobar?yeah=test', { 'foo': 'hello', 'bar': 'open', 'yeah': 'man', 'ipsum': 10, }, status=400, headers=headers)
def test_multiple_querystrings(self): app = TestApp(main({})) # it is possible to have more than one value with the same name in the # querystring self.assertEquals(b'{"field": ["5"]}', app.get('/foobaz?field=5').body) self.assertEquals(b'{"field": ["5", "2"]}', app.get('/foobaz?field=5&field=2').body)
def test_content_type_with_callable(self): # test that using a callable for content_type works as well app = TestApp(main({})) res = app.post('/service6', headers={'Content-Type': 'audio/*'}, status=415) error_description = res.json['errors'][0]['description'] self.assertTrue('text/xml' in error_description) self.assertTrue('application/json' in error_description) app.post('/service6', headers={'Content-Type': 'text/xml'}, status=200)
def test_content_type_with_callable_returning_scalar(self): # Test that using a callable for content_type works as well. # Now, the callable returns a scalar instead of a list. app = TestApp(main({})) response = app.put('/service6', headers={'Content-Type': 'audio/*'}, status=415) error_description = response.json['errors'][0]['description'] self.assertIn('text/xml', error_description)
def test_content_type_missing_with_no_body_should_pass(self): # test that a Content-Type request headers is present app = TestApp(main({})) # requesting without a Content-Type header nor a body should # return a 200. request = app.RequestClass.blank('/service5', method='POST') response = app.do_request(request, 200, True) self.assertEqual(response.status_code, 200)
def test_content_type_with_callable(self): # Test that using a callable for content_type works as well. app = TestApp(main({})) response = app.post('/service6', headers={'Content-Type': 'audio/*'}, status=415) error_description = response.json['errors'][0]['description'] self.assertIn('text/xml', error_description) self.assertIn('application/json', error_description)
def test_content_type_correct(self): # tests that the Content-Type request header satisfies the requirement app = TestApp(main({})) # requesting with one of the allowed Content-Type headers should work, # even when having a charset parameter as suffix response = app.put( '/service5', headers={'Content-Type': 'text/plain; charset=utf-8'}) self.assertEqual(response.json, "some response")
def test_content_type_with_callable(self): # test that using a callable for content_type works as well app = TestApp(main({})) res = app.post("/service6", headers={"Content-Type": "audio/*"}, status=415) error_description = res.json["errors"][0]["description"] self.assertTrue("text/xml" in error_description) self.assertTrue("application/json" in error_description) app.post("/service6", headers={"Content-Type": "text/xml"})
def test_accept_and_content_type(self): # tests that giving both Accept and Content-Type # request headers satisfy the requirement app = TestApp(main({})) # POST endpoint just has one accept and content_type definition response = app.post('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/json; charset=utf-8' }, status=200) self.assertEqual(response.json, "some response") response = app.post('/service7', headers={ 'Accept': 'text/plain, application/json', 'Content-Type': 'application/json; charset=utf-8' }, status=406) response = app.post('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/x-www-form-urlencoded' }, status=415) # PUT endpoint has a list of accept and content_type definitions response = app.put('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/json; charset=utf-8' }, status=200) self.assertEqual(response.json, "some response") response = app.put('/service7', headers={ 'Accept': 'audio/*', 'Content-Type': 'application/json; charset=utf-8' }, status=406) response = app.put('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/x-www-form-urlencoded' }, status=415)
def test_content_type_wrong_single(self): # tests that the Content-Type request header satisfies the requirement app = TestApp(main({})) # requesting the wrong Content-Type header should return a 415 ... response = app.post("/service5", headers={"Content-Type": "text/plain"}, status=415) # ... with an appropriate json error structure error_description = response.json["errors"][0]["description"] self.assertTrue("application/json" in error_description)
def test_accept_issue_113_audio_or_text(self): app = TestApp(main({})) res = app.get('/service2', headers={'Accept': 'audio/mp4; q=0.9, text/plain; q=0.5'}, status=200) self.assertEquals(res.content_type, "text/plain") # if we are not asking for a particular content-type, # we should get one of the two types that the service supports. r = app.get('/service2', status=200) self.assertTrue(r.content_type in ("application/json", "text/plain"))
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... response = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types error_location = response.json['errors'][0]['location'] error_name = response.json['errors'][0]['name'] error_description = response.json['errors'][0]['description'] self.assertEquals('header', error_location) self.assertEquals('Accept', error_name) self.assertTrue('application/json' in error_description) self.assertTrue('text/json' in error_description) self.assertTrue('text/plain' in error_description) # requesting a supported type should give an appropriate response type response = app.get('/service2', headers={'Accept': 'application/*'}) self.assertEqual(response.content_type, "application/json") response = app.get('/service2', headers={'Accept': 'text/plain'}) self.assertEqual(response.content_type, "text/plain") # it should also work with multiple Accept headers response = app.get('/service2', headers={'Accept': 'audio/*, application/*'}) self.assertEqual(response.content_type, "application/json") # and requested preference order should be respected headers = {'Accept': 'application/json; q=1.0, text/plain; q=0.9'} response = app.get('/service2', headers=headers) self.assertEqual(response.content_type, "application/json") headers = {'Accept': 'application/json; q=0.9, text/plain; q=1.0'} response = app.get('/service2', headers=headers) self.assertEqual(response.content_type, "text/plain") # test that using a callable to define what's accepted works as well response = app.get('/service3', headers={'Accept': 'audio/*'}, status=406) error_description = response.json['errors'][0]['description'] self.assertTrue('text/json' in error_description) response = app.get('/service3', headers={'Accept': 'text/*'}) self.assertEqual(response.content_type, "text/json") # if we are not asking for a particular content-type, # we should get one of the two types that the service supports. response = app.get('/service2') self.assertTrue(response.content_type in ("application/json", "text/plain"))
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... response = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types error_location = response.json['errors'][0]['location'] error_name = response.json['errors'][0]['name'] error_description = response.json['errors'][0]['description'] self.assertEquals('header', error_location) self.assertEquals('Accept', error_name) self.assertTrue('application/json' in error_description) self.assertTrue('text/json' in error_description) self.assertTrue('text/plain' in error_description) # requesting a supported type should give an appropriate response type response = app.get('/service2', headers={'Accept': 'application/*'}) self.assertEqual(response.content_type, "application/json") response = app.get('/service2', headers={'Accept': 'text/plain'}) self.assertEqual(response.content_type, "text/plain") # it should also work with multiple Accept headers response = app.get('/service2', headers={ 'Accept': 'audio/*, application/*' }) self.assertEqual(response.content_type, "application/json") # and requested preference order should be respected headers = {'Accept': 'application/json; q=1.0, text/plain; q=0.9'} response = app.get('/service2', headers=headers) self.assertEqual(response.content_type, "application/json") headers = {'Accept': 'application/json; q=0.9, text/plain; q=1.0'} response = app.get('/service2', headers=headers) self.assertEqual(response.content_type, "text/plain") # test that using a callable to define what's accepted works as well response = app.get('/service3', headers={'Accept': 'audio/*'}, status=406) error_description = response.json['errors'][0]['description'] self.assertTrue('text/json' in error_description) response = app.get('/service3', headers={'Accept': 'text/*'}) self.assertEqual(response.content_type, "text/json") # if we are not asking for a particular content-type, # we should get one of the two types that the service supports. response = app.get('/service2') self.assertTrue(response.content_type in ("application/json", "text/plain"))
def test_content_type_wrong_single(self): # tests that the Content-Type request header satisfies the requirement app = TestApp(main({})) # requesting the wrong Content-Type header should return a 415 ... response = app.post('/service5', headers={'Content-Type': 'text/plain'}, status=415) # ... with an appropriate json error structure error_description = response.json['errors'][0]['description'] self.assertTrue('application/json' in error_description)
def test_accept_issue_113_audio_or_text(self): app = TestApp(main({})) res = app.get( '/service2', headers={'Accept': 'audio/mp4; q=0.9, text/plain; q=0.5'}) self.assertEqual(res.content_type, "text/plain") # if we are not asking for a particular content-type, # we should get one of the two types that the service supports. r = app.get('/service2') self.assertTrue(r.content_type in ("application/json", "text/plain"))
def test_override_default_accept_issue_252(self): # override default acceptable content_types for interoperate with # legacy applications i.e. ExtJS 3 from cornice.util import _JsonRenderer _JsonRenderer.acceptable += ('text/html',) app = TestApp(main({})) response = app.get('/service5', headers={'Accept': 'text/html'}) self.assertEqual(response.content_type, "text/html") # revert the override _JsonRenderer.acceptable = _JsonRenderer.acceptable[:-1]
def test_content_type_wrong_multiple(self): # Tests that the Content-Type request header satisfies the requirement. app = TestApp(main({})) # Requesting without a Content-Type header should # return "415 Unsupported Media Type" ... response = app.put('/service5', headers={'Content-Type': 'text/xml'}, status=415) # ... with an appropriate json error structure. error_description = response.json['errors'][0]['description'] self.assertIn('text/plain', error_description) self.assertIn('application/json', error_description)
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... res = app.get("/service2", headers={"Accept": "audio/*"}, status=406) # ... with the list of accepted content-types error_location = res.json["errors"][0]["location"] error_name = res.json["errors"][0]["name"] error_description = res.json["errors"][0]["description"] self.assertEquals("header", error_location) self.assertEquals("Accept", error_name) self.assertTrue("application/json" in error_description) self.assertTrue("text/json" in error_description) self.assertTrue("text/plain" in error_description) # requesting a supported type should give an appropriate response type r = app.get("/service2", headers={"Accept": "application/*"}) self.assertEqual(r.content_type, "application/json") r = app.get("/service2", headers={"Accept": "text/plain"}) self.assertEqual(r.content_type, "text/plain") # it should also work with multiple Accept headers r = app.get("/service2", headers={"Accept": "audio/*, application/*"}) self.assertEqual(r.content_type, "application/json") # and requested preference order should be respected headers = {"Accept": "application/json; q=1.0, text/plain; q=0.9"} r = app.get("/service2", headers=headers) self.assertEqual(r.content_type, "application/json") headers = {"Accept": "application/json; q=0.9, text/plain; q=1.0"} r = app.get("/service2", headers=headers) self.assertEqual(r.content_type, "text/plain") # test that using a callable to define what's accepted works as well res = app.get("/service3", headers={"Accept": "audio/*"}, status=406) error_description = res.json["errors"][0]["description"] self.assertTrue("text/json" in error_description) res = app.get("/service3", headers={"Accept": "text/*"}) self.assertEqual(res.content_type, "text/json") # if we are not asking for a particular content-type, # we should get one of the two types that the service supports. r = app.get("/service2") self.assertTrue(r.content_type in ("application/json", "text/plain"))
def test_accept_and_content_type(self): # tests that giving both Accept and Content-Type # request headers satisfy the requirement app = TestApp(main({})) # POST endpoint just has one accept and content_type definition response = app.post('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/json; charset=utf-8' }) self.assertEqual(response.json, "some response") response = app.post( '/service7', headers={ 'Accept': 'text/plain, application/json', 'Content-Type': 'application/json; charset=utf-8' }, status=406) response = app.post( '/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/x-www-form-urlencoded' }, status=415) # PUT endpoint has a list of accept and content_type definitions response = app.put('/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/json; charset=utf-8' }) self.assertEqual(response.json, "some response") response = app.put( '/service7', headers={ 'Accept': 'audio/*', 'Content-Type': 'application/json; charset=utf-8' }, status=406) response = app.put( '/service7', headers={ 'Accept': 'text/xml, application/json', 'Content-Type': 'application/x-www-form-urlencoded' }, status=415)
def test_content_type_missing(self): # test that a Content-Type request headers is present app = TestApp(main({})) # requesting without a Content-Type header should return a 415 ... request = app.RequestClass.blank("/service5", method="POST") response = app.do_request(request, 415, True) # ... with an appropriate json error structure error_location = response.json["errors"][0]["location"] error_name = response.json["errors"][0]["name"] error_description = response.json["errors"][0]["description"] self.assertEqual("header", error_location) self.assertEqual("Content-Type", error_name) self.assertTrue("application/json" in error_description)
def test_content_type_missing(self): # test that a Content-Type request headers is present app = TestApp(main({})) # requesting without a Content-Type header should return a 415 ... request = app.RequestClass.blank('/service5', method='POST') response = app.do_request(request, 415, True) # ... with an appropriate json error structure error_location = response.json['errors'][0]['location'] error_name = response.json['errors'][0]['name'] error_description = response.json['errors'][0]['description'] self.assertEqual('header', error_location) self.assertEqual('Content-Type', error_name) self.assertTrue('application/json' in error_description)
def test_content_type_missing(self): # test that a Content-Type request headers is present app = TestApp(main({})) # Requesting without a Content-Type header should # return "415 Unsupported Media Type" ... request = app.RequestClass.blank('/service5', method='POST', POST="some data") response = app.do_request(request, 415, True) self.assertEqual(response.status_code, 415) # ... with an appropriate json error structure. error_location = response.json['errors'][0]['location'] error_name = response.json['errors'][0]['name'] error_description = response.json['errors'][0]['description'] self.assertEqual('header', error_location) self.assertEqual('Content-Type', error_name) self.assertIn('application/json', error_description)
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... res = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types self.assertTrue('application/json' in res.json) self.assertTrue('text/json' in res.json) self.assertTrue('text/plain' in res.json) # requesting a supported type should give an appropriate response type r = app.get('/service2', headers={'Accept': 'application/*'}) self.assertEquals(r.content_type, "application/json") r = app.get('/service2', headers={'Accept': 'text/plain'}) self.assertEquals(r.content_type, "text/plain") # it should also work with multiple Accept headers r = app.get('/service2', headers={'Accept': 'audio/*, application/*'}) self.assertEquals(r.content_type, "application/json") # and requested preference order should be respected r = app.get('/service2', headers={'Accept': 'application/json, text/plain'}) self.assertEquals(r.content_type, "application/json") r = app.get('/service2', headers={'Accept': 'text/plain, application/json'}) self.assertEquals(r.content_type, "application/json") # test that using a callable to define what's accepted works as well res = app.get('/service3', headers={'Accept': 'audio/*'}, status=406) self.assertTrue('text/json' in res.json) res = app.get('/service3', headers={'Accept': 'text/*'}, status=200) self.assertEquals(res.content_type, "text/json") # if we are not asking for a particular content-type, # we should get the type defined by outermost declaration. r = app.get('/service2', status=200) self.assertEquals(r.content_type, "application/json")
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... res = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types self.assertTrue('application/json' in res.json) self.assertTrue('text/json' in res.json) self.assertTrue('text/plain' in res.json) # requesting a supported type should give an appropriate response type r = app.get('/service2', headers={'Accept': 'application/*'}) self.assertEquals(r.content_type, "application/json") r = app.get('/service2', headers={'Accept': 'text/plain'}) self.assertEquals(r.content_type, "text/plain") # it should also work with multiple Accept headers r = app.get('/service2', headers={'Accept': 'audio/*, application/*'}) self.assertEquals(r.content_type, "application/json") # and requested preference order should be respected r = app.get('/service2', headers={'Accept': 'application/json, text/plain'}) self.assertEquals(r.content_type, "application/json") r = app.get('/service2', headers={'Accept': 'text/plain, application/json'}) self.assertEquals(r.content_type, "application/json") # test that using a callable to define what's accepted works as well res = app.get('/service3', headers={'Accept': 'audio/*'}, status=406) self.assertTrue('text/json' in res.json) app.get('/service3', headers={'Accept': 'text/*'}, status=200) # if we are not asking for a particular content-type, # we should get the type defined by outermost declaration. r = app.get('/service2', status=200) self.assertEquals(r.content_type, "application/json")
def test_accept(self): # tests that the accept headers are handled the proper way app = TestApp(main({})) # requesting the wrong accept header should return a 406 ... res = app.get('/service2', headers={'Accept': 'audio/*'}, status=406) # ... with the list of accepted content-types self.assertTrue('application/json' in res.json) app.get('/service2', headers={'Accept': 'application/*'}, status=200) # it should also work with multiple Accept headers app.get('/service2', headers={'Accept': 'audio/*, application/*'}, status=200) # test that using a callable to define what's accepted works as well app.get('/service3', headers={'Accept': 'audio/*'}, status=406) app.get('/service3', headers={'Accept': 'text/*'}, status=200) # if we are not asking for a particular content-type, everything # should work just fine app.get('/service2', status=200)
def test_validation(self): app = TestApp(main({})) app.get('/service', status=400) res = app.post('/service', params='buh', status=400) self.assertTrue('Not a json body' in res.body) res = app.post('/service', params=json.dumps('buh')) self.assertEqual(res.body, json.dumps({'body': '"buh"'})) app.get('/service?paid=yup') # valid = foo is one res = app.get('/service?foo=1&paid=yup') self.assertEqual(res.json['foo'], 1) # invalid value for foo res = app.get('/service?foo=buh&paid=yup', status=400) # check that json is returned errors = Errors.from_json(res.body) self.assertEqual(len(errors), 1)
def test_validation(self): app = TestApp(main({})) # 413 self.assertRaises(AppError, app.get, '/service') self.assertRaises(AppError, app.post, '/service', params='buh') res = app.post('/service', params=json.dumps('buh')) self.assertEqual(res.body, json.dumps({'body': '"buh"'})) app.get('/service?paid=yup') # valid = foo is one res = app.get('/service?foo=1&paid=yup') self.assertEqual(res.json['foo'], 1) # invalid value for foo self.assertRaises(AppError, app.get, '/service?foo=buh&paid=yup') # let's see the docstring ! apidocs = app.app.registry.settings['apidocs'] post_doc = apidocs[('/service', 'POST')]['docstring'] self.assertEqual(post_doc, 'The request body should be a JSON object.')
def test_validation(self): app = TestApp(main({})) app.get("/service", status=400) res = app.post("/service", params="buh", status=400) self.assertTrue(b"Not a json body" in res.body) res = app.post("/service", params=json.dumps("buh")) expected = json.dumps({"body": '"buh"'}).encode("ascii") self.assertEqual(res.body, expected) app.get("/service?paid=yup") # valid = foo is one res = app.get("/service?foo=1&paid=yup") self.assertEqual(res.json["foo"], 1) # invalid value for foo res = app.get("/service?foo=buh&paid=yup", status=400) # check that json is returned errors = Errors.from_json(res.body) self.assertEqual(len(errors), 1)
def test_accept_issue_113_audio_or_text(self): app = TestApp(main({})) res = app.get('/service2', headers={'Accept': 'audio/mp4; q=0.9, text/plain; q=0.5'}, status=200) self.assertEquals(res.content_type, "text/plain")
def test_accept_issue_113_text_application_star(self): app = TestApp(main({})) response = app.get('/service3', headers={'Accept': 'application/*'}) self.assertEqual(response.content_type, "application/json")
def test_accept_issue_113_text_html_not_acceptable(self): app = TestApp(main({})) # Requesting an unsupported content type should # return HTTP response "406 Not Acceptable". app.get('/service3', headers={'Accept': 'text/html'}, status=406)
def make_ordinary_app(self): return TestApp(main({}))
def test_validation_hooked_error_response(self): app = TestApp(main({})) res = app.post('/service4', status=400) self.assertTrue('<errors>' in res.body)
def test_validation_hooked_error_response(self): app = TestApp(main({})) res = app.post('/service4', status=400) self.assertTrue(b'<errors>' in res.body)
def test_accept_issue_113_text_star(self): app = TestApp(main({})) res = app.get('/service3', headers={'Accept': 'text/*'}) self.assertEqual(res.content_type, "text/json")
def test_accept_issue_113_text_star(self): app = TestApp(main({})) response = app.get('/service3', headers={'Accept': 'text/*'}) self.assertEqual(response.content_type, "text/json")
def test_content_type_on_get(self): # test that a Content-Type request header is not # checked on GET requests, they don't usually have a body app = TestApp(main({})) response = app.get('/service5') self.assertEqual(response.json, "some response")
def test_accept_issue_113_text_html_not_acceptable(self): app = TestApp(main({})) # requesting an unsupported content type should return a HTTP 406 (Not # Acceptable) app.get('/service3', headers={'Accept': 'text/html'}, status=406)
def test_accept_issue_113_text_application_json(self): app = TestApp(main({})) response = app.get('/service3', headers={'Accept': 'application/json'}) self.assertEqual(response.content_type, "application/json")
def test_email_field(self): app = TestApp(main({})) content = json.dumps({'email': '*****@*****.**'}) app.post('/newsletter', params=content)
def test_email_field(self): app = TestApp(main({})) content = {'email': '*****@*****.**'} app.post_json('/newsletter', params=content)
def test_filters(self): app = TestApp(main({})) # filters can be applied to all the methods of a service self.assertTrue("filtered response" in app.get('/filtered').body) self.assertTrue("unfiltered" in app.post('/filtered').body)
def test_accept_issue_113_text_application_star(self): app = TestApp(main({})) res = app.get('/service3', headers={'Accept': 'application/*'}, status=200) self.assertEquals(res.content_type, "application/json")