def test_cdn_get_no_content(self): prev_data = json.dumps( {"account": "acc", "container": "cont", "ttl": 1234, "logs_enabled": True, "cdn_enabled": True} ) self.test_origin.app = FakeApp( iter([("204 No Content", {}, prev_data), ("304 No Content", {}, "")]) # call to _get_cdn_data ) # call to get obj req = Request.blank( "http://1234.r34.origin_cdn.com:8080/obj1.jpg", environ={"REQUEST_METHOD": "HEAD", "swift.cdn_hash": "abcd", "swift.cdn_object_name": "obj1.jpg"}, ) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 304) self.test_origin.app = FakeApp( iter([("204 No Content", {}, prev_data), ("404 No Content", {}, "")]) # call to _get_cdn_data ) # call to get obj req = Request.blank( "http://1234.r34.origin_cdn.com:8080/obj1.jpg", environ={"REQUEST_METHOD": "HEAD", "swift.cdn_hash": "abcd", "swift.cdn_object_name": "obj1.jpg"}, ) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 404) self.test_origin.app = FakeApp( iter([("204 No Content", {}, prev_data), ("416 No Content", {}, "")]) # call to _get_cdn_data ) # call to get obj req = Request.blank( "http://1234.r34.origin_cdn.com:8080/obj1.jpg", environ={"REQUEST_METHOD": "HEAD", "swift.cdn_hash": "abcd", "swift.cdn_object_name": "obj1.jpg"}, ) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 416)
def test_GET_limit_marker_json(self): req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': '0'}) self.controller.PUT(req) for c in xrange(5): req = Request.blank('/sda1/p/a/c%d' % c, environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Put-Timestamp': str(c + 1), 'X-Delete-Timestamp': '0', 'X-Object-Count': '2', 'X-Bytes-Used': '3', 'X-Timestamp': normalize_timestamp(0)}) self.controller.PUT(req) req = Request.blank('/sda1/p/a?limit=3&format=json', environ={'REQUEST_METHOD': 'GET'}) resp = self.controller.GET(req) self.assertEquals(resp.status_int, 200) self.assertEquals(simplejson.loads(resp.body), [{'count': 2, 'bytes': 3, 'name': 'c0'}, {'count': 2, 'bytes': 3, 'name': 'c1'}, {'count': 2, 'bytes': 3, 'name': 'c2'}]) req = Request.blank('/sda1/p/a?limit=3&marker=c2&format=json', environ={'REQUEST_METHOD': 'GET'}) resp = self.controller.GET(req) self.assertEquals(resp.status_int, 200) self.assertEquals(simplejson.loads(resp.body), [{'count': 2, 'bytes': 3, 'name': 'c3'}, {'count': 2, 'bytes': 3, 'name': 'c4'}])
def test_POST_reset_container_sync(self): req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = self.controller.PUT(req) self.assertEquals(resp.status_int, 201) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() self.assertEquals(info['x_container_sync_point1'], -1) self.assertEquals(info['x_container_sync_point2'], -1) db.set_x_container_sync_points(123, 456) info = db.get_info() self.assertEquals(info['x_container_sync_point1'], 123) self.assertEquals(info['x_container_sync_point2'], 456) # Set to same value req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = self.controller.POST(req) self.assertEquals(resp.status_int, 204) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() self.assertEquals(info['x_container_sync_point1'], 123) self.assertEquals(info['x_container_sync_point2'], 456) # Set to new value req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c2'}) resp = self.controller.POST(req) self.assertEquals(resp.status_int, 204) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() self.assertEquals(info['x_container_sync_point1'], -1) self.assertEquals(info['x_container_sync_point2'], -1)
def test_admin_setup(self): # PUTs for account and 16 .hash's self.test_origin.app = FakeApp(iter([("204 No Content", {}, "") for i in xrange(102)])) resp = Request.blank( "/origin/.prep", environ={"REQUEST_METHOD": "PUT"}, headers={"X-Origin-Admin-User": "******", "X-Origin-Admin-Key": "unittest"}, ).get_response(self.test_origin) self.assertEquals(resp.status_int, 204) self.assertEquals(self.test_origin.app.calls, 101) self.test_origin.app = FakeApp(iter([("404 Not Found", {}, "")])) req = Request.blank( "/origin/.prep", environ={"REQUEST_METHOD": "PUT"}, headers={"X-Origin-Admin-User": "******", "X-Origin-Admin-Key": "unittest"}, ) self.assertRaises(Exception, req.get_response, self.test_origin) self.test_origin.app = FakeApp(iter([("204 No Content", {}, ""), ("404 Not Found", {}, "")])) req = Request.blank( "/origin/.prep", environ={"REQUEST_METHOD": "PUT"}, headers={"X-Origin-Admin-User": "******", "X-Origin-Admin-Key": "unittest"}, ) self.assertRaises(Exception, req.get_response, self.test_origin)
def test_GET_empty_account_plain(self): req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': '0'}) self.controller.PUT(req) req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'}) resp = self.controller.GET(req) self.assertEquals(resp.status_int, 204)
def test_cdn_get_regex(self): prev_data = json.dumps({'account': 'acc', 'container': 'cont', 'ttl': 1234, 'logs_enabled': True, 'cdn_enabled': True}) def check_urls(req): vrs, acc, cont, obj = utils.split_path(req.path, 1, 4) self.assertEquals(acc, 'acc') self.assertEquals(cont, 'cont') self.assertEquals(obj, 'obj1.jpg') self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, prev_data), # call to _get_cdn_data ('304 No Content', {}, '', check_urls)])) #call to get obj req = Request.blank('http://1234.r3.origin_cdn.com:8080/obj1.jpg', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 304) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, prev_data), # call to _get_cdn_data ('304 No Content', {}, '', check_urls)])) #call to get obj req = Request.blank('http://r3.origin_cdn.com:8080/nohash/obj1.jpg', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 404)
def make_pre_authed_request(env, method, path, body=None, headers=None, agent="Swift"): """ Makes a new webob.Request based on the current env but with the parameters specified. Note that this request will be preauthorized. :param env: Current WSGI environment dictionary :param method: HTTP method of new request :param path: HTTP path of new request :param body: HTTP body of new request; None by default :param headers: Extra HTTP headers of new request; None by default :returns: webob.Request object (Stolen from Swauth: https://github.com/gholt/swauth) """ newenv = {"REQUEST_METHOD": method, "HTTP_USER_AGENT": agent} for name in ("swift.cache", "swift.trans_id"): if name in env: newenv[name] = env[name] newenv["swift.authorize"] = lambda req: None if not headers: headers = {} if body: return Request.blank(path, environ=newenv, body=body, headers=headers) else: return Request.blank(path, environ=newenv, headers=headers)
def test_origin_db_post_fail(self): self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, ''), # call to _get_cdn_data ('404 Not Found', {}, ''), # put to .hash ])) req = Request.blank('http://origin_db.com:8080/v1/acc/cont', environ={'REQUEST_METHOD': 'PUT'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, ''), # call to _get_cdn_data ('204 No Content', {}, ''), # put to .hash ('404 Not Found', {}, ''), # HEAD check to list container ('404 Not Found', {}, ''), # PUT to list container ])) req = Request.blank('http://origin_db.com:8080/v1/acc/cont', environ={'REQUEST_METHOD': 'PUT'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, ''), # call to _get_cdn_data ('204 No Content', {}, ''), # put to .hash ('204 No Content', {}, ''), # HEAD check to list container ('404 Not Found', {}, ''), # PUT to list container ])) req = Request.blank('http://origin_db.com:8080/v1/acc/cont', environ={'REQUEST_METHOD': 'PUT'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500)
def test_cdn_get_no_content(self): prev_data = json.dumps({'account': 'acc', 'container': 'cont', 'ttl': 1234, 'logs_enabled': True, 'cdn_enabled': True}) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, prev_data), # call to _get_cdn_data ('304 No Content', {}, '')])) #call to get obj req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg', environ={'REQUEST_METHOD': 'HEAD', 'swift.cdn_hash': 'abcd', 'swift.cdn_object_name': 'obj1.jpg'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 304) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, prev_data), # call to _get_cdn_data ('404 No Content', {}, '')])) #call to get obj req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg', environ={'REQUEST_METHOD': 'HEAD', 'swift.cdn_hash': 'abcd', 'swift.cdn_object_name': 'obj1.jpg'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 404) self.test_origin.app = FakeApp(iter([ ('204 No Content', {}, prev_data), # call to _get_cdn_data ('416 No Content', {}, '')])) #call to get obj req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg', environ={'REQUEST_METHOD': 'HEAD', 'swift.cdn_hash': 'abcd', 'swift.cdn_object_name': 'obj1.jpg'}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 416)
def test_admin_setup(self): # PUTs for account and 16 .hash's self.test_origin.app = FakeApp(iter( [('204 No Content', {}, '') for i in xrange(102)])) resp = Request.blank('/origin/.prep', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Origin-Admin-User': '******', 'X-Origin-Admin-Key': 'unittest'}).get_response( self.test_origin) self.assertEquals(resp.status_int, 204) self.assertEquals(self.test_origin.app.calls, 101) self.test_origin.app = FakeApp(iter( [('404 Not Found', {}, '')])) req = Request.blank('/origin/.prep', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Origin-Admin-User': '******', 'X-Origin-Admin-Key': 'unittest'}) self.assertRaises(Exception, req.get_response, self.test_origin) self.test_origin.app = FakeApp(iter( [('204 No Content', {}, ''), ('404 Not Found', {}, '')])) req = Request.blank('/origin/.prep', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Origin-Admin-User': '******', 'X-Origin-Admin-Key': 'unittest'}) self.assertRaises(Exception, req.get_response, self.test_origin)
def test_origin_db_valid_setup(self): fake_conf = FakeConf(data=['[sos]', 'origin_cdn_host_suffixes = origin_cdn.com']) test_origin = origin.filter_factory( {'sos_conf': fake_conf})(FakeApp()) resp = Request.blank('http://origin_db.com:8080/v1/acc/cont', environ={'REQUEST_METHOD': 'POST'}).get_response(test_origin) self.assertEquals(resp.status_int, 404) fake_conf = FakeConf(data='''[sos] origin_admin_key = unittest origin_cdn_host_suffixes = origin_cdn.com origin_db_hosts = origin_db.com origin_account = .origin max_cdn_file_size = 0 '''.split('\n')) test_origin = origin.filter_factory( {'sos_conf': fake_conf})(FakeApp()) resp = Request.blank('http://origin_db.com:8080/v1/acc/cont', environ={'REQUEST_METHOD': 'POST'}).get_response(test_origin) self.assertEquals(resp.status_int, 500) fake_conf = FakeConf(data='''[sos] origin_admin_key = unittest origin_db_hosts = origin_db.com origin_account = .origin max_cdn_file_size = 0 '''.split('\n')) factory = origin.filter_factory( {'sos_conf': fake_conf}) self.assertRaises(origin.InvalidConfiguration, factory, FakeApp())
def test_translation_fails(self): # No language request = Request.blank('') response = self.item_descriptor.studio_transcript(request=request, dispatch='translation') self.assertEqual(response.status, '400 Bad Request') # No filename in request.GET request = Request.blank('') response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/uk') self.assertEqual(response.status, '400 Bad Request') # Correct case: filename = os.path.split(self.non_en_file.name)[1] _upload_file(self.non_en_file, self.item_descriptor.location, filename) self.non_en_file.seek(0) request = Request.blank(u'translation/uk?filename={}'.format(filename)) response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/uk') self.assertEqual(response.body, self.non_en_file.read()) self.assertEqual(response.headers['Content-Type'], 'application/x-subrip; charset=utf-8') self.assertEqual( response.headers['Content-Disposition'], 'attachment; filename="{}"'.format(filename) ) self.assertEqual(response.headers['Content-Language'], 'uk') # Non ascii file name download: self.non_en_file.seek(0) _upload_file(self.non_en_file, self.item_descriptor.location, u'塞.srt') self.non_en_file.seek(0) request = Request.blank('translation/zh?filename={}'.format(u'塞.srt'.encode('utf8'))) response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/zh') self.assertEqual(response.body, self.non_en_file.read()) self.assertEqual(response.headers['Content-Type'], 'application/x-subrip; charset=utf-8') self.assertEqual(response.headers['Content-Disposition'], 'attachment; filename="塞.srt"') self.assertEqual(response.headers['Content-Language'], 'zh')
def test_bucket_GET_max_keys(self): class FakeApp(object): def __call__(self, env, start_response): self.query_string = env['QUERY_STRING'] start_response('200 OK', []) return '[]' fake_app = FakeApp() local_app = swift3.filter_factory({})(fake_app) bucket_name = 'junk' req = Request.blank('/%s' % bucket_name, environ={'REQUEST_METHOD': 'GET', 'QUERY_STRING': 'max-keys=5'}, headers={'Authorization': 'AWS test:tester:hmac'}) resp = local_app(req.environ, lambda *args: None) dom = xml.dom.minidom.parseString("".join(resp)) self.assertEquals(dom.getElementsByTagName('MaxKeys')[0]. childNodes[0].nodeValue, '5') args = dict(cgi.parse_qsl(fake_app.query_string)) self.assert_(args['limit'] == '6') req = Request.blank('/%s' % bucket_name, environ={'REQUEST_METHOD': 'GET', 'QUERY_STRING': 'max-keys=5000'}, headers={'Authorization': 'AWS test:tester:hmac'}) resp = local_app(req.environ, lambda *args: None) dom = xml.dom.minidom.parseString("".join(resp)) self.assertEquals(dom.getElementsByTagName('MaxKeys')[0]. childNodes[0].nodeValue, '1000') args = dict(cgi.parse_qsl(fake_app.query_string)) self.assertEquals(args['limit'], '1001')
def test_translation_static_transcript(self): """ Set course static_asset_path and ensure we get redirected to that path if it isn't found in the contentstore """ self.course.static_asset_path = 'dummy/static' self.course.save() store = modulestore() with store.branch_setting(ModuleStoreEnum.Branch.draft_preferred, self.course.id): store.update_item(self.course, self.user.id) # Test youtube style en request = Request.blank('/translation/en?videoId=12345') response = self.item.transcript(request=request, dispatch='translation/en') self.assertEqual(response.status, '307 Temporary Redirect') self.assertIn( ('Location', '/static/dummy/static/subs_12345.srt.sjson'), response.headerlist ) # Test HTML5 video style self.item.sub = 'OEoXaMPEzfM' request = Request.blank('/translation/en') response = self.item.transcript(request=request, dispatch='translation/en') self.assertEqual(response.status, '307 Temporary Redirect') self.assertIn( ('Location', '/static/dummy/static/subs_OEoXaMPEzfM.srt.sjson'), response.headerlist ) # Test different language to ensure we are just ignoring it since we can't # translate with static fallback request = Request.blank('/translation/uk') response = self.item.transcript(request=request, dispatch='translation/uk') self.assertEqual(response.status, '404 Not Found')
def test_xml_transcript(self): """ Set data_dir and remove runtime modulestore to simulate an XMLModuelStore course. Then run the same tests as static_asset_path run. """ # Simulate XMLModuleStore xmodule self.item_descriptor.data_dir = 'dummy/static' del self.item_descriptor.runtime.modulestore self.assertFalse(self.course.static_asset_path) # Test youtube style en request = Request.blank('/translation/en?videoId=12345') response = self.item.transcript(request=request, dispatch='translation/en') self.assertEqual(response.status, '307 Temporary Redirect') self.assertIn( ('Location', '/static/dummy/static/subs_12345.srt.sjson'), response.headerlist ) # Test HTML5 video style self.item.sub = 'OEoXaMPEzfM' request = Request.blank('/translation/en') response = self.item.transcript(request=request, dispatch='translation/en') self.assertEqual(response.status, '307 Temporary Redirect') self.assertIn( ('Location', '/static/dummy/static/subs_OEoXaMPEzfM.srt.sjson'), response.headerlist ) # Test different language to ensure we are just ignoring it since we can't # translate with static fallback request = Request.blank('/translation/uk') response = self.item.transcript(request=request, dispatch='translation/uk') self.assertEqual(response.status, '404 Not Found')
def test_translation_fails(self): # No language request = Request.blank("") response = self.item_descriptor.studio_transcript(request=request, dispatch="translation") self.assertEqual(response.status, "400 Bad Request") # No filename in request.GET request = Request.blank("") response = self.item_descriptor.studio_transcript(request=request, dispatch="translation/uk") self.assertEqual(response.status, "400 Bad Request") # Correct case: filename = os.path.split(self.non_en_file.name)[1] _upload_file(self.non_en_file, self.item_descriptor.location, filename) self.non_en_file.seek(0) request = Request.blank(u"translation/uk?filename={}".format(filename)) response = self.item_descriptor.studio_transcript(request=request, dispatch="translation/uk") self.assertEqual(response.body, self.non_en_file.read()) self.assertEqual(response.headers["Content-Type"], "application/x-subrip; charset=utf-8") self.assertEqual(response.headers["Content-Disposition"], 'attachment; filename="{}"'.format(filename)) self.assertEqual(response.headers["Content-Language"], "uk") # Non ascii file name download: self.non_en_file.seek(0) _upload_file(self.non_en_file, self.item_descriptor.location, u"塞.srt") self.non_en_file.seek(0) request = Request.blank("translation/zh?filename={}".format(u"塞.srt".encode("utf8"))) response = self.item_descriptor.studio_transcript(request=request, dispatch="translation/zh") self.assertEqual(response.body, self.non_en_file.read()) self.assertEqual(response.headers["Content-Type"], "application/x-subrip; charset=utf-8") self.assertEqual(response.headers["Content-Disposition"], 'attachment; filename="塞.srt"') self.assertEqual(response.headers["Content-Language"], "zh")
def test_GET_json_last_modified(self): # make a container req = Request.blank('/sda1/p/a/jsonc', environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': '0'}) resp = self.controller.PUT(req) for i, d in [(0, 1.5), (1, 1.0),]: req = Request.blank('/sda1/p/a/jsonc/%s'%i, environ= {'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': d, 'HTTP_X_CONTENT_TYPE': 'text/plain', 'HTTP_X_ETAG': 'x', 'HTTP_X_SIZE': 0}) resp = self.controller.PUT(req) self.assertEquals(resp.status_int, 201) # test format # last_modified format must be uniform, even when there are not msecs json_body = [{"name":"0", "hash":"x", "bytes":0, "content_type":"text/plain", "last_modified":"1970-01-01T00:00:01.500000"}, {"name":"1", "hash":"x", "bytes":0, "content_type":"text/plain", "last_modified":"1970-01-01T00:00:01.000000"},] req = Request.blank('/sda1/p/a/jsonc?format=json', environ={'REQUEST_METHOD': 'GET'}) resp = self.controller.GET(req) self.assertEquals(resp.content_type, 'application/json') self.assertEquals(eval(resp.body), json_body) self.assertEquals(resp.charset, 'utf-8')
def test_container4unknown_memcache(self): fake_memcache = FakeMemcache() self.assertEquals(fake_memcache.store, {}) resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb) self.assertEquals(resp.status_int, 301) self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")}) self.assert_(self.test_staticweb.app.get_c4_called) self.test_staticweb.app.get_c4_called = False resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb) self.assertEquals(resp.status_int, 301) self.assert_(not self.test_staticweb.app.get_c4_called) self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")}) resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache, "REQUEST_METHOD": "PUT"}).get_response( self.test_staticweb ) self.assertEquals(resp.status_int, 200) self.assertEquals(fake_memcache.store, {}) resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb) self.assertEquals(resp.status_int, 301) self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")}) resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache, "REQUEST_METHOD": "POST"}).get_response( self.test_staticweb ) self.assertEquals(resp.status_int, 200) self.assertEquals(fake_memcache.store, {})
def test_translation_static_transcript(self): """ Set course static_asset_path and ensure we get redirected to that path if it isn't found in the contentstore """ self.course.static_asset_path = "dummy/static" self.course.save() store = editable_modulestore() store.update_item(self.course, "OEoXaMPEzfM") # Test youtube style en request = Request.blank("/translation/en?videoId=12345") response = self.item.transcript(request=request, dispatch="translation/en") self.assertEqual(response.status, "307 Temporary Redirect") self.assertIn(("Location", "/static/dummy/static/subs_12345.srt.sjson"), response.headerlist) # Test HTML5 video style self.item.sub = "OEoXaMPEzfM" request = Request.blank("/translation/en") response = self.item.transcript(request=request, dispatch="translation/en") self.assertEqual(response.status, "307 Temporary Redirect") self.assertIn(("Location", "/static/dummy/static/subs_OEoXaMPEzfM.srt.sjson"), response.headerlist) # Test different language to ensure we are just ignoring it since we can't # translate with static fallback request = Request.blank("/translation/uk") response = self.item.transcript(request=request, dispatch="translation/uk") self.assertEqual(response.status, "404 Not Found")
def test_domain_remap_account(self): req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "AUTH_a.example.com"}) resp = self.app(req.environ, start_response) self.assertEquals(resp, "/v1/AUTH_a") req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "AUTH-uuid.example.com"}) resp = self.app(req.environ, start_response) self.assertEquals(resp, "/v1/AUTH_uuid")
def test_method_inner(self): r = route( route('news', 'news'), route(GET, 'comments', 'comments_get'), route(POST, 'comments', 'comments_post')) req = Request.blank('/news', {'REQUEST_METHOD': 'GET'}) tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.target), ((), {}, 'news')) req = Request.blank('/news', {'REQUEST_METHOD': 'POST'}) self.assertRaises( RouteGuarded, r, req) req = Request.blank('/comments', {'REQUEST_METHOD': 'POST'}) tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.target), ((), {}, 'comments_post')) req = Request.blank('/comments', {'REQUEST_METHOD': 'DELETE'}) self.assertRaises( RouteGuarded, r, req) self.assertNoMatch(r, '/newsweeek') self.assertNoMatch(r, '/ne')
def test_method_inner(self): r = route( route("news", "news"), route(GET, "comments", "comments_get"), route(POST, "comments", "comments_post")) req = Request.blank("/news", {"REQUEST_METHOD": "GET"}) tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.target), ((), {}, "news")) req = Request.blank("/news", {"REQUEST_METHOD": "POST"}) self.assertRaises( RouteGuarded, r, req) req = Request.blank("/comments", {"REQUEST_METHOD": "POST"}) tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.target), ((), {}, "comments_post")) req = Request.blank("/comments", {"REQUEST_METHOD": "DELETE"}) self.assertRaises( RouteGuarded, r, req) self.assertNoMatch(r, "/newsweeek") self.assertNoMatch(r, "/ne")
def test_param_guard(self): r = route( "/news/{id:int}/", "target", guards=qs(q=opt(String), page=opt(Int))) req = Request.blank("/news/42/") tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.target), ((42,), {}, "target")) req = Request.blank("/news/42/?q=search") tr = r(req) self.assertEqual( (tr.args, tr.kwargs.items(), tr.target), ((42,), [("q", "search")], "target")) req = Request.blank("/news/42/?q=search&page=100") tr = r(req) self.assertEqual( (tr.args, tr.kwargs.items(), tr.target), ((42,), [("q", "search"), ("page", 100)], "target")) self.assertRaises( exc.HTTPBadRequest, r, Request.blank("/news/42/?q=search&page=aa"))
def test_translation_static_transcript_xml_with_data_dirc(self): """ Test id data_dir is set in XML course. Set course data_dir and ensure we get redirected to that path if it isn't found in the contentstore. """ # Simulate data_dir set in course. test_modulestore = MagicMock() attrs = {"get_course.return_value": Mock(data_dir="dummy/static", static_asset_path="")} test_modulestore.configure_mock(**attrs) self.item_descriptor.runtime.modulestore = test_modulestore # Test youtube style en request = Request.blank("/translation/en?videoId=12345") response = self.item.transcript(request=request, dispatch="translation/en") self.assertEqual(response.status, "307 Temporary Redirect") self.assertIn(("Location", "/static/dummy/static/subs_12345.srt.sjson"), response.headerlist) # Test HTML5 video style self.item.sub = "OEoXaMPEzfM" request = Request.blank("/translation/en") response = self.item.transcript(request=request, dispatch="translation/en") self.assertEqual(response.status, "307 Temporary Redirect") self.assertIn(("Location", "/static/dummy/static/subs_OEoXaMPEzfM.srt.sjson"), response.headerlist) # Test different language to ensure we are just ignoring it since we can't # translate with static fallback request = Request.blank("/translation/uk") response = self.item.transcript(request=request, dispatch="translation/uk") self.assertEqual(response.status, "404 Not Found")
def test_client(client_app=None): with serve(simple_app) as server: req = Request.blank(server.url, method="POST", content_type="application/json", json={"test": 1}) resp = req.send(client_app) assert resp.status_code == 200, resp.status assert resp.json["headers"]["Content-Type"] == "application/json" assert resp.json["method"] == "POST" # Test that these values get filled in: del req.environ["SERVER_NAME"] del req.environ["SERVER_PORT"] resp = req.send(client_app) assert resp.status_code == 200, resp.status req = Request.blank(server.url) del req.environ["SERVER_NAME"] del req.environ["SERVER_PORT"] assert req.send(client_app).status_code == 200 req.headers["Host"] = server.url.lstrip("http://") del req.environ["SERVER_NAME"] del req.environ["SERVER_PORT"] resp = req.send(client_app) assert resp.status_code == 200, resp.status del req.environ["SERVER_NAME"] del req.environ["SERVER_PORT"] del req.headers["Host"] assert req.environ.get("SERVER_NAME") is None assert req.environ.get("SERVER_PORT") is None assert req.environ.get("HTTP_HOST") is None assert_raises(ValueError, req.send, client_app) req = Request.blank(server.url) req.environ["CONTENT_LENGTH"] = "not a number" assert req.send(client_app).status_code == 200
def test_bucket_GET_max_keys(self): class FakeApp(object): def __call__(self, env, start_response): self.query_string = env["QUERY_STRING"] start_response("200 OK", []) return "[]" fake_app = FakeApp() local_app = swift3.filter_factory({})(fake_app) bucket_name = "junk" req = Request.blank( "/%s" % bucket_name, environ={"REQUEST_METHOD": "GET", "QUERY_STRING": "max-keys=5"}, headers={"Authorization": "AWS test:tester:hmac"}, ) resp = local_app(req.environ, lambda *args: None) dom = xml.dom.minidom.parseString("".join(resp)) self.assertEquals(dom.getElementsByTagName("MaxKeys")[0].childNodes[0].nodeValue, "5") args = dict(cgi.parse_qsl(fake_app.query_string)) self.assert_(args["limit"] == "6") req = Request.blank( "/%s" % bucket_name, environ={"REQUEST_METHOD": "GET", "QUERY_STRING": "max-keys=5000"}, headers={"Authorization": "AWS test:tester:hmac"}, ) resp = local_app(req.environ, lambda *args: None) dom = xml.dom.minidom.parseString("".join(resp)) self.assertEquals(dom.getElementsByTagName("MaxKeys")[0].childNodes[0].nodeValue, "1000") args = dict(cgi.parse_qsl(fake_app.query_string)) self.assertEquals(args["limit"], "1001")
def test_create_source_validation(self): c = Controller({'account_id': self.account_id, 'id': 'test1'}, self.mock_app) req = Request.blank('?size=2&volume_type_name=vtype&source_volume=%s' % 'backupnotfound') self.assertRaises(HTTPPreconditionFailed, c.create, req) source_vol = db.models.Volume(node=self.node0, account=self.account, status='NOTACTIVE', size=1) self.db.add(source_vol) self.db.commit() req = Request.blank('?size=2&volume_type_name=vtype&source_volume=%s' % source_vol.id) self.assertRaises(HTTPPreconditionFailed, c.create, req) source_vol.status = 'ACTIVE' source_vol.node = None self.db.add(source_vol) self.db.commit() req = Request.blank('?size=2&volume_type_name=vtype&source_volume=%s' % source_vol.id) self.assertRaises(HTTPPreconditionFailed, c.create, req) source_vol = db.models.Volume(node=self.node0, account=self.account, status='NOTACTIVE', size=1) self.db.add(source_vol) self.db.commit() req = Request.blank('?size=2&volume_type_name=vtype&source_volume=%s' % source_vol.id) self.assertRaises(HTTPPreconditionFailed, c.create, req)
def test_group_inexact_pattern(self): r = route("news", route("{id:int}", route("comments", "view"))) req = Request.blank("/news/42/comments") tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.endpoint.target), ((42,), {}, "view")) r = route("news/{id:int}", route("comments", "view")) req = Request.blank("/news/42/comments") tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.endpoint.target), ((42,), {}, "view")) r = route("news", route("{id:int}/comments", "view")) req = Request.blank("/news/42/comments") tr = r(req) self.assertEqual( (tr.args, tr.kwargs, tr.endpoint.target), ((42,), {}, "view"))
def test_origin_db_post_fail(self): self.test_origin.app = FakeApp( iter([("204 No Content", {}, ""), ("404 Not Found", {}, "")]) # call to _get_cdn_data # put to .hash ) req = Request.blank("http://origin_db.com:8080/v1/acc/cont", environ={"REQUEST_METHOD": "PUT"}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500) self.test_origin.app = FakeApp( iter( [ ("204 No Content", {}, ""), # call to _get_cdn_data ("204 No Content", {}, ""), # put to .hash ("404 Not Found", {}, ""), # HEAD check to list container ("404 Not Found", {}, ""), # PUT to list container ] ) ) req = Request.blank("http://origin_db.com:8080/v1/acc/cont", environ={"REQUEST_METHOD": "PUT"}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500) self.test_origin.app = FakeApp( iter( [ ("204 No Content", {}, ""), # call to _get_cdn_data ("204 No Content", {}, ""), # put to .hash ("204 No Content", {}, ""), # HEAD check to list container ("404 Not Found", {}, ""), # PUT to list container ] ) ) req = Request.blank("http://origin_db.com:8080/v1/acc/cont", environ={"REQUEST_METHOD": "PUT"}) resp = req.get_response(self.test_origin) self.assertEquals(resp.status_int, 500)
def test_domain_remap_passthrough(self): req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "example.com"}) resp = self.app(req.environ, start_response) self.assertEquals(resp, "/") req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "example.com:8080"}) resp = self.app(req.environ, start_response) self.assertEquals(resp, "/")
def test_container2(self): resp = Request.blank('/v1/a/c2').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 200) self.assertEquals(resp.content_type, 'text/plain') self.assertEquals(len(resp.body.split('\n')), int(resp.headers['x-container-object-count']))
def test_container3subdirz(self): resp = Request.blank('/v1/a/c3/subdirz').get_response( self.test_staticweb) self.assertEquals(resp.status_int, 301)
def test_container3subsubdircontents(self): resp = Request.blank('/v1/a/c3/subdir3/subsubdir/').get_response( self.test_staticweb) self.assertEquals(resp.status_int, 200) self.assertEquals(resp.body, 'index file')
def test_container3indexhtml(self): resp = Request.blank('/v1/a/c3/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 200) self.assert_('Test main index.html file.' in resp.body)
def test_container3(self): resp = Request.blank('/v1/a/c3').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 301) self.assertEquals(resp.headers['location'], 'http://localhost/v1/a/c3/')
def test_container2json_web_mode_explicitly_on(self): resp = Request.blank('/v1/a/c2?format=json', headers={ 'x-web-mode': 'true' }).get_response(self.test_staticweb) self.assertEquals(resp.status_int, 404)
def test_container2onetxt(self): resp = Request.blank('/v1/a/c2/one.txt').get_response( self.test_staticweb) self.assertEquals(resp.status_int, 404)
def test_container1(self): resp = Request.blank('/v1/a/c1').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 401)
def test_version(self): resp = Request.blank('/v1').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 412)
def test_container1_web_mode_explicitly_off(self): resp = Request.blank('/v1/a/c1', headers={ 'x-web-mode': 'false' }).get_response(self.test_staticweb) self.assertEquals(resp.status_int, 401)
from webob import Request, Response def wsgi_app(environ, start_response): response = Response() response.content_type = 'text/plain' parts = [] for name, value in sorted(environ.items()): parts.append('%s: %r' % (name, value)) response.body = str.encode('\n'.join(parts)) return response(environ, start_response) req = Request.blank('/test') print(req.call_application(wsgi_app)) # WSGI-application response print() print(req.get_response(wsgi_app)) # HTTP response
def test_account(self): resp = Request.blank('/v1/a').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 401)
def setUp(self): super(Test__Init__, self).setUp() self.request = Request.blank('https://www.example.com/status')
def test_root(self): resp = Request.blank('/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 404)
def make_paginator(pg): paginator = Paginator(Request.blank('/news?page='+pg), limit=1, count=10, invalid_page=invalid_page) paginator.page
def response(get_dict): req = Request.blank("/interactive_chooser") for key, value in get_dict.items(): req.GET.add(key, value) return json.loads(xhr_api(req).body)
def test_container9listingcss(self): resp = Request.blank('/v1/a/c9/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 200) self.assert_('Listing of /v1/a/c9/' in resp.body) self.assert_('<link' in resp.body) self.assert_('href="/absolute/listing.css"' in resp.body)
def test_invalid(self): paginator = Paginator(Request.blank('/news?page=xx'), limit=1, count=10) self.assertEqual(paginator.page, 1) paginator = Paginator(Request.blank('/news?page=-1'), limit=1, count=10) self.assertEqual(paginator.page, 1)
def test_container5indexhtml(self): resp = Request.blank('/v1/a/c5/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 503)
def test_cache_middleware(self): req = Request.blank('/something', environ={'REQUEST_METHOD': 'GET'}) resp = self.app(req.environ, start_response) self.assertTrue('swift.cache' in resp) self.assertTrue(isinstance(resp['swift.cache'], MemcacheRing))
def test_container4indexhtml(self): resp = Request.blank('/v1/a/c4/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 200) self.assert_('Listing of /v1/a/c4/' in resp.body) self.assert_('href="listing.css"' in resp.body)
def test_container5unknown(self): resp = Request.blank('/v1/a/c5/unknown').get_response( self.test_staticweb) self.assertEquals(resp.status_int, 404) self.assert_("Chrome's 404 fancy-page sucks." not in resp.body)
def test_no_querystring(self): req = Request.blank('/') self.setup_switch(req) assert not self.operator.is_active('test', req)
def test_container4twotxt(self): resp = Request.blank('/v1/a/c4/two.txt').get_response( self.test_staticweb) self.assertEquals(resp.status_int, 503)
def test_flag_present(self): req = Request.blank('/?alpha') self.setup_switch(req) assert self.operator.is_active('test', req)
def test_container3bindexhtml(self): resp = Request.blank('/v1/a/c3b/').get_response(self.test_staticweb) self.assertEquals(resp.status_int, 204) self.assertEquals(resp.body, '')
def test_paste_testing_variables(self): app = self.call_FUT(check='1') req = Request.blank('/') resp = app.do_request(req, '*', False) self.assertEqual(resp.check, '1')
def test_flag_missing(self): req = Request.blank('/?beta') self.setup_switch(req) assert not self.operator.is_active('test', req)
def test_paste_testing_variables_raises(self): app = self.call_FUT(body='1') req = Request.blank('/') self.assertRaises(ValueError, app.do_request, req, '*', False)
def check_status(self, status, awaiting_status=None): resp = Response() resp.request = Request.blank('/') resp.status = status return self.app._check_status(awaiting_status, resp)