def test_fixture(): app = TestApp(SimpleApplication()) res = app.get('/', params={'a': ['1', '2']}) assert (res.request.environ['QUERY_STRING'] == 'a=1&a=2') res = app.put('/') assert (res.request.environ['REQUEST_METHOD'] == 'PUT') res = app.delete('/') assert (res.request.environ['REQUEST_METHOD'] == 'DELETE') class FakeDict(object): def items(self): return [('a', '10'), ('a', '20')] res = app.post('/params', params=FakeDict()) # test multiple cookies in one request app.cookies['one'] = 'first'; app.cookies['two'] = 'second'; app.cookies['three'] = ''; res = app.get('/') hc = res.request.environ['HTTP_COOKIE'].split('; '); assert ('one=first' in hc) assert ('two=second' in hc) assert ('three=' in hc)
def test_basic_get(self, logging_info): # what the middleware app does is that creates a class based on another # and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementation1 config = DotDict( logger=logging, web_server=DotDict( ip_address='127.0.0.1', port='88888' ) ) server = CherryPy(config, ( ('/aux/(.*)', MadeUp), )) testapp = TestApp(server._wsgi_func) response = testapp.get('/aux/') self.assertEqual(response.status, 200) self.assertEqual(json.loads(response.body), {'age': 100}) logging_info.assert_called_with('Running AuxImplementation1') response = testapp.get('/xxxjunkxxx', expect_errors=True) self.assertEqual(response.status, 404)
class TestGET(): def setUp(self): self.url_1 = ''.join([controller, 'c221']) self.url_2 = ''.join([controller, 'c222']) middleware = [] self.client = TestApp(app.wsgifunc(*middleware)) self.client.post(self.url_1, 'test') self.client.post(self.url_2, 'test') def test_get_with_no_key_should_return_all_keys(self): r = self.client.get(controller) assert_equal(r.status, 200) r.mustcontain('c222') r.mustcontain('c221') def test_get_with_valid_key(self): r = self.client.get(self.url_2) assert_equal(r.status, 200) r.mustcontain('test') def test_get_with_invalid_key(self): """No Assertion required """ self.url_3 = ''.join([controller, 'c223']) self.client.get(self.url_3, status=404)
def test_basic_get_args(self, logging_info): # what the middleware app does is that it creates a class based on # another and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementation2 all_services = {} config = DotDict(logger=logging, web_server=DotDict(ip_address="127.0.0.1", port="88888")) server = CherryPy(config, (("/aux/(age|gender|misconfigured)/(.*)", MadeUp),)) testapp = TestApp(server._wsgi_func) response = testapp.get("/aux/age/") eq_(response.status, 200) eq_(json.loads(response.body), {"age": 100}) eq_(response.header_dict["content-length"], str(len(response.body))) eq_(response.header_dict["content-type"], "application/json") logging_info.assert_called_with("Running AuxImplementation2") response = testapp.get("/aux/gender/", expect_errors=True) eq_(response.status, 200) eq_(json.loads(response.body), {"gender": 0}) # if the URL allows a certain first argument but the implementation # isn't prepared for it, it barfs a 405 at you response = testapp.get("/aux/misconfigured/", expect_errors=True) eq_(response.status, 405)
class TestGET(): def setUp(self): middleware = [] self.client = TestApp(app.wsgifunc(*middleware)) self.lazy_url_2 = ''.join([lazy_controller, 'l222']) self.lazy_url_3 = ''.join([lazy_controller, 'l223']) canonical_url_1 = ''.join([canonical_controller, 'l221']) canonical_url_2 = ''.join([canonical_controller, 'l222']) self.client.post(canonical_url_1, 'test') #Propagated to all nodes self.client.post(canonical_url_2, 'test') #Propagated to all nodes def test_get_with_no_key_should_return_all_keys_present_in_any_node(self): r = self.client.get(lazy_controller) assert_equal(r.status, 200) r.mustcontain('l222') r.mustcontain('l221') def test_get_with_valid_key_present_in_all_nodes(self): r = self.client.get(self.lazy_url_2) assert_equal(r.status, 200) r.mustcontain('test') def test_get_with_invalid_key(self): """No Assertion required """ self.client.get(self.lazy_url_3, status=404)
class TestPOST(): def setUp(self): middleware = [] self.client = TestApp(app.wsgifunc(*middleware)) def test_set_a_key_value(self): url_225 = ''.join([controller, 'c225']) r = self.client.post(url_225, "testing post method:newly set key") assert_equal(r.status, 201) r.mustcontain("c225") r2 = self.client.get(url_225) r2.mustcontain("testing post method:newly set key") def test_set_a_key_value_where_key_exists(self): url_335 = ''.join([controller, 'c335']) self.client.post(url_335, "value exists. should have been overwritten.") r2 = self.client.get(url_335) r2.mustcontain("value exists. should have been overwritten.") r3 = self.client.post(url_335, "overwritten the existing value") assert_equal(r3.status, 201) r4 = self.client.get(url_335) r4.mustcontain("overwritten the existing value") def test_long_key_results_error(self): """No Assertion required """ key = "".join(map(str, range(40))) url_too_long_key = ''.join([controller, key]) self.client.post(url_too_long_key, "very very long. longer key than in database. should not get inserted", status=400) self.client.get(url_too_long_key, status=404)
def test_if_mod_304(): base_dir = os.path.dirname(__file__) test_dir = os.path.join(base_dir, 'test-data', '304') cache_app = CacheFixtureApp() index_page = CacheFixtureResponseInfo(open(os.path.join(test_dir,'index.html')).read()) page1 = CacheFixtureResponseInfo(open(os.path.join(test_dir,'page1.html')).read()) page2 = CacheFixtureResponseInfo(open(os.path.join(test_dir,'page2.html')).read()) cache_app.map_url('/index.html',index_page) cache_app.map_url('/page1.html',page1) cache_app.map_url('/page2.html',page2) index_page.mod_time = 1000 page1.mod_time = 1000 page2.mod_time = 1000 transcluder = TranscluderMiddleware(cache_app) test_app = TestApp(transcluder) #load up the deptracker result = test_app.get('/index.html', extra_environ={'HTTP_IF_MODIFIED_SINCE' : make_http_time(2000)}) #and test it result = test_app.get('/index.html', extra_environ={'HTTP_IF_MODIFIED_SINCE' : make_http_time(2000)}) assert result.status == 304 result = test_app.get('/index.html', extra_environ={'HTTP_IF_MODIFIED_SINCE' : make_http_time(500)}) assert result.status == 200 page1.mod_time = 3000 result = test_app.get('/index.html', extra_environ={'HTTP_IF_MODIFIED_SINCE' : make_http_time(2000)}) assert result.status == 200
class CountriesTests(unittest.TestCase): def setUp(self): middleware = [] self.testApp = TestApp(app.wsgifunc(*middleware)) def test_Countries(self): countries = Countries.find(lambda c: True) with_code = [country for country in countries if country['code']] self.assertTrue(len(with_code)/float(len(countries)) > 0.67) def test_GetWithNoParams(self): r = self.testApp.get('/countries/') self.assertEqual(r.status, 200) countries = json.loads(r.body) self.assertListEqual(countries, Countries.find(lambda c: True)) def test_GetCountriesByContinent(self): r = self.testApp.get('/continents/') self.assertEqual(r.status, 200) continents = json.loads(r.body) for continent in continents: r = self.testApp.get('/countries/%s' % continent['code']) actualCountries = [c for c in Countries._countries if c['continent'] == continent['code']] self.assertEqual(r.status, 200) responseCountries = json.loads(r.body) self.assertListEqual(responseCountries, actualCountries)
class TestDELETE(): def setUp(self): middleware = [] self.client = TestApp(app.wsgifunc(*middleware)) def test_delete_a_key_value(self): lazy_url = ''.join([lazy_controller, 'l777']) canonical_url = ''.join([canonical_controller, 'l777']) self.client.post(canonical_url, "should have a deleted flag") self.client.delete(lazy_url, status=202) self.client.get(canonical_url, status=404) def test_cannot_delete_a_non_existing_key_value(self): url_xyz = ''.join([lazy_controller, 'lxyz']) self.client.delete(url_xyz, status=404) def test_delete_existing_and_immediately_insert_a_key_value(self): lazy_url = ''.join([lazy_controller, 'l737']) canonical_url = ''.join([canonical_controller, 'l737']) self.client.post(canonical_url, "will be deleted and over written on canonical. Can be visible in others.") self.client.delete(lazy_url, status=202) self.client.post(lazy_url, "deleted existing. and written a new value") r2 = self.client.get(canonical_url) r2.mustcontain("deleted existing. and written a new value")
def test_wsgirequest_charset(): # Jose, 'José' app = TestApp(AssertApp(assertfunc=valid_name(u'José', encoding='iso-8859-1'))) res = app.get('/?name=Jos%E9') # Tanaka, '田中' app = TestApp(AssertApp(assertfunc=valid_name(u'田中', encoding='UTF-8'))) res = app.get('/?name=%E7%94%B0%E4%B8%AD') # Nippon (Japan), '日本' app = TestApp(AssertApp(assertfunc=valid_name(u'日本', encoding='UTF-8', post=True))) res = app.post('/', params=dict(name='日本')) # WSGIRequest will determine the charset from the Content-Type header when # unicode is expected. # No encoding specified: not expecting unicode app = TestApp(AssertApp(assertfunc=valid_name('日本', post=True))) content_type = 'application/x-www-form-urlencoded; charset=%s' res = app.post('/', params=dict(name='日本'), headers={'content-type': content_type % 'UTF-8'}) # Encoding specified: expect unicode. Shiftjis is the default encoding, but # params become UTF-8 because the browser specified so app = TestApp(AssertApp(assertfunc=valid_name(u'日本', post=True, encoding='shiftjis'))) res = app.post('/', params=dict(name='日本'), headers={'content-type': content_type % 'UTF-8'}) # Browser did not specify: parse params as the fallback shiftjis app = TestApp(AssertApp(assertfunc=valid_name(u'日本', post=True, encoding='shiftjis'))) res = app.post('/', params=dict(name=u'日本'.encode('shiftjis')))
class TestFilteredWSGI(TestWSGIController): def __init__(self, *args, **kargs): TestWSGIController.__init__(self, *args, **kargs) self.baseenviron = {} app = ControllerWrap(FilteredWSGIController) app = self.sap = SetupCacheGlobal(app, self.baseenviron) app = RegistryManager(app) self.app = TestApp(app) def setUp(self): TestWSGIController.setUp(self) self.baseenviron.update(self.environ) def test_before(self): resp = self.get_response(action='index') assert 'hi' in resp assert 'before is 1' in resp def test_after_response(self): resp = self.get_response(action='after_response') assert 'hi from __after__' in resp def test_after_string_response(self): resp = self.get_response(action='after_string_response') assert 'hello from __after__' in resp def test_start_response(self): self.baseenviron['pylons.routes_dict']['action'] = 'start_response' self.app.get('/', status=404)
class TestPOST(): def setUp(self): middleware = [] self.client = TestApp(app.wsgifunc(*middleware)) def test_set_a_key_value(self): lazy_post_url = ''.join([lazy_controller, 'l555']) canonical_get_url = ''.join([canonical_controller, 'l555']) r = self.client.post(lazy_post_url, "testing post method: newly created value") assert_equal(r.status, 201) r2 = self.client.get(canonical_get_url) r2.mustcontain("testing post method: newly created value") def test_set_a_key_value_where_key_exists(self): lazy_post_url = ''.join([lazy_controller, 'l655']) canonical_url = ''.join([canonical_controller, 'l655']) self.client.post(canonical_url, "value exists. over written on canonical. Can be visible in others") r2 = self.client.get(canonical_url) r3 = self.client.post(lazy_post_url, "overwritten the existing value") assert_equal(r3.status, 201) r4 = self.client.get(canonical_url) r4.mustcontain("overwritten the existing value") def test_long_key_results_error(self): """No Assertion required """ key = "".join(map(str, range(40))) url_too_long_key = ''.join([lazy_controller, key]) self.client.post(url_too_long_key, "very very long. longer key than in database. should not get inserted", status=400) self.client.get(url_too_long_key, status=404)
class ModelsApiUnhappyTest(unittest.TestCase): """ Unhappy tests for Cloudwatch API """ def setUp(self): self.app = TestApp(models_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(grok.app.config) @patch("grok.app.repository.engineFactory") def testNoAuthHeaders(self, engineFactoryMock): # pylint: disable=W0613 """ negative test for authentication guarded route. invoke get request without passing authentication headers response is validated for appropriate headers and body """ response = self.app.get("", status="*") assertions.assertInvalidAuthenticationResponse(self, response) @patch("grok.app.repository.engineFactory") def testInvalidAuthHeaders(self, engineFactoryMock): # pylint: disable=W0613 """ negative test for authentication guarded route. invoke get request with invalid authentication headers response is validated for appropriate headers and body """ invalidHeaders = getInvalidHTTPHeaders() response = self.app.get("", status="*", headers=invalidHeaders) assertions.assertInvalidAuthenticationResponse(self, response)
class TestFilteredWSGI(TestWSGIController): def __init__(self, *args, **kargs): TestWSGIController.__init__(self, *args, **kargs) self.baseenviron = {} app = ControllerWrap(FilteredWSGIController) app = self.sap = SetupCacheGlobal(app, self.baseenviron) app = RegistryManager(app) self.app = TestApp(app) def setUp(self): TestWSGIController.setUp(self) self.baseenviron.update(self.environ) def test_before(self): resp = self.get_response(action="index") assert "hi" in resp assert "before is 1" in resp def test_after_response(self): resp = self.get_response(action="after_response") assert "hi from __after__" in resp def test_after_string_response(self): resp = self.get_response(action="after_string_response") assert "hello from __after__" in resp def test_start_response(self): self.baseenviron["pylons.routes_dict"]["action"] = "start_response" self.app.get("/", status=404)
class TestWsgi(unittest.TestCase): def setUp(self): import tempfile from paste.fixture import TestApp from collective.eggproxy.wsgi import EggProxyApp from collective.eggproxy.config import config self.tempdir = tempfile.mkdtemp() config["eggs_directory"] = self.tempdir self.app = TestApp(EggProxyApp(config)) def tearDown(self): import shutil shutil.rmtree(self.tempdir) def test_root_index(self): response = self.app.get('/') assert 'collective.eggproxy' in response, response def test_package_index(self): response = self.app.get('/collective.eggproxy') assert '<title>Links for collective.eggproxy</title>' in response, \ response def test_package(self): # without trailing '/', paste.fixture.TestResponse click results in: # >>> urlparse.urljoin('/collective.eggproxy', # 'collective.eggproxy-0.2.0.tar.gz') # '/collective.eggproxy-0.2.0.tar.gz' # actual url is: /collective.eggproxy/collective.eggproxy-0.2.0.tar.gz response = self.app.get('/collective.eggproxy/') response = response.click(index=0, verbose=True) assert ('Content-Encoding', 'gzip') in response.headers, \ response.headers
class TestWSGICombo(ComboTestBase): def setUp(self): super(TestWSGICombo, self).setUp() self.root = self.makeDir() self.app = TestApp(combo_app(self.root)) def test_combo_app_sets_content_type_for_js(self): """The WSGI App should set a proper Content-Type for Javascript.""" files = [ self.makeSampleFile( self.root, os.path.join("yui", "yui-min.js"), "** yui-min **"), self.makeSampleFile( self.root, os.path.join("oop", "oop-min.js"), "** oop-min **"), self.makeSampleFile( self.root, os.path.join("event-custom", "event-custom-min.js"), "** event-custom-min **"), ] expected = "\n".join(("// yui/yui-min.js", "** yui-min **", "// oop/oop-min.js", "** oop-min **", "// event-custom/event-custom-min.js", "** event-custom-min **")) res = self.app.get("/?" + "&".join( ["yui/yui-min.js", "oop/oop-min.js", "event-custom/event-custom-min.js"]), status=200) self.assertEquals(res.headers, [("Content-Type", "text/javascript")]) self.assertEquals(res.body.strip(), expected) def test_combo_app_sets_content_type_for_css(self): """The WSGI App should set a proper Content-Type for CSS.""" files = [ self.makeSampleFile( self.root, os.path.join("widget", "skin", "sam", "widget.css"), "/* widget-skin-sam */"), ] expected = "/* widget/skin/sam/widget.css */" res = self.app.get("/?" + "&".join( ["widget/skin/sam/widget.css"]), status=200) self.assertEquals(res.headers, [("Content-Type", "text/css")]) self.assertEquals(res.body.strip(), expected) def test_no_filename_gives_404(self): """If no filename is included, a 404 should be returned.""" res = self.app.get("/", status=404) self.assertEquals(res.headers, [("Content-Type", "text/plain")]) self.assertEquals(res.body, "Not Found")
def test_errors(self, logging_info): # what the middleware app does is that it creates a class based on # another and sets an attribute called `cls` class WithNotFound(middleware_app.ImplementationWrapper): cls = AuxImplementationWithNotFoundError all_services = {} class WithUnavailable(middleware_app.ImplementationWrapper): cls = AuxImplementationWithUnavailableError all_services = {} class WithMissingArgument(middleware_app.ImplementationWrapper): cls = AuxImplementationWithMissingArgumentError all_services = {} class WithBadArgument(middleware_app.ImplementationWrapper): cls = AuxImplementationWithBadArgumentError all_services = {} config = DotDict(logger=logging, web_server=DotDict(ip_address="127.0.0.1", port="88888")) server = CherryPy( config, ( ("/aux/notfound", WithNotFound), ("/aux/unavailable", WithUnavailable), ("/aux/missing", WithMissingArgument), ("/aux/bad", WithBadArgument), ), ) testapp = TestApp(server._wsgi_func) # Test a Not Found error response = testapp.get("/aux/notfound", expect_errors=True) eq_(response.status, 404) eq_(response.header("content-type"), "application/json; charset=UTF-8") body = json.loads(response.body) eq_(body["error"]["message"], "not here") # Test a Timeout error response = testapp.get("/aux/unavailable", expect_errors=True) eq_(response.status, 408) eq_(response.header("content-type"), "application/json; charset=UTF-8") body = json.loads(response.body) eq_(body["error"]["message"], "unavailable") # Test BadRequest errors response = testapp.get("/aux/missing", expect_errors=True) eq_(response.status, 400) eq_(response.header("content-type"), "application/json; charset=UTF-8") body = json.loads(response.body) eq_(body["error"]["message"], "Mandatory parameter(s) 'missing arg' is missing or empty.") response = testapp.get("/aux/bad", expect_errors=True) eq_(response.status, 400) eq_(response.header("content-type"), "application/json; charset=UTF-8") body = json.loads(response.body) eq_(body["error"]["message"], "Bad value for parameter(s) 'bad arg'")
def test_app2(): app = TestApp(wsgi_app) info[:] = ['fluff'] res = app.get('/put2') res = app.get('/get1') assert res.body == b'fluff' res = app.get('/get2') assert res.body == b'fluff'
def test_increment(): app = TestApp(SessionMiddleware(simple_app)) res = app.get('/') assert 'current value is: 1' in res res = app.get('/') assert 'current value is: 2' in res res = app.get('/') assert 'current value is: 3' in res
def run_dir(dir): static_app = StaticURLParser(dir) trans_app = TranscluderMiddleware(static_app) app = TestApp(trans_app) expected_app = TestApp(static_app) result = app.get('/index.html') expected = expected_app.get('/expected.html') html_string_compare(result.body, expected.body)
class TestTemplatingApp(object): def setUp(self): self.app = TestApp(make_app({'cache_dir': os.path.join(os.path.dirname(__file__), 'cache')}, include_cache_middleware=True)) def test_testvars(self): resp = self.app.get('/hello/intro_template') assert 'Hi there 6' in resp def test_template_cache(self): resp = self.app.get('/hello/time_template') resp2 = self.app.get('/hello/time_template') assert resp.body == resp2.body
class TestAuthenticateFormDecorator(TestWSGIController): def setUp(self): from pylons.testutil import ControllerWrap, SetupCacheGlobal ProtectedController = make_protected() TestWSGIController.setUp(self) app = ControllerWrap(ProtectedController) app = SetupCacheGlobal(app, self.environ, setup_session=True) app = SessionMiddleware(app, {}, data_dir=session_dir) app = RegistryManager(app) self.app = TestApp(app) def test_unauthenticated(self): from pylons.decorators.secure import csrf_detected_message self.environ['pylons.routes_dict']['action'] = 'protected' response = self.app.post('/protected', extra_environ=self.environ, expect_errors=True) assert response.status == 403 assert csrf_detected_message in response def test_authenticated(self): from webhelpers.pylonslib import secure_form self.environ['pylons.routes_dict']['action'] = 'form' response = self.app.get('/form', extra_environ=self.environ) token = response.body self.environ['pylons.routes_dict']['action'] = 'protected' response = self.app.post('/protected', params={secure_form.token_key: token}, extra_environ=self.environ, expect_errors=True) assert 'Authenticated' in response self.environ['pylons.routes_dict']['action'] = 'protected' response = self.app.put('/protected', params={secure_form.token_key: token}, extra_environ=self.environ, expect_errors=True) assert 'Authenticated' in response # GET with token_key in query string response = self.app.get('/protected', params={secure_form.token_key: token}, extra_environ=self.environ, expect_errors=True) assert 'Authenticated' in response # POST with token_key in query string response = self.app.post('/protected?' + secure_form.token_key + '=' + token, extra_environ=self.environ, expect_errors=True) assert 'Authenticated' in response
def test_app1(): app = TestApp(wsgi_app) res = app.get('/get1') assert res.body == b'no-info' res = app.get('/get2') assert res.body ==b'no-info' info[:] = ['test'] res = app.get('/put1') res = app.get('/get1') assert res.body == b'test' res = app.get('/get2') assert res.body == b'test'
def test_different_sessions(): app = TestApp(SessionMiddleware(simple_app)) app2 = TestApp(SessionMiddleware(simple_app)) res = app.get('/') assert 'current value is: 1' in res res = app2.get('/') assert 'current value is: 1' in res res = app2.get('/') res = app2.get('/') res = app2.get('/') res2 = app.get('/') assert 'current value is: 2' in res2 assert 'current value is: 4' in res
class TestCWRegionsHandler(unittest.TestCase): """ Unit tests CWRegionsHandler """ @classmethod def setUpClass(cls): adapter = datasource_adapter_factory.createCloudwatchDatasourceAdapter() cls.resources = adapter.describeSupportedMetrics() cls.regions = adapter.describeRegions() def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(cloudwatch_api.app.wsgifunc()) @patch("grok.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testGetListRegionsEmptyResponse(self, adapterMock): """ Test for Get '/_metrics/cloudwatch/regions' response is validated for appropriate headers, body and status """ adapterMock.return_value.describeRegions.return_value = [] response = self.app.get("/regions", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertEqual(result, {}) @patch("grok.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testGetListRegionsNonEmptyResponse(self, adapterMock): """ Test for Get '/_metrics/cloudwatch/regions' response is validated for appropriate headers, body and status and pre-defined values """ adapterMock.return_value.describeRegions.return_value = self.regions response = self.app.get("/regions", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertEqual(result, dict(self.regions)) @patch("grok.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testGetListRegionMetricsEmptyResponse(self, adapterMock): """ Test for Get '/_metrics/cloudwatch/regions/<invalid-region-name>' response is validated for appropriate headers, body and status response is validated against expected error message """ adapterMock.return_value.describeRegions.return_value = self.regions response = self.app.get("/regions/fake-region", status="*", headers=self.headers) assertions.assertNotFound(self, response) self.assertIn("Region 'fake-region' was not found", response.body)
class MetricsApiUnhappyTest(unittest.TestCase): """ Unhappy tests for Metrics API """ def setUp(self): self.app = TestApp(metrics_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(grok.app.config) def testNoAuthHeaders(self): """ negative test for authentication guarded route. invoke get request without passing authentication headers resoponse is validated for appropriate headers and body """ response = self.app.get("/datasources", status="*") assertions.assertInvalidAuthenticationResponse(self, response) def testInvalidAuthHeaders(self): """ negative test for authentication guarded route. invoke get request with invalid authentication headers resoponse is validated for appropriate headers and body """ invalidHeaders = getInvalidHTTPHeaders() response = self.app.get("/datasources", status="*", headers=invalidHeaders) assertions.assertInvalidAuthenticationResponse(self, response) def testInvalidRoute(self): """ Invoke non supported route resoponse is validated for appropriate headers and body """ response = self.app.get("/foo", status="*", headers=self.headers) assertions.assertRouteNotFound(self, response) def testInvalidMethod(self): """ Invoe non supported methods resoponse is validated for appropriate headers and body """ response = self.app.post("/datasources", status="*", headers=self.headers) assertions.assertMethodNotAllowed(self, response) headers = dict(response.headers) self.assertEqual(headers["Allow"], "GET")
def test_nosave(): app = TestApp(SessionMiddleware(simple_app)) res = app.get('/nosave') assert 'current value is: 1' in res assert [] == res.all_headers('Set-Cookie') res = app.get('/nosave') assert 'current value is: 1' in res res = app.get('/') assert 'current value is: 1' in res assert len(res.all_headers('Set-Cookie')) > 0 res = app.get('/') assert [] == res.all_headers('Set-Cookie') assert 'current value is: 2' in res
class AjaxTest(unittest.TestCase): def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(webapp.app.wsgifunc()) def testSettingsAPIGET(self): response = self.app.get("/_settings", headers=self.headers) assertions.assertSuccess(self, response) @patch.object(repository, "engineFactory", autospec=True) @patch.object(repository, "getInstanceStatusHistory", autospec=True) @patch.object(repository, 'getAllModels', autospec=True) def testModelsAPIGET(self, getAllMetricsMock, getInstanceStatusHistoryMock, engineFactoryMock, *args): #import pdb; pdb.set_trace() getAllMetricsMock.return_value = [] getInstanceStatusHistoryMock.return_value = [] response = self.app.get("/_models", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertEqual(result, []) self.assertTrue(getAllMetricsMock.called) @patch.object(metrics_api.MetricsHandler, "getDatasources") def testMetricsAPIGETDataSources(self, getDatasources): getDatasources.return_value = [] response = self.app.get("/_metrics/datasources", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertEqual(result, []) self.assertTrue(getDatasources.called) @patch("grok.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testMetricsAPIGETCouldWatch(self, adapterMock): adapterMock.return_value.describeRegions.return_value = [] adapterMock.return_value.describeSupportedMetrics.return_value = {} response = self.app.get("/_metrics/cloudwatch", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertEqual(result, {'regions': {}, 'namespaces': {}})
class TestCode: def setup(self): middleware = [] self.testApp = TestApp(app) def test_invalid_page_request(self): r = self.testApp.get("/", expect_errors=True) r.mustcontain("Invalid") assert_equal(400, r.status) def test_receive_push_sms(self): url = "" data = {"sender": "0827824665", "text": "53543298", "timestamp": "2013"} response = self.testApp.get("/", data, headers={"Content-Type": "text/plain"}, status=200)
def test_cookie(): base_dir = os.path.dirname(__file__) test_dir = os.path.join(base_dir, 'test-data', 'cookie') static_app = StaticURLParser(test_dir) cookie_app = CookieMiddleware(static_app) transcluder = AnyDomainTranscluderMiddleware(cookie_app) test_app = TestApp(transcluder) test_static_app = TestApp(static_app) result = test_app.get('/index.html') expected = test_static_app.get('/expected1.html') html_string_compare(result.body, expected.body) result = test_app.get('/index.html') expected = test_static_app.get('/expected2.html') html_string_compare(result.body, expected.body)
class CWApiUnhappyTest(unittest.TestCase): """ Unhappy tests for Cloudwatch API """ def setUp(self): self.app = TestApp(cloudwatch_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(grok.app.config) def testNoAuthHeaders(self): """ negative test for authentication guarded route. invoke get request without passing authentication headers response is validated for appropriate headers and body """ response = self.app.get("", status="*") assertions.assertInvalidAuthenticationResponse(self, response) def testInvalidAuthHeaders(self): """ negative test for authentication guarded route. invoke get request with invalid authentication headers response is validated for appropriate headers and body """ invalidHeaders = getInvalidHTTPHeaders() response = self.app.get("", status="*", headers=invalidHeaders) assertions.assertInvalidAuthenticationResponse(self, response) def testInvalidRoute(self): """ Invoke non supported route resoponse is validated for appropriate headers and body """ response = self.app.get("/foo", status="*", headers=self.headers) assertions.assertRouteNotFound(self, response) def testInvalidMethod(self): """ Invoe non supported methods resoponse is validated for appropriate headers and body """ response = self.app.post("", status="*", headers=self.headers) assertions.assertMethodNotAllowed(self, response) headers = dict(response.headers) self.assertEqual(headers["Allow"], "GET")
class TestBasicWSGI(TestWSGIController): def __init__(self, *args, **kargs): TestWSGIController.__init__(self, *args, **kargs) self.baseenviron = {} app = ControllerWrap(BasicWSGIController) app = self.sap = SetupCacheGlobal(app, self.baseenviron) app = RegistryManager(app) self.app = TestApp(app) def setUp(self): TestWSGIController.setUp(self) self.baseenviron.update(self.environ) def test_wsgi_call(self): resp = self.get_response() assert 'hello world' in resp def test_yield_wrapper(self): resp = self.get_response(action='yield_fun') assert 'hi' * 100 in resp def test_404(self): self.environ['paste.config']['global_conf']['debug'] = False self.environ['pylons.routes_dict']['action'] = 'notthere' resp = self.app.get('/', status=404) assert resp.status == 404 def test_private_func(self): self.baseenviron['pylons.routes_dict']['action'] = '_private' resp = self.app.get('/', status=404) assert resp.status == 404 def test_strme_func(self): self.baseenviron['pylons.routes_dict']['action'] = 'strme' resp = self.app.get('/') assert "hi there" in resp def test_header_check(self): self.baseenviron['pylons.routes_dict']['action'] = 'header_check' resp = self.app.get('/') assert "Hello all!" in resp assert resp.response.headers['Content-Type'] == 'text/plain' assert resp.response.headers['Cache-Control'] == 'private' assert resp.header('Content-Type') == 'text/plain' def test_redirect(self): self.baseenviron['pylons.routes_dict']['action'] = 'use_redirect' resp = self.app.get('/', status=301) def test_nothing(self): self.baseenviron['pylons.routes_dict']['action'] = 'nothing' resp = self.app.get('/') assert '' == resp.body assert resp.response.headers['Cache-Control'] == 'private' def test_unicode_action(self): self.baseenviron['pylons.routes_dict'][ 'action'] = u'ОбсуждениеКомпаний' resp = self.app.get('/', status=404)
def test_product_pager(): """ Test paginating products is working Using ? in modern REST API's... comon """ restApp = TestApp(webservice.app.wsgifunc(*[])) req = restApp.get('/products/?page=2') product_list = json.loads(req.body) assert len(product_list) == 10
def test_products(): """ Test first item in the list has to be cheaper than the last item in the list """ restApp = TestApp(webservice.app.wsgifunc(*[])) req = restApp.get('/products/') products = json.loads(req.body) assert products[0]['price'] < products[9]['price']
def _deleteOneMetric(self): """ Delete one metric from test EC2 instance """ app = TestApp(models_api.app.wsgifunc()) response = app.get("/", headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertIsInstance(result, list) app.delete("/" + result[0]['uid'], headers=self.headers)
def test_basic_get(self, logging_info): # what the middleware app does is that creates a class based on another # and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementation1 config = DotDict(logger=logging, web_server=DotDict(ip_address='127.0.0.1', port='88888')) server = CherryPy(config, (('/aux/(.*)', MadeUp), )) testapp = TestApp(server._wsgi_func) response = testapp.get('/aux/') self.assertEqual(response.status, 200) self.assertEqual(json.loads(response.body), {'age': 100}) logging_info.assert_called_with('Running AuxImplementation1') response = testapp.get('/xxxjunkxxx', expect_errors=True) self.assertEqual(response.status, 404)
def test_add(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) key = 'test2' message = 'jhfsdf' obj_data = {'key': key, 'message': message} r1 = testApp.post('/storage/' + key, params=json.dumps(obj_data)) r = testApp.get('/storage/' + key) self.assertEqual(r1.status, 200) self.assertEqual(r.status, 200) self.assertEqual(json.loads(r.body.decode('utf-8'))['message'], message)
def test_errors(self, logging_info): # what the middleware app does is that it creates a class based on # another and sets an attribute called `cls` class WithNotFound(middleware_app.ImplementationWrapper): cls = AuxImplementationWithNotFoundError class WithUnavailable(middleware_app.ImplementationWrapper): cls = AuxImplementationWithUnavailableError class WithMissingArgument(middleware_app.ImplementationWrapper): cls = AuxImplementationWithMissingArgumentError class WithBadArgument(middleware_app.ImplementationWrapper): cls = AuxImplementationWithBadArgumentError config = DotDict(logger=logging, web_server=DotDict(ip_address='127.0.0.1', port='88888')) server = CherryPy(config, ( ('/aux/notfound', WithNotFound), ('/aux/unavailable', WithUnavailable), ('/aux/missing', WithMissingArgument), ('/aux/bad', WithBadArgument), )) testapp = TestApp(server._wsgi_func) # Test a Not Found error response = testapp.get('/aux/notfound', expect_errors=True) self.assertEqual(response.status, 404) # Test a Timeout error response = testapp.get('/aux/unavailable', expect_errors=True) self.assertEqual(response.status, 408) # Test BadRequest errors response = testapp.get('/aux/missing', expect_errors=True) self.assertEqual(response.status, 400) response = testapp.get('/aux/bad', expect_errors=True) self.assertEqual(response.status, 400)
class TestWsgiApp(object): def setUp(self): from paste.fixture import TestApp from routes.util import URLGenerator app = make_app({}) self.app = TestApp(app) self.url = URLGenerator(app.config['routes.map'], {}) def test_testvars(self): resp = self.app.get('/_test_vars', extra_environ={'paste.testing_variables': True}) assert re.match(r'^\d+$', resp.body) def test_exception_resp_attach(self): resp = self.app.get('/test_func', expect_errors=True) assert resp.status == 404 @raises(Exception) def test_no_content(self): resp = self.app.get('/test_empty', expect_errors=True) assert 'wontgethre' def test_middleware_cache_obj_instance(self): from paste.fixture import TestApp app = TestApp(make_app({}, include_cache_middleware=True)) resp = app.get('/hello/index') assert resp.cache def test_attribsafe_tmpl_context(self): from paste.fixture import TestApp app = TestApp(make_app({}, attribsafe=True)) resp = app.get('/hello/index') assert 'Hello World' in resp def test_cache_obj_appglobals(self): resp = self.app.get('/hello/index', extra_environ={'paste.testing_variables': True}) assert resp.cache == 'Nothing here but a string' def test_controller_name_override(self): resp = self.app.get('/goodbye/index') assert 'Hello World' in resp
class Test(): def setUp(self): middleware = [] self.testApp = TestApp(app.wsgifunc(*middleware)) def test_homepage_route(self): r = self.testApp.get('/') assert_equal(r.status, 200) r.mustcontain('A REST way to manage your Cron') r.mustcontain('curl -XGET http://localhost:8080/cron') r.mustcontain('curl -XGET http://localhost:8080/cron/1') r.mustcontain('curl -XDELETE http://localhost:8080/cron/2') def test_cron_list_route(self): r = self.testApp.get('/cron') assert_equal(r.status, 200) r.mustcontain('"id": 1') r.mustcontain('"minute": "0"') r.mustcontain('"hour": "3"') r.mustcontain('"day_of_month": "*"') r.mustcontain('"day_of_week": "*"') r.mustcontain('"month": "*"') r.mustcontain('curl -I http://eher.com.br/') r.mustcontain('"id": 2') r.mustcontain('"minute": "1"') r.mustcontain('"hour": "*"') r.mustcontain('"day_of_month": "*"') r.mustcontain('"day_of_week": "*"') r.mustcontain('"month": "*"') r.mustcontain('curl -I http://chegamos.com/') def test_cron_route(self): r = self.testApp.get('/cron/1') assert_equal(r.status, 200) r.mustcontain('"id": 1') r.mustcontain('"minute": "0"') r.mustcontain('"hour": "3"') r.mustcontain('"day_of_month": "*"') r.mustcontain('"day_of_week": "*"') r.mustcontain('"month": "*"') r.mustcontain('curl -I http://eher.com.br/')
def test_home_page_redirects_to_cas(): '''A plain request for the homepage redirects us to the CAS login page: >>> t, r1 = test_home_page_redirects_to_cas() >>> dict(r1.headers)['Location'] 'https://example/cas/login?service=http%3A%2F%2Fheron-service%2F' ''' from paste.fixture import TestApp t = TestApp(Mock.make([HeronAdminConfig])[0].make_wsgi_app()) r1 = t.get('/', status=303) return t, r1
def test_product_id(): """ Test that we get product data by product id when it's passed as a URL parameter """ product = Product.get() restApp = TestApp(webservice.app.wsgifunc(*[])) req = restApp.get("/product/{0}/".format(product.product_id)) product_data = json.loads(req.body) assert product.name == product_data['name']
def test_GET(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) # Return all thermostats with 200 OK r = testApp.get('/thermostats', {'content-type': 'application/json'}) json_data = json.loads(r.body) assert_equal(r.status, 200) assert_equal(json_data, thermostats) # Return thermostat with id 100 with 200 OK r = testApp.get('/thermostats/100', {'content-type': 'application/json'}) json_data = json.loads(r.body) assert_equal(r.status, 200) assert_equal(json_data, thermostats[0]) # Return 404 error for thermostat that doesn't exists r = testApp.get('/thermostats/102', status="*") assert_equal(r.status, 404) r.mustcontain('not found')
class GrokHandlerTest(unittest.TestCase): def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(webapp.app.wsgifunc()) @patch.object(web.template, "render") def testgrokHandlerGET(self, render, _instanceDataMock): response = self.app.get("/grok", headers=self.headers) self.assertTrue(render.called) assertions.assertResponseStatusCode(self, response, code=200) headers = dict(response.headers) self.assertEqual(headers["Content-Type"], "text/html; charset=UTF-8")
class DefaultHandlerTest(unittest.TestCase): def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(webapp.app.wsgifunc()) def testDefaultHandlerGET(self): response = self.app.get("", headers=self.headers) self.assertEqual(response.status, 303) self.assertEqual(response.full_status, "303 See Other") headers = dict(response.headers) self.assertEqual(headers["Content-Type"], "text/html") self.assertEqual(headers["Location"], "http://localhost/static/index.html") def testDefaultHandlerGETWithSlash(self): response = self.app.get("/", headers=self.headers) self.assertEqual(response.status, 303) self.assertEqual(response.full_status, "303 See Other") headers = dict(response.headers) self.assertEqual(headers["Content-Type"], "text/html") self.assertEqual(headers["Location"], "http://localhost/static/index.html")
def test_wsgirequest_charset(): # Jose, 'José' app = TestApp( AssertApp(assertfunc=valid_name(u'José', encoding='iso-8859-1'))) res = app.get('/?name=Jos%E9') # Tanaka, '田中' app = TestApp(AssertApp(assertfunc=valid_name(u'田中', encoding='UTF-8'))) res = app.get('/?name=%E7%94%B0%E4%B8%AD') # Nippon (Japan), '日本' app = TestApp( AssertApp(assertfunc=valid_name(u'日本', encoding='UTF-8', post=True))) res = app.post('/', params=dict(name='日本')) # WSGIRequest will determine the charset from the Content-Type header when # unicode is expected. # No encoding specified: not expecting unicode app = TestApp(AssertApp(assertfunc=valid_name('日本', post=True))) content_type = 'application/x-www-form-urlencoded; charset=%s' res = app.post('/', params=dict(name='日本'), headers={'content-type': content_type % 'UTF-8'}) # Encoding specified: expect unicode. Shiftjis is the default encoding, but # params become UTF-8 because the browser specified so app = TestApp( AssertApp( assertfunc=valid_name(u'日本', post=True, encoding='shiftjis'))) res = app.post('/', params=dict(name='日本'), headers={'content-type': content_type % 'UTF-8'}) # Browser did not specify: parse params as the fallback shiftjis app = TestApp( AssertApp( assertfunc=valid_name(u'日本', post=True, encoding='shiftjis'))) res = app.post('/', params=dict(name=u'日本'.encode('shiftjis')))
def init_mediadrop(config_filename, here_dir=None, disable_logging=False): if not os.path.exists(config_filename): raise IOError('Config file %r does not exist.' % config_filename) if here_dir is None: here_dir = os.getcwd() if not disable_logging: logging_config.fileConfig(config_filename) config_name = 'config:%s' % config_filename # XXX: Note, initializing CONFIG here is Legacy support. pylons.config # will automatically be initialized and restored via the registry # restorer along with the other StackedObjectProxys # Load app config into paste.deploy to simulate request config # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy # code conf = appconfig(config_name, relative_to=here_dir) conf.update(dict(app_conf=conf.local_conf, global_conf=conf.global_conf)) paste.deploy.config.CONFIG.push_thread_config(conf) # Load locals and populate with objects for use in shell sys.path.insert(0, here_dir) # WebOb 1.2+ does not support unicode_errors/decode_param_names anymore for # the Request() class so we need to override Pylons' defaults to prevent # DeprecationWarnings (only shown in Python 2.6 by default). webob_request_options = { 'charset': 'utf-8', 'errors': None, 'decode_param_names': None, 'language': 'en-us', } global_conf = {'pylons.request_options': webob_request_options} # Load the wsgi app first so that everything is initialized right wsgiapp = loadapp(config_name, relative_to=here_dir, global_conf=global_conf) test_app = TestApp(wsgiapp) # Query the test app to setup the environment tresponse = test_app.get('/_test_vars') request_id = int(tresponse.body) # Disable restoration during test_app requests test_app.pre_request_hook = lambda self: paste.registry.restorer.restoration_end( ) test_app.post_request_hook = lambda self: paste.registry.restorer.restoration_begin( request_id) # Restore the state of the Pylons special objects (StackedObjectProxies) paste.registry.restorer.restoration_begin(request_id)
class Tests(TestCase): def test_DateTimeJSONEncoder(self): dt = datetime.datetime(1978, 6, 15) self.assertEqual(json.dumps([dt, 1], cls=handlers.DateTimeJSONEncoder), '["1978-06-15T00:00:00", 1]') @mock.patch('time.time') def test_InMemCacheMixin(self, time): loaded_urls = templeton.handlers.load_urls([ '/test/', 'CachedHandler', ]) webapp = web.application(loaded_urls, globals()) self.app = TestApp(webapp.wsgifunc()) CachedHandler.updates = [] time.return_value = 10 for i in xrange(30): self.app.get('/api/test/') time.return_value += 1 self.assertEqual(CachedHandler.updates, [10, 20, 30])
def test_basic_get_args(self, logging_info): # what the middleware app does is that it creates a class based on # another and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementation2 all_services = {} config = DotDict( logger=logging, web_server=DotDict( ip_address='127.0.0.1', port='88888' ) ) server = CherryPy(config, ( ('/aux/(age|gender|misconfigured)/(.*)', MadeUp), )) testapp = TestApp(server._wsgi_func) response = testapp.get('/aux/age/') eq_(response.status, 200) eq_(json.loads(response.body), {'age': 100}) eq_(response.header_dict['content-length'], str(len(response.body))) eq_(response.header_dict['content-type'], 'application/json') logging_info.assert_called_with('Running AuxImplementation2') response = testapp.get('/aux/gender/', expect_errors=True) eq_(response.status, 200) eq_(json.loads(response.body), {'gender': 0}) # if the URL allows a certain first argument but the implementation # isn't prepared for it, it barfs a 405 at you response = testapp.get('/aux/misconfigured/', expect_errors=True) eq_(response.status, 405)
def test_fixture(): app = TestApp(SimpleApplication()) res = app.get('/', params={'a': ['1', '2']}) assert (res.request.environ['QUERY_STRING'] == 'a=1&a=2') res = app.put('/') assert (res.request.environ['REQUEST_METHOD'] == 'PUT') res = app.delete('/') assert (res.request.environ['REQUEST_METHOD'] == 'DELETE') class FakeDict(object): def items(self): return [('a', '10'), ('a', '20')] res = app.post('/params', params=FakeDict()) # test multiple cookies in one request app.cookies['one'] = 'first' app.cookies['two'] = 'second' app.cookies['three'] = '' res = app.get('/') hc = res.request.environ['HTTP_COOKIE'].split('; ') assert ('one=first' in hc) assert ('two=second' in hc) assert ('three=' in hc)
class TestCode(object): ''' go to individual module view, press edit mounting, check if edit mounting is loaded correctly. ''' URL_INDIVIDUAL_MOUNTING = '/individualModuleInfo?code=BT5110&aysem=AY+17%2F18+Sem+1' URL_EDIT_MOUNTING = '/editMounting?code=BT5110&aysem=AY+17%2F18+Sem+1' EDIT_MOUNTING_BUTTON_FORM_ID = 'edit-mounting-button' EDIT_MOUNTING_FORM_ID = 'edit-mounting-form' def __init__(self): self.middleware = None self.test_app = None def setUp(self): ''' Sets up the 'app.py' fixture ''' self.middleware = [] self.test_app = TestApp(APP.wsgifunc(*self.middleware)) session.set_up(self.test_app) def tearDown(self): ''' Tears down 'app.py' fixture and logs out ''' session.tear_down(self.test_app) def test_mounting_edit_submit_button(self): ''' tests whether the user accessed mounting edit page has a submit button and works as intended ''' root = self.test_app.get(self.URL_EDIT_MOUNTING) assert_equal(root.status, 200) #tests if the correct page is loaded root.mustcontain('BT5110') root.mustcontain('Module Info') submit_edit_mounting_form = root.forms__get()[ self.EDIT_MOUNTING_FORM_ID] root = submit_edit_mounting_form.submit() assert_equal(root.status, 200) #redirect back to individual module info page root.mustcontain("edited successfully")
class TestHttpsDecorator(TestWSGIController): def setUp(self): TestWSGIController.setUp(self) from routes import Mapper map = Mapper() map.connect('/:action/:id') map.connect('/:controller/:action/:id') app = ControllerWrap(HttpsController) app = SetupCacheGlobal(app, self.environ, setup_cache=False) app = RoutesMiddleware(app, map) app = RegistryManager(app) self.app = TestApp(app) def test_https_explicit_path(self): self.environ['pylons.routes_dict']['action'] = 'index' response = self.app.get('/index', status=302) assert response.header_dict.get('location') == \ 'https://localhost/pylons' self.environ['wsgi.url_scheme'] = 'https' response = self.app.get('/index', status=200) assert 'location' not in response.header_dict assert 'index page' in response def test_https_disallows_post(self): self.environ['pylons.routes_dict']['action'] = 'index' response = self.app.post('/index', status=405) def test_https_url_for_kwargs(self): self.environ['pylons.routes_dict']['action'] = 'login' response = self.app.get('/login', status=302) assert response.header_dict.get('location') == \ 'https://localhost/auth/login' self.environ['wsgi.url_scheme'] = 'https' response = self.app.get('/login', status=200) assert 'location' not in response.header_dict assert 'login page' in response def test_https_redirect_to_self(self): self.environ['pylons.routes_dict']['action'] = 'get' response = self.app.get('/get', status=302) assert response.header_dict.get('location') == \ 'https://localhost/get' self.environ['wsgi.url_scheme'] = 'https' response = self.app.get('/get', status=200) assert 'location' not in response.header_dict assert 'get page' in response
class CWDefaultHandlerTest(unittest.TestCase): """ Integration test CWDefaultHandler """ def setUp(self): self.app = TestApp(cloudwatch_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(grok.app.config) def _testGETCloudWatchImpl(self, url): response = self.app.get(url, headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertIsInstance(result, dict) supportedMetrics = createCloudwatchDatasourceAdapter( ).describeSupportedMetrics() for metrics in supportedMetrics.values(): for metric, keys in metrics.items(): self.assertIn( keys["namespace"], result["namespaces"], "Expected namespace (%s) not found in response." % (keys["namespace"])) self.assertIn( metric, result["namespaces"][keys["namespace"]]["metrics"], "Expected metric (%s, %s) not found in response." % (keys["namespace"], metric)) @ManagedTempRepository("CWDefaultHandlerTest") def testGETCloudWatch(self): """ Test for Get '/_metrics/cloudwatch' response is validated for appropriate headers, body and status response is validated against known namespaces and available metrics """ self._testGETCloudWatchImpl("") @ManagedTempRepository("CWDefaultHandlerTest") def testGETCloudWatchWithSlash(self): """ Test for Get '/_metrics/cloudwatch' response is validated for appropriate headers, body and status response is validated against known namespaces and available metrics """ self._testGETCloudWatchImpl("/")
class TestJsonifyDecorator(object): def setUp(self): from paste.fixture import TestApp from routes.util import URLGenerator app = make_app({}) self.config = app.config self.app = TestApp(app) self.url = URLGenerator(app.config['routes.map'], {}) def test_basic_response(self): response = self.app.get('/hello/index') assert 'Hello World' in response def test_config(self): import pylons import pylons.configuration as configuration assert pylons.config == configuration.config @raises(AssertionError) def test_eval(self): from paste.fixture import TestApp app = TestApp(make_app(dict(debug='True'))) app.get('/hello/oops', status=500, extra_environ={'paste.throw_errors': False}) def test_set_lang(self): self._test_set_lang('set_lang') def test_set_lang_pylonscontext(self): self._test_set_lang('set_lang_pylonscontext') def _test_set_lang(self, action): response = self.app.get(self.url(controller='i18nc', action=action, lang='ja')) assert u'\u8a00\u8a9e\u8a2d\u5b9a\u3092\u300cja\u300d\u306b\u5909\u66f4\u3057\u307e\u3057\u305f'.encode('utf-8') in response response = self.app.get(self.url(controller='i18nc', action=action, lang='ch')) assert 'Could not set language to "ch"' in response def test_detect_lang(self): response = self.app.get(self.url(controller='i18nc', action='i18n_index'), headers={ 'Accept-Language':'fr;q=0.6, en;q=0.1, ja;q=0.3'}) # expect japanese fallback for nonexistent french. assert u'\u6839\u672c\u30a4\u30f3\u30c7\u30af\u30b9\u30da\u30fc\u30b8'.encode('utf-8') in response def test_no_lang(self): response = self.app.get(self.url(controller='i18nc', action='no_lang')) assert 'No language' in response assert 'No languages' in response def test_langs(self): response = self.app.get(self.url(controller='i18nc', action='langs'), headers={ 'Accept-Language':'fr;q=0.6, en;q=0.1, ja;q=0.3'}) assert "['fr', 'ja', 'en-us']" in response
class CWDefaultHandlerTest(unittest.TestCase): """ Unit tests CWDefaultHandler """ def setUp(self): self.headers = getDefaultHTTPHeaders(htm.it.app.config) self.app = TestApp(cloudwatch_api.app.wsgifunc()) adapter = datasource_adapter_factory.createCloudwatchDatasourceAdapter() self.resources = adapter.describeSupportedMetrics() self.regions = adapter.describeRegions() def _getCloudWatchCommon(self, url, expectedResult): response = self.app.get(url, headers=self.headers) assertions.assertSuccess(self, response) result = app_utils.jsonDecode(response.body) self.assertIsInstance(result, dict) self.assertEqual(result, expectedResult) @patch("htm.it.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testCWDefaultHandlerDefault(self, adapterMock): """ Test for Get '/_metrics/cloudwatch' response is validated for appropriate headers, body and status """ adapterMock.return_value.describeRegions.return_value = [] adapterMock.return_value.describeSupportedMetrics.return_value = {} self._getCloudWatchCommon("", {"regions": {}, "namespaces": {}}) @patch("htm.it.app.webservices.cloudwatch_api.datasource_adapter_factory." "createCloudwatchDatasourceAdapter") def testCWDefaultHandlerDefaultWithSlash(self, adapterMock): """ Test for Get '/_metrics/cloudwatch/' response is validated for appropriate headers, body and status """ adapterMock.return_value.describeRegions.return_value = [] adapterMock.return_value.describeSupportedMetrics.return_value = {} self._getCloudWatchCommon("/", {"regions": {}, "namespaces": {}})
def test_errors_to_sentry(self, logging_info, raven_client_mocked): # what the middleware app does is that it creates a class based on # another and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementationErroring all_services = {} FAKE_DSN = 'https://[email protected]/XX' mock_logging = mock.MagicMock() config = DotDict( logger=mock_logging, web_server=DotDict( ip_address='127.0.0.1', port='88888' ), sentry=DotDict( dsn=FAKE_DSN ) ) server = CherryPy(config, ( ('/aux/(.*)', MadeUp), )) def fake_get_ident(exception): return '123456789' mocked_client = mock.MagicMock() mocked_client.get_ident.side_effect = fake_get_ident def fake_client(dsn): assert dsn == FAKE_DSN return mocked_client raven_client_mocked.side_effect = fake_client testapp = TestApp(server._wsgi_func) response = testapp.get('/aux/bla', expect_errors=True) eq_(response.status, 500) mock_logging.info.has_call([mock.call( 'Error captured in Sentry. Reference: 123456789' )])
class MetricsHandlerTest(unittest.TestCase): """ Integration tests for metrics API """ def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(metrics_api.app.wsgifunc()) @ManagedTempRepository("MettricsHandlerTest") def testGETDatasources(self): """ Test for GET for '/_metrics/datasources' response is validated for appropriate headers and body """ response = self.app.get('/datasources', headers=self.headers) assertions.assertSuccess(self, response) self.assertIsInstance(utils.jsonDecode(response.body), list) self.assertSetEqual(set(utils.jsonDecode(response.body)), set(["autostack", "custom", "cloudwatch"]))
def test_basic_get_with_parsed_query_string(self, logging_info): # what the middleware app does is that creates a class based on another # and sets an attribute called `cls` class MadeUp(middleware_app.ImplementationWrapper): cls = AuxImplementation5 config = DotDict(logger=logging, web_server=DotDict(ip_address='127.0.0.1', port='88888')) server = CherryPy(config, (('/aux/(.*)', MadeUp), )) testapp = TestApp(server._wsgi_func) response = testapp.get('/aux/foo/bar/names/peter+anders') self.assertEqual(response.status, 200) self.assertEqual(json.loads(response.body), { 'foo': 'bar', 'names': ['peter', 'anders'] }) logging_info.assert_called_with('Running AuxImplementation5')
class TestHelpers(TestWSGIController): def __init__(self, *args, **kargs): from pylons.testutil import ControllerWrap, SetupCacheGlobal HelpersController = make_helperscontroller() TestWSGIController.__init__(self, *args, **kargs) self.baseenviron = {} app = ControllerWrap(HelpersController) app = self.sap = SetupCacheGlobal(app, self.baseenviron) app = RegistryManager(app) self.app = TestApp(app) def setUp(self): TestWSGIController.setUp(self) self.baseenviron.update(self.environ) warnings.simplefilter('error', DeprecationWarning) def tearDown(self): warnings.simplefilter('always', DeprecationWarning) def test_return_etag_cache(self): self.baseenviron['pylons.routes_dict']['action'] = 'test_etag_cache' response = self.app.get('/') assert '"test"' == response.header('Etag') assert 'from etag_cache' in response