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_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_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_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_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")