awspub 0.0.10__py3-none-any.whl

awspub/tests/test_image.py

@@ -0,0 +1,556 @@
+import pathlib
+from unittest.mock import MagicMock, patch
+
+import botocore.exceptions
+import pytest
+
+from awspub import context, exceptions, image
+
+curdir = pathlib.Path(__file__).parent.resolve()
+
+
+@pytest.mark.parametrize(
+    "imagename,snapshotname",
+    [
+        # test-image-1 without any separate snapshot or billing products.
+        # so snapshotname should match source sha256sum
+        ("test-image-1", "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"),
+        # test-image-2 with separate snapshot but without billing products.
+        # so snapshotname should be the shasum of the concatenated string of:
+        # - 6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8
+        # - echo -n test-image-2 | sha256sum
+        ("test-image-2", "0c274a96fe840cdd9cf65b0bf8e4d755d94fddf00916aa6f26ee3f08e412c88f"),
+        # test-image-3 with separate snapshot and billing products
+        ("test-image-3", "ef7c5bbbc2816c60acfa4f3954e431c849054f7370bf351055f6d665b60623e7"),
+        # test-image-4 without separate snapshot but with billing products
+        ("test-image-4", "bf795c602d53ff9c9548cc6305aa1240bd0f3d4429869abe4c96bcef65c4e48d"),
+        # test-image-5 without separate snapshot but with multiple billing products
+        ("test-image-5", "8171cd4d36d06150a5ff8bb519439c5efd4e91841be62f50736db3b82e4aaedc"),
+    ],
+)
+def test_snapshot_names(imagename, snapshotname):
+    """
+    Test the snapshot name calculation based on the image properties
+    """
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    assert ctx.conf["source"]["path"] == curdir / "fixtures/config1.vmdk"
+    assert ctx.source_sha256 == "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"
+
+    img = image.Image(ctx, imagename)
+    assert img.snapshot_name == snapshotname
+
+
+@pytest.mark.parametrize(
+    "imagename,regions_in_partition,regions_expected",
+    [
+        # test-image-1 has 2 regions defined
+        ("test-image-1", ["region1", "region2"], ["region1", "region2"]),
+        # test-image-1 has 2 regions defined and there are more regions in the partition
+        ("test-image-1", ["region1", "region2", "region3"], ["region1", "region2"]),
+        ("test-image-1", ["region1", "region2"], ["region1", "region2"]),
+        # test-image-2 has no regions defined, so whatever the ec2 client returns should be valid
+        ("test-image-2", ["all-region-1", "all-region-2"], ["all-region-1", "all-region-2"]),
+        # test-image-1 has 2 regions defined, but those regions are not in the partition
+        ("test-image-1", ["region3", "region4"], []),
+        # test-image-1 has 2 regions defined, but those regions are not partially in the partition
+        ("test-image-1", ["region2", "region4"], ["region2"]),
+        # test-image-2 has no regions defined and the ec2 client doesn't return any regions
+        ("test-image-2", [], []),
+    ],
+)
+@patch("awspub.s3.S3.bucket_region", return_value="region1")
+def test_image_regions(s3_region_mock, imagename, regions_in_partition, regions_expected):
+    """
+    Test the regions for a given image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_regions.return_value = {"Regions": [{"RegionName": r} for r in regions_in_partition]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, imagename)
+        assert sorted(img.image_regions) == sorted(regions_expected)
+
+
+@pytest.mark.parametrize(
+    "imagename,cleanup",
+    [
+        ("test-image-1", True),
+        ("test-image-2", False),
+    ],
+)
+def test_image_cleanup(imagename, cleanup):
+    """
+    Test the cleanup for a given image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {"Images": [{"Name": imagename, "Public": False, "ImageId": "ami-123"}]}
+        instance.describe_regions.return_value = {"Regions": [{"RegionName": "region1"}, {"RegionName": "region2"}]}
+        instance.list_buckets.return_value = {"Buckets": [{"Name": "bucket1"}]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, imagename)
+        img.cleanup()
+        assert instance.deregister_image.called == cleanup
+
+
+@pytest.mark.parametrize(
+    "root_device_name,block_device_mappings,snapshot_id",
+    [
+        ("", [], None),
+        ("/dev/sda1", [], None),
+        (
+            "/dev/sda1",
+            [
+                {
+                    "DeviceName": "/dev/sda1",
+                    "Ebs": {
+                        "DeleteOnTermination": True,
+                        "SnapshotId": "snap-0be0763f84af34e05",
+                        "VolumeSize": 17,
+                        "VolumeType": "gp2",
+                        "Encrypted": False,
+                    },
+                },
+                {"DeviceName": "/dev/sdb", "VirtualName": "ephemeral0"},
+            ],
+            "snap-0be0763f84af34e05",
+        ),
+    ],
+)
+def test_image___get_root_device_snapshot_id(root_device_name, block_device_mappings, snapshot_id):
+    """
+    Test the _get_root_device_snapshot_id() method
+    """
+    i = {"RootDeviceName": root_device_name, "BlockDeviceMappings": block_device_mappings}
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    img = image.Image(ctx, "test-image-1")
+    assert img._get_root_device_snapshot_id(i) == snapshot_id
+
+
+@pytest.mark.parametrize(
+    (
+        "imagename",
+        "partition",
+        "called_mod_image",
+        "called_mod_snapshot",
+        "called_start_change_set",
+        "called_put_parameter",
+        "called_sns_publish",
+    ),
+    [
+        ("test-image-6", "aws", True, True, False, False, False),
+        ("test-image-7", "aws", False, False, False, False, False),
+        ("test-image-8", "aws", True, True, True, True, False),
+        ("test-image-8", "aws-cn", True, True, False, True, False),
+        ("test-image-10", "aws", False, False, False, False, True),
+        ("test-image-11", "aws", False, False, False, False, True),
+        ("test-image-12", "aws", False, False, False, False, True),
+    ],
+)
+def test_image_publish(
+    imagename,
+    partition,
+    called_mod_image,
+    called_mod_snapshot,
+    called_start_change_set,
+    called_put_parameter,
+    called_sns_publish,
+):
+    """
+    Test the publish() for a given image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.meta.partition = partition
+        instance.describe_images.return_value = {
+            "Images": [
+                {
+                    "Name": imagename,
+                    "ImageId": "ami-abc",
+                    "RootDeviceName": "/dev/sda1",
+                    "BlockDeviceMappings": [
+                        {
+                            "DeviceName": "/dev/sda1",
+                            "Ebs": {
+                                "DeleteOnTermination": True,
+                                "SnapshotId": "snap-0be0763f84af34e05",
+                            },
+                        },
+                    ],
+                }
+            ]
+        }
+        instance.get_parameters.return_value = {"Parameters": []}
+        instance.describe_regions.return_value = {
+            "Regions": [{"RegionName": "eu-central-1"}, {"RegionName": "us-east-1"}]
+        }
+        instance.list_buckets.return_value = {"Buckets": [{"Name": "bucket1"}]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, imagename)
+        img.publish()
+        assert instance.modify_image_attribute.called == called_mod_image
+        assert instance.modify_snapshot_attribute.called == called_mod_snapshot
+        assert instance.start_change_set.called == called_start_change_set
+        assert instance.put_parameter.called == called_put_parameter
+        assert instance.publish.called == called_sns_publish
+
+
+def test_image__get_zero_images():
+    """
+    Test the Image._get() method with zero matching image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {"Images": []}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-1")
+        assert img._get(instance) is None
+
+
+def test_image__get_one_images():
+    """
+    Test the Image._get() method with a single matching image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {
+            "Images": [
+                {
+                    "Name": "test-image-1",
+                    "ImageId": "ami-abc",
+                    "RootDeviceName": "/dev/sda1",
+                    "BlockDeviceMappings": [
+                        {
+                            "DeviceName": "/dev/sda1",
+                            "Ebs": {
+                                "DeleteOnTermination": True,
+                                "SnapshotId": "snap-abc",
+                            },
+                        },
+                    ],
+                }
+            ]
+        }
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-1")
+        assert img._get(instance) == image._ImageInfo("ami-abc", "snap-abc")
+
+
+def test_image__get_multiple_images():
+    """
+    Test the Image._get() method with a multiple matching image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {
+            "Images": [
+                {
+                    "Name": "test-image-1",
+                    "ImageId": "ami-1,",
+                },
+                {
+                    "Name": "test-image-1",
+                    "ImageId": "ami-2,",
+                },
+            ]
+        }
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-1")
+        with pytest.raises(exceptions.MultipleImagesException):
+            img._get(instance)
+
+
+@pytest.mark.parametrize(
+    "imagename,expected_tags",
+    [
+        # no image specific tags - assume the common tags
+        (
+            "test-image-1",
+            [
+                {"Key": "awspub:source:filename", "Value": "config1.vmdk"},
+                {"Key": "awspub:source:architecture", "Value": "x86_64"},
+                {
+                    "Key": "awspub:source:sha256",
+                    "Value": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8",
+                },
+                {"Key": "name", "Value": "foobar"},
+            ],
+        ),
+        # with image specific tag but no override
+        (
+            "test-image-6",
+            [
+                {"Key": "awspub:source:filename", "Value": "config1.vmdk"},
+                {"Key": "awspub:source:architecture", "Value": "x86_64"},
+                {
+                    "Key": "awspub:source:sha256",
+                    "Value": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8",
+                },
+                {"Key": "name", "Value": "foobar"},
+                {"Key": "key1", "Value": "value1"},
+            ],
+        ),
+        # with image specific tag which overrides common tag
+        (
+            "test-image-7",
+            [
+                {"Key": "awspub:source:filename", "Value": "config1.vmdk"},
+                {"Key": "awspub:source:architecture", "Value": "x86_64"},
+                {
+                    "Key": "awspub:source:sha256",
+                    "Value": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8",
+                },
+                {"Key": "name", "Value": "not-foobar"},
+                {"Key": "key2", "Value": "name"},
+            ],
+        ),
+    ],
+)
+def test_image__tags(imagename, expected_tags):
+    """
+    Test the Image._tags() method
+    """
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    img = image.Image(ctx, imagename)
+    assert img._tags == expected_tags
+
+
+@pytest.mark.parametrize(
+    "available_images,expected",
+    [
+        # image available
+        ([{"Name": "test-image-6", "ImageId": "ami-123"}], {"eu-central-1": image._ImageInfo("ami-123", None)}),
+        # image not available
+        ([], {}),
+    ],
+)
+def test_image_list(available_images, expected):
+    """
+    Test the list for a given image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {"Images": available_images}
+        instance.describe_regions.return_value = {
+            "Regions": [{"RegionName": "eu-central-1"}, {"RegionName": "us-east-1"}]
+        }
+        instance.list_buckets.return_value = {"Buckets": [{"Name": "bucket1"}]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-6")
+        assert img.list() == expected
+
+
+@patch("awspub.s3.S3.bucket_region", return_value="region1")
+def test_image_create_existing(s3_bucket_mock):
+    """
+    Test the create() method for a given image that already exist
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_snapshots.return_value = {"Snapshots": [{"SnapshotId": "snap-123"}]}
+        instance.describe_images.return_value = {
+            "Images": [
+                {
+                    "Name": "test-image-6",
+                    "ImageId": "ami-123",
+                    "RootDeviceName": "/dev/sda1",
+                    "BlockDeviceMappings": [
+                        {
+                            "DeviceName": "/dev/sda1",
+                            "Ebs": {
+                                "DeleteOnTermination": True,
+                                "SnapshotId": "snap-123",
+                            },
+                        },
+                    ],
+                }
+            ]
+        }
+        instance.describe_regions.return_value = {
+            "Regions": [{"RegionName": "eu-central-1"}, {"RegionName": "us-east-1"}]
+        }
+        instance.list_buckets.return_value = {"Buckets": [{"Name": "bucket1"}]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-6")
+        assert img.create() == {"eu-central-1": image._ImageInfo(image_id="ami-123", snapshot_id="snap-123")}
+        # register and create_tags shouldn't be called given that the image was already there
+        assert not instance.register_image.called
+        assert not instance.create_tags.called
+
+
+@pytest.mark.parametrize(
+    "imagename,describe_images,get_parameters,get_parameters_called,put_parameter_called",
+    [
+        # no image, no parameters (this should actually never happen but test it anyway)
+        ("test-image-8", [], [], False, False),
+        # with image, no parameter, no overwrite
+        ("test-image-8", [{"Name": "test-image-8", "ImageId": "ami-123"}], [], True, True),
+        # with image, with parameter, no overwrite
+        (
+            "test-image-8",
+            [{"Name": "test-image-8", "ImageId": "ami-123"}],
+            [{"Name": "/awspub-test/param1", "Value": "ami-123"}],
+            True,
+            False,
+        ),
+        # with image, no parameter, with overwrite
+        ("test-image-9", [{"Name": "test-image-8", "ImageId": "ami-123"}], [], False, True),
+        # with image, with parameter, with overwrite
+        (
+            "test-image-9",
+            [{"Name": "test-image-8", "ImageId": "ami-123"}],
+            [{"Name": "/awspub-test/param1", "Value": "ami-123"}],
+            False,
+            True,
+        ),
+    ],
+)
+def test_image__put_ssm_parameters(
+    imagename, describe_images, get_parameters, get_parameters_called, put_parameter_called
+):
+    """
+    Test the _put_ssm_parameters() method
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {"Images": describe_images}
+        instance.get_parameters.return_value = {"Parameters": get_parameters}
+        instance.describe_regions.return_value = {
+            "Regions": [{"RegionName": "eu-central-1"}, {"RegionName": "us-east-1"}]
+        }
+        instance.list_buckets.return_value = {"Buckets": [{"Name": "bucket1"}]}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, imagename)
+        img._put_ssm_parameters()
+        assert instance.get_parameters.called == get_parameters_called
+        assert instance.put_parameter.called == put_parameter_called
+
+
+@pytest.mark.parametrize(
+    "image_found,config,config_image_name, expected_problems",
+    [
+        # image not available
+        ([], "fixtures/config1.yaml", "test-image-6", [image.ImageVerificationErrors.NOT_EXIST]),
+        # image matches expectations from config
+        (
+            [
+                {
+                    "Name": "test-image-6",
+                    "State": "available",
+                    "ImageId": "ami-123",
+                    "RootDeviceName": "/dev/sda1",
+                    "RootDeviceType": "ebs",
+                    "BootMode": "uefi-preferred",
+                    "BlockDeviceMappings": [
+                        {
+                            "DeviceName": "/dev/sda1",
+                            "Ebs": {
+                                "DeleteOnTermination": True,
+                                "VolumeType": "gp3",
+                                "VolumeSize": 8,
+                                "SnapshotId": "snap-123",
+                            },
+                        },
+                    ],
+                    "Tags": [
+                        {"Key": "name", "Value": "foobar"},
+                    ],
+                }
+            ],
+            "fixtures/config1.yaml",
+            "test-image-6",
+            [],
+        ),
+    ],
+)
+def test_image__verify(image_found, config, config_image_name, expected_problems):
+    """
+    Test _verify() for a given image and configuration
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_images.return_value = {"Images": image_found}
+        instance.describe_snapshots.return_value = {"Snapshots": [{"State": "completed"}]}
+        ctx = context.Context(curdir / config, None)
+        img = image.Image(ctx, config_image_name)
+        problems = img._verify("eu-central-1")
+        assert problems == expected_problems
+
+
+@pytest.mark.parametrize(
+    "partition,imagename,share_list_expected",
+    [
+        ("aws", "test-image-8", [{"UserId": "123456789123"}, {"UserId": "221020170000"}, {"UserId": "290620200000"}]),
+        ("aws-cn", "test-image-8", [{"UserId": "334455667788"}]),
+        ("aws-us-gov", "test-image-8", []),
+    ],
+)
+def test_image__share_list_filtered(partition, imagename, share_list_expected):
+    """
+    Test _share_list_filtered() for a given image
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.meta.partition = partition
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, imagename)
+        assert img._share_list_filtered(img.conf["share"]) == share_list_expected
+
+
+@patch("awspub.s3.S3.bucket_region", return_value="region1")
+def test_create__should_allow_partial_registration(s3_bucket_mock):
+    """
+    Test that the create() method allows a partial upload set
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image.Image(ctx, "test-image-6")
+        img._image_regions = ["region1", "region2"]
+        img._image_regions_cached = True
+        with patch.object(img, "_get") as get_mock, patch.object(img._snapshot, "copy") as copy_mock:
+            copy_mock.return_value = {r: f"snapshot{i}" for i, r in enumerate(img.image_regions)}
+            get_mock.return_value = None
+            instance.register_image.side_effect = [
+                botocore.exceptions.ClientError(
+                    {
+                        "Error": {
+                            "Code": "OperationNotPermitted",
+                            "Message": "Intentional permission failure for snapshot0",
+                        }
+                    },
+                    "awspub Testing",
+                ),
+                {"ImageId": "id1"},
+            ]
+            with pytest.raises(exceptions.IncompleteImageSetException):
+                img.create() == {"region2": image._ImageInfo("id1", "snapshot1")}
+        # register and create_tags should be called since at least one snapshot made it
+        assert instance.register_image.called
+        assert instance.create_tags.called
+
+
+def test_register_image__should_return_none_on_permission_failures():
+    instance = MagicMock()
+
+    instance.register_image.side_effect = botocore.exceptions.ClientError(
+        {"Error": {"Code": "OperationNotPermitted", "Message": "Testing"}}, "Testing"
+    )
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    img = image.Image(ctx, "test-image-6")
+    snapshot_ids = {"eu-central-1": "my-snapshot"}
+    assert img._register_image(snapshot_ids["eu-central-1"], instance) is None
+
+
+def test_register_image__should_raise_on_unhandled_client_error():
+    instance = MagicMock()
+
+    instance.register_image.side_effect = botocore.exceptions.ClientError(
+        {"Error": {"Code": "UnsupportedOperation", "Message": "Testing"}}, "Testing"
+    )
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    img = image.Image(ctx, "test-image-6")
+    snapshot_ids = {"eu-central-1": "my-snapshot"}
+    with pytest.raises(botocore.exceptions.ClientError):
+        img._register_image(snapshot_ids["eu-central-1"], instance) is None

awspub/tests/test_image_marketplace.py

@@ -0,0 +1,44 @@
+import pathlib
+from unittest.mock import patch
+
+import pytest
+
+from awspub import context, image_marketplace
+
+curdir = pathlib.Path(__file__).parent.resolve()
+
+
+@pytest.mark.parametrize(
+    "imagename,new_version,called_start_change_set",
+    [
+        # same version that already exists
+        ("test-image-8", "1.0.0", False),
+        # new version
+        ("test-image-8", "2.0.0", True),
+    ],
+)
+def test_image_marketplace_request_new_version(imagename, new_version, called_start_change_set):
+    """
+    Test the request_new_version logic
+    """
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.describe_entity.return_value = {"DetailsDocument": {"Versions": [{"VersionTitle": new_version}]}}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        img = image_marketplace.ImageMarketplace(ctx, imagename)
+        img.request_new_version("ami-123")
+        assert instance.start_change_set.called == called_start_change_set
+
+
+@pytest.mark.parametrize(
+    "name,expected",
+    [
+        ("1.0.0", "1.0.0"),
+        ("1.0.0 (testing)", "1.0.0 testing"),
+        ("a sentence with spaces", "a sentence with spaces"),
+        ("_+=.:@-", "_+=.:@-"),
+        ("(parens) [brackets] |pipes|", "parens brackets pipes"),
+    ],
+)
+def test_changeset_name_sanitization(name, expected):
+    assert image_marketplace.ImageMarketplace.sanitize_changeset_name(name) == expected

awspub/tests/test_s3.py

@@ -0,0 +1,74 @@
+import pathlib
+from unittest.mock import patch
+
+import pytest
+
+from awspub import context, s3
+from awspub.exceptions import BucketDoesNotExistException
+
+curdir = pathlib.Path(__file__).parent.resolve()
+
+
+@pytest.mark.parametrize(
+    "list_multipart_uploads_resp,create_multipart_upload_called",
+    [
+        # no available uploads - create one
+        ([], True),
+        # one available upload with non-matching key
+        ([{"UploadId": "abc", "Key": "does-not-match"}], True),
+        # multiple available upload with non-matching key
+        ([{"UploadId": "abc", "Key": "does-not-match"}, {"UploadId": "def", "Key": "does-not-match2"}], True),
+        # one available upload with matching key
+        ([{"UploadId": "abc", "Key": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"}], False),
+        # multiple available upload with one matching key
+        (
+            [
+                {"UploadId": "abc", "Key": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"},
+                {"UploadId": "abc", "Key": "does-not-match"},
+            ],
+            False,
+        ),
+        # multiple available upload with multiple matching keys
+        (
+            [
+                {"UploadId": "abc", "Key": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"},
+                {"UploadId": "def", "Key": "6252475408b9f9ee64452b611d706a078831a99b123db69d144d878a0488a0a8"},
+            ],
+            False,
+        ),
+    ],
+)
+def test_s3__get_multipart_upload_id(list_multipart_uploads_resp, create_multipart_upload_called):
+    """
+    test the _get_multipart_upload_id() function
+    """
+
+    with patch("boto3.client") as bclient_mock:
+        instance = bclient_mock.return_value
+        instance.list_multipart_uploads.return_value = {"Uploads": list_multipart_uploads_resp}
+        ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+        sthree = s3.S3(ctx)
+        sthree._get_multipart_upload_id()
+        assert instance.create_multipart_upload.called == create_multipart_upload_called
+
+
+@patch("awspub.s3.S3._bucket_exists", return_value=True)
+@patch("awspub.s3.boto3")
+def test_s3_bucket_region_bucket_exists(boto3_mock, bucket_exists_mock):
+    region_name = "sample-region-1"
+    head_bucket = {"BucketRegion": region_name}
+    boto3_mock.client.return_value.head_bucket.return_value = head_bucket
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    sthree = s3.S3(ctx)
+
+    assert sthree.bucket_region == region_name
+
+
+@patch("awspub.s3.S3._bucket_exists", return_value=False)
+@patch("boto3.client")
+def test_s3_bucket_region_bucket_not_exists(bclient_mock, bucket_exists_mock):
+    ctx = context.Context(curdir / "fixtures/config1.yaml", None)
+    sthree = s3.S3(ctx)
+
+    with pytest.raises(BucketDoesNotExistException):
+        sthree.bucket_region()