def test_multipart_POST(self):
        class FakeResponse201(object):
            status_int = 201
            headers = {"ETag": "1b2cf535f27731c974343645a3985328"}

        with mock.patch('webob.Request.get_response') as mocked:
            mocked.return_value = FakeResponse201()
            local_app = swift3.filter_factory({})(FakeAppObject(201))
            req = Request.blank('/' + self.MULTIPART_UPLOAD_PREFIX + \
                                'bucket/object?uploads=123',
                                environ={'REQUEST_METHOD': 'POST'},
                                headers={'Authorization': \
                                                      'AWS test:tester:hmac'})
            resp = local_app(req.environ, local_app.app.do_start_response)
            self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        with mock.patch('swifts3.middleware.meta_request_head') as mocked:
            with mock.patch('webob.Request.get_response') as mocked_manifest:
                mocked.return_value = Response(status=200,
                                               headers={"test": "test"})
                mocked_manifest.return_value = FakeResponse201()
                local_app = swift3.filter_factory({})(FakeAppObject(201))
                req = Request.blank('/' + self.MULTIPART_UPLOAD_PREFIX + \
                                    'bucket/object?uploadId=deadbeef',
                                    environ={'REQUEST_METHOD': 'POST'},
                                    headers={'Authorization': \
                                                       'AWS test:tester:hmac'})
                resp = local_app(req.environ, local_app.app.do_start_response)
                self.assertEquals(local_app.app.response_args[0].split()[0],
                                                                         '200')
 def test_object_acl_GET(self):
     local_app = swift3.filter_factory({})(FakeAppObject())
     req = Request.blank('/bucket/object?acl',
                         environ={'REQUEST_METHOD': 'GET'},
                         headers={'Authorization': 'AWS test:tester:hmac'})
     resp = local_app(req.environ, local_app.app.do_start_response)
     self._check_acl('test:tester', resp)
    def _test_object_GETorHEAD(self, method):
        local_app = swift3.filter_factory({})(FakeAppObject())
        req = Request.blank('/bucket/object',
                            environ={'REQUEST_METHOD': method},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        headers = dict(local_app.app.response_args[1])
        for key, val in local_app.app.response_headers.iteritems():
            if key in ('Content-Length', 'Content-Type', 'Content-Encoding',
                       'etag', 'last-modified'):
                self.assertTrue(key in headers)

                if key == 'Content-Length' and method == 'HEAD':
                    self.assertEquals(headers[key], '0')
                else:
                    self.assertEquals(headers[key], val)

            elif key.startswith('x-object-meta-'):
                self.assertTrue('x-amz-meta-' + key[14:] in headers)
                self.assertEquals(headers['x-amz-meta-' + key[14:]], val)

        if method == 'GET':
            self.assertEquals(resp, local_app.app.object_body)
 def test_bucket_PUT(self):
     local_app = swift3.filter_factory({})(FakeAppBucket(201))
     req = Request.blank('/bucket',
                         environ={'REQUEST_METHOD': 'PUT'},
                         headers={'Authorization': 'AWS test:tester:hmac'})
     resp = local_app(req.environ, local_app.app.do_start_response)
     self.assertEquals(local_app.app.response_args[0].split()[0], '200')
 def test_bucket_GET_passthroughs(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':
                      'delimiter=a&marker=b&prefix=c'},
             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('Prefix')[0].
             childNodes[0].nodeValue, 'c')
     self.assertEquals(dom.getElementsByTagName('Marker')[0].
             childNodes[0].nodeValue, 'b')
     self.assertEquals(dom.getElementsByTagName('Delimiter')[0].
             childNodes[0].nodeValue, 'a')
     args = dict(cgi.parse_qsl(fake_app.query_string))
     self.assertEquals(args['delimiter'], 'a')
     self.assertEquals(args['marker'], 'b')
     self.assertEquals(args['prefix'], 'c')
    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_bucket_GET(self):
        local_app = swift3.filter_factory({})(FakeAppBucket())
        bucket_name = 'junk'
        req = Request.blank('/%s' % bucket_name,
                            environ={'REQUEST_METHOD': 'GET'},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.firstChild.nodeName, 'ListBucketResult')
        name = dom.getElementsByTagName('Name')[0].childNodes[0].nodeValue
        self.assertEquals(name, bucket_name)

        objects = [n for n in dom.getElementsByTagName('Contents')]
        listing = [n for n in objects[0].childNodes if n.nodeName != '#text']

        names = []
        for o in objects:
            if o.childNodes[0].nodeName == 'Key':
                names.append(o.childNodes[0].childNodes[0].nodeValue)
            if o.childNodes[1].nodeName == 'LastModified':
                self.assertTrue(
                    o.childNodes[1].childNodes[0].nodeValue.endswith('Z'))

        self.assertEquals(len(names), len(FakeAppBucket().objects))
        for i in FakeAppBucket().objects:
            self.assertTrue(i[0] in names)
    def test_bucket_GET_uploads(self):
        local_app = swift3.filter_factory({})(FakeAppBucketMPU())
        bucket_name = 'junk'
        req = Request.blank('/%s?uploads' % bucket_name,
                            environ={'REQUEST_METHOD': 'GET'},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.firstChild.nodeName,
                          'ListMultipartUploadsResult')
        name = dom.getElementsByTagName('Bucket')[0].childNodes[0].nodeValue
        self.assertEquals(name, bucket_name)

        objects = [n for n in dom.getElementsByTagName('Upload')]

        names = []
        for o in objects:
            if o.childNodes[0].nodeName == 'Key':
                names.append(o.childNodes[0].childNodes[0].nodeValue)
            if o.childNodes[-1].nodeName == 'Initiated':
                self.assertTrue(
                    o.childNodes[-1].childNodes[0].nodeValue.endswith('Z'))

        self.assertEquals(len(names), len(FakeAppBucketMPU().objects))
        for i in FakeAppBucketMPU().objects:
            for name in names:
                if name in i[0]:
                    self.assertTrue(name in i[0])
 def _test_method_error(self, cl, method, path, status):
     local_app = swift3.filter_factory({})(cl(status))
     req = Request.blank(path,
                         environ={'REQUEST_METHOD': method},
                         headers={'Authorization': 'AWS test:tester:hmac'})
     resp = local_app(req.environ, start_response)
     dom = xml.dom.minidom.parseString("".join(resp))
     self.assertEquals(dom.firstChild.nodeName, 'Error')
     return dom.getElementsByTagName('Code')[0].childNodes[0].nodeValue
 def test_bucket_DELETE(self):
     local_app = swift3.filter_factory({})(FakeAppBucket(204))
     req = Request.blank('/bucket',
                         environ={'REQUEST_METHOD': 'DELETE'},
                         headers={'Authorization': 'AWS test:tester:hmac'})
     with mock.patch('swifts3.middleware.BucketController'
                                          '.mpu_bucket_deletion') as mocked:
         mocked.return_value = Response(status=204)
         resp = local_app(req.environ, local_app.app.do_start_response)
         self.assertEquals(local_app.app.response_args[0].split()[0], '204')
    def test_object_DELETE(self):
        local_app = swift3.filter_factory({})(FakeAppObject(204))
        req = Request.blank('/bucket/object',
                            environ={'REQUEST_METHOD': 'DELETE'},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '204')

        local_app = swift3.filter_factory({})(FakeAppObject(204))
        req = Request.blank('/bucket/object',
                            environ={'REQUEST_METHOD': 'DELETE'},
                            headers={'Authorization': 'AWS test:tester:hmac',
                                     'X-Object-Manifest': '123'})

        class FakeResponse(object):
            status_int = 200
            headers = {'X-Object-Manifest': \
                       'somefile_new2/18dc9b42566848abb58d8bb1ccbaf37a/'}

        with mock.patch('webob.Request.get_response') as mocked:
            mocked.return_value = FakeResponse()
            resp = local_app(req.environ, local_app.app.do_start_response)
            self.assertEquals(local_app.app.response_args[0].split()[0], '204')
 def test_signed_urls(self):
     class FakeApp(object):
         def __call__(self, env, start_response):
             self.req = Request(env)
             start_response('200 OK', [])
     app = FakeApp()
     local_app = swift3.filter_factory({})(app)
     req = Request.blank('/bucket/object?Signature=X&Expires=Y&'
             'AWSAccessKeyId=Z', environ={'REQUEST_METHOD': 'GET'})
     req.date = datetime.now()
     req.content_type = 'text/plain'
     resp = local_app(req.environ, lambda *args: None)
     self.assertEquals(app.req.headers['Authorization'], 'AWS Z:X')
     self.assertEquals(app.req.headers['Date'], 'Y')
    def test_object_PUT(self):
        local_app = swift3.filter_factory({})(FakeAppObject(201))
        req = Request.blank('/bucket/object',
                            environ={'REQUEST_METHOD': 'PUT'},
                            headers={
                                   'Authorization': 'AWS test:tester:hmac',
                                   'x-amz-storage-class': 'REDUCED_REDUNDANCY',
                                   'Content-MD5': 'Gyz1NfJ3Mcl0NDZFo5hTKA==',
                                    })
        req.date = datetime.now()
        req.content_type = 'text/plain'
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        headers = dict(local_app.app.response_args[1])
        self.assertEquals(headers['ETag'],
                          "\"%s\"" % local_app.app.response_headers['etag'])
    def test_multipart_DELETE(self):
        class FakeResponse200(object):
            status_int = 200
            body = [{"name": "test"}]
            body = simplejson.dumps(body)

        local_app = swift3.filter_factory({})(FakeAppObject(200))
        with mock.patch('webob.Request.get_response') as mocked:
            mocked.return_value = FakeResponse200()
            req = Request.blank('/bucket/object?uploadId=deadbeef',
                                environ={'REQUEST_METHOD': 'DELETE'},
                                headers={
                                     'Authorization': 'AWS test:tester:hmac',
                                     'Content-MD5': 'Gyz1NfJ3Mcl0NDZFo5hTKA==',
                                      })
            resp = local_app(req.environ, local_app.app.do_start_response)
            self.assertEquals(local_app.app.response_args[0].split()[0], '204')
    def test_bucket_DELETE_mpu(self):
        class FakeObjects(object):
            status_int = 200
            body = simplejson.dumps([{'name': 'some_name/meta'},
                                     {'name': 'some_name'}])
            headers = {"test": "test"}

        local_app = swift3.filter_factory({})(FakeAppBucket(204))
        req = Request.blank('/bucket',
                            environ={'REQUEST_METHOD': 'DELETE'},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        with mock.patch('webob.Request.get_response') as mocked:
            with mock.patch('swifts3.middleware.BucketController'
                       '.mpu_bucket_deletion_list_request') as mocked_list_req:
                mocked.return_value = Response(status=204)
                mocked_list_req.return_value = FakeObjects()
                resp = local_app(req.environ, local_app.app.do_start_response)
                self.assertEquals(local_app.app.response_args[0].split()[0],
                                                                        '204')
    def test_multipart_GET(self):
        class FakeResponse(object):
            status_int = 200
            body = [{"name": "test_bucket",
                     "last_modified": "2011-01-05T02:19:14.275290",
                     "hash": 0,
                     "bytes": 3909}]
            body = simplejson.dumps(body)

        local_app = swift3.filter_factory({})(FakeAppObject(200))
        bucket_name = 'bucket'
        req = Request.blank('/%s/object?uploadId=deadbeef' % bucket_name,
                            environ={'REQUEST_METHOD': 'GET'},
                            headers={'Authorization': 'AWS test:tester:hmac'})

        with mock.patch('webob.Request.get_response') as mocked:
            mocked.return_value = FakeResponse()
            resp = local_app(req.environ, local_app.app.do_start_response)
            self.assertEquals(local_app.app.response_args[0].split()[0], '200')
    def test_bucket_GET_is_truncated(self):
        local_app = swift3.filter_factory({})(FakeAppBucket())
        bucket_name = 'junk'

        req = Request.blank('/%s' % bucket_name,
                environ={'REQUEST_METHOD': 'GET',
                         'QUERY_STRING': 'max-keys=3'},
                headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.getElementsByTagName('IsTruncated')[0].
                childNodes[0].nodeValue, 'false')

        req = Request.blank('/%s' % bucket_name,
                environ={'REQUEST_METHOD': 'GET',
                         'QUERY_STRING': 'max-keys=2'},
                headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.getElementsByTagName('IsTruncated')[0].
                childNodes[0].nodeValue, 'true')
 def test_object_PUT_headers(self):
     class FakeApp(object):
         def __call__(self, env, start_response):
             self.req = Request(env)
             start_response('200 OK', [])
     app = FakeApp()
     local_app = swift3.filter_factory({})(app)
     req = Request.blank('/bucket/object',
                     environ={'REQUEST_METHOD': 'PUT'},
                     headers={'Authorization': 'AWS test:tester:hmac',
                              'X-Amz-Storage-Class': 'REDUCED_REDUNDANCY',
                              'X-Amz-Meta-Something': 'oh hai',
                              'X-Amz-Copy-Source': '/some/source',
                              'Content-MD5': 'ffoHqOWd280dyE1MT4KuoQ=='})
     req.date = datetime.now()
     req.content_type = 'text/plain'
     resp = local_app(req.environ, lambda *args: None)
     self.assertEquals(app.req.headers['ETag'],
                       '7dfa07a8e59ddbcd1dc84d4c4f82aea1')
     self.assertEquals(app.req.headers['X-Object-Meta-Something'], 'oh hai')
     self.assertEquals(app.req.headers['X-Copy-From'], '/some/source')
    def test_service_GET(self):
        local_app = swift3.filter_factory({})(FakeAppService())
        req = Request.blank('/',
                            environ={'REQUEST_METHOD': 'GET'},
                            headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, local_app.app.do_start_response)
        self.assertEquals(local_app.app.response_args[0].split()[0], '200')

        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.firstChild.nodeName, 'ListAllMyBucketsResult')

        buckets = [n for n in dom.getElementsByTagName('Bucket')]
        listing = [n for n in buckets[0].childNodes if n.nodeName != '#text']
        self.assertEquals(len(listing), 2)

        names = []
        for b in buckets:
            if b.childNodes[0].nodeName == 'Name':
                names.append(b.childNodes[0].childNodes[0].nodeValue)

        self.assertEquals(len(names), len(FakeAppService().buckets))
        for i in FakeAppService().buckets:
            self.assertTrue(i[0] in names)
 def setUp(self):
     self.app = swift3.filter_factory({})(FakeApp())
     self.MULTIPART_UPLOAD_PREFIX = 'mpu.'