merged with trunk

test/functional/tests.py

@@ -170,6 +170,15 @@ class TestAccount(Base):
         self.assert_status(412)
         self.assert_body('Bad URL')
 
+    def testInvalidPath(self):
+        was_url = self.env.account.conn.storage_url
+        self.env.account.conn.storage_url = "/%s" % was_url
+        self.env.account.conn.make_request('GET')
+        try:
+            self.assert_status(404)
+        finally:
+            self.env.account.conn.storage_url = was_url
+
     def testPUT(self):
         self.env.account.conn.make_request('PUT')
         self.assert_status([403, 405])

test/unit/auth/test_server.py

@@ -241,8 +241,9 @@ class TestAuthServer(unittest.TestCase):
             len(set(repr(a) for a in cfaccounts) - set(failed)), 2)
 
     def test_auth_bad_path(self):
-        self.assertRaises(ValueError, self.controller.handle_auth,
+        res = self.controller.handle_auth(
             Request.blank('', environ={'REQUEST_METHOD': 'GET'}))
+        self.assertEquals(res.status_int, 400)
         res = self.controller.handle_auth(Request.blank('/bad',
                 environ={'REQUEST_METHOD': 'GET'}))
         self.assertEquals(res.status_int, 400)

test/unit/common/middleware/test_ratelimit.py

@@ -366,6 +366,26 @@ class TestRateLimit(unittest.TestCase):
         time_took = time.time() - begin
         self.assert_(round(time_took, 1) == .4)
 
+    def test_call_invalid_path(self):
+        env = {'REQUEST_METHOD': 'GET',
+               'SCRIPT_NAME': '',
+               'PATH_INFO': '//v1/AUTH_1234567890',
+               'SERVER_NAME': '127.0.0.1',
+               'SERVER_PORT': '80',
+               'swift.cache': FakeMemcache(),
+               'SERVER_PROTOCOL': 'HTTP/1.0'}
+
+        app = lambda *args, **kwargs: None
+        rate_mid = ratelimit.RateLimitMiddleware(app, {},
+                                                 logger=FakeLogger())
+
+        class a_callable(object):
+
+            def __call__(self, *args, **kwargs):
+                pass
+        resp = rate_mid.__call__(env, a_callable())
+        self.assert_('404 Not Found' in resp[0])
+
 
 if __name__ == '__main__':
     unittest.main()

test/unit/container/test_server.py

@@ -479,18 +479,20 @@ class TestContainerController(unittest.TestCase):
         resp = self.controller.GET(req)
         self.assertEquals(resp.status_int, 412)
 
-    def test_GET_format(self):
+    def test_GET_json(self):
         # make a container
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT',
+        req = Request.blank('/sda1/p/a/jsonc', environ={'REQUEST_METHOD': 'PUT',
             'HTTP_X_TIMESTAMP': '0'})
         resp = self.controller.PUT(req)
         # test an empty container
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'})
+        req = Request.blank('/sda1/p/a/jsonc?format=json',
+            environ={'REQUEST_METHOD': 'GET'})
         resp = self.controller.GET(req)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEquals(resp.status_int, 200)
+        self.assertEquals(eval(resp.body), [])
         # fill the container
         for i in range(3):
-            req = Request.blank('/sda1/p/a/c/%s'%i, environ=
+            req = Request.blank('/sda1/p/a/jsonc/%s'%i, environ=
                     {'REQUEST_METHOD': 'PUT',
                     'HTTP_X_TIMESTAMP': '1',
                     'HTTP_X_CONTENT_TYPE': 'text/plain',
@@ -514,8 +516,88 @@ class TestContainerController(unittest.TestCase):
                     "bytes":0,
                     "content_type":"text/plain",
                     "last_modified":"1970-01-01T00:00:01"}]
+
+        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)
+
+        for accept in ('application/json', 'application/json;q=1.0,*/*;q=0.9',
+                 '*/*;q=0.9,application/json;q=1.0', 'application/*'):
+            req = Request.blank('/sda1/p/a/jsonc',
+                    environ={'REQUEST_METHOD': 'GET'})
+            req.accept = accept
+            resp = self.controller.GET(req)
+            self.assertEquals(eval(resp.body), json_body,
+                'Invalid body for Accept: %s' % accept)
+            self.assertEquals(resp.content_type, 'application/json',
+                'Invalid content_type for Accept: %s' % accept)
+
+    def test_GET_plain(self):
+        # make a container
+        req = Request.blank('/sda1/p/a/plainc', environ={'REQUEST_METHOD': 'PUT',
+            'HTTP_X_TIMESTAMP': '0'})
+        resp = self.controller.PUT(req)
+        # test an empty container
+        req = Request.blank('/sda1/p/a/plainc', environ={'REQUEST_METHOD': 'GET'})
+        resp = self.controller.GET(req)
+        self.assertEquals(resp.status_int, 204)
+        # fill the container
+        for i in range(3):
+            req = Request.blank('/sda1/p/a/plainc/%s'%i, environ=
+                    {'REQUEST_METHOD': 'PUT',
+                    'HTTP_X_TIMESTAMP': '1',
+                    '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)
+        plain_body = '0\n1\n2\n'
+
+        req = Request.blank('/sda1/p/a/plainc',
+                environ={'REQUEST_METHOD': 'GET'})
+        resp = self.controller.GET(req)
+        self.assertEquals(resp.content_type, 'text/plain')
+        self.assertEquals(resp.body, plain_body)
+
+        for accept in ('', 'text/plain', 'application/xml;q=0.8,*/*;q=0.9',
+                '*/*;q=0.9,application/xml;q=0.8', '*/*',
+                'text/plain,application/xml'):
+            req = Request.blank('/sda1/p/a/plainc',
+                    environ={'REQUEST_METHOD': 'GET'})
+            req.accept = accept
+            resp = self.controller.GET(req)
+            self.assertEquals(resp.body, plain_body,
+                'Invalid body for Accept: %s' % accept)
+            self.assertEquals(resp.content_type, 'text/plain',
+                'Invalid content_type for Accept: %s' % accept)
+
+        # test conflicting formats
+        req = Request.blank('/sda1/p/a/plainc?format=plain',
+                environ={'REQUEST_METHOD': 'GET'})
+        req.accept = 'application/json'
+        resp = self.controller.GET(req)
+        self.assertEquals(resp.content_type, 'text/plain')
+        self.assertEquals(resp.body, plain_body)
+
+    def test_GET_xml(self):
+        # make a container
+        req = Request.blank('/sda1/p/a/xmlc', environ={'REQUEST_METHOD': 'PUT',
+            'HTTP_X_TIMESTAMP': '0'})
+        resp = self.controller.PUT(req)
+        # fill the container
+        for i in range(3):
+            req = Request.blank('/sda1/p/a/xmlc/%s'%i, environ=
+                    {'REQUEST_METHOD': 'PUT',
+                    'HTTP_X_TIMESTAMP': '1',
+                    '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)
         xml_body = '<?xml version="1.0" encoding="UTF-8"?>\n' \
-            '<container name="c">' \
+            '<container name="xmlc">' \
                 '<object><name>0</name><hash>x</hash><bytes>0</bytes>' \
                     '<content_type>text/plain</content_type>' \
                     '<last_modified>1970-01-01T00:00:01' \
@@ -529,46 +611,30 @@ class TestContainerController(unittest.TestCase):
                     '<last_modified>1970-01-01T00:00:01' \
                     '</last_modified></object>' \
             '</container>'
-        plain_body = '0\n1\n2\n'
-        req = Request.blank('/sda1/p/a/c?format=json', environ={'REQUEST_METHOD': 'GET'})
-        resp = self.controller.GET(req)
-        self.assertEquals(resp.content_type, 'application/json')
-        result = eval(resp.body)
-        self.assertEquals(result, json_body)
-        req = Request.blank('/sda1/p/a/c?format=xml', environ={'REQUEST_METHOD': 'GET'})
+        # tests
+        req = Request.blank('/sda1/p/a/xmlc?format=xml',
+                environ={'REQUEST_METHOD': 'GET'})
         resp = self.controller.GET(req)
         self.assertEquals(resp.content_type, 'application/xml')
-        result = resp.body
-        self.assertEquals(result, xml_body)
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'})
-        req.accept = 'application/json'
+        self.assertEquals(resp.body, xml_body)
+
+        for xml_accept in ('application/xml', 'application/xml;q=1.0,*/*;q=0.9',
+                 '*/*;q=0.9,application/xml;q=1.0', 'application/xml,text/xml'):
+            req = Request.blank('/sda1/p/a/xmlc',
+                    environ={'REQUEST_METHOD': 'GET'})
+            req.accept = xml_accept
+            resp = self.controller.GET(req)
+            self.assertEquals(resp.body, xml_body,
+                'Invalid body for Accept: %s' % xml_accept)
+            self.assertEquals(resp.content_type, 'application/xml',
+                'Invalid content_type for Accept: %s' % xml_accept)
+
+        req = Request.blank('/sda1/p/a/xmlc',
+                environ={'REQUEST_METHOD': 'GET'})
+        req.accept = 'text/xml'
         resp = self.controller.GET(req)
-        self.assertEquals(resp.content_type, 'application/json')
-        result = eval(resp.body)
-        self.assertEquals(result, json_body)
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'})
-        req.accept = '*/*'
-        resp = self.controller.GET(req)
-        self.assertEquals(resp.content_type, 'text/plain')
-        result = resp.body
-        self.assertEquals(result, plain_body)
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'})
-        req.accept = 'application/*'
-        resp = self.controller.GET(req)
-        result = eval(resp.body)
-        self.assertEquals(result, json_body)
-        req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'})
-        req.accept = 'application/xml'
-        resp = self.controller.GET(req)
-        result = resp.body
-        self.assertEquals(result, xml_body)
-        # test conflicting formats
-        req = Request.blank('/sda1/p/a/c?format=plain', environ={'REQUEST_METHOD': 'GET'})
-        req.accept = 'application/json'
-        resp = self.controller.GET(req)
-        self.assertEquals(resp.content_type, 'text/plain')
-        result = resp.body
-        self.assertEquals(result, plain_body)
+        self.assertEquals(resp.content_type, 'text/xml')
+        self.assertEquals(resp.body, xml_body)
 
     def test_GET_marker(self):
         # make a container