def test_StoreBackend_id_initialization(tmp_path_factory):
"""
What does this test and why?
A StoreBackend should have a store_backend_id property. That store_backend_id should be read and initialized
from an existing persistent store_backend_id during instantiation, or a new store_backend_id should be generated
and persisted. The store_backend_id should be a valid UUIDv4
If a new store_backend_id cannot be persisted, use an ephemeral store_backend_id.
Persistence should be in a .ge_store_backend_id file for for filesystem and blob-stores.
Note: StoreBackend & TupleStoreBackend are abstract classes, so we will test the
concrete classes that inherit from them.
See also test_database_store_backend::test_database_store_backend_id_initialization
"""
# InMemoryStoreBackend
# Initialize without store_backend_id and check that it is generated correctly
in_memory_store_backend = InMemoryStoreBackend()
check_store_backend_store_backend_id_functionality(
store_backend=in_memory_store_backend)
# Create a new store with the same config and make sure it reports the same store_backend_id
# in_memory_store_backend_duplicate = InMemoryStoreBackend()
# assert in_memory_store_backend.store_backend_id == in_memory_store_backend_duplicate.store_backend_id
# This is not currently implemented for the InMemoryStoreBackend, the store_backend_id is ephemeral since
# there is no place to persist it.
# TupleFilesystemStoreBackend
# Initialize without store_backend_id and check that it is generated correctly
path = "dummy_str"
project_path = str(
tmp_path_factory.mktemp("test_StoreBackend_id_initialization__dir"))
tuple_filesystem_store_backend = TupleFilesystemStoreBackend(
root_directory=os.path.abspath(path),
base_directory=project_path,
# filepath_template="my_file_{0}",
)
# Check that store_backend_id is created on instantiation, before being accessed
desired_directory_tree_str = """\
test_StoreBackend_id_initialization__dir0/
.ge_store_backend_id
"""
assert gen_directory_tree_str(project_path) == desired_directory_tree_str
check_store_backend_store_backend_id_functionality(
store_backend=tuple_filesystem_store_backend)
assert gen_directory_tree_str(project_path) == desired_directory_tree_str
# Repeat the above with a filepath template
project_path_with_filepath_template = str(
tmp_path_factory.mktemp("test_StoreBackend_id_initialization__dir"))
tuple_filesystem_store_backend_with_filepath_template = TupleFilesystemStoreBackend(
root_directory=os.path.abspath(path),
base_directory=project_path_with_filepath_template,
filepath_template="my_file_{0}",
)
check_store_backend_store_backend_id_functionality(
store_backend=tuple_filesystem_store_backend_with_filepath_template)
assert (gen_directory_tree_str(project_path_with_filepath_template) == """\
test_StoreBackend_id_initialization__dir1/
.ge_store_backend_id
""")
# Create a new store with the same config and make sure it reports the same store_backend_id
tuple_filesystem_store_backend_duplicate = TupleFilesystemStoreBackend(
root_directory=os.path.abspath(path),
base_directory=project_path,
# filepath_template="my_file_{0}",
)
check_store_backend_store_backend_id_functionality(
store_backend=tuple_filesystem_store_backend_duplicate)
assert (tuple_filesystem_store_backend.store_backend_id ==
tuple_filesystem_store_backend_duplicate.store_backend_id)
# TupleS3StoreBackend
# Initialize without store_backend_id and check that it is generated correctly
bucket = "leakybucket"
prefix = "this_is_a_test_prefix"
# create a bucket in Moto's mock AWS environment
conn = boto3.resource("s3", region_name="us-east-1")
conn.create_bucket(Bucket=bucket)
s3_store_backend = TupleS3StoreBackend(
filepath_template="my_file_{0}",
bucket=bucket,
prefix=prefix,
)
check_store_backend_store_backend_id_functionality(
store_backend=s3_store_backend)
# Create a new store with the same config and make sure it reports the same store_backend_id
s3_store_backend_duplicate = TupleS3StoreBackend(
filepath_template="my_file_{0}",
bucket=bucket,
prefix=prefix,
)
check_store_backend_store_backend_id_functionality(
store_backend=s3_store_backend_duplicate)
assert (s3_store_backend.store_backend_id ==
s3_store_backend_duplicate.store_backend_id)
# TODO: Fix GCS Testing
# TupleGCSStoreBackend
# Initialize without store_backend_id and check that it is generated correctly
bucket = "leakybucket"
prefix = "this_is_a_test_prefix"
project = "dummy-project"
base_public_path = "http://www.test.com/"
with patch("google.cloud.storage.Client",
autospec=True) as mock_gcs_client:
gcs_store_backend_with_base_public_path = TupleGCSStoreBackend(
filepath_template=None,
bucket=bucket,
prefix=prefix,
project=project,
base_public_path=base_public_path,
)
gcs_store_backend_with_base_public_path_duplicate = TupleGCSStoreBackend(
filepath_template=None,
bucket=bucket,
prefix=prefix,
project=project,
base_public_path=base_public_path,
)
assert gcs_store_backend_with_base_public_path.store_backend_id is not None
# Currently we don't have a good way to mock GCS functionality
# check_store_backend_store_backend_id_functionality(store_backend=gcs_store_backend_with_base_public_path)
# Create a new store with the same config and make sure it reports the same store_backend_id
assert (
gcs_store_backend_with_base_public_path.store_backend_id ==
gcs_store_backend_with_base_public_path_duplicate.store_backend_id)
store_error_uuid = "00000000-0000-0000-0000-00000000e003"
assert (gcs_store_backend_with_base_public_path.store_backend_id !=
store_error_uuid)
assert (
gcs_store_backend_with_base_public_path_duplicate.store_backend_id
!= store_error_uuid)
def test_InMemoryStoreBackend():
my_store = InMemoryStoreBackend()
my_key = ("A", )
with pytest.raises(InvalidKeyError):
my_store.get(my_key)
my_store.set(my_key, "aaa")
assert my_store.get(my_key) == "aaa"
my_store.set(("B", ), {"x": 1})
assert my_store.has_key(my_key) is True
assert my_store.has_key(("B", )) is True
assert my_store.has_key(("A", )) is True
assert my_store.has_key(("C", )) is False
assert my_store.list_keys() == [(".ge_store_backend_id", ), ("A", ),
("B", )]
with pytest.raises(StoreError):
my_store.get_url_for_key(my_key)
def test_StoreBackendValidation():
backend = InMemoryStoreBackend()
backend._validate_key(("I", "am", "a", "string", "tuple"))
with pytest.raises(TypeError):
backend._validate_key("nope")
with pytest.raises(TypeError):
backend._validate_key(("I", "am", "a", "string", 100))
with pytest.raises(TypeError):
backend._validate_key(("I", "am", "a", "string", None))
# zero-length tuple is allowed
backend._validate_key(())
def test_InMemoryStoreBackend():
my_store = InMemoryStoreBackend()
my_key = ("A",)
with pytest.raises(KeyError):
my_store.get(my_key)
print(my_store.store)
my_store.set(my_key, "aaa")
print(my_store.store)
assert my_store.get(my_key) == "aaa"
my_store.set(("B",), {"x":1})
assert my_store.has_key(my_key) == True
assert my_store.has_key(("B",)) == True
assert my_store.has_key(("A",)) == True
assert my_store.has_key(("C",)) == False
assert my_store.list_keys() == [("A",), ("B",)]