def test_delete_properties(self):
api = self.api
name = utils.random_string()
properties = [utils.random_string()]
resp = fakes.FakeResponse()
api._request = Mock(return_value=(resp, None))
api.del_properties(self.account, name, properties)
uri = "%s/reference/del_properties" % self.uri_base
params = {'acct': self.account, 'ref': name}
data = json.dumps(properties)
api._request.assert_called_once_with(
'POST', uri, data=data, params=params, headers=None)
def test_renew(self):
api = self.api
name = utils.random_string()
service_type = utils.random_string()
resp = fakes.FakeResponse()
api._request = Mock(return_value=(resp, None))
api.renew(self.account, name, service_type)
uri = "%s/reference/renew" % self.uri_base
params = {'acct': self.account, 'ref': name,
'type': service_type}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=None)
def test_force(self):
api = self.api
name = utils.random_string()
service_type = utils.random_string()
services = {'seq': 1, 'type': service_type, 'host': '127.0.0.1:8000'}
resp = fakes.FakeResponse()
api._request = Mock(return_value=(resp, None))
api.force(self.account, name, service_type, services)
uri = "%s/reference/force" % self.uri_base
params = {'acct': self.account, 'ref': name,
'type': service_type}
data = json.dumps(services)
api._request.assert_called_once_with(
'POST', uri, data=data, params=params, headers=None)
def test_object_delete_not_found(self):
api = self.api
name = utils.random_string()
api._request = Mock(side_effect=exceptions.NotFound("No object"))
self.assertRaises(
exceptions.NoSuchObject, api.object_delete, self.account,
self.container, name)
def setUp(self):
self.api = fakes.FakeStorageAPI("NS", "http://1.2.3.4:8000")
self.account = "test"
self.container = "fake"
self.headers = {"x-req-id": utils.random_string()}
self.policy = "THREECOPIES"
self.uri_base = "NS"
def test_container_update(self):
api = self.api
name = utils.random_string()
key = utils.random_string()
value = utils.random_string()
meta = {key: value}
resp = fakes.FakeResponse()
api._request = Mock(return_value=(resp, None))
api.container_update(self.account, name, meta, headers=self.headers)
data = json.dumps(meta)
uri = "%s/container/set_properties" % self.uri_base
params = {'acct': self.account, 'ref': name}
api._request.assert_called_once_with(
'POST', uri, data=data, params=params, headers=self.headers)
def test_object_create_no_content_length(self):
api = self.api
name = utils.random_string()
f = Mock()
self.assertRaises(
exceptions.MissingContentLength, api.object_create, self.account,
self.container, f, obj_name=name)
def test_container_metadata(self):
key = "user." + utils.random_string()
key2 = "user." + utils.random_string()
value = utils.random_string()
meta = {key: value}
self.storage.container_update(self.account, self.container_name, meta)
rmeta = self.storage.container_show(self.account, self.container_name)
self.assertEqual(rmeta.get(key), value)
self.storage.container_update(self.account, self.container_name,
{key2: value},
True)
rmeta = self.storage.container_show(self.account, self.container_name)
self.assertEqual(rmeta.get(key), None)
self.assertEqual(rmeta.get(key2), value)
self.assertTrue(rmeta.get("sys.m2.usage"))
self.assertTrue(rmeta.get("sys.m2.ctime"))
def test_handle_container_not_found(self):
@handle_container_not_found
def test(self, account, container):
raise exceptions.NotFound("No container")
container = utils.random_string()
self.assertRaises(
exceptions.NoSuchContainer, test, self, self.account, container)
def test_handle_object_not_found(self):
@handle_object_not_found
def test(self, account, container, obj):
raise exceptions.NotFound("No object")
obj = utils.random_string()
self.assertRaises(
exceptions.NoSuchObject, test, self, self.account, self.container,
obj)
def test_create_error(self):
api = self.api
name = utils.random_string()
resp = fakes.FakeResponse()
resp.status_code = 300
api._request = Mock(return_value=(resp, None))
self.assertRaises(exceptions.ClientException, api.create, self.account,
name)
def test_list(self):
api = self.api
name = utils.random_string()
service_type = utils.random_string()
resp = fakes.FakeResponse()
resp_body = [{"seq": 1,
"type": service_type,
"host": "127.0.0.1:6000",
"args": ""}]
api._request = Mock(return_value=(resp, resp_body))
l = api.list_services(self.account, name, service_type)
uri = "%s/reference/show" % self.uri_base
params = {'acct': self.account, 'ref': name,
'type': service_type}
api._request.assert_called_once_with(
'GET', uri, params=params, headers=None)
self.assertEqual(l, resp_body)
def test_container_create_exist(self):
api = self.api
resp = fakes.FakeResponse()
resp.status_code = 201
api._request = Mock(return_value=(resp, None))
name = utils.random_string()
result = api.container_create(self.account, name)
self.assertEqual(result, False)
def test_container_delete_not_empty(self):
api = self.api
api._request = Mock(side_effect=exceptions.Conflict(""))
api.directory.unlink = Mock(return_value=None)
name = utils.random_string()
self.assertRaises(
exceptions.ContainerNotEmpty, api.container_delete, self.account,
name)
def test_has(self):
api = self.api
resp = fakes.FakeResponse()
name = utils.random_string()
api._request = Mock(return_value=(resp, None))
uri = "%s/reference/has" % self.uri_base
params = {'acct': self.account, 'ref': name}
self.assertTrue(api.has(self.account, name))
api._request.assert_called_once_with(
'GET', uri, params=params, headers=None)
def test_object_store(self):
api = self.api
name = utils.random_string()
raw_chunks = [
{"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 32},
{"url": "http://1.2.3.4:6000/BBBB", "pos": "1", "size": 32},
{"url": "http://1.2.3.4:6000/CCCC", "pos": "2", "size": 32}
]
meta = {object_headers['id']: utils.random_string(),
object_headers['policy']: self.policy,
object_headers['mime_type']: "octet/stream",
object_headers['chunk_method']: "bytes",
object_headers['version']: utils.random_string()}
api._content_prepare = Mock(return_value=(meta, raw_chunks))
api._content_create = Mock(return_value=({}, {}))
with set_http_connect(201, 201, 201):
api.object_create(
self.account, self.container, obj_name=name, data="x",
headers=self.headers)
def test_create_already_exists(self):
api = self.api
name = utils.random_string()
resp = fakes.FakeResponse()
resp.status_code = 200
api._request = Mock(return_value=(resp, None))
api.create(self.account, name)
uri = "%s/reference/create" % self.uri_base
params = {'acct': self.account, 'ref': name}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=None)
def test_container_list(self):
resp = fakes.FakeResponse()
name = utils.random_string()
marker = utils.random_string()
delimiter = utils.random_string()
end_marker = utils.random_string()
prefix = utils.random_string()
limit = random.randint(1, 1000)
body = {"listing": [[name, 0, 0, 0]]}
self.api._request = Mock(return_value=(resp, body))
self.api._get_account_url = Mock(return_value='fake_endpoint')
containers, meta = self.api.container_list(
self.account, limit=limit, marker=marker, prefix=prefix,
delimiter=delimiter, end_marker=end_marker, headers=self.headers)
params = {"id": self.account, "prefix": prefix, "delimiter": delimiter,
"marker": marker, "end_marker": end_marker, "limit": limit}
uri = "v1.0/account/containers"
self.api._request.assert_called_once_with(
'GET', uri, endpoint='fake_endpoint', params=params,
headers=self.headers)
self.assertEqual(len(containers), 1)
def test_object_show(self):
api = self.api
name = utils.random_string()
size = random.randint(1, 1000)
content_hash = utils.random_string()
content_type = utils.random_string()
resp = fakes.FakeResponse()
resp.headers = {object_headers["name"]: name,
object_headers["size"]: size,
object_headers["hash"]: content_hash,
object_headers["mime_type"]: content_type}
api._request = Mock(return_value=(resp, {}))
obj = api.object_show(
self.account, self.container, name, headers=self.headers)
uri = "%s/content/get_properties" % self.uri_base
params = {'acct': self.account, 'ref': self.container,
'path': name}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=self.headers)
self.assertIsNotNone(obj)
def test_put_stream_connect_exception(self):
api = self.api
name = utils.random_string()
chunks = {
0: [
{"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 32},
{"url": "http://1.2.3.4:6000/BBBB", "pos": "0", "size": 32},
{"url": "http://1.2.3.4:6000/CCCC", "pos": "0", "size": 32}
]
}
src = empty_stream()
sysmeta = {'content_length': 0,
'id': utils.random_string(),
'version': utils.random_string(),
'mime_type': utils.random_string(),
'chunk_method': utils.random_string(),
'policy': utils.random_string()}
with set_http_connect(201, Exception(), Exception()):
chunks, bytes_transferred, content_checksum = api._put_stream(
self.account, self.container, name, src, sysmeta, chunks)
self.assertEqual(len(chunks), 1)
chunk = {"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 0,
"hash": "d41d8cd98f00b204e9800998ecf8427e"}
self.assertEqual(chunk, chunks[0])
def test_object_metadata(self):
key = utils.random_string()
value = utils.random_string()
meta = {key: value}
self.storage.object_update(self.account, self.container_name,
self.object_name, meta)
rmeta = self.storage.object_show(self.account, self.container_name,
self.object_name)
self.assertEqual(rmeta['properties'].get(key), value)
key2 = utils.random_string()
value2 = utils.random_string()
meta2 = {key2: value2}
self.storage.object_update(self.account, self.container_name,
self.object_name, meta2, clear=True)
rmeta = self.storage.object_show(self.account, self.container_name,
self.object_name)
self.assertEqual(rmeta['properties'].get(key), None)
self.assertEqual(rmeta['properties'].get(key2), value2)
self.assertEqual(rmeta.get("name"), self.object_name)
self.assertEqual(rmeta.get("hash"), self.hash_data)
self.assertEqual(rmeta.get("length"), "40")
self.assertTrue(rmeta.get("mime-type"))
def test_container_delete(self):
api = self.api
resp = fakes.FakeResponse()
resp.status_code = 204
api._request = Mock(return_value=(resp, None))
api.directory.unlink = Mock(return_value=None)
name = utils.random_string()
api.container_delete(self.account, name, headers=self.headers)
uri = "%s/container/destroy" % self.uri_base
params = {'acct': self.account, 'ref': name}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=self.headers)
def test_container_show(self):
api = self.api
resp = fakes.FakeResponse()
name = utils.random_string()
cont_size = random.randint(1, 1000)
resp.headers = {
container_headers["size"]: cont_size
}
api._request = Mock(return_value=(resp, {}))
info = api.container_show(self.account, name, headers=self.headers)
uri = "%s/container/get_properties" % self.uri_base
params = {'acct': self.account, 'ref': name}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=self.headers)
self.assertEqual(info, {})
def test_container_create(self):
api = self.api
resp = fakes.FakeResponse()
resp.status_code = 204
api._request = Mock(return_value=(resp, None))
name = utils.random_string()
result = api.container_create(self.account, name, headers=self.headers)
self.assertEqual(result, True)
uri = "%s/container/create" % self.uri_base
params = {'acct': self.account, 'ref': name}
self.headers['x-oio-action-mode'] = 'autocreate'
api._request.assert_called_once_with(
'POST', uri, params=params, headers=self.headers)
def test_object_delete(self):
api = self.api
name = utils.random_string()
resp_body = [
{"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 32},
{"url": "http://1.2.3.4:6000/BBBB", "pos": "1", "size": 32},
{"url": "http://1.2.3.4:6000/CCCC", "pos": "2", "size": 32}
]
api._request = Mock(return_value=(None, resp_body))
api.object_delete(
self.account, self.container, name, headers=self.headers)
uri = "%s/content/delete" % self.uri_base
params = {'acct': self.account, 'ref': self.container,
'path': name}
api._request.assert_called_once_with(
'POST', uri, params=params, headers=self.headers)
def test_put_stream_connect_timeout(self):
api = self.api
name = utils.random_string()
chunks = {
0: [
{"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 32}
]
}
src = empty_stream()
sysmeta = {'content_length': 0,
'id': utils.random_string(),
'version': utils.random_string(),
'mime_type': utils.random_string(),
'chunk_method': utils.random_string(),
'policy': utils.random_string()}
with set_http_connect(200, slow_connect=True):
chunks, bytes_transferred, content_checksum = api._put_stream(
self.account, self.container, name, src, sysmeta, chunks)
def test_put_stream_client_timeout(self):
api = self.api
name = utils.random_string()
chunks = {
0: [
{"url": "http://1.2.3.4:6000/AAAA", "pos": "0", "size": 32}
]
}
src = fakes.FakeTimeoutStream(5)
sysmeta = {'content_length': 0,
'id': utils.random_string(),
'version': utils.random_string(),
'mime_type': utils.random_string(),
'chunk_method': utils.random_string(),
'policy': utils.random_string()}
with set_http_connect(200):
self.assertRaises(
exceptions.ClientReadTimeout, api._put_stream, self.account,
self.container, name, src, sysmeta, chunks)
def test_object_list(self):
api = self.api
marker = utils.random_string()
delimiter = utils.random_string()
end_marker = utils.random_string()
prefix = utils.random_string()
limit = random.randint(1, 1000)
name0 = utils.random_string()
name1 = utils.random_string()
resp_body = {"objects": [{"name": name0}, {"name": name1}]}
api._request = Mock(return_value=(None, resp_body))
l = api.object_list(
self.account, self.container, limit=limit, marker=marker,
prefix=prefix, delimiter=delimiter, end_marker=end_marker,
headers=self.headers)
uri = "%s/container/list" % self.uri_base
params = {'acct': self.account, 'ref': self.container,
'marker': marker, 'max': limit,
'delimiter': delimiter, 'prefix': prefix,
'end_marker': end_marker}
api._request.assert_called_once_with(
'GET', uri, params=params, headers=self.headers)
self.assertEqual(len(l['objects']), 2)
def test_object_create_no_data(self):
api = self.api
name = utils.random_string()
self.assertRaises(exceptions.MissingData, api.object_create,
self.account, self.container, obj_name=name)
def test_object_create_missing_file(self):
api = self.api
name = utils.random_string()
self.assertRaises(
exceptions.FileNotFound, api.object_create, self.account,
self.container, name)
