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",)]