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)
