import os import string import uuid from datetime import datetime, timedelta from random import choices, sample import allure import pytest from frostfs_testlib.utils import wallet_utils from pytest_tests.helpers.aws_cli_client import AwsCliClient from pytest_tests.helpers.file_helper import ( concat_files, generate_file, generate_file_with_content, get_file_hash, ) from pytest_tests.helpers.payment_neogo import deposit_gas, transfer_gas from pytest_tests.helpers.s3_helper import ( assert_object_lock_mode, assert_s3_acl, check_objects_in_bucket, set_bucket_versioning, ) from pytest_tests.resources.common import ASSETS_DIR, FREE_STORAGE, WALLET_PASS from pytest_tests.steps import s3_gate_bucket, s3_gate_object from pytest_tests.steps.s3_gate_base import TestS3GateBase def pytest_generate_tests(metafunc): if "s3_client" in metafunc.fixturenames: metafunc.parametrize("s3_client", ["aws cli", "boto3"], indirect=True) @pytest.mark.sanity @pytest.mark.s3_gate @pytest.mark.s3_gate_object class TestS3GateObject(TestS3GateBase): @staticmethod def object_key_from_file_path(full_path: str) -> str: return os.path.basename(full_path) @allure.title("Test S3: Copy object") def test_s3_copy_object(self, two_buckets, simple_object_size): file_path = generate_file(simple_object_size) file_name = self.object_key_from_file_path(file_path) bucket_1_objects = [file_name] bucket_1, bucket_2 = two_buckets objects_list = s3_gate_object.list_objects_s3(self.s3_client, bucket_1) assert not objects_list, f"Expected empty bucket, got {objects_list}" with allure.step("Put object into one bucket"): s3_gate_object.put_object_s3(self.s3_client, bucket_1, file_path) with allure.step("Copy one object into the same bucket"): copy_obj_path = s3_gate_object.copy_object_s3(self.s3_client, bucket_1, file_name) bucket_1_objects.append(copy_obj_path) check_objects_in_bucket(self.s3_client, bucket_1, bucket_1_objects) objects_list = s3_gate_object.list_objects_s3(self.s3_client, bucket_2) assert not objects_list, f"Expected empty bucket, got {objects_list}" with allure.step("Copy object from first bucket into second"): copy_obj_path_b2 = s3_gate_object.copy_object_s3( self.s3_client, bucket_1, file_name, bucket_dst=bucket_2 ) check_objects_in_bucket(self.s3_client, bucket_1, expected_objects=bucket_1_objects) check_objects_in_bucket(self.s3_client, bucket_2, expected_objects=[copy_obj_path_b2]) with allure.step("Check copied object has the same content"): got_copied_file_b2 = s3_gate_object.get_object_s3( self.s3_client, bucket_2, copy_obj_path_b2 ) assert get_file_hash(file_path) == get_file_hash( got_copied_file_b2 ), "Hashes must be the same" with allure.step("Delete one object from first bucket"): s3_gate_object.delete_object_s3(self.s3_client, bucket_1, file_name) bucket_1_objects.remove(file_name) check_objects_in_bucket(self.s3_client, bucket_1, expected_objects=bucket_1_objects) check_objects_in_bucket(self.s3_client, bucket_2, expected_objects=[copy_obj_path_b2]) with allure.step("Copy one object into the same bucket"): with pytest.raises(Exception): s3_gate_object.copy_object_s3(self.s3_client, bucket_1, file_name) @allure.title("Test S3: Copy version of object") def test_s3_copy_version_object(self, two_buckets, simple_object_size): version_1_content = "Version 1" file_name_simple = generate_file_with_content(simple_object_size, content=version_1_content) obj_key = os.path.basename(file_name_simple) bucket_1, bucket_2 = two_buckets set_bucket_versioning(self.s3_client, bucket_1, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put object into bucket"): s3_gate_object.put_object_s3(self.s3_client, bucket_1, file_name_simple) bucket_1_objects = [obj_key] check_objects_in_bucket(self.s3_client, bucket_1, [obj_key]) with allure.step("Copy one object into the same bucket"): copy_obj_path = s3_gate_object.copy_object_s3(self.s3_client, bucket_1, obj_key) bucket_1_objects.append(copy_obj_path) check_objects_in_bucket(self.s3_client, bucket_1, bucket_1_objects) set_bucket_versioning(self.s3_client, bucket_2, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Copy object from first bucket into second"): copy_obj_path_b2 = s3_gate_object.copy_object_s3( self.s3_client, bucket_1, obj_key, bucket_dst=bucket_2 ) check_objects_in_bucket(self.s3_client, bucket_1, expected_objects=bucket_1_objects) check_objects_in_bucket(self.s3_client, bucket_2, expected_objects=[copy_obj_path_b2]) with allure.step("Delete one object from first bucket and check object in bucket"): s3_gate_object.delete_object_s3(self.s3_client, bucket_1, obj_key) bucket_1_objects.remove(obj_key) check_objects_in_bucket(self.s3_client, bucket_1, expected_objects=bucket_1_objects) with allure.step("Copy one object into the same bucket"): with pytest.raises(Exception): s3_gate_object.copy_object_s3(self.s3_client, bucket_1, obj_key) @allure.title("Test S3: Checking copy with acl") def test_s3_copy_acl(self, bucket, simple_object_size): version_1_content = "Version 1" file_name_simple = generate_file_with_content(simple_object_size, content=version_1_content) obj_key = os.path.basename(file_name_simple) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_simple) check_objects_in_bucket(self.s3_client, bucket, [obj_key]) with allure.step("Copy object and check acl attribute"): copy_obj_path = s3_gate_object.copy_object_s3( self.s3_client, bucket, obj_key, ACL="public-read-write" ) obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, copy_obj_path) assert_s3_acl(acl_grants=obj_acl, permitted_users="CanonicalUser") @allure.title("Test S3: Copy object with metadata") def test_s3_copy_metadate(self, bucket, simple_object_size): object_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} file_path = generate_file(simple_object_size) file_name = self.object_key_from_file_path(file_path) bucket_1_objects = [file_name] set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put object into bucket"): s3_gate_object.put_object_s3( self.s3_client, bucket, file_path, Metadata=object_metadata ) bucket_1_objects = [file_name] check_objects_in_bucket(self.s3_client, bucket, bucket_1_objects) with allure.step("Copy one object"): copy_obj_path = s3_gate_object.copy_object_s3(self.s3_client, bucket, file_name) bucket_1_objects.append(copy_obj_path) check_objects_in_bucket(self.s3_client, bucket, bucket_1_objects) obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, copy_obj_path) assert ( obj_head.get("Metadata") == object_metadata ), f"Metadata must be {object_metadata}" with allure.step("Copy one object with metadata"): copy_obj_path = s3_gate_object.copy_object_s3( self.s3_client, bucket, file_name, metadata_directive="COPY" ) bucket_1_objects.append(copy_obj_path) obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, copy_obj_path) assert ( obj_head.get("Metadata") == object_metadata ), f"Metadata must be {object_metadata}" with allure.step("Copy one object with new metadata"): object_metadata_1 = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} copy_obj_path = s3_gate_object.copy_object_s3( self.s3_client, bucket, file_name, metadata_directive="REPLACE", metadata=object_metadata_1, ) bucket_1_objects.append(copy_obj_path) obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, copy_obj_path) assert ( obj_head.get("Metadata") == object_metadata_1 ), f"Metadata must be {object_metadata_1}" @allure.title("Test S3: Copy object with tagging") def test_s3_copy_tagging(self, bucket, simple_object_size): object_tagging = [(f"{uuid.uuid4()}", f"{uuid.uuid4()}")] file_path = generate_file(simple_object_size) file_name_simple = self.object_key_from_file_path(file_path) bucket_1_objects = [file_name_simple] set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): s3_gate_object.put_object_s3(self.s3_client, bucket, file_path) version_id_1 = s3_gate_object.put_object_tagging( self.s3_client, bucket, file_name_simple, tags=object_tagging ) bucket_1_objects = [file_name_simple] check_objects_in_bucket(self.s3_client, bucket, bucket_1_objects) with allure.step("Copy one object without tag"): copy_obj_path = s3_gate_object.copy_object_s3(self.s3_client, bucket, file_name_simple) got_tags = s3_gate_object.get_object_tagging(self.s3_client, bucket, copy_obj_path) assert got_tags, f"Expected tags, got {got_tags}" expected_tags = [{"Key": key, "Value": value} for key, value in object_tagging] for tag in expected_tags: assert tag in got_tags, f"Expected tag {tag} in {got_tags}" with allure.step("Copy one object with tag"): copy_obj_path_1 = s3_gate_object.copy_object_s3( self.s3_client, bucket, file_name_simple, tagging_directive="COPY" ) got_tags = s3_gate_object.get_object_tagging(self.s3_client, bucket, copy_obj_path_1) assert got_tags, f"Expected tags, got {got_tags}" expected_tags = [{"Key": key, "Value": value} for key, value in object_tagging] for tag in expected_tags: assert tag in got_tags, f"Expected tag {tag} in {got_tags}" with allure.step("Copy one object with new tag"): tag_key = "tag1" tag_value = uuid.uuid4() new_tag = f"{tag_key}={tag_value}" copy_obj_path = s3_gate_object.copy_object_s3( self.s3_client, bucket, file_name_simple, tagging_directive="REPLACE", tagging=new_tag, ) got_tags = s3_gate_object.get_object_tagging(self.s3_client, bucket, copy_obj_path) assert got_tags, f"Expected tags, got {got_tags}" expected_tags = [{"Key": tag_key, "Value": str(tag_value)}] for tag in expected_tags: assert tag in got_tags, f"Expected tag {tag} in {got_tags}" @allure.title("Test S3: Delete version of object") def test_s3_delete_versioning(self, bucket, complex_object_size, simple_object_size): version_1_content = "Version 1" version_2_content = "Version 2" file_name_simple = generate_file_with_content(simple_object_size, content=version_1_content) obj_key = os.path.basename(file_name_simple) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_simple) file_name_1 = generate_file_with_content( simple_object_size, file_path=file_name_simple, content=version_2_content ) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_1) with allure.step("Check bucket shows all versions"): versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = { version.get("VersionId") for version in versions if version.get("Key") == obj_key } assert obj_versions == { version_id_1, version_id_2, }, f"Expected object has versions: {version_id_1, version_id_2}" with allure.step("Delete 1 version of object"): delete_obj = s3_gate_object.delete_object_s3( self.s3_client, bucket, obj_key, version_id=version_id_1 ) versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = { version.get("VersionId") for version in versions if version.get("Key") == obj_key } assert obj_versions == {version_id_2}, f"Expected object has versions: {version_id_2}" assert not "DeleteMarkers" in delete_obj.keys(), "Delete markes not found" with allure.step("Delete second version of object"): delete_obj = s3_gate_object.delete_object_s3( self.s3_client, bucket, obj_key, version_id=version_id_2 ) versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = { version.get("VersionId") for version in versions if version.get("Key") == obj_key } assert not obj_versions, "Expected object not found" assert not "DeleteMarkers" in delete_obj.keys(), "Delete markes not found" with allure.step("Put new object into bucket"): file_name_simple = generate_file(complex_object_size) obj_key = os.path.basename(file_name_simple) version_id = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_simple) with allure.step("Delete last object"): delete_obj = s3_gate_object.delete_object_s3(self.s3_client, bucket, obj_key) versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket, True) assert versions.get("DeleteMarkers", None), f"Expected delete Marker" assert "DeleteMarker" in delete_obj.keys(), f"Expected delete Marker" @allure.title("Test S3: bulk delete version of object") def test_s3_bulk_delete_versioning(self, bucket, simple_object_size): version_1_content = "Version 1" version_2_content = "Version 2" version_3_content = "Version 3" version_4_content = "Version 4" file_name_1 = generate_file_with_content(simple_object_size, content=version_1_content) obj_key = os.path.basename(file_name_1) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_1) file_name_2 = generate_file_with_content( simple_object_size, file_path=file_name_1, content=version_2_content ) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_2) file_name_3 = generate_file_with_content( simple_object_size, file_path=file_name_1, content=version_3_content ) version_id_3 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_3) file_name_4 = generate_file_with_content( simple_object_size, file_path=file_name_1, content=version_4_content ) version_id_4 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_4) version_ids = {version_id_1, version_id_2, version_id_3, version_id_4} with allure.step("Check bucket shows all versions"): versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = { version.get("VersionId") for version in versions if version.get("Key") == obj_key } assert obj_versions == version_ids, f"Expected object has versions: {version_ids}" with allure.step("Delete two objects from bucket one by one"): version_to_delete_b1 = sample( [version_id_1, version_id_2, version_id_3, version_id_4], k=2 ) version_to_save = list(set(version_ids) - set(version_to_delete_b1)) for ver in version_to_delete_b1: s3_gate_object.delete_object_s3(self.s3_client, bucket, obj_key, ver) with allure.step("Check bucket shows all versions"): versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = [ version.get("VersionId") for version in versions if version.get("Key") == obj_key ] assert ( obj_versions.sort() == version_to_save.sort() ), f"Expected object has versions: {version_to_save}" @allure.title("Test S3: Get versions of object") def test_s3_get_versioning(self, bucket, simple_object_size): version_1_content = "Version 1" version_2_content = "Version 2" file_name_simple = generate_file_with_content(simple_object_size, content=version_1_content) obj_key = os.path.basename(file_name_simple) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_simple) file_name_1 = generate_file_with_content( simple_object_size, file_path=file_name_simple, content=version_2_content ) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_1) with allure.step("Get first version of object"): object_1 = s3_gate_object.get_object_s3( self.s3_client, bucket, obj_key, version_id_1, full_output=True ) assert ( object_1.get("VersionId") == version_id_1 ), f"Get object with version {version_id_1}" with allure.step("Get second version of object"): object_2 = s3_gate_object.get_object_s3( self.s3_client, bucket, obj_key, version_id_2, full_output=True ) assert ( object_2.get("VersionId") == version_id_2 ), f"Get object with version {version_id_2}" with allure.step("Get object"): object_3 = s3_gate_object.get_object_s3( self.s3_client, bucket, obj_key, full_output=True ) assert ( object_3.get("VersionId") == version_id_2 ), f"Get object with version {version_id_2}" @allure.title("Test S3: Get range") def test_s3_get_range(self, bucket, complex_object_size: int, simple_object_size: int): file_path = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path) file_hash = get_file_hash(file_path) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_path) file_name_1 = generate_file_with_content(simple_object_size, file_path=file_path) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_1) with allure.step("Get first version of object"): object_1_part_1 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_1, range=[0, int(complex_object_size / 3)], ) object_1_part_2 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_1, range=[int(complex_object_size / 3) + 1, 2 * int(complex_object_size / 3)], ) object_1_part_3 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_1, range=[2 * int(complex_object_size / 3) + 1, complex_object_size], ) con_file = concat_files([object_1_part_1, object_1_part_2, object_1_part_3]) assert get_file_hash(con_file) == file_hash, "Hashes must be the same" with allure.step("Get second version of object"): object_2_part_1 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_2, range=[0, int(simple_object_size / 3)], ) object_2_part_2 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_2, range=[int(simple_object_size / 3) + 1, 2 * int(simple_object_size / 3)], ) object_2_part_3 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, version_id_2, range=[2 * int(simple_object_size / 3) + 1, simple_object_size], ) con_file_1 = concat_files([object_2_part_1, object_2_part_2, object_2_part_3]) assert get_file_hash(con_file_1) == get_file_hash( file_name_1 ), "Hashes must be the same" with allure.step("Get object"): object_3_part_1 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, range=[0, int(simple_object_size / 3)] ) object_3_part_2 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, range=[int(simple_object_size / 3) + 1, 2 * int(simple_object_size / 3)], ) object_3_part_3 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name, range=[2 * int(simple_object_size / 3) + 1, simple_object_size], ) con_file = concat_files([object_3_part_1, object_3_part_2, object_3_part_3]) assert get_file_hash(con_file) == get_file_hash(file_name_1), "Hashes must be the same" @allure.title("Test S3: Copy object with metadata") @pytest.mark.smoke def test_s3_head_object(self, bucket, complex_object_size, simple_object_size): object_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} file_path = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): version_id_1 = s3_gate_object.put_object_s3( self.s3_client, bucket, file_path, Metadata=object_metadata ) file_name_1 = generate_file_with_content(simple_object_size, file_path=file_path) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_name_1) with allure.step("Get head of first version of object"): response = s3_gate_object.head_object_s3(self.s3_client, bucket, file_name) assert "LastModified" in response, "Expected LastModified field" assert "ETag" in response, "Expected ETag field" assert response.get("Metadata") == {}, "Expected Metadata empty" assert ( response.get("VersionId") == version_id_2 ), f"Expected VersionId is {version_id_2}" assert response.get("ContentLength") != 0, "Expected ContentLength is not zero" with allure.step("Get head ob first version of object"): response = s3_gate_object.head_object_s3( self.s3_client, bucket, file_name, version_id=version_id_1 ) assert "LastModified" in response, "Expected LastModified field" assert "ETag" in response, "Expected ETag field" assert ( response.get("Metadata") == object_metadata ), f"Expected Metadata is {object_metadata}" assert ( response.get("VersionId") == version_id_1 ), f"Expected VersionId is {version_id_1}" assert response.get("ContentLength") != 0, "Expected ContentLength is not zero" @allure.title("Test S3: list of object with versions") @pytest.mark.parametrize("list_type", ["v1", "v2"]) def test_s3_list_object(self, list_type: str, bucket, complex_object_size): file_path_1 = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path_1) file_path_2 = generate_file(complex_object_size) file_name_2 = self.object_key_from_file_path(file_path_2) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step("Put several versions of object into bucket"): s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_1) s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_2) with allure.step("Get list of object"): if list_type == "v1": list_obj = s3_gate_object.list_objects_s3(self.s3_client, bucket) elif list_type == "v2": list_obj = s3_gate_object.list_objects_s3_v2(self.s3_client, bucket) assert len(list_obj) == 2, f"bucket have 2 objects" assert ( list_obj.sort() == [file_name, file_name_2].sort() ), f"bucket have object key {file_name, file_name_2}" with allure.step("Delete object"): delete_obj = s3_gate_object.delete_object_s3(self.s3_client, bucket, file_name) if list_type == "v1": list_obj_1 = s3_gate_object.list_objects_s3( self.s3_client, bucket, full_output=True ) elif list_type == "v2": list_obj_1 = s3_gate_object.list_objects_s3_v2( self.s3_client, bucket, full_output=True ) contents = list_obj_1.get("Contents", []) assert len(contents) == 1, f"bucket have only 1 object" assert contents[0].get("Key") == file_name_2, f"bucket has object key {file_name_2}" assert "DeleteMarker" in delete_obj.keys(), f"Expected delete Marker" @allure.title("Test S3: put object") def test_s3_put_object(self, bucket, complex_object_size, simple_object_size): file_path_1 = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path_1) object_1_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} tag_key_1 = "tag1" tag_value_1 = uuid.uuid4() tag_1 = f"{tag_key_1}={tag_value_1}" object_2_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} tag_key_2 = "tag2" tag_value_2 = uuid.uuid4() tag_2 = f"{tag_key_2}={tag_value_2}" set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.SUSPENDED) with allure.step("Put first object into bucket"): s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, Metadata=object_1_metadata, Tagging=tag_1 ) obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, file_name) assert obj_head.get("Metadata") == object_1_metadata, "Matadata must be the same" got_tags = s3_gate_object.get_object_tagging(self.s3_client, bucket, file_name) assert got_tags, f"Expected tags, got {got_tags}" assert got_tags == [ {"Key": tag_key_1, "Value": str(tag_value_1)} ], "Tags must be the same" with allure.step("Rewrite file into bucket"): file_path_2 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_2, Metadata=object_2_metadata, Tagging=tag_2 ) obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, file_name) assert obj_head.get("Metadata") == object_2_metadata, "Matadata must be the same" got_tags_1 = s3_gate_object.get_object_tagging(self.s3_client, bucket, file_name) assert got_tags_1, f"Expected tags, got {got_tags_1}" assert got_tags_1 == [ {"Key": tag_key_2, "Value": str(tag_value_2)} ], "Tags must be the same" set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) file_path_3 = generate_file(complex_object_size) file_hash = get_file_hash(file_path_3) file_name_3 = self.object_key_from_file_path(file_path_3) object_3_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} tag_key_3 = "tag3" tag_value_3 = uuid.uuid4() tag_3 = f"{tag_key_3}={tag_value_3}" with allure.step("Put third object into bucket"): version_id_1 = s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_3, Metadata=object_3_metadata, Tagging=tag_3 ) obj_head_3 = s3_gate_object.head_object_s3(self.s3_client, bucket, file_name_3) assert obj_head_3.get("Metadata") == object_3_metadata, "Matadata must be the same" got_tags_3 = s3_gate_object.get_object_tagging(self.s3_client, bucket, file_name_3) assert got_tags_3, f"Expected tags, got {got_tags_3}" assert got_tags_3 == [ {"Key": tag_key_3, "Value": str(tag_value_3)} ], "Tags must be the same" with allure.step("Put new version of file into bucket"): file_path_4 = generate_file_with_content(simple_object_size, file_path=file_path_3) version_id_2 = s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_4) versions = s3_gate_object.list_objects_versions_s3(self.s3_client, bucket) obj_versions = { version.get("VersionId") for version in versions if version.get("Key") == file_name_3 } assert obj_versions == { version_id_1, version_id_2, }, f"Expected object has versions: {version_id_1, version_id_2}" got_tags_4 = s3_gate_object.get_object_tagging(self.s3_client, bucket, file_name_3) assert not got_tags_4, f"No expected tags" with allure.step("Get object"): object_3 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name_3, full_output=True ) assert ( object_3.get("VersionId") == version_id_2 ), f"get object with version {version_id_2}" object_3 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name_3) assert get_file_hash(file_path_4) == get_file_hash(object_3), "Hashes must be the same" with allure.step("Get first version of object"): object_4 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name_3, version_id_1, full_output=True ) assert ( object_4.get("VersionId") == version_id_1 ), f"get object with version {version_id_1}" object_4 = s3_gate_object.get_object_s3( self.s3_client, bucket, file_name_3, version_id_1 ) assert file_hash == get_file_hash(object_4), "Hashes must be the same" obj_head_3 = s3_gate_object.head_object_s3( self.s3_client, bucket, file_name_3, version_id_1 ) assert obj_head_3.get("Metadata") == object_3_metadata, "Matadata must be the same" got_tags_3 = s3_gate_object.get_object_tagging( self.s3_client, bucket, file_name_3, version_id_1 ) assert got_tags_3, f"Expected tags, got {got_tags_3}" assert got_tags_3 == [ {"Key": tag_key_3, "Value": str(tag_value_3)} ], "Tags must be the same" @pytest.fixture def prepare_two_wallets(self, default_wallet, client_shell): self.main_wallet = default_wallet self.main_public_key = wallet_utils.get_wallet_public_key(self.main_wallet, WALLET_PASS) self.other_wallet = os.path.join(os.getcwd(), ASSETS_DIR, f"{str(uuid.uuid4())}.json") wallet_utils.init_wallet(self.other_wallet, WALLET_PASS) self.other_public_key = wallet_utils.get_wallet_public_key(self.other_wallet, WALLET_PASS) if not FREE_STORAGE: main_chain = self.cluster.main_chain_nodes[0] deposit = 30 transfer_gas( shell=client_shell, amount=deposit + 1, main_chain=main_chain, wallet_to_path=self.other_wallet, wallet_to_password=WALLET_PASS, ) deposit_gas( shell=client_shell, main_chain=main_chain, amount=deposit, wallet_from_path=self.other_wallet, wallet_from_password=WALLET_PASS, ) @allure.title("Test S3: put object with ACL") @pytest.mark.parametrize("bucket_versioning", ["ENABLED", "SUSPENDED"]) def test_s3_put_object_acl( self, prepare_two_wallets, bucket_versioning, bucket, complex_object_size, simple_object_size, ): file_path_1 = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path_1) if bucket_versioning == "ENABLED": status = s3_gate_bucket.VersioningStatus.ENABLED elif bucket_versioning == "SUSPENDED": status = s3_gate_bucket.VersioningStatus.SUSPENDED set_bucket_versioning(self.s3_client, bucket, status) with allure.step("Put object with acl private"): s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_1, ACL="private") obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name) assert_s3_acl(acl_grants=obj_acl, permitted_users="CanonicalUser") object_1 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name) assert get_file_hash(file_path_1) == get_file_hash(object_1), "Hashes must be the same" with allure.step("Put object with acl public-read"): file_path_2 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_2, ACL="public-read") obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name) assert_s3_acl(acl_grants=obj_acl, permitted_users="AllUsers") object_2 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name) assert get_file_hash(file_path_2) == get_file_hash(object_2), "Hashes must be the same" with allure.step("Put object with acl public-read-write"): file_path_3 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_3, ACL="public-read-write" ) obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name) assert_s3_acl(acl_grants=obj_acl, permitted_users="AllUsers") object_3 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name) assert get_file_hash(file_path_3) == get_file_hash(object_3), "Hashes must be the same" with allure.step("Put object with acl authenticated-read"): file_path_4 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_4, ACL="authenticated-read" ) obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name) assert_s3_acl(acl_grants=obj_acl, permitted_users="AllUsers") object_4 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name) assert get_file_hash(file_path_4) == get_file_hash(object_4), "Hashes must be the same" file_path_5 = generate_file(complex_object_size) file_name_5 = self.object_key_from_file_path(file_path_5) with allure.step("Put object with --grant-full-control id=mycanonicaluserid"): file_path_6 = generate_file_with_content(simple_object_size, file_path=file_path_5) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_6, GrantFullControl=f"id={self.other_public_key}", ) obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name_5) assert_s3_acl(acl_grants=obj_acl, permitted_users="CanonicalUser") object_4 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name_5) assert get_file_hash(file_path_5) == get_file_hash(object_4), "Hashes must be the same" with allure.step( "Put object with --grant-read uri=http://acs.amazonaws.com/groups/global/AllUsers" ): file_path_7 = generate_file_with_content(simple_object_size, file_path=file_path_5) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_7, GrantRead="uri=http://acs.amazonaws.com/groups/global/AllUsers", ) obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, file_name_5) assert_s3_acl(acl_grants=obj_acl, permitted_users="AllUsers") object_7 = s3_gate_object.get_object_s3(self.s3_client, bucket, file_name_5) assert get_file_hash(file_path_7) == get_file_hash(object_7), "Hashes must be the same" @allure.title("Test S3: put object with lock-mode") def test_s3_put_object_lock_mode(self, complex_object_size, simple_object_size): file_path_1 = generate_file(complex_object_size) file_name = self.object_key_from_file_path(file_path_1) bucket = s3_gate_bucket.create_bucket_s3(self.s3_client, True) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) with allure.step( "Put object with lock-mode GOVERNANCE lock-retain-until-date +1day, lock-legal-hold-status" ): date_obj = datetime.utcnow() + timedelta(days=1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, ObjectLockMode="GOVERNANCE", ObjectLockRetainUntilDate=date_obj.strftime("%Y-%m-%dT%H:%M:%S"), ObjectLockLegalHoldStatus="OFF", ) assert_object_lock_mode( self.s3_client, bucket, file_name, "GOVERNANCE", date_obj, "OFF" ) with allure.step( "Put new version of object with [--object-lock-mode COMPLIANCE] и [--object-lock-retain-until-date +3days]" ): date_obj = datetime.utcnow() + timedelta(days=2) file_name_1 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, ObjectLockMode="COMPLIANCE", ObjectLockRetainUntilDate=date_obj, ) assert_object_lock_mode( self.s3_client, bucket, file_name, "COMPLIANCE", date_obj, "OFF" ) with allure.step( "Put new version of object with [--object-lock-mode COMPLIANCE] и [--object-lock-retain-until-date +2days]" ): date_obj = datetime.utcnow() + timedelta(days=3) file_name_1 = generate_file_with_content(simple_object_size, file_path=file_path_1) s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, ObjectLockMode="COMPLIANCE", ObjectLockRetainUntilDate=date_obj, ObjectLockLegalHoldStatus="ON", ) assert_object_lock_mode(self.s3_client, bucket, file_name, "COMPLIANCE", date_obj, "ON") with allure.step("Put object with lock-mode"): with pytest.raises( Exception, match=r".*must both be supplied*", ): # x-amz-object-lock-retain-until-date and x-amz-object-lock-mode must both be supplied s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, ObjectLockMode="COMPLIANCE" ) with allure.step("Put object with lock-mode and past date"): date_obj = datetime.utcnow() - timedelta(days=3) with pytest.raises( Exception, match=r".*until date must be in the future*", ): # The retain until date must be in the future s3_gate_object.put_object_s3( self.s3_client, bucket, file_path_1, ObjectLockMode="COMPLIANCE", ObjectLockRetainUntilDate=date_obj, ) @allure.title("Test S3 Sync directory") @pytest.mark.parametrize("sync_type", ["sync", "cp"]) def test_s3_sync_dir(self, sync_type, bucket, simple_object_size): file_path_1 = os.path.join(os.getcwd(), ASSETS_DIR, "test_sync", "test_file_1") file_path_2 = os.path.join(os.getcwd(), ASSETS_DIR, "test_sync", "test_file_2") object_metadata = {f"{uuid.uuid4()}": f"{uuid.uuid4()}"} key_to_path = {"test_file_1": file_path_1, "test_file_2": file_path_2} if not isinstance(self.s3_client, AwsCliClient): pytest.skip("This test is not supported with boto3 client") generate_file_with_content(simple_object_size, file_path=file_path_1) generate_file_with_content(simple_object_size, file_path=file_path_2) set_bucket_versioning(self.s3_client, bucket, s3_gate_bucket.VersioningStatus.ENABLED) # TODO: return ACL, when https://github.com/nspcc-dev/neofs-s3-gw/issues/685 will be closed if sync_type == "sync": self.s3_client.sync( bucket_name=bucket, dir_path=os.path.dirname(file_path_1), # ACL="public-read-write", Metadata=object_metadata, ) elif sync_type == "cp": self.s3_client.cp( bucket_name=bucket, dir_path=os.path.dirname(file_path_1), # ACL="public-read-write", Metadata=object_metadata, ) with allure.step("Check objects are synced"): objects = s3_gate_object.list_objects_s3(self.s3_client, bucket) assert set(key_to_path.keys()) == set( objects ), f"Expected all abjects saved. Got {objects}" with allure.step("Check these are the same objects"): for obj_key in objects: got_object = s3_gate_object.get_object_s3(self.s3_client, bucket, obj_key) assert get_file_hash(got_object) == get_file_hash( key_to_path.get(obj_key) ), "Expected hashes are the same" obj_head = s3_gate_object.head_object_s3(self.s3_client, bucket, obj_key) assert ( obj_head.get("Metadata") == object_metadata ), f"Metadata of object is {object_metadata}" # Uncomment after https://github.com/nspcc-dev/neofs-s3-gw/issues/685 is solved # obj_acl = s3_gate_object.get_object_acl_s3(self.s3_client, bucket, obj_key) # assert_s3_acl(acl_grants = obj_acl, permitted_users = "AllUsers") @allure.title("Test S3 Put 10 nested level object") def test_s3_put_10_folder(self, bucket, temp_directory, simple_object_size): path = "/".join(["".join(choices(string.ascii_letters, k=3)) for _ in range(10)]) file_path_1 = os.path.join(temp_directory, path, "test_file_1") generate_file_with_content(simple_object_size, file_path=file_path_1) file_name = self.object_key_from_file_path(file_path_1) objects_list = s3_gate_object.list_objects_s3(self.s3_client, bucket) assert not objects_list, f"Expected empty bucket, got {objects_list}" with allure.step("Put object"): s3_gate_object.put_object_s3(self.s3_client, bucket, file_path_1) check_objects_in_bucket(self.s3_client, bucket, [file_name])