def test_delete_object_versions_with_invalid_arguments(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-delete-object-versions"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
config = BucketVersioningConfig()
config.status = 'Enabled'
bucket.put_bucket_versioning(config)
wait_meta_sync()
version_list = BatchDeleteObjectVersionList()
version_list.append(BatchDeleteObjectVersion('test-key', '234'))
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.delete_object_versions, version_list)
self.assertRaises(oss2.exceptions.ClientError,
bucket.delete_object_versions, None)
self.assertRaises(oss2.exceptions.ClientError,
bucket.delete_object_versions, [])
def setUp(self):
OssTestCase.setUp(self)
self.endpoint = OSS_ENDPOINT
bucket_name = OSS_BUCKET + "-test-request-payment-versionging"
policy_text = ''
policy_text += '{'
policy_text += '"Version":"1",'
policy_text += '"Statement":[{'
policy_text += '"Action":["oss:*"],'
policy_text += '"Effect":"Allow",'
policy_text += '"Principal":["{0}"],'.format(OSS_PAYER_UID)
policy_text += '"Resource": ["acs:oss:*:*:{0}","acs:oss:*:*:{0}/*"]'.format(
bucket_name)
policy_text += '}]}'
auth = oss2.Auth(OSS_ID, OSS_SECRET)
self.owner_bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
self.owner_bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
self.owner_bucket.put_bucket_policy(policy_text)
# Enable bucket request payment
result = self.owner_bucket.put_bucket_request_payment(PAYER_REQUESTER)
self.assertEqual(result.status, 200)
self.payer_bucket = oss2.Bucket(
oss2.Auth(OSS_PAYER_ID, OSS_PAYER_SECRET), self.endpoint,
bucket_name)
# Enable bucket versioning
config = BucketVersioningConfig()
config.status = oss2.BUCKET_VERSIONING_ENABLE
self.owner_bucket.put_bucket_versioning(config)
self.assertEqual(result.status, 200)
def test_bucket_versioning(self):
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket = oss2.Bucket(auth, OSS_ENDPOINT, random_string(63).lower())
self.assertRaises(oss2.exceptions.NoSuchBucket, bucket.get_bucket_info)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
result = bucket.get_bucket_versioning()
self.assertTrue(result.status is None)
config = BucketVersioningConfig()
config.status = oss2.BUCKET_VERSIONING_ENABLE
result = bucket.put_bucket_versioning(config)
self.assertEqual(int(result.status) / 100, 2)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(result.bucket_encryption_rule.ssealgorithm, None)
self.assertEqual(result.versioning_status, 'Enabled')
config.status = oss2.BUCKET_VERSIONING_SUSPEND
result = bucket.put_bucket_versioning(config)
self.assertEqual(int(result.status) / 100, 2)
bucket.delete_bucket()
def test_batch_delete_same_object_multi_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-batch-delete-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status)/100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status)/100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put version 2
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status)/100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
version_list = BatchDeleteObjectVersionList()
version_list.append(BatchDeleteObjectVersion(key="test", versionid=versionid1))
version_list.append(BatchDeleteObjectVersion(key="test", versionid=versionid2))
self.assertTrue(version_list.len(), 2)
result = bucket.delete_object_versions(version_list)
self.assertTrue(len(result.delete_versions) == 2)
self.assertTrue(result.delete_versions[0].versionid == versionid1
or result.delete_versions[0].versionid == versionid2)
self.assertTrue(result.delete_versions[1].versionid == versionid1
or result.delete_versions[1].versionid == versionid2)
result = bucket.delete_object_versions(version_list)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_resumable_download_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-resumable-download-with-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
key = "test_resumable_download_with_version-object"
content_version1 = random_bytes(5 * 1024)
content_version2 = random_bytes(5 * 1024 * 1024)
# Put object version1
result = bucket.put_object(key, content_version1)
versionid1 = result.versionid
# Put object version2
result = bucket.put_object(key, content_version2)
versionid2 = result.versionid
# Resumable download object verison1, and check file length.
filename = self.random_filename()
oss2.resumable_download(bucket,
key,
filename,
params={'versionId': versionid1})
self.assertFileContent(filename, content_version1)
# Resumable download object verison2, and check file length.
filename = self.random_filename()
oss2.resumable_download(bucket,
key,
filename,
params={'versionId': versionid2})
self.assertFileContent(filename, content_version2)
version_list = BatchDeleteObjectVersionList()
version_list.append(BatchDeleteObjectVersion(key, versionid1))
version_list.append(BatchDeleteObjectVersion(key, versionid2))
result = bucket.delete_object_versions(version_list)
self.assertTrue(len(result.delete_versions) == 2)
bucket.delete_bucket()
def test_list_object_versions_wrong(self):
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-list-object-versions-wrong"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
self.assertRaises(oss2.exceptions.NoSuchBucket, bucket.get_bucket_info)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = "Enabled"
result = bucket.put_bucket_versioning(config)
self.assertEqual(int(result.status) / 100, 2)
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
versionid1 = result.versionid
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status) / 100, 2)
versionid2 = result.versionid
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.list_object_versions,
prefix=1025 * 'a')
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.list_object_versions,
key_marker=1025 * 'a')
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.list_object_versions,
versionid_marker=1025 * 'a')
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.list_object_versions,
delimiter=1025 * 'a')
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.list_object_versions,
max_keys=1001)
result = bucket.list_object_versions()
self.assertEqual(len(result.versions), 2)
self.assertEqual(result.versions[0].versionid, versionid2)
self.assertEqual(result.versions[1].versionid, versionid1)
self.assertEqual(len(result.delete_marker), 0)
bucket.delete_object("test", {"versionId": versionid1})
bucket.delete_object("test", {"versionId": versionid2})
bucket.delete_bucket()
def test_multipart_with_versionging(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
from oss2.utils import calc_obj_crc_from_parts
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-multipart-with-versionging"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status)/100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
key = self.random_key()
content = random_bytes(128 * 1024)
parts = []
upload_id = bucket.init_multipart_upload(key).upload_id
headers = {'Content-Md5': oss2.utils.content_md5(content)}
result = bucket.upload_part(key, upload_id, 1, content, headers=headers)
parts.append(oss2.models.PartInfo(1, result.etag, size=len(content), part_crc=result.crc))
self.assertTrue(result.crc is not None)
complete_result = bucket.complete_multipart_upload(key, upload_id, parts)
object_crc = calc_obj_crc_from_parts(parts)
self.assertTrue(complete_result.crc is not None)
self.assertEqual(object_crc, result.crc)
self.assertTrue(complete_result.versionid is not None)
bucket.delete_object(key, params={'versionId': complete_result.versionid})
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_bucket_versioning_wrong(self):
from oss2.models import BucketVersioningConfig
config = BucketVersioningConfig()
self.assertRaises(oss2.exceptions.MalformedXml,
self.bucket.put_bucket_versioning, config)
config.status = "Disabled"
self.assertRaises(oss2.exceptions.MalformedXml,
self.bucket.put_bucket_versioning, config)
def test_resumable_download_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-resumable-download-with-version"
bucket = oss2.Bucket(auth, OSS_ENDPOINT, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
self.version_bucket = bucket
content_small = random_bytes(5 * 1024)
result = bucket.put_object("object_small", content_small)
version_small = result.versionid
filename_small = self.random_filename()
result = oss2.resumable_download(bucket, "object_small",
filename_small)
self.assertFileContent(filename_small, content_small)
content_big = random_bytes(5 * 1024 * 1024)
result = bucket.put_object("object_big", content_big)
version_big = result.versionid
filename_big = self.random_filename()
result = oss2.resumable_download(bucket, "object_big", filename_big)
self.assertFileContent(filename_big, content_big)
version_list = BatchDeleteObjectVersionList()
version_list.append(
BatchDeleteObjectVersion("object_small", version_small))
version_list.append(BatchDeleteObjectVersion("object_big",
version_big))
result = bucket.delete_object_versions(version_list)
self.assertTrue(len(result.delete_versions) == 2)
bucket.delete_bucket()
def test_update_metadata_versioning(self):
object_name = "test-object"
# test normal bucket
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-update-metadata"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
bucket.put_object(object_name, "123")
result = bucket.head_object(object_name)
self.assertEqual("application/octet-stream", result.content_type)
headers = {"Content-Type": "text/plain"}
bucket.update_object_meta(object_name, headers)
result = bucket.head_object(object_name)
self.assertEqual("text/plain", result.content_type)
headers = None
bucket.update_object_meta(object_name, headers)
result = bucket.head_object(object_name)
self.assertEqual("text/plain", result.content_type)
# test versioning bucket
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-update-metadata-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.versioning_status, "Enabled")
result = bucket.put_object(object_name, "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
result = bucket.head_object(object_name)
self.assertEqual("application/octet-stream", result.content_type)
headers = {"Content-Type": "text/plain"}
bucket.update_object_meta(object_name, headers)
result = bucket.head_object(object_name)
self.assertEqual("text/plain", result.content_type)
def test_bucket_versioning_wrong(self):
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-bucket-versioning-wrong"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
config = BucketVersioningConfig()
self.assertRaises(oss2.exceptions.MalformedXml,
bucket.put_bucket_versioning, config)
config.status = "Disabled"
self.assertRaises(oss2.exceptions.MalformedXml,
bucket.put_bucket_versioning, config)
def test_restore_object_with_version(self):
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-restore-object-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(
oss2.BUCKET_ACL_PRIVATE,
oss2.models.BucketCreateConfig(oss2.BUCKET_STORAGE_CLASS_ARCHIVE))
service = oss2.Service(auth, OSS_ENDPOINT)
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
self.retry_assert(lambda: bucket.bucket_name in (
b.name
for b in service.list_buckets(prefix=bucket.bucket_name).buckets))
key = 'a.txt'
result = bucket.put_object(key, 'content_version1')
self.assertEqual(202, bucket.restore_object(key).status)
version1 = result.versionid
result = bucket.put_object(key, 'content_version2')
version2 = result.versionid
result = bucket.restore_object(key, params={'versionId': version2})
self.assertEqual(202, result.status)
bucket.delete_object(key, params={'versionId': version1})
bucket.delete_object(key, params={'versionId': version2})
bucket.delete_bucket()
def test_head_object_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-head-object-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
# put "test" version 1
result = bucket.put_object("test_no_version", "test")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid is None)
try:
result_exception = bucket.head_object(
"test_no_version", params={"versionId": "IllegalVersion"})
self.assertFalse(True, "should get a exception")
except:
pass
bucket.delete_object("test_no_version")
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put "test" version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put "test" version 2
headers = {}
headers['x-oss-storage-class'] = oss2.BUCKET_STORAGE_CLASS_ARCHIVE
result = bucket.put_object("test", "test2", headers=headers)
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
try:
result_exception = bucket.head_object("test",
params={"versionId": None})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_normal = bucket.head_object("test",
params={"versionId": ''})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.head_object(
"test_no_version", params={"versionId": "IllegalVersion"})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.head_object(
"test",
params={
"versionId":
"CAEQJhiBgIDVmYrr1RYiIGE5ZmUxMjViZDIwYjQwY2I5ODA1YWIxNmIyNDNjYjk4"
})
self.assertFalse(True, "should get a exception")
except:
pass
result1 = bucket.head_object("test", params={"versionId": versionid1})
result2 = bucket.head_object("test", params={"versionId": versionid2})
result3 = bucket.head_object("test")
self.assertEqual(result2.versionid, result3.versionid)
self.assertEqual(result1.object_type, result2.object_type)
self.assertEqual(result1.content_type, result2.content_type)
self.assertEqual(result1.content_length, result2.content_length)
self.assertTrue(result1.etag != result2.etag)
delete_result = bucket.delete_object("test")
delete_marker_versionid = delete_result.versionid
try:
result3 = bucket.head_object(
"test", params={'versionId': delete_marker_versionid})
self.assertFalse(True, "should get a exception, but not")
except:
pass
version_list = BatchDeleteObjectVersionList()
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid1))
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid2))
version_list.append(
BatchDeleteObjectVersion(key="test",
versionid=delete_marker_versionid))
self.assertTrue(version_list.len(), 3)
result = bucket.delete_object_versions(version_list)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_list_object_versions_truncated(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-list-object-versions-truncated"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
bucket.put_object("test_dir/sub_dir1/test_object",
"test-subdir-content")
bucket.put_object("test_dir/sub_dir2/test_object",
"test-subdir-content")
for i in range(0, 50):
bucket.put_object("test_dir/test_object", "test" + str(i))
versions_count = 0
common_prefixes_count = 0
loop_time = 0
next_key_marker = ''
next_version_marker = ''
# List object versions truncated with prefix and delimiter arguments.
while True:
# It will list objects that under test_dir, and not contains subdirectorys
result = bucket.list_object_versions(
max_keys=20,
prefix='test_dir/',
delimiter='/',
key_marker=next_key_marker,
versionid_marker=next_version_marker)
self.assertTrue(len(result.versions) > 0)
self.assertTrue(len(result.delete_marker) == 0)
versions_count += len(result.versions)
common_prefixes_count += len(result.common_prefix)
if result.is_truncated:
next_key_marker = result.next_key_marker
next_version_marker = result.next_versionid_marker
else:
break
loop_time += 1
if loop_time > 12:
self.assertFalse(True, "loop too much times, break")
self.assertEqual(versions_count, 50)
self.assertEqual(common_prefixes_count, 2)
# Create a delete marker
bucket.delete_object("test_dir/sub_dir1/test_object")
# List all objects to delete, and it will contains 52 objects and 1 delete marker.
all_objects = bucket.list_object_versions()
self.assertEqual(len(all_objects.versions), 52)
self.assertEqual(len(all_objects.delete_marker), 1)
for obj in all_objects.versions:
bucket.delete_object(obj.key, params={'versionId': obj.versionid})
for del_maker in all_objects.delete_marker:
bucket.delete_object(del_maker.key,
params={'versionId': del_maker.versionid})
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_list_object_versions_truncated(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = random_string(63).lower()
bucket = oss2.Bucket(auth, OSS_ENDPOINT, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.ssealgorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
for i in range(0, 1024):
bucket.put_object("test", "test" + str(i))
loop_time = 0
next_key_marker = ''
next_version_marker = ''
delete_versions = []
while True:
result = bucket.list_object_versions(
key_marker=next_key_marker,
versionid_marker=next_version_marker)
self.assertTrue(len(result.versions) > 0)
self.assertTrue(len(result.delete_marker) == 0)
version_list = BatchDeleteObjectVersionList()
for item in result.versions:
version_list.append(
BatchDeleteObjectVersion(item.key, item.versionid))
delete_versions.append(version_list)
if result.is_truncated:
next_key_marker = result.next_key_marker
next_version_marker = result.next_versionid_marker
else:
break
loop_time += 1
if loop_time > 12:
self.assertFalse(True, "loop too much times, break")
for item in delete_versions:
result = bucket.delete_object_versions(item)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_upload_part_copy_with_versioning(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-upload-part-copy-with-versioning"
bucket = oss2.Bucket(auth, OSS_ENDPOINT, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status)/100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
src_object = self.random_key()
dst_object = self.random_key()
content = random_bytes(200 * 1024)
content2 = random_bytes(200 * 1024)
# 上传源文件 version1
put_result1 = bucket.put_object(src_object, content)
self.assertTrue(put_result1.versionid is not None)
versionid1 = put_result1.versionid
# 上传源文件 version2
put_result2 = bucket.put_object(src_object, content2)
self.assertTrue(put_result2.versionid is not None)
versionid2 = put_result2.versionid
# part copy到目标文件
parts = []
upload_id = bucket.init_multipart_upload(dst_object).upload_id
result = bucket.upload_part_copy(bucket_name, src_object,
(0, 100 * 1024 - 1), dst_object, upload_id, 1)
parts.append(oss2.models.PartInfo(1, result.etag))
result = bucket.upload_part_copy(bucket_name, src_object,
(100*1024, None), dst_object, upload_id, 2, params={'versionId': versionid1})
parts.append(oss2.models.PartInfo(2, result.etag))
complete_result = bucket.complete_multipart_upload(dst_object, upload_id, parts)
# 验证
content_got = bucket.get_object(dst_object).read()
self.assertEqual(len(content_got), len(content))
self.assertTrue(content_got != content)
version_list = BatchDeleteObjectVersionList()
version_list.append(BatchDeleteObjectVersion(key=src_object, versionid=versionid1))
version_list.append(BatchDeleteObjectVersion(key=src_object, versionid=versionid2))
version_list.append(BatchDeleteObjectVersion(key=dst_object, versionid=complete_result.versionid))
self.assertTrue(version_list.len(), 3)
result = bucket.delete_object_versions(version_list)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_put_symlink_with_version(self):
from oss2.models import BucketVersioningConfig
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-put-symlink-with-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
result = bucket.put_object("test", "test")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid = result.versionid
object_version = result.versionid
params = dict()
params['versionId'] = result.versionid
result = bucket.put_symlink("test", "test_link")
self.assertEqual(int(result.status) / 100, 2)
params['versionId'] = result.versionid
result = bucket.get_symlink("test_link", params=params)
self.assertEqual(int(result.status) / 100, 2)
result = bucket.delete_object("test_link")
self.assertEqual(int(result.status), 204)
self.assertTrue(result.versionid != '')
delete_marker_versionid = result.versionid
try:
result = bucket.get_symlink("test_link")
except oss2.exceptions.NotFound:
pass
self.assertEqual(result.delete_marker, True)
result = bucket.delete_object("test_link", params=params)
self.assertEqual(int(result.status), 204)
params['versionId'] = delete_marker_versionid
result = bucket.delete_object("test_link", params=params)
self.assertEqual(int(result.status), 204)
params['versionId'] = object_version
result = bucket.delete_object("test", params=params)
self.assertEqual(int(result.status), 204)
bucket.delete_bucket()
def test_put_object_tagging_with_versioning(self):
from oss2.models import BucketVersioningConfig
from oss2.models import Tagging
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-put-object-tagging-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
self.assertTrue(versionid1 != versionid2)
tagging = Tagging()
tagging.tag_set.add('k1', 'v1')
tagging.tag_set.add('+++', ':::')
# put object tagging without version
result = bucket.put_object_tagging("test", tagging)
self.assertEqual(int(result.status) / 100, 2)
params = dict()
params['versionId'] = versionid2
result = bucket.get_object_tagging("test", params=params)
self.assertEqual(int(result.status) / 100, 2)
rule = result.tag_set.tagging_rule
self.assertEqual('v1', rule['k1'])
self.assertEqual(':::', rule['+++'])
tagging = Tagging()
tagging.tag_set.add('k2', 'v2')
tagging.tag_set.add(':::', '+++')
params['versionId'] = versionid1
# put object tagging with version
result = bucket.put_object_tagging("test", tagging, params=params)
self.assertEqual(int(result.status) / 100, 2)
result = bucket.get_object_tagging("test", params=params)
self.assertEqual(int(result.status) / 100, 2)
rule = result.tag_set.tagging_rule
self.assertEqual('v2', rule['k2'])
self.assertEqual('+++', rule[':::'])
result = bucket.delete_object_tagging("test", params=params)
self.assertEqual(int(result.status), 204)
params['versionId'] = versionid2
result = bucket.delete_object_tagging("test", params=params)
self.assertEqual(int(result.status), 204)
result = bucket.delete_object("test")
self.assertEqual(int(result.status), 204)
delete_marker_versionid = result.versionid
self.assertTrue(delete_marker_versionid is not None)
params['versionId'] = versionid2
try:
result = bucket.get_object("test", params=params)
self.assertFalse(True)
except:
pass
# delete 'DELETE' mark
bucket.delete_object("test",
params={'versionId': delete_marker_versionid})
bucket.delete_object("test", params={'versionId': versionid1})
bucket.delete_object("test", params={'versionId': versionid2})
bucket.delete_bucket()
def test_delete_object_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-delete-object-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
# put "test" version 1
result = bucket.put_object("test_no_version", "test")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid is None)
try:
result_exception = bucket.head_object(
"test_no_version", params={"versionId": "IllegalVersion"})
self.assertFalse(True, "should get a exception")
except:
pass
try:
bucket.delete_object("test_no_version", params={"versionId": None})
self.assertFalse(True, "should get a exception")
except:
pass
try:
bucket.delete_object("test_no_version", params={"versionId": ""})
self.assertFalse(True, "should get a exception")
except:
pass
bucket.delete_object("test_no_version")
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put "test" version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put "test" version 2
headers = {}
headers['x-oss-storage-class'] = oss2.BUCKET_STORAGE_CLASS_ARCHIVE
result = bucket.put_object("test", "test2", headers=headers)
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
bucket.delete_object("test", params={'versionId': versionid1})
bucket.delete_object("test", params={'versionId': versionid2})
bucket.delete_bucket()
def test_copy_object_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-copy-object-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put "test" version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put "test" version 2
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
try:
result_exception = bucket.copy_object(bucket_name,
"test",
"test_copy_wrong",
params={"versionId": None})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.copy_object(bucket_name,
"test",
"test_copy_wrong",
params={"versionId": ''})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.copy_object(
bucket_name,
"test",
"test_copy_wrong",
params={"versionId": 'NotExistVersionID'})
self.assertFalse(True, "should get a exception")
except:
pass
result = bucket.copy_object(bucket_name,
"test",
"test_copy",
params={'versionId': versionid1})
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
copy_versionid = result.versionid
version_list = BatchDeleteObjectVersionList()
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid1))
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid2))
version_list.append(
BatchDeleteObjectVersion(key="test_copy",
versionid=copy_versionid))
self.assertTrue(version_list.len(), 3)
result = bucket.delete_object_versions(version_list)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_batch_delete_objects_multi_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-batch-delete-objects-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put "test" version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put "test" version 2
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
# put "foo" version 1
result = bucket.put_object("foo", "bar")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
result = bucket.list_object_versions()
self.assertTrue(result.is_truncated == False)
self.assertTrue(result.key_marker == '')
self.assertTrue(result.versionid_marker == '')
self.assertTrue(result.next_key_marker == '')
self.assertTrue(result.next_versionid_marker == '')
self.assertTrue(result.name == bucket_name)
self.assertTrue(result.prefix == '')
self.assertTrue(result.delimiter == '')
self.assertTrue(len(result.delete_marker) == 0)
self.assertTrue(len(result.versions) == 3)
self.assertTrue(result.versions[0].key == "foo")
self.assertTrue(result.versions[1].key == "test")
# batch delete without version
key_list = []
key_list.append("foo")
key_list.append("test")
result = bucket.batch_delete_objects(key_list)
self.assertTrue(len(result.delete_versions) == 2)
self.assertTrue(len(result.deleted_keys) == 2)
self.assertTrue(result.delete_versions[0].delete_marker == True)
self.assertTrue(result.delete_versions[1].delete_marker == True)
result = bucket.list_object_versions()
self.assertTrue(result.is_truncated == False)
self.assertTrue(result.key_marker == '')
self.assertTrue(result.versionid_marker == '')
self.assertTrue(result.next_key_marker == '')
self.assertTrue(result.next_versionid_marker == '')
self.assertTrue(result.prefix == '')
self.assertTrue(result.delimiter == '')
self.assertTrue(len(result.delete_marker) == 2)
self.assertTrue(len(result.versions) == 3)
self.assertTrue(result.versions[0].key == "foo")
self.assertTrue(result.versions[1].key == "test")
version_list = BatchDeleteObjectVersionList()
version_list.append(
BatchDeleteObjectVersion(result.delete_marker[0].key,
result.delete_marker[0].versionid))
version_list.append(
BatchDeleteObjectVersion(result.delete_marker[1].key,
result.delete_marker[1].versionid))
version_list.append(
BatchDeleteObjectVersion(result.versions[0].key,
result.versions[0].versionid))
version_list.append(
BatchDeleteObjectVersion(result.versions[1].key,
result.versions[1].versionid))
version_list.append(
BatchDeleteObjectVersion(result.versions[2].key,
result.versions[2].versionid))
result = bucket.delete_object_versions(version_list)
self.assertTrue(len(result.delete_versions) == 5)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")
def test_object_acl_with_version(self):
from oss2.models import BucketVersioningConfig
from oss2.models import BatchDeleteObjectVersion
from oss2.models import BatchDeleteObjectVersionList
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-object-acl-version"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
# put "test"
result = bucket.put_object("test_no_version", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid is None)
result = bucket.get_object_acl("test_no_version")
bucket.delete_object("test_no_version")
config = BucketVersioningConfig()
config.status = 'Enabled'
result = bucket.put_bucket_versioning(config)
wait_meta_sync()
result = bucket.get_bucket_info()
self.assertEqual(int(result.status) / 100, 2)
self.assertEqual(result.bucket_encryption_rule.sse_algorithm, None)
self.assertEqual(result.versioning_status, "Enabled")
# put "test" version 1
result = bucket.put_object("test", "test1")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid1 = result.versionid
# put "test" version 2
result = bucket.put_object("test", "test2")
self.assertEqual(int(result.status) / 100, 2)
self.assertTrue(result.versionid != "")
versionid2 = result.versionid
try:
result_exception = bucket.put_object_acl(
"test",
oss2.OBJECT_ACL_DEFAULT,
params={'versionId': 'IllegalVersion'})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.put_object_acl("test",
oss2.OBJECT_ACL_DEFAULT,
params={'versionId': ''})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.get_object_acl(
"test", params={'versionId': 'IllegalVersion'})
self.assertFalse(True, "should get a exception")
except:
pass
try:
result_exception = bucket.get_object_acl("test",
params={'versionId': ''})
self.assertFalse(True, "should get a exception")
except:
pass
result = bucket.get_object_acl("test",
params={"versionId": versionid2})
self.assertEqual(result.acl, oss2.OBJECT_ACL_DEFAULT)
result = bucket.put_object_acl("test",
oss2.OBJECT_ACL_PUBLIC_READ,
params={"versionId": versionid2})
self.assertEqual(int(result.status) / 100, 2)
result = bucket.get_object_acl("test",
params={"versionId": versionid2})
self.assertEqual(result.acl, oss2.OBJECT_ACL_PUBLIC_READ)
version_list = BatchDeleteObjectVersionList()
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid1))
version_list.append(
BatchDeleteObjectVersion(key="test", versionid=versionid2))
self.assertTrue(version_list.len(), 2)
result = bucket.delete_object_versions(version_list)
try:
bucket.delete_bucket()
except:
self.assertFalse(True, "should not get a exception")