toil 8.2.0__py3-none-any.whl → 9.1.0__py3-none-any.whl

toil/test/docs/scripts/tutorial_staging.py

@@ -4,7 +4,6 @@ from toil.common import Toil
 from toil.job import Job
 from toil.lib.io import mkdtemp
 
-
 class HelloWorld(Job):
     def __init__(self, id):
         Job.__init__(self)
@@ -22,6 +21,7 @@ class HelloWorld(Job):
 
 if __name__ == "__main__":
     jobstore: str = mkdtemp("tutorial_staging")
+    tmp: str = mkdtemp("tutorial_staging_tmp")
     os.rmdir(jobstore)
     options = Job.Runner.getDefaultOptions(jobstore)
     options.logLevel = "INFO"
@@ -29,17 +29,26 @@ if __name__ == "__main__":
 
     with Toil(options) as toil:
         if not toil.options.restart:
-            ioFileDirectory = os.path.join(
-                os.path.dirname(os.path.abspath(__file__)), "stagingExampleFiles"
-            )
-            inputFileID = toil.importFile(
-                "file://" + os.path.abspath(os.path.join(ioFileDirectory, "in.txt"))
-            )
+            # Prepare an input file
+            path = os.path.join(tmp, "in.txt")
+            with open(path, "w") as f:
+                f.write("Hello,\n")
+            # In a real workflow, you would obtain an input file path from the
+            # user.
+
+            # Stage it into the Toil job store.
+            #
+            # Note: this may create a symlink depending on the value of the
+            # --linkImports command line option, in which case the original
+            # input file needs to still exist if the workflow is restarted.
+            inputFileID = toil.importFile(f"file://{path}")
+
+            # Run the workflow
             outputFileID = toil.start(HelloWorld(inputFileID))
         else:
             outputFileID = toil.restart()
 
         toil.exportFile(
             outputFileID,
-            "file://" + os.path.abspath(os.path.join(ioFileDirectory, "out.txt")),
+            "file://" + os.path.join(tmp, "out.txt"),
         )

toil/test/docs/scriptsTest.py

@@ -36,8 +36,9 @@ class ToilDocumentationTest(ToilTest):
 
     def checkExitCode(self, script, extra_args: list[str] = []):
         program = os.path.join(self.directory, "scripts", script)
+        job_store = self._getTestJobStorePath()
         process = subprocess.Popen(
-            [python, program, "file:my-jobstore", "--clean=always"] + extra_args,
+            [python, program, f"file:{job_store}", "--clean=always"] + extra_args,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )

toil/test/jobStores/jobStoreTest.py

@@ -420,27 +420,31 @@ class AbstractJobStoreTest:
 
         def testReadWriteFileStreamTextMode(self):
             """Checks if text mode is compatible for file streams."""
-            jobstore = self.jobstore_initialized
+            jobstore1 = self.jobstore_initialized
+            jobstore2 = self.jobstore_resumed_noconfig
             job = self.arbitraryJob()
-            jobstore.assign_job_id(job)
-            jobstore.create_job(job)
+            jobstore1.assign_job_id(job)
+            jobstore1.create_job(job)
 
             foo = "foo"
             bar = "bar"
 
-            with jobstore.write_file_stream(job.jobStoreID, encoding="utf-8") as (
+            with jobstore1.write_file_stream(job.jobStoreID, encoding="utf-8") as (
                 f,
                 fileID,
             ):
                 f.write(foo)
 
-            with jobstore.read_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.read_file_stream(fileID, encoding="utf-8") as f:
                 self.assertEqual(foo, f.read())
 
-            with jobstore.update_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.update_file_stream(fileID, encoding="utf-8") as f:
                 f.write(bar)
 
-            with jobstore.read_file_stream(fileID, encoding="utf-8") as f:
+            with jobstore1.read_file_stream(fileID, encoding="utf-8") as f:
+                self.assertEqual(bar, f.read())
+
+            with jobstore2.read_file_stream(fileID, encoding="utf-8") as f:
                 self.assertEqual(bar, f.read())
 
         def testPerJobFiles(self):
@@ -1173,6 +1177,9 @@ class AbstractEncryptedJobStoreTest:
             Create an encrypted file. Read it in encrypted mode then try with encryption off
             to ensure that it fails.
             """
+
+            from toil.lib.aws.s3 import AWSBadEncryptionKeyError
+
             phrase = b"This file is encrypted."
             fileName = "foo"
             with self.jobstore_initialized.write_shared_file_stream(
@@ -1186,13 +1193,14 @@ class AbstractEncryptedJobStoreTest:
             self.jobstore_initialized.config.sseKey = None
             try:
                 with self.jobstore_initialized.read_shared_file_stream(fileName) as f:
-                    self.assertEqual(phrase, f.read())
-            except AssertionError as e:
-                self.assertEqual(
-                    "Content is encrypted but no key was provided.", e.args[0]
-                )
-            else:
-                self.fail("Read encryption content with encryption off.")
+                    # If the read goes through, we should fail the assert because
+                    # we read the cyphertext
+                    assert f.read() != phrase, (
+                        "Managed to read plaintext content with encryption off."
+                    )
+            except AWSBadEncryptionKeyError as e:
+                # If the read doesn't go through, we get this.
+                assert "Your AWS encryption key is most likely configured incorrectly" in str(e)
 
 
 class FileJobStoreTest(AbstractJobStoreTest.Test):
@@ -1435,113 +1443,6 @@ class AWSJobStoreTest(AbstractJobStoreTest.Test):
         assert isinstance(self.jobstore_initialized, AWSJobStore)  # type hinting
         self.jobstore_initialized.destroy()
 
-    def testSDBDomainsDeletedOnFailedJobstoreBucketCreation(self):
-        """
-        This test ensures that SDB domains bound to a jobstore are deleted if the jobstore bucket
-        failed to be created.  We simulate a failed jobstore bucket creation by using a bucket in a
-        different region with the same name.
-        """
-        from botocore.exceptions import ClientError
-
-        from toil.jobStores.aws.jobStore import BucketLocationConflictException
-        from toil.lib.aws.session import establish_boto3_session
-        from toil.lib.aws.utils import retry_s3
-
-        externalAWSLocation = "us-west-1"
-        for testRegion in "us-east-1", "us-west-2":
-            # We run this test twice, once with the default s3 server us-east-1 as the test region
-            # and once with another server (us-west-2).  The external server is always us-west-1.
-            # This incidentally tests that the BucketLocationConflictException is thrown when using
-            # both the default, and a non-default server.
-            testJobStoreUUID = str(uuid.uuid4())
-            # Create the bucket at the external region
-            bucketName = "domain-test-" + testJobStoreUUID + "--files"
-            client = establish_boto3_session().client(
-                "s3", region_name=externalAWSLocation
-            )
-            resource = establish_boto3_session().resource(
-                "s3", region_name=externalAWSLocation
-            )
-
-            for attempt in retry_s3(delays=(2, 5, 10, 30, 60), timeout=600):
-                with attempt:
-                    # Create the bucket at the home region
-                    client.create_bucket(
-                        Bucket=bucketName,
-                        CreateBucketConfiguration={
-                            "LocationConstraint": externalAWSLocation
-                        },
-                    )
-
-            owner_tag = os.environ.get("TOIL_OWNER_TAG")
-            if owner_tag:
-                for attempt in retry_s3(delays=(1, 1, 2, 4, 8, 16), timeout=33):
-                    with attempt:
-                        bucket_tagging = resource.BucketTagging(bucketName)
-                        bucket_tagging.put(
-                            Tagging={"TagSet": [{"Key": "Owner", "Value": owner_tag}]}
-                        )
-
-            options = Job.Runner.getDefaultOptions(
-                "aws:" + testRegion + ":domain-test-" + testJobStoreUUID
-            )
-            options.logLevel = "DEBUG"
-            try:
-                with Toil(options) as toil:
-                    pass
-            except BucketLocationConflictException:
-                # Catch the expected BucketLocationConflictException and ensure that the bound
-                # domains don't exist in SDB.
-                sdb = establish_boto3_session().client(
-                    region_name=self.awsRegion(), service_name="sdb"
-                )
-                next_token = None
-                allDomainNames = []
-                while True:
-                    if next_token is None:
-                        domains = sdb.list_domains(MaxNumberOfDomains=100)
-                    else:
-                        domains = sdb.list_domains(
-                            MaxNumberOfDomains=100, NextToken=next_token
-                        )
-                    allDomainNames.extend(domains["DomainNames"])
-                    next_token = domains.get("NextToken")
-                    if next_token is None:
-                        break
-                self.assertFalse([d for d in allDomainNames if testJobStoreUUID in d])
-            else:
-                self.fail()
-            finally:
-                try:
-                    for attempt in retry_s3():
-                        with attempt:
-                            client.delete_bucket(Bucket=bucketName)
-                except ClientError as e:
-                    # The actual HTTP code of the error is in status.
-                    if (
-                        e.response.get("ResponseMetadata", {}).get("HTTPStatusCode")
-                        == 404
-                    ):
-                        # The bucket doesn't exist; maybe a failed delete actually succeeded.
-                        pass
-                    else:
-                        raise
-
-    @slow
-    def testInlinedFiles(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        jobstore = self.jobstore_initialized
-        for encrypted in (True, False):
-            n = AWSJobStore.FileInfo.maxInlinedSize()
-            sizes = (1, n // 2, n - 1, n, n + 1, 2 * n)
-            for size in chain(sizes, islice(reversed(sizes), 1)):
-                s = os.urandom(size)
-                with jobstore.write_shared_file_stream("foo") as f:
-                    f.write(s)
-                with jobstore.read_shared_file_stream("foo") as f:
-                    self.assertEqual(s, f.read())
-
     def testOverlargeJob(self):
         jobstore = self.jobstore_initialized
         jobRequirements = dict(memory=12, cores=34, disk=35, preemptible=True)
@@ -1661,19 +1562,8 @@ class AWSJobStoreTest(AbstractJobStoreTest.Test):
         )
         delete_s3_bucket(resource, bucket.name)
 
-    def _largeLogEntrySize(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        # So we get into the else branch of reader() in uploadStream(multiPart=False):
-        return AWSJobStore.FileInfo.maxBinarySize() * 2
-
-    def _batchDeletionSize(self):
-        from toil.jobStores.aws.jobStore import AWSJobStore
-
-        return AWSJobStore.itemsPerBatchDelete
-
 
-@needs_aws_s3
+# @needs_aws_s3
 class InvalidAWSJobStoreTest(ToilTest):
     def testInvalidJobStoreName(self):
         from toil.jobStores.aws.jobStore import AWSJobStore

toil/test/lib/aws/test_iam.py

@@ -28,9 +28,9 @@ logging.basicConfig(level=logging.DEBUG)
 class IAMTest(ToilTest):
     """Check that given permissions and associated functions perform correctly"""
 
-    def test_permissions_iam(self):
+    def test_permissions_iam(self) -> None:
         granted_perms = {
-            "*": {"Action": ["ec2:*", "iam:*", "s3:*", "sdb:*"], "NotAction": []}
+            "*": {"Action": ["ec2:*", "iam:*", "s3:*"], "NotAction": []}
         }
         assert (
             iam.policy_permissions_allow(
@@ -46,8 +46,8 @@ class IAMTest(ToilTest):
             is True
         )
 
-    def test_negative_permissions_iam(self):
-        granted_perms = {"*": {"Action": ["ec2:*", "s3:*", "sdb:*"], "NotAction": []}}
+    def test_negative_permissions_iam(self) -> None:
+        granted_perms = {"*": {"Action": ["ec2:*", "s3:*"], "NotAction": []}}
         assert (
             iam.policy_permissions_allow(
                 granted_perms, iam.CLUSTER_LAUNCHING_PERMISSIONS
@@ -62,7 +62,7 @@ class IAMTest(ToilTest):
             is False
         )
 
-    def test_wildcard_handling(self):
+    def test_wildcard_handling(self) -> None:
         assert iam.permission_matches_any("iam:CreateRole", ["iam:Create**"]) is True
         assert iam.permission_matches_any("iam:GetUser", ["iam:???????"]) is True
         assert iam.permission_matches_any("iam:ListRoleTags", ["iam:*?*Tags"]) is True
@@ -71,7 +71,7 @@ class IAMTest(ToilTest):
 
     @mock_aws
     @needs_aws_s3  # mock is incomplete, this avoid 'botocore.exceptions.NoCredentialsError: Unable to locate credentials'
-    def test_get_policy_permissions(self):
+    def test_get_policy_permissions(self) -> None:
         mock_iam = boto3.client("iam")
 
         # username that moto pretends we have from client.get_user()
@@ -167,7 +167,7 @@ class IAMTest(ToilTest):
         assert notactions_set == set()
 
     @needs_aws_s3
-    def test_create_delete_iam_role(self):
+    def test_create_delete_iam_role(self) -> None:
         region = "us-west-2"
         role_name = f'test{str(uuid4()).replace("-", "")}'
         with self.subTest("Create role w/policies."):

toil/test/lib/aws/test_s3.py

@@ -18,67 +18,64 @@ from typing import TYPE_CHECKING, Optional
 
 from toil.jobStores.aws.jobStore import AWSJobStore
 from toil.lib.aws.session import establish_boto3_session
-from toil.lib.aws.utils import create_s3_bucket, get_bucket_region
+from toil.lib.aws.utils import create_s3_bucket, delete_s3_bucket, get_bucket_region
 from toil.test import ToilTest, needs_aws_s3
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG)
 
+if TYPE_CHECKING:
+    from mypy_boto3_s3 import S3ServiceResource
+    from mypy_boto3_s3.service_resource import Bucket
 
 @needs_aws_s3
 class S3Test(ToilTest):
     """Confirm the workarounds for us-east-1."""
 
-    if TYPE_CHECKING:
-        from mypy_boto3_s3 import S3ServiceResource
-        from mypy_boto3_s3.service_resource import Bucket
-
     s3_resource: Optional["S3ServiceResource"]
-    bucket: Optional["Bucket"]
 
     @classmethod
     def setUpClass(cls) -> None:
         super().setUpClass()
         session = establish_boto3_session(region_name="us-east-1")
         cls.s3_resource = session.resource("s3", region_name="us-east-1")
-        cls.bucket = None
 
     def test_create_bucket(self) -> None:
         """Test bucket creation for us-east-1."""
         bucket_name = f"toil-s3test-{uuid.uuid4()}"
         assert self.s3_resource
-        S3Test.bucket = create_s3_bucket(self.s3_resource, bucket_name, "us-east-1")
-        S3Test.bucket.wait_until_exists()
-        owner_tag = os.environ.get("TOIL_OWNER_TAG")
-        if owner_tag:
-            bucket_tagging = self.s3_resource.BucketTagging(bucket_name)
-            bucket_tagging.put(
-                Tagging={"TagSet": [{"Key": "Owner", "Value": owner_tag}]}
-            )
-        self.assertEqual(get_bucket_region(bucket_name), "us-east-1")
+        bucket: Optional["Bucket"] = None
+        try:
+            bucket = create_s3_bucket(self.s3_resource, bucket_name, "us-east-1")
+            bucket.wait_until_exists()
+            owner_tag = os.environ.get("TOIL_OWNER_TAG")
+            if owner_tag:
+                bucket_tagging = self.s3_resource.BucketTagging(bucket_name)
+                bucket_tagging.put(
+                    Tagging={"TagSet": [{"Key": "Owner", "Value": owner_tag}]}
+                )
+            self.assertEqual(get_bucket_region(bucket_name), "us-east-1")
 
-        # Make sure all the bucket location getting strategies work on a bucket we created
-        self.assertEqual(
-            get_bucket_region(bucket_name, only_strategies={1}), "us-east-1"
-        )
-        self.assertEqual(
-            get_bucket_region(bucket_name, only_strategies={2}), "us-east-1"
-        )
-        self.assertEqual(
-            get_bucket_region(bucket_name, only_strategies={3}), "us-east-1"
-        )
+            # Make sure all the bucket location getting strategies work on a bucket we created
+            self.assertEqual(
+                get_bucket_region(bucket_name, only_strategies={1}), "us-east-1"
+            )
+            self.assertEqual(
+                get_bucket_region(bucket_name, only_strategies={2}), "us-east-1"
+            )
+            self.assertEqual(
+                get_bucket_region(bucket_name, only_strategies={3}), "us-east-1"
+            )
+        finally:
+            # Clean up the bucket if we managed to make it
+            if bucket is not None:
+                delete_s3_bucket(self.s3_resource, bucket_name)
 
     def test_get_bucket_location_public_bucket(self) -> None:
         """
-        Test getting buket location for a bucket we don't own.
+        Test getting bucket location for a bucket we don't own.
         """
 
         bucket_name = "spacenet-dataset"
         # This bucket happens to live in us-east-1
         self.assertEqual(get_bucket_region(bucket_name), "us-east-1")
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        if cls.bucket:
-            AWSJobStore._delete_bucket(cls.bucket)
-        super().tearDownClass()

toil/test/lib/aws/test_utils.py

@@ -27,35 +27,35 @@ class TagGenerationTest(ToilTest):
     Test for tag generation from environment variables
     """
 
-    def test_build_tag(self):
+    def test_build_tag(self) -> None:
         environment = dict()
         environment["TOIL_OWNER_TAG"] = "😀"
-        environment["TOIL_AWS_TAGS"] = None
+        environment["TOIL_AWS_TAGS"] = ""
         tag_dict = build_tag_dict_from_env(environment)
         assert tag_dict == {"Owner": "😀"}
 
-    def test_empty_aws_tags(self):
+    def test_empty_aws_tags(self) -> None:
         environment = dict()
-        environment["TOIL_OWNER_TAG"] = None
+        environment["TOIL_OWNER_TAG"] = ""
         environment["TOIL_AWS_TAGS"] = "{}"
         tag_dict = build_tag_dict_from_env(environment)
         assert tag_dict == dict()
 
-    def test_incorrect_json_object(self):
+    def test_incorrect_json_object(self) -> None:
         with pytest.raises(SystemExit):
             environment = dict()
-            environment["TOIL_OWNER_TAG"] = None
+            environment["TOIL_OWNER_TAG"] = ""
             environment["TOIL_AWS_TAGS"] = "231"
             tag_dict = build_tag_dict_from_env(environment)
 
-    def test_incorrect_json_emoji(self):
+    def test_incorrect_json_emoji(self) -> None:
         with pytest.raises(SystemExit):
             environment = dict()
-            environment["TOIL_OWNER_TAG"] = None
+            environment["TOIL_OWNER_TAG"] = ""
             environment["TOIL_AWS_TAGS"] = "😀"
             tag_dict = build_tag_dict_from_env(environment)
 
-    def test_build_tag_with_tags(self):
+    def test_build_tag_with_tags(self) -> None:
         environment = dict()
         environment["TOIL_OWNER_TAG"] = "😀"
         environment["TOIL_AWS_TAGS"] = '{"1": "2", " ":")"}'

toil/test/lib/test_url.py

@@ -0,0 +1,69 @@
+# Copyright (C) 2015-2022 Regents of the University of California
+#
+# 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 getpass
+import logging
+
+from pytest_httpserver import HTTPServer
+
+from toil.lib.misc import get_user_name
+from toil.lib.url import URLAccess
+from toil.test import needs_aws_s3, needs_online
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.DEBUG)
+
+class TestURLAccess():
+    """
+    Test URLAccess class handling read, list,
+    and checking the size/existence of resources at given URL
+    """
+
+    def test_get_url_access(self, httpserver: HTTPServer) -> None:
+        httpserver.expect_request("/some_url").respond_with_data("Yep that's a URL")
+        file_url = httpserver.url_for("/some_url")
+        assert URLAccess.url_exists(file_url)
+
+    @needs_aws_s3
+    def test_get_size(self) -> None:
+        size = URLAccess.get_size("s3://toil-datasets/hello.txt")
+        assert isinstance(size, int)
+        assert size > 0
+
+    @needs_aws_s3
+    def test_get_is_directory(self) -> None:
+        assert not URLAccess.get_is_directory("s3://toil-datasets/hello.txt")
+
+    @needs_aws_s3
+    def test_list_url(self) -> None:
+        test_dir = URLAccess.list_url("s3://1000genomes/")
+        assert isinstance(test_dir, list)
+        assert len(test_dir) > 0
+
+    @needs_aws_s3
+    def test_read_from_url(self) -> None:
+        import io
+        output = io.BytesIO()
+        size, executable = URLAccess.read_from_url("s3://toil-datasets/hello.txt", output)
+        assert isinstance(size, int)
+        assert size > 0
+        assert not executable
+        assert len(output.getvalue()) > 0
+
+    @needs_aws_s3
+    def test_open_url(self) -> None:
+        with URLAccess.open_url("s3://toil-datasets/hello.txt") as readable:
+            content = readable.read()
+            assert isinstance(content, bytes)
+            assert len(content) > 0

toil/test/lib/url_plugin_test.py

@@ -0,0 +1,105 @@
+# Copyright (C) 2015-2025 Regents of the University of California
+#
+# 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 logging
+from typing import IO, Optional, Union
+
+from configargparse import ArgParser, ArgumentParser
+
+from toil.batchSystems.abstractBatchSystem import (
+    AbstractBatchSystem,
+    UpdatedBatchJobInfo,
+)
+from toil.batchSystems.cleanup_support import BatchSystemCleanupSupport
+from toil.batchSystems.options import OptionSetter
+from toil.batchSystems.registry import add_batch_system_factory
+from toil.common import Toil, addOptions
+from toil.job import JobDescription
+
+import io
+from urllib.parse import ParseResult
+from toil.test import ToilTest
+from toil.lib.url import URLAccess
+from toil.lib.plugins import register_plugin, remove_plugin
+
+logger = logging.getLogger(__name__)
+
+class FakeURLPlugin(URLAccess):
+    @classmethod
+    def _supports_url(cls, url: ParseResult, export: bool = False) -> bool:
+        return url.scheme == "fake"
+
+    @classmethod
+    def _url_exists(cls, url: ParseResult) -> bool:
+        return url.netloc == "exists"
+
+    @classmethod
+    def _get_size(cls, url: ParseResult) -> int:
+        return 1234
+
+    @classmethod
+    def _get_is_directory(cls, url: ParseResult) -> bool:
+        return url.path.endswith("/")
+
+    @classmethod
+    def _list_url(cls, url: ParseResult) -> list[str]:
+        return ["file1.txt", "subdir/"]
+
+    @classmethod
+    def _read_from_url(cls, url: ParseResult, writable: IO[bytes]) -> tuple[int, bool]:
+        content = b"hello world"
+        writable.write(content)
+        return len(content), False
+
+    @classmethod
+    def _open_url(cls, url: ParseResult) -> IO[bytes]:
+        return io.BytesIO(b"hello world")
+
+    @classmethod
+    def _write_to_url(cls, readable: Union[IO[bytes], IO[str]], url: ParseResult, executable: bool = False) -> None:
+        pass
+
+
+class TestURLAccess(ToilTest):
+    def setUp(self) -> None:
+        super().setUp()
+        register_plugin("url_access", "fake", lambda: FakeURLPlugin)
+
+    def tearDown(self) -> None:
+        remove_plugin("url_access", "fake")
+        super().tearDown()
+
+    def test_url_exists(self) -> None:
+        assert URLAccess.url_exists("fake://exists/resource") == True
+        assert URLAccess.url_exists("fake://missing/resource") == False
+
+    def test_get_size(self) -> None:
+        assert URLAccess.get_size("fake://any/resource") == 1234
+
+    def test_get_is_directory(self) -> None:
+        assert URLAccess.get_is_directory("fake://any/folder/") == True
+        assert URLAccess.get_is_directory("fake://any/file.txt") == False
+
+    def test_list_url(self) -> None:
+        assert URLAccess.list_url("fake://any/folder/") == ["file1.txt", "subdir/"]
+
+    def test_read_from_url(self) -> None:
+        output = io.BytesIO()
+        size, _ = URLAccess.read_from_url("fake://any/resource", output)
+        assert output.getvalue() == b"hello world"
+        assert size == len("hello world")
+
+    def test_open_url(self) -> None:
+        with URLAccess.open_url("fake://any/resource") as stream:
+            content = stream.read()
+            assert content == b"hello world"