repos/googleapis-python-storage-85aa02f/samples/snippets/snippets_test.py

# Copyright 2016 Google, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import io
import os
import tempfile
import time
import uuid

from google.cloud import storage
import google.cloud.exceptions
import pytest
import requests

import storage_add_bucket_label
import storage_async_upload
import storage_batch_request
import storage_bucket_delete_default_kms_key
import storage_change_default_storage_class
import storage_change_file_storage_class
import storage_compose_file
import storage_configure_retries
import storage_copy_file
import storage_copy_file_archived_generation
import storage_cors_configuration
import storage_create_bucket_class_location
import storage_create_bucket_dual_region
import storage_create_bucket_hierarchical_namespace
import storage_create_bucket_object_retention
import storage_define_bucket_website_configuration
import storage_delete_file
import storage_delete_file_archived_generation
import storage_disable_bucket_lifecycle_management
import storage_disable_versioning
import storage_download_byte_range
import storage_download_file
import storage_download_into_memory
import storage_download_public_file
import storage_download_to_stream
import storage_enable_bucket_lifecycle_management
import storage_enable_versioning
import storage_generate_signed_post_policy_v4
import storage_generate_signed_url_v2
import storage_generate_signed_url_v4
import storage_generate_upload_signed_url_v4
import storage_get_autoclass
import storage_get_bucket_labels
import storage_get_bucket_metadata
import storage_get_metadata
import storage_get_service_account
import storage_list_buckets
import storage_list_file_archived_generations
import storage_list_files
import storage_list_files_with_prefix
import storage_make_public
import storage_move_file
import storage_object_get_kms_key
import storage_remove_bucket_label
import storage_remove_cors_configuration
import storage_rename_file
import storage_set_autoclass
import storage_set_bucket_default_kms_key
import storage_set_client_endpoint
import storage_set_object_retention_policy
import storage_set_metadata
import storage_transfer_manager_download_bucket
import storage_transfer_manager_download_chunks_concurrently
import storage_transfer_manager_download_many
import storage_transfer_manager_upload_chunks_concurrently
import storage_transfer_manager_upload_directory
import storage_transfer_manager_upload_many
import storage_upload_file
import storage_upload_from_memory
import storage_upload_from_stream
import storage_upload_with_kms_key

KMS_KEY = os.environ.get("CLOUD_KMS_KEY")


def test_enable_default_kms_key(test_bucket):
    storage_set_bucket_default_kms_key.enable_default_kms_key(
        bucket_name=test_bucket.name, kms_key_name=KMS_KEY
    )
    time.sleep(2)  # Let change propagate as needed
    bucket = storage.Client().get_bucket(test_bucket.name)
    assert bucket.default_kms_key_name.startswith(KMS_KEY)
    bucket.default_kms_key_name = None
    bucket.patch()


def test_get_bucket_labels(test_bucket):
    storage_get_bucket_labels.get_bucket_labels(test_bucket.name)


def test_add_bucket_label(test_bucket, capsys):
    storage_add_bucket_label.add_bucket_label(test_bucket.name)
    out, _ = capsys.readouterr()
    assert "example" in out


def test_remove_bucket_label(test_bucket, capsys):
    storage_add_bucket_label.add_bucket_label(test_bucket.name)
    storage_remove_bucket_label.remove_bucket_label(test_bucket.name)
    out, _ = capsys.readouterr()
    assert "Removed labels" in out


@pytest.fixture(scope="module")
def test_bucket():
    """Yields a bucket that is deleted after the test completes."""
    bucket = None
    while bucket is None or bucket.exists():
        bucket_name = f"storage-snippets-test-{uuid.uuid4()}"
        bucket = storage.Client().bucket(bucket_name)
    bucket.create()
    yield bucket
    bucket.delete(force=True)


@pytest.fixture(scope="function")
def test_public_bucket():
    # The new projects don't allow to make a bucket available to public, so
    # for some tests we need to use the old main project for now.
    original_value = os.environ["GOOGLE_CLOUD_PROJECT"]
    os.environ["GOOGLE_CLOUD_PROJECT"] = os.environ["MAIN_GOOGLE_CLOUD_PROJECT"]
    bucket = None
    while bucket is None or bucket.exists():
        storage_client = storage.Client()
        bucket_name = f"storage-snippets-test-{uuid.uuid4()}"
        bucket = storage_client.bucket(bucket_name)
    storage_client.create_bucket(bucket)
    yield bucket
    bucket.delete(force=True)
    # Set the value back.
    os.environ["GOOGLE_CLOUD_PROJECT"] = original_value


@pytest.fixture(scope="module")
def new_bucket_obj():
    """Yields a new bucket object that is deleted after the test completes."""
    bucket = None
    while bucket is None or bucket.exists():
        bucket_name = f"storage-snippets-test-{uuid.uuid4()}"
        bucket = storage.Client().bucket(bucket_name)
    yield bucket
    bucket.delete(force=True)


@pytest.fixture
def test_blob(test_bucket):
    """Yields a blob that is deleted after the test completes."""
    bucket = test_bucket
    blob = bucket.blob(f"storage_snippets_test_sigil-{uuid.uuid4()}")
    blob.upload_from_string("Hello, is it me you're looking for?")
    yield blob


@pytest.fixture(scope="function")
def test_public_blob(test_public_bucket):
    """Yields a blob that is deleted after the test completes."""
    bucket = test_public_bucket
    blob = bucket.blob(f"storage_snippets_test_sigil-{uuid.uuid4()}")
    blob.upload_from_string("Hello, is it me you're looking for?")
    yield blob


@pytest.fixture
def test_bucket_create():
    """Yields a bucket object that is deleted after the test completes."""
    bucket = None
    while bucket is None or bucket.exists():
        bucket_name = f"storage-snippets-test-{uuid.uuid4()}"
        bucket = storage.Client().bucket(bucket_name)
    yield bucket
    bucket.delete(force=True)


def test_list_buckets(test_bucket, capsys):
    storage_list_buckets.list_buckets()
    out, _ = capsys.readouterr()
    assert test_bucket.name in out


def test_list_blobs(test_blob, capsys):
    storage_list_files.list_blobs(test_blob.bucket.name)
    out, _ = capsys.readouterr()
    assert test_blob.name in out


def test_bucket_metadata(test_bucket, capsys):
    storage_get_bucket_metadata.bucket_metadata(test_bucket.name)
    out, _ = capsys.readouterr()
    assert test_bucket.name in out


def test_list_blobs_with_prefix(test_blob, capsys):
    storage_list_files_with_prefix.list_blobs_with_prefix(
        test_blob.bucket.name, prefix="storage_snippets"
    )
    out, _ = capsys.readouterr()
    assert test_blob.name in out


def test_upload_blob(test_bucket):
    with tempfile.NamedTemporaryFile() as source_file:
        source_file.write(b"test")
        source_file.flush()

        storage_upload_file.upload_blob(
            test_bucket.name, source_file.name, "test_upload_blob"
        )


def test_upload_blob_from_memory(test_bucket, capsys):
    storage_upload_from_memory.upload_blob_from_memory(
        test_bucket.name, "Hello, is it me you're looking for?", "test_upload_blob"
    )
    out, _ = capsys.readouterr()

    assert "Hello, is it me you're looking for?" in out


def test_upload_blob_from_stream(test_bucket, capsys):
    file_obj = io.StringIO()
    file_obj.write("This is test data.")
    storage_upload_from_stream.upload_blob_from_stream(
        test_bucket.name, file_obj, "test_upload_blob"
    )
    out, _ = capsys.readouterr()

    assert "Stream data uploaded to test_upload_blob" in out


def test_upload_blob_with_kms(test_bucket):
    blob_name = f"test_upload_with_kms_{uuid.uuid4().hex}"
    with tempfile.NamedTemporaryFile() as source_file:
        source_file.write(b"test")
        source_file.flush()
        storage_upload_with_kms_key.upload_blob_with_kms(
            test_bucket.name,
            source_file.name,
            blob_name,
            KMS_KEY,
        )
        bucket = storage.Client().bucket(test_bucket.name)
        kms_blob = bucket.get_blob(blob_name)
        assert kms_blob.kms_key_name.startswith(KMS_KEY)
    test_bucket.delete_blob(blob_name)


def test_async_upload(bucket, capsys):
    asyncio.run(storage_async_upload.async_upload_blob(bucket.name))
    out, _ = capsys.readouterr()
    assert f"Uploaded 3 files to bucket {bucket.name}" in out


def test_download_byte_range(test_blob):
    with tempfile.NamedTemporaryFile() as dest_file:
        storage_download_byte_range.download_byte_range(
            test_blob.bucket.name, test_blob.name, 0, 4, dest_file.name
        )
        assert dest_file.read() == b"Hello"


def test_download_blob(test_blob):
    with tempfile.NamedTemporaryFile() as dest_file:
        storage_download_file.download_blob(
            test_blob.bucket.name, test_blob.name, dest_file.name
        )

        assert dest_file.read()


def test_download_blob_into_memory(test_blob, capsys):
    storage_download_into_memory.download_blob_into_memory(
        test_blob.bucket.name, test_blob.name
    )
    out, _ = capsys.readouterr()

    assert "Hello, is it me you're looking for?" in out


def test_download_blob_to_stream(test_blob, capsys):
    file_obj = io.BytesIO()
    storage_download_to_stream.download_blob_to_stream(
        test_blob.bucket.name, test_blob.name, file_obj
    )
    out, _ = capsys.readouterr()

    file_obj.seek(0)
    content = file_obj.read()

    assert "Downloaded blob" in out
    assert b"Hello, is it me you're looking for?" in content


def test_blob_metadata(test_blob, capsys):
    storage_get_metadata.blob_metadata(test_blob.bucket.name, test_blob.name)
    out, _ = capsys.readouterr()
    assert test_blob.name in out


def test_set_blob_metadata(test_blob, capsys):
    storage_set_metadata.set_blob_metadata(test_blob.bucket.name, test_blob.name)
    out, _ = capsys.readouterr()
    assert test_blob.name in out


def test_delete_blob(test_blob):
    storage_delete_file.delete_blob(test_blob.bucket.name, test_blob.name)


def test_make_blob_public(test_public_blob):
    storage_make_public.make_blob_public(
        test_public_blob.bucket.name, test_public_blob.name
    )

    r = requests.get(test_public_blob.public_url)
    assert r.text == "Hello, is it me you're looking for?"


def test_generate_signed_url(test_blob, capsys):
    url = storage_generate_signed_url_v2.generate_signed_url(
        test_blob.bucket.name, test_blob.name
    )

    r = requests.get(url)
    assert r.text == "Hello, is it me you're looking for?"


def test_generate_download_signed_url_v4(test_blob, capsys):
    url = storage_generate_signed_url_v4.generate_download_signed_url_v4(
        test_blob.bucket.name, test_blob.name
    )

    r = requests.get(url)
    assert r.text == "Hello, is it me you're looking for?"


def test_generate_upload_signed_url_v4(test_bucket, capsys):
    blob_name = "storage_snippets_test_upload"
    content = b"Uploaded via v4 signed url"
    url = storage_generate_upload_signed_url_v4.generate_upload_signed_url_v4(
        test_bucket.name, blob_name
    )

    requests.put(
        url,
        data=content,
        headers={"content-type": "application/octet-stream"},
    )

    bucket = storage.Client().bucket(test_bucket.name)
    blob = bucket.blob(blob_name)
    assert blob.download_as_bytes() == content


def test_generate_signed_policy_v4(test_bucket, capsys):
    blob_name = "storage_snippets_test_form"
    short_name = storage_generate_signed_post_policy_v4
    form = short_name.generate_signed_post_policy_v4(test_bucket.name, blob_name)
    assert f"name='key' value='{blob_name}'" in form
    assert "name='x-goog-signature'" in form
    assert "name='x-goog-date'" in form
    assert "name='x-goog-credential'" in form
    assert "name='x-goog-algorithm' value='GOOG4-RSA-SHA256'" in form
    assert "name='policy'" in form
    assert "name='x-goog-meta-test' value='data'" in form
    assert "type='file' name='file'/>" in form


def test_rename_blob(test_blob):
    bucket = storage.Client().bucket(test_blob.bucket.name)

    try:
        bucket.delete_blob("test_rename_blob")
    except google.cloud.exceptions.exceptions.NotFound:
        print(f"test_rename_blob not found in bucket {bucket.name}")

    storage_rename_file.rename_blob(bucket.name, test_blob.name, "test_rename_blob")

    assert bucket.get_blob("test_rename_blob") is not None
    assert bucket.get_blob(test_blob.name) is None


def test_move_blob(test_bucket_create, test_blob):
    bucket = test_blob.bucket
    storage.Client().create_bucket(test_bucket_create)

    try:
        test_bucket_create.delete_blob("test_move_blob")
    except google.cloud.exceptions.NotFound:
        print(f"test_move_blob not found in bucket {test_bucket_create.name}")

    storage_move_file.move_blob(
        bucket.name,
        test_blob.name,
        test_bucket_create.name,
        "test_move_blob",
    )

    assert test_bucket_create.get_blob("test_move_blob") is not None
    assert bucket.get_blob(test_blob.name) is None


def test_copy_blob(test_blob):
    bucket = storage.Client().bucket(test_blob.bucket.name)

    try:
        bucket.delete_blob("test_copy_blob")
    except google.cloud.exceptions.NotFound:
        pass

    storage_copy_file.copy_blob(
        bucket.name,
        test_blob.name,
        bucket.name,
        "test_copy_blob",
    )

    assert bucket.get_blob("test_copy_blob") is not None
    assert bucket.get_blob(test_blob.name) is not None


def test_versioning(test_bucket, capsys):
    bucket = storage_enable_versioning.enable_versioning(test_bucket)
    out, _ = capsys.readouterr()
    assert "Versioning was enabled for bucket" in out
    assert bucket.versioning_enabled is True

    bucket = storage_disable_versioning.disable_versioning(test_bucket)
    out, _ = capsys.readouterr()
    assert "Versioning was disabled for bucket" in out
    assert bucket.versioning_enabled is False


def test_get_set_autoclass(new_bucket_obj, test_bucket, capsys):
    # Test default values when Autoclass is unset
    bucket = storage_get_autoclass.get_autoclass(test_bucket.name)
    out, _ = capsys.readouterr()
    assert "Autoclass enabled is set to False" in out
    assert bucket.autoclass_toggle_time is None
    assert bucket.autoclass_terminal_storage_class_update_time is None

    # Test enabling Autoclass at bucket creation
    new_bucket_obj.autoclass_enabled = True
    bucket = storage.Client().create_bucket(new_bucket_obj)
    assert bucket.autoclass_enabled is True
    assert bucket.autoclass_terminal_storage_class == "NEARLINE"

    # Test set terminal_storage_class to ARCHIVE
    bucket = storage_set_autoclass.set_autoclass(bucket.name)
    out, _ = capsys.readouterr()
    assert "Autoclass enabled is set to True" in out
    assert bucket.autoclass_enabled is True
    assert bucket.autoclass_terminal_storage_class == "ARCHIVE"

    # Test get Autoclass
    bucket = storage_get_autoclass.get_autoclass(bucket.name)
    out, _ = capsys.readouterr()
    assert "Autoclass enabled is set to True" in out
    assert bucket.autoclass_toggle_time is not None
    assert bucket.autoclass_terminal_storage_class_update_time is not None


def test_bucket_lifecycle_management(test_bucket, capsys):
    bucket = (
        storage_enable_bucket_lifecycle_management.enable_bucket_lifecycle_management(
            test_bucket
        )
    )
    out, _ = capsys.readouterr()
    assert "[]" in out
    assert "Lifecycle management is enable" in out
    assert len(list(bucket.lifecycle_rules)) > 0

    bucket = (
        storage_disable_bucket_lifecycle_management.disable_bucket_lifecycle_management(
            test_bucket
        )
    )
    out, _ = capsys.readouterr()
    assert "[]" in out
    assert len(list(bucket.lifecycle_rules)) == 0


def test_create_bucket_class_location(test_bucket_create):
    bucket = storage_create_bucket_class_location.create_bucket_class_location(
        test_bucket_create.name
    )

    assert bucket.location == "US"
    assert bucket.storage_class == "COLDLINE"


def test_create_bucket_dual_region(test_bucket_create, capsys):
    location = "US"
    region_1 = "US-EAST1"
    region_2 = "US-WEST1"
    storage_create_bucket_dual_region.create_bucket_dual_region(
        test_bucket_create.name, location, region_1, region_2
    )
    out, _ = capsys.readouterr()
    assert f"Created bucket {test_bucket_create.name}" in out
    assert location in out
    assert region_1 in out
    assert region_2 in out
    assert "dual-region" in out


def test_bucket_delete_default_kms_key(test_bucket, capsys):
    test_bucket.default_kms_key_name = KMS_KEY
    test_bucket.patch()

    assert test_bucket.default_kms_key_name == KMS_KEY

    bucket = storage_bucket_delete_default_kms_key.bucket_delete_default_kms_key(
        test_bucket.name
    )

    out, _ = capsys.readouterr()
    assert bucket.default_kms_key_name is None
    assert bucket.name in out


def test_get_service_account(capsys):
    storage_get_service_account.get_service_account()

    out, _ = capsys.readouterr()

    assert "@gs-project-accounts.iam.gserviceaccount.com" in out


def test_download_public_file(test_public_blob):
    storage_make_public.make_blob_public(
        test_public_blob.bucket.name, test_public_blob.name
    )
    with tempfile.NamedTemporaryFile() as dest_file:
        storage_download_public_file.download_public_file(
            test_public_blob.bucket.name, test_public_blob.name, dest_file.name
        )

        assert dest_file.read() == b"Hello, is it me you're looking for?"


def test_define_bucket_website_configuration(test_bucket):
    bucket = (
        storage_define_bucket_website_configuration.define_bucket_website_configuration(
            test_bucket.name, "index.html", "404.html"
        )
    )

    website_val = {"mainPageSuffix": "index.html", "notFoundPage": "404.html"}

    assert bucket._properties["website"] == website_val


def test_object_get_kms_key(test_bucket):
    with tempfile.NamedTemporaryFile() as source_file:
        storage_upload_with_kms_key.upload_blob_with_kms(
            test_bucket.name,
            source_file.name,
            "test_upload_blob_encrypted",
            KMS_KEY,
        )
    kms_key = storage_object_get_kms_key.object_get_kms_key(
        test_bucket.name, "test_upload_blob_encrypted"
    )

    assert kms_key.startswith(KMS_KEY)


def test_storage_compose_file(test_bucket):
    source_files = ["test_upload_blob_1", "test_upload_blob_2"]
    for source in source_files:
        blob = test_bucket.blob(source)
        blob.upload_from_string(source)

    with tempfile.NamedTemporaryFile() as dest_file:
        destination = storage_compose_file.compose_file(
            test_bucket.name,
            source_files[0],
            source_files[1],
            dest_file.name,
        )
        composed = destination.download_as_bytes()

        assert composed.decode("utf-8") == source_files[0] + source_files[1]


def test_cors_configuration(test_bucket, capsys):
    bucket = storage_cors_configuration.cors_configuration(test_bucket)
    out, _ = capsys.readouterr()
    assert "Set CORS policies for bucket" in out
    assert len(bucket.cors) > 0

    bucket = storage_remove_cors_configuration.remove_cors_configuration(test_bucket)
    out, _ = capsys.readouterr()
    assert "Remove CORS policies for bucket" in out
    assert len(bucket.cors) == 0


def test_delete_blobs_archived_generation(test_blob, capsys):
    storage_delete_file_archived_generation.delete_file_archived_generation(
        test_blob.bucket.name, test_blob.name, test_blob.generation
    )
    out, _ = capsys.readouterr()
    assert "blob " + test_blob.name + " was deleted" in out
    blob = test_blob.bucket.get_blob(test_blob.name, generation=test_blob.generation)
    assert blob is None


def test_change_default_storage_class(test_bucket, capsys):
    bucket = storage_change_default_storage_class.change_default_storage_class(
        test_bucket
    )
    out, _ = capsys.readouterr()
    assert "Default storage class for bucket" in out
    assert bucket.storage_class == "COLDLINE"


def test_change_file_storage_class(test_blob, capsys):
    blob = storage_change_file_storage_class.change_file_storage_class(
        test_blob.bucket.name,
        test_blob.name,
    )
    out, _ = capsys.readouterr()
    assert f"Blob {blob.name} in bucket {blob.bucket.name}" in out
    assert blob.storage_class == "NEARLINE"


def test_copy_file_archived_generation(test_blob):
    bucket = storage.Client().bucket(test_blob.bucket.name)

    try:
        bucket.delete_blob("test_copy_blob")
    except google.cloud.exceptions.NotFound:
        pass

    storage_copy_file_archived_generation.copy_file_archived_generation(
        bucket.name, test_blob.name, bucket.name, "test_copy_blob", test_blob.generation
    )

    assert bucket.get_blob("test_copy_blob") is not None
    assert bucket.get_blob(test_blob.name) is not None


def test_list_blobs_archived_generation(test_blob, capsys):
    storage_list_file_archived_generations.list_file_archived_generations(
        test_blob.bucket.name
    )
    out, _ = capsys.readouterr()
    assert str(test_blob.generation) in out


def test_storage_configure_retries(test_blob, capsys):
    storage_configure_retries.configure_retries(test_blob.bucket.name, test_blob.name)

    # This simply checks if the retry configurations were set and printed as intended.
    out, _ = capsys.readouterr()
    assert "The following library method is customized to be retried" in out
    assert "_should_retry" in out
    assert "initial=1.5, maximum=45.0, multiplier=1.2" in out
    assert "500" in out  # "deadline" or "timeout" depending on dependency ver.


def test_batch_request(test_bucket):
    blob1 = test_bucket.blob("b/1.txt")
    blob2 = test_bucket.blob("b/2.txt")
    blob1.upload_from_string("hello world")
    blob2.upload_from_string("hello world")

    storage_batch_request.batch_request(test_bucket.name, "b/")
    blob1.reload()
    blob2.reload()

    assert blob1.metadata.get("your-metadata-key") == "your-metadata-value"
    assert blob2.metadata.get("your-metadata-key") == "your-metadata-value"


def test_storage_set_client_endpoint(capsys):
    storage_set_client_endpoint.set_client_endpoint("https://storage.googleapis.com")
    out, _ = capsys.readouterr()

    assert "client initiated with endpoint: https://storage.googleapis.com" in out


def test_transfer_manager_snippets(test_bucket, capsys):
    BLOB_NAMES = [
        "test.txt",
        "test2.txt",
        "blobs/test.txt",
        "blobs/nesteddir/test.txt",
    ]

    with tempfile.TemporaryDirectory() as uploads:
        # Create dirs and nested dirs
        for name in BLOB_NAMES:
            relpath = os.path.dirname(name)
            os.makedirs(os.path.join(uploads, relpath), exist_ok=True)

        # Create files with nested dirs to exercise directory handling.
        for name in BLOB_NAMES:
            with open(os.path.join(uploads, name), "w") as f:
                f.write(name)

        storage_transfer_manager_upload_many.upload_many_blobs_with_transfer_manager(
            test_bucket.name,
            BLOB_NAMES,
            source_directory="{}/".format(uploads),
            workers=8,
        )
        out, _ = capsys.readouterr()

        for name in BLOB_NAMES:
            assert "Uploaded {}".format(name) in out

    with tempfile.TemporaryDirectory() as downloads:
        # Download the files.
        storage_transfer_manager_download_bucket.download_bucket_with_transfer_manager(
            test_bucket.name,
            destination_directory=os.path.join(downloads, ""),
            workers=8,
            max_results=10000,
        )
        out, _ = capsys.readouterr()

        for name in BLOB_NAMES:
            assert "Downloaded {}".format(name) in out

    with tempfile.TemporaryDirectory() as downloads:
        # Download the files.
        storage_transfer_manager_download_many.download_many_blobs_with_transfer_manager(
            test_bucket.name,
            blob_names=BLOB_NAMES,
            destination_directory=os.path.join(downloads, ""),
            workers=8,
        )
        out, _ = capsys.readouterr()

        for name in BLOB_NAMES:
            assert "Downloaded {}".format(name) in out


def test_transfer_manager_directory_upload(test_bucket, capsys):
    BLOB_NAMES = [
        "dirtest/test.txt",
        "dirtest/test2.txt",
        "dirtest/blobs/test.txt",
        "dirtest/blobs/nesteddir/test.txt",
    ]

    with tempfile.TemporaryDirectory() as uploads:
        # Create dirs and nested dirs
        for name in BLOB_NAMES:
            relpath = os.path.dirname(name)
            os.makedirs(os.path.join(uploads, relpath), exist_ok=True)

        # Create files with nested dirs to exercise directory handling.
        for name in BLOB_NAMES:
            with open(os.path.join(uploads, name), "w") as f:
                f.write(name)

        storage_transfer_manager_upload_directory.upload_directory_with_transfer_manager(
            test_bucket.name, source_directory="{}/".format(uploads)
        )
        out, _ = capsys.readouterr()

        assert "Found {}".format(len(BLOB_NAMES)) in out
        for name in BLOB_NAMES:
            assert "Uploaded {}".format(name) in out


def test_transfer_manager_download_chunks_concurrently(test_bucket, capsys):
    BLOB_NAME = "test_file.txt"

    with tempfile.NamedTemporaryFile() as file:
        file.write(b"test")
        file.flush()

        storage_upload_file.upload_blob(test_bucket.name, file.name, BLOB_NAME)

    with tempfile.TemporaryDirectory() as downloads:
        # Download the file.
        storage_transfer_manager_download_chunks_concurrently.download_chunks_concurrently(
            test_bucket.name,
            BLOB_NAME,
            os.path.join(downloads, BLOB_NAME),
            workers=8,
        )
        out, _ = capsys.readouterr()

        assert (
            "Downloaded {} to {}".format(BLOB_NAME, os.path.join(downloads, BLOB_NAME))
            in out
        )


def test_transfer_manager_upload_chunks_concurrently(test_bucket, capsys):
    BLOB_NAME = "test_file.txt"

    with tempfile.NamedTemporaryFile() as file:
        file.write(b"test")
        file.flush()

        storage_transfer_manager_upload_chunks_concurrently.upload_chunks_concurrently(
            test_bucket.name, file.name, BLOB_NAME
        )

        out, _ = capsys.readouterr()
        assert "File {} uploaded to {}".format(file.name, BLOB_NAME) in out


def test_object_retention_policy(test_bucket_create, capsys):
    storage_create_bucket_object_retention.create_bucket_object_retention(
        test_bucket_create.name
    )
    out, _ = capsys.readouterr()
    assert f"Created bucket {test_bucket_create.name} with object retention enabled setting" in out

    blob_name = "test_object_retention"
    storage_set_object_retention_policy.set_object_retention_policy(
        test_bucket_create.name, "hello world", blob_name
    )
    out, _ = capsys.readouterr()
    assert f"Retention policy for file {blob_name}" in out

    # Remove retention policy for test cleanup
    blob = test_bucket_create.blob(blob_name)
    blob.retention.mode = None
    blob.retention.retain_until_time = None
    blob.patch(override_unlocked_retention=True)


def test_create_bucket_hierarchical_namespace(test_bucket_create, capsys):
    storage_create_bucket_hierarchical_namespace.create_bucket_hierarchical_namespace(
        test_bucket_create.name
    )
    out, _ = capsys.readouterr()
    assert f"Created bucket {test_bucket_create.name} with hierarchical namespace enabled" in out