diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 8b085e791..fdf83c188 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -31,7 +31,7 @@ repos:
     hooks:
       - id: mypy
         exclude: (docs/.*)
-        additional_dependencies: ["types-filelock", "types-freezegun", "types-pkg_resources"]
+        additional_dependencies: ["attrs", "types-filelock", "types-freezegun", "types-pkg_resources"]
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0
diff --git a/CHANGES.md b/CHANGES.md
index 6f84930bf..e91086c4d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -8,6 +8,11 @@
 
 - Updated documentation for `[mirror]` configuration options `PR #1669`
 
+## Bug Fixes
+
+- Don't write a diff file unless the 'diff-file' option is set in the configuration file `PR #1694`
+- Correctly interpret references with surrounding text when using custom reference syntax in 'diff-file' `PR #1694`
+
 # 6.5.0
 
 ## New Features
diff --git a/src/bandersnatch/config/__init__.py b/src/bandersnatch/config/__init__.py
new file mode 100644
index 000000000..565b68aad
--- /dev/null
+++ b/src/bandersnatch/config/__init__.py
@@ -0,0 +1,4 @@
+# flake8: noqa
+from .core import BandersnatchConfig
+from .errors import ConfigurationError, InvalidValueError, MissingOptionError
+from .mirror_options import MirrorOptions
diff --git a/src/bandersnatch/config/attrs_utils.py b/src/bandersnatch/config/attrs_utils.py
new file mode 100644
index 000000000..c47e7cdcc
--- /dev/null
+++ b/src/bandersnatch/config/attrs_utils.py
@@ -0,0 +1,72 @@
+from collections.abc import Callable
+from configparser import ConfigParser
+from typing import Any, TypeAlias, TypeVar
+
+import attrs
+from attrs import Attribute
+
+from . import errors
+
+AttrsConverter: TypeAlias = Callable[[Any], Any]
+AttrsFieldTransformer: TypeAlias = Callable[[type, list[Attribute]], list[Attribute]]
+
+_V = TypeVar("_V")
+AttrsValidator: TypeAlias = Callable[[Any, Attribute, _V], _V]
+
+
+def only_if_str(converter_fn: AttrsConverter) -> AttrsConverter:
+    """Wrap an attrs converter function so it is only applied to strings.
+
+    'converter' functions on attrs fields are applied to all values set to the field,
+    *including* the default value. This causes problems if the default value is already
+    the desired type but the converter only handles strings.
+
+    :param AttrsConverter converter_fn: any attrs converter
+    :return AttrsConverter: converter function that uses `converter_fn` if the passed
+        value is a string, and otherwise returns the value unmodified.
+    """
+
+    def _apply_if_str(value: Any) -> Any:
+        if isinstance(value, str):
+            return converter_fn(value)
+        else:
+            return value
+
+    return _apply_if_str
+
+
+def get_name_value_for_option(
+    config: ConfigParser, section_name: str, option: Attribute
+) -> tuple[str, object | None]:
+    option_name = config.optionxform(option.alias or option.name)
+
+    if option.default is attrs.NOTHING and not config.has_option(
+        section_name, option_name
+    ):
+        raise errors.MissingOptionError.for_option(section_name, option_name)
+
+    getter: Callable[..., Any]
+    if option.converter is not None:
+        getter = config.get
+    elif option.type == bool:
+        getter = config.getboolean
+    elif option.type == float:
+        getter = config.getfloat
+    elif option.type == int:
+        getter = config.getint
+    else:
+        getter = config.get
+
+    try:
+        option_value = getter(section_name, option_name, fallback=None)
+    except ValueError as conversion_error:
+        type_name = option.type.__name__ if option.type else "???"
+        message = f"can't convert option name '{option_name}' to expected type '{type_name}': {conversion_error!s}"
+        raise errors.InvalidValueError.for_option(
+            section_name, option_name, message
+        ) from conversion_error
+
+    return option_name, option_value
+
+
+validate_not_empty: AttrsValidator = attrs.validators.min_len(1)
diff --git a/src/bandersnatch/config/comparison_method.py b/src/bandersnatch/config/comparison_method.py
new file mode 100644
index 000000000..f2a356c8b
--- /dev/null
+++ b/src/bandersnatch/config/comparison_method.py
@@ -0,0 +1,30 @@
+"""Enumeration of supported file comparison strategies"""
+
+import sys
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from bandersnatch.utils import StrEnum
+
+
+class ComparisonMethod(StrEnum):
+    HASH = "hash"
+    STAT = "stat"
+
+
+class InvalidComparisonMethod(ValueError):
+    """We don't have a valid comparison method choice from configuration"""
+
+    pass
+
+
+def get_comparison_value(method: str) -> ComparisonMethod:
+    try:
+        return ComparisonMethod(method)
+    except ValueError:
+        valid_methods = sorted(v.value for v in ComparisonMethod)
+        raise InvalidComparisonMethod(
+            f"{method} is not a valid file comparison method. "
+            + f"Valid options are: {valid_methods}"
+        )
diff --git a/src/bandersnatch/config/core.py b/src/bandersnatch/config/core.py
new file mode 100644
index 000000000..e2e07549f
--- /dev/null
+++ b/src/bandersnatch/config/core.py
@@ -0,0 +1,63 @@
+import importlib.resources
+import shutil
+import sys
+from collections.abc import Mapping
+from configparser import ConfigParser, ExtendedInterpolation
+from pathlib import Path
+from typing import Protocol, TypeVar, cast
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    Self = TypeVar("Self", bound="ConfigModel")
+
+
+class ConfigModel(Protocol):
+
+    @classmethod
+    def from_config_parser(cls: type[Self], source: ConfigParser) -> Self: ...
+
+
+_C = TypeVar("_C", bound=ConfigModel)
+
+
+class BandersnatchConfig(ConfigParser):
+
+    def __init__(self, defaults: Mapping[str, str] | None = None) -> None:
+        super().__init__(
+            defaults=defaults,
+            delimiters=("=",),
+            strict=True,
+            interpolation=ExtendedInterpolation(),
+        )
+
+        self._validate_config_models: dict[str, ConfigModel] = {}
+
+    # This allows writing option names in the config file with either '_' or '-' as word separators
+    def optionxform(self, optionstr: str) -> str:
+        return optionstr.lower().replace("-", "_")
+
+    def read_path(self, file_path: Path) -> None:
+        with file_path.open() as cfg_file:
+            self.read_file(cfg_file)
+
+    def get_validated(self, model: type[_C]) -> _C:
+        name = model.__qualname__
+        if name not in self._validate_config_models:
+            self._validate_config_models[name] = model.from_config_parser(self)
+        return cast(_C, self._validate_config_models[name])
+
+    @classmethod
+    def from_path(
+        cls, source_file: Path, *, defaults: Mapping[str, str] | None = None
+    ) -> "BandersnatchConfig":
+        config = cls(defaults=defaults)
+        config.read_path(source_file)
+        return config
+
+
+def write_default_config_file(dest: Path) -> None:
+    with importlib.resources.path(
+        "bandersnatch", "default.conf"
+    ) as default_config_path:
+        shutil.copy(default_config_path, dest)
diff --git a/src/bandersnatch/config/diff_file_reference.py b/src/bandersnatch/config/diff_file_reference.py
new file mode 100644
index 000000000..2d7a02ec4
--- /dev/null
+++ b/src/bandersnatch/config/diff_file_reference.py
@@ -0,0 +1,60 @@
+"""
+Custom configparser section/option reference syntax for the diff-file option.
+
+diff-file supports a "section reference" syntax for it's value:
+
+    [mirror]
+    ...
+    diff-file = /folder{{ <SECTION>_<OPTION> }}/more
+
+<SECTION> matches a configparser section and <OPTION> matches an option in that section.
+The portion of the diff-file value delimited with {{ and }} is replaced with the
+value from the specified option, which should be a string.
+
+The configparser module's ExtendedInterpolation feature is preferred to this custom syntax.
+"""
+
+import re
+from configparser import ConfigParser, NoOptionError, NoSectionError
+
+# Pattern to check if a string contains a custom section reference
+_LEGACY_REF_PAT = r".*\{\{.+_.+\}\}.*"
+
+# Pattern to decompose a custom section reference into parts
+_LEGACY_REF_COMPONENT_PAT = r"""
+    # capture everything from start-of-line to the opening '{{' braces into group 'pre'
+    ^(?P<pre>.*)\{\{
+    # restrict section names to ignore surrounding whitespace (different from
+    # configparser's default SECTRE) and disallow '_' (since that's our separator)
+    \s*
+    (?P<section>[^_\s](?:[^_]*[^_\s]))
+    # allow (but ignore) whitespace around the section-option delimiter
+    \s*_\s*
+    # option names ignore surrounding whitespace and can include any character, but
+    # must start and end with a non-whitespace character
+    (?P<option>\S(?:.*\S)?)
+    \s*
+    # capture from the closing '}}' braces to end-of-line into group 'post'
+    \}\}(?P<post>.*)$
+"""
+
+
+def has_legacy_config_ref(value: str) -> bool:
+    return re.match(_LEGACY_REF_PAT, value) is not None
+
+
+def eval_legacy_config_ref(config: ConfigParser, value: str) -> str:
+    match_result = re.match(_LEGACY_REF_COMPONENT_PAT, value, re.VERBOSE)
+
+    if match_result is None:
+        raise ValueError(f"Unable to parse config option reference from '{value}'")
+
+    pre, sect_name, opt_name, post = match_result.group(
+        "pre", "section", "option", "post"
+    )
+
+    try:
+        ref_value = config.get(sect_name, opt_name)
+        return pre + ref_value + post
+    except (NoSectionError, NoOptionError) as exc:
+        raise ValueError(exc.message)
diff --git a/src/bandersnatch/config/errors.py b/src/bandersnatch/config/errors.py
new file mode 100644
index 000000000..8ff536e4b
--- /dev/null
+++ b/src/bandersnatch/config/errors.py
@@ -0,0 +1,29 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing import TypeVar
+
+    Self = TypeVar("Self", bound="ConfigurationError")
+
+
+class ConfigurationError(Exception):
+
+    @classmethod
+    def for_section(cls: type[Self], section: str, message: str) -> Self:
+        return cls(f"Configuration error in [{section}] section: {message}")
+
+
+class MissingOptionError(ConfigurationError):
+
+    @classmethod
+    def for_option(cls: type[Self], section: str, option: str) -> Self:
+        return cls.for_section(section, f"missing required option '{option}'")
+
+
+class InvalidValueError(ConfigurationError):
+
+    @classmethod
+    def for_option(cls: type[Self], section: str, option: str, info: str) -> Self:
+        return cls.for_section(section, f"invalid value for option '{option}': {info}")
diff --git a/src/bandersnatch/config/mirror_options.py b/src/bandersnatch/config/mirror_options.py
new file mode 100644
index 000000000..6e3c0b14e
--- /dev/null
+++ b/src/bandersnatch/config/mirror_options.py
@@ -0,0 +1,175 @@
+from configparser import ConfigParser, NoOptionError, NoSectionError
+from logging import getLogger
+from pathlib import PurePath
+from typing import Any
+
+import attrs
+
+from bandersnatch.simple import (
+    SimpleDigest,
+    SimpleFormat,
+    get_digest_value,
+    get_format_value,
+)
+
+from .attrs_utils import get_name_value_for_option, only_if_str, validate_not_empty
+from .comparison_method import ComparisonMethod, get_comparison_value
+from .diff_file_reference import eval_legacy_config_ref, has_legacy_config_ref
+from .errors import ConfigurationError, InvalidValueError
+
+logger = getLogger("bandersnatch")
+
+_default_master_url = "https://pypi.org"
+_default_root_uri = "https://files.pythonhosted.org"
+
+
+@attrs.define(kw_only=True)
+class MirrorOptions:
+    """Class with attributes for all the options that may appear in the
+    '[mirror]' section of a config file.
+    """
+
+    directory: PurePath = attrs.field(converter=PurePath)
+
+    storage_backend_name: str = attrs.field(
+        default="filesystem",
+        alias="storage_backend",
+        validator=validate_not_empty,
+    )
+
+    master_url: str = attrs.field(default=_default_master_url, alias="master")
+    proxy_url: str | None = attrs.field(default=None, alias="proxy")
+
+    download_mirror_url: str | None = attrs.field(default=None, alias="download_mirror")
+    download_mirror_no_fallback: bool = False
+
+    save_release_files: bool = attrs.field(default=True, alias="release_files")
+    save_json: bool = attrs.field(default=False, alias="json")
+
+    # type-ignores on converters for the following enums b/c MyPy's plugin for attrs
+    # doesn't handle using arbitrary functions as converters
+    simple_format: SimpleFormat = attrs.field(
+        default=SimpleFormat.ALL,
+        converter=only_if_str(get_format_value),  # type: ignore
+    )
+
+    compare_method: ComparisonMethod = attrs.field(
+        default=ComparisonMethod.HASH,
+        converter=only_if_str(get_comparison_value),  # type: ignore
+    )
+
+    digest_name: SimpleDigest = attrs.field(
+        default=SimpleDigest.SHA256,
+        converter=only_if_str(get_digest_value),  # type: ignore
+    )
+
+    # this gets a non-empty default value in post-init if save_release_files is False
+    root_uri: str = ""
+
+    hash_index: bool = False
+
+    keep_index_versions: int = attrs.field(default=0, validator=attrs.validators.ge(0))
+
+    diff_file: PurePath | None = attrs.field(
+        default=None, converter=attrs.converters.optional(PurePath)
+    )
+    diff_append_epoch: bool = False
+
+    stop_on_error: bool = False
+    timeout: float = attrs.field(default=10.0, validator=attrs.validators.gt(0))
+    global_timeout: float = attrs.field(
+        default=1800.0, validator=attrs.validators.gt(0)
+    )
+
+    workers: int = attrs.field(
+        default=3, validator=[attrs.validators.gt(0), attrs.validators.le(10)]
+    )
+
+    verifiers: int = attrs.field(
+        default=3, validator=[attrs.validators.gt(0), attrs.validators.le(10)]
+    )
+
+    log_config: PurePath | None = attrs.field(
+        default=None, converter=attrs.converters.optional(PurePath)
+    )
+
+    cleanup: bool = attrs.field(default=False, metadata={"deprecated": True})
+
+    # Called after the attrs class is constructed; doing cross-field validation here
+    def __attrs_post_init__(self) -> None:
+        # set default for root_uri if release-files is disabled
+        if not self.save_release_files and not self.root_uri:
+            logger.warning(
+                (
+                    "Inconsistent config: 'root_uri' should be set when "
+                    "'release-files' is disabled. Please set 'root-uri' in the "
+                    "[mirror] section of your config file. Using default value '%s'"
+                ),
+                _default_root_uri,
+            )
+            self.root_uri = _default_root_uri
+
+    @classmethod
+    def from_config_parser(cls, source: ConfigParser) -> "MirrorOptions":
+        if "mirror" not in source:
+            raise ConfigurationError("Config file missing required section '[mirror]'")
+
+        model_kwargs: dict[str, Any] = {}
+
+        for option in attrs.fields(cls):
+            option_name, option_value = get_name_value_for_option(
+                source, "mirror", option
+            )
+
+            if option_name == "diff_file" and isinstance(option_value, str):
+                option_value = _check_legacy_reference(source, option_value)
+
+            if option_value is not None:
+                model_kwargs[option_name] = option_value
+
+        try:
+            instance = cls(**model_kwargs)
+        except ValueError as err:
+            raise InvalidValueError.for_section("mirror", str(err)) from err
+        except TypeError as err:
+            raise ConfigurationError.for_section("mirror", str(err)) from err
+
+        return instance
+
+    @classmethod
+    def populate_defaults(cls, config: ConfigParser) -> None:
+        if not config.has_section("mirror"):
+            config.add_section("mirror")
+        section = config["mirror"]
+
+        option: attrs.Attribute
+        for option in attrs.fields(cls):
+            if option.default is attrs.NOTHING or option.default is None:
+                continue
+            option_name = option.alias or option.name
+            if isinstance(option.default, PurePath):
+                option_value = option.default.as_posix()
+            elif not isinstance(option.default, str):
+                option_value = str(option.default)
+            else:
+                option_value = option.default
+            section[option_name] = option_value
+
+
+def _check_legacy_reference(config: ConfigParser, value: str) -> str | None:
+    if not has_legacy_config_ref(value):
+        return value
+
+    logger.warning(
+        "Found section reference using '{{ }}' in 'diff-file' path. "
+        "Use ConfigParser's built-in extended interpolation instead, "
+        "for example '${mirror:directory}/new-files'"
+    )
+    try:
+        return eval_legacy_config_ref(config, value)
+    except (ValueError, NoSectionError, NoOptionError) as ref_err:
+        # NOTE: raise here would be a breaking change; previous impl. logged and
+        # fell back to a default. Create exception anyway for consistent error messages.
+        exc = InvalidValueError.for_option("mirror", "diff-file", str(ref_err))
+        logger.error(str(exc))
+        return None
diff --git a/src/bandersnatch/configuration.py b/src/bandersnatch/configuration.py
index f03ff597f..b8a65a390 100644
--- a/src/bandersnatch/configuration.py
+++ b/src/bandersnatch/configuration.py
@@ -6,8 +6,9 @@
 import importlib.resources
 import logging
 from pathlib import Path
-from typing import Any, NamedTuple
+from typing import NamedTuple
 
+from .config.diff_file_reference import eval_legacy_config_ref, has_legacy_config_ref
 from .simple import SimpleDigest, SimpleFormat, get_digest_value, get_format_value
 
 logger = logging.getLogger("bandersnatch")
@@ -28,25 +29,13 @@ class SetConfigValues(NamedTuple):
     simple_format: SimpleFormat
 
 
-class Singleton(type):  # pragma: no cover
-    _instances: dict["Singleton", type] = {}
-
-    def __call__(cls, *args: Any, **kwargs: Any) -> type:
-        if cls not in cls._instances:
-            cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cls._instances[cls]
-
-
-class BandersnatchConfig(metaclass=Singleton):
+class BandersnatchConfig:
     # Ensure we only show the deprecations once
     SHOWN_DEPRECATIONS = False
 
     def __init__(self, config_file: str | None = None) -> None:
         """
-        Bandersnatch configuration class singleton
-
-        This class is a singleton that parses the configuration once at the
-        start time.
+        Bandersnatch configuration management class.
 
         Parameters
         ==========
@@ -101,20 +90,17 @@ def validate_config_values(  # noqa: C901
         diff_file_path = config.get("mirror", "diff-file")
     except configparser.NoOptionError:
         diff_file_path = ""
-    if "{{" in diff_file_path and "}}" in diff_file_path:
-        diff_file_path = diff_file_path.replace("{{", "").replace("}}", "")
-        diff_ref_section, _, diff_ref_key = diff_file_path.partition("_")
+
+    if diff_file_path and has_legacy_config_ref(diff_file_path):
         try:
-            diff_file_path = config.get(diff_ref_section, diff_ref_key)
-        except (configparser.NoOptionError, configparser.NoSectionError):
+            diff_file_path = eval_legacy_config_ref(config, diff_file_path)
+        except ValueError as err:
             logger.error(
-                "Invalid section reference in `diff-file` key. "
-                "Please correct this error. Saving diff files in"
-                " base mirror directory."
-            )
-            diff_file_path = str(
-                Path(config.get("mirror", "directory")) / "mirrored-files"
+                "Invalid section reference in `diff-file` key: %s. Saving diff files in base mirror directory.",
+                str(err),
             )
+            mirror_dir = config.get("mirror", "directory")
+            diff_file_path = (Path(mirror_dir) / "mirrored-files").as_posix()
 
     try:
         diff_append_epoch = config.getboolean("mirror", "diff-append-epoch")
diff --git a/src/bandersnatch/delete.py b/src/bandersnatch/delete.py
index 43e22b088..43d8ef7f4 100644
--- a/src/bandersnatch/delete.py
+++ b/src/bandersnatch/delete.py
@@ -14,14 +14,15 @@
 from packaging.utils import canonicalize_name
 
 from .master import Master
-from .storage import storage_backend_plugins
+from .storage import Storage, storage_backend_plugins
 from .verify import get_latest_json
 
 logger = logging.getLogger(__name__)
 
 
-async def delete_path(blob_path: Path, dry_run: bool = False) -> int:
-    storage_backend = next(iter(storage_backend_plugins()))
+async def delete_path(
+    blob_path: Path, storage_backend: Storage, dry_run: bool = False
+) -> int:
     if dry_run:
         logger.info(f" rm {blob_path}")
         return 0
@@ -131,7 +132,9 @@ async def delete_packages(config: ConfigParser, args: Namespace, master: Master)
                 for blob in blobs:
                     url_parts = urlparse(blob["url"])
                     blob_path = web_base_path / url_parts.path[1:]
-                    delete_coros.append(delete_path(blob_path, args.dry_run))
+                    delete_coros.append(
+                        delete_path(blob_path, storage_backend, args.dry_run)
+                    )
 
         # Attempt to delete json, normal simple path + hash simple path
         hash_index_enabled = config.getboolean("mirror", "hash-index")
@@ -160,7 +163,9 @@ async def delete_packages(config: ConfigParser, args: Namespace, master: Master)
             if not package_path:
                 continue
 
-            delete_coros.append(delete_path(package_path, args.dry_run))
+            delete_coros.append(
+                delete_path(package_path, storage_backend, args.dry_run)
+            )
 
     if args.dry_run:
         logger.info("-- bandersnatch delete DRY RUN --")
diff --git a/src/bandersnatch/filter.py b/src/bandersnatch/filter.py
index d78735825..a6104ae17 100644
--- a/src/bandersnatch/filter.py
+++ b/src/bandersnatch/filter.py
@@ -3,12 +3,11 @@
 """
 
 from collections import defaultdict
+from configparser import ConfigParser
 from typing import TYPE_CHECKING, Any
 
 import pkg_resources
 
-from .configuration import BandersnatchConfig
-
 if TYPE_CHECKING:
     from configparser import SectionProxy
 
@@ -36,8 +35,8 @@ class Filter:
     name = "filter"
     deprecated_name: str = ""
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        self.configuration = BandersnatchConfig().config
+    def __init__(self, *args: Any, config: ConfigParser, **kwargs: Any) -> None:
+        self.configuration = config
         if (
             "plugins" not in self.configuration
             or "enabled" not in self.configuration["plugins"]
@@ -152,11 +151,11 @@ class LoadedFilters:
         RELEASE_FILE_PLUGIN_RESOURCE,
     ]
 
-    def __init__(self, load_all: bool = False) -> None:
+    def __init__(self, config: ConfigParser, load_all: bool = False) -> None:
         """
         Loads and stores all of specified filters from the config file
         """
-        self.config = BandersnatchConfig().config
+        self.config = config
         self.loaded_filter_plugins: dict[str, list["Filter"]] = defaultdict(list)
         self.enabled_plugins = self._load_enabled()
         if load_all:
@@ -189,7 +188,7 @@ def _load_filters(self, groups: list[str]) -> None:
             plugins = set()
             for entry_point in pkg_resources.iter_entry_points(group=group):
                 plugin_class = entry_point.load()
-                plugin_instance = plugin_class()
+                plugin_instance = plugin_class(config=self.config)
                 if (
                     "all" in self.enabled_plugins
                     or plugin_instance.name in self.enabled_plugins
diff --git a/src/bandersnatch/main.py b/src/bandersnatch/main.py
index 92a0386e8..79c3be483 100644
--- a/src/bandersnatch/main.py
+++ b/src/bandersnatch/main.py
@@ -4,16 +4,17 @@
 import logging.config
 import shutil
 import sys
-from configparser import ConfigParser
 from pathlib import Path
 from tempfile import gettempdir
 
-import bandersnatch.configuration
 import bandersnatch.delete
 import bandersnatch.log
 import bandersnatch.master
 import bandersnatch.mirror
 import bandersnatch.verify
+from bandersnatch.config import BandersnatchConfig
+from bandersnatch.config.core import write_default_config_file
+from bandersnatch.config.errors import ConfigurationError
 from bandersnatch.storage import storage_backend_plugins
 
 # See if we have uvloop and use if so
@@ -149,7 +150,7 @@ def _make_parser() -> argparse.ArgumentParser:
     return parser
 
 
-async def async_main(args: argparse.Namespace, config: ConfigParser) -> int:
+async def async_main(args: argparse.Namespace, config: BandersnatchConfig) -> int:
     if args.op.lower() == "delete":
         async with bandersnatch.master.Master(
             config.get("mirror", "master"),
@@ -165,7 +166,7 @@ async def async_main(args: argparse.Namespace, config: ConfigParser) -> int:
         )
 
     if args.force_check:
-        storage_plugin = next(iter(storage_backend_plugins()))
+        storage_plugin = next(iter(storage_backend_plugins(config)))
         status_file = (
             storage_plugin.PATH_BACKEND(config.get("mirror", "directory")) / "status"
         )
@@ -203,22 +204,23 @@ def main(loop: asyncio.AbstractEventLoop | None = None) -> int:
     # Prepare default config file if needed.
     config_path = Path(args.config)
     if not config_path.exists():
-        logger.warning(f"Config file '{args.config}' missing, creating default config.")
+        logger.warning(f"Config file '{args.config}' missing; creating default config.")
         logger.warning("Please review the config file, then run 'bandersnatch' again.")
-
-        default_config_path = Path(__file__).parent / "default.conf"
         try:
-            shutil.copy(default_config_path, args.config)
+            write_default_config_file(config_path)
         except OSError as e:
-            logger.error(f"Could not create config file: {e}")
+            logger.error("Could not create config file: %s", e)
         return 1
 
-    config = bandersnatch.configuration.BandersnatchConfig(
-        config_file=args.config
-    ).config
+    try:
+        config = BandersnatchConfig.from_path(config_path)
+    except (ConfigurationError, OSError) as err:
+        logger.error("Error reading config file: %s", str(err))
+        logger.debug("Error reading config file; exception info:", exc_info=err)
+        return 1
 
     if config.has_option("mirror", "log-config"):
-        logging.config.fileConfig(str(Path(config.get("mirror", "log-config"))))
+        logging.config.fileConfig(Path(config.get("mirror", "log-config")))
 
     if loop:
         loop.set_debug(args.debug)
diff --git a/src/bandersnatch/mirror.py b/src/bandersnatch/mirror.py
index d4eb83bf1..7625603a2 100644
--- a/src/bandersnatch/mirror.py
+++ b/src/bandersnatch/mirror.py
@@ -1,28 +1,30 @@
 import asyncio
-import configparser
 import datetime
 import hashlib
 import logging
 import os
 import sys
 import time
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from json import dump
-from pathlib import Path, WindowsPath
+from pathlib import Path, PurePath
 from threading import RLock
-from typing import Any
+from typing import Any, TypeVar
 from urllib.parse import unquote, urlparse
 
 from filelock import Timeout
 
+from bandersnatch.config.errors import ConfigurationError
+
 from . import utils
-from .configuration import validate_config_values
+from .config import BandersnatchConfig, MirrorOptions
+from .config.comparison_method import ComparisonMethod
 from .errors import PackageNotFound
 from .filter import LoadedFilters
 from .master import Master
 from .package import Package
-from .simple import SimpleAPI, SimpleFormat, SimpleFormats
-from .storage import storage_backend_plugins
+from .simple import SimpleAPI, SimpleDigest, SimpleFormat, SimpleFormats
+from .storage import Storage, storage_backend_plugins
 
 LOG_PLUGINS = True
 logger = logging.getLogger(__name__)
@@ -36,11 +38,11 @@ class Mirror:
     # We are required to leave a 'last changed' timestamp. I'd rather err
     # on the side of giving a timestamp that is too old so we keep track
     # of it when starting to sync.
-    now = None
+    now: datetime.datetime | None = None
 
-    def __init__(self, master: Master, workers: int = 3):
+    def __init__(self, master: Master, filters: LoadedFilters, workers: int = 3):
         self.master = master
-        self.filters = LoadedFilters(load_all=True)
+        self.filters = filters
         self.workers = workers
         if self.workers > 10:
             raise ValueError("Downloading with more than 10 workers is not allowed")
@@ -178,42 +180,36 @@ class BandersnatchMirror(Mirror):
 
     def __init__(
         self,
-        homedir: Path,
+        homedir: PurePath,
         master: Master,
-        storage_backend: str | None = None,
+        storage_backend: Storage,
+        filters: LoadedFilters,
         stop_on_error: bool = False,
         workers: int = 3,
         hash_index: bool = False,
         json_save: bool = False,
-        digest_name: str | None = None,
-        root_uri: str | None = None,
+        digest_name: SimpleDigest = SimpleDigest.SHA256,
+        root_uri: str = "",
         keep_index_versions: int = 0,
-        diff_file: Path | str | None = None,
         diff_append_epoch: bool = False,
-        diff_full_path: Path | str | None = None,
+        diff_full_path: Path | None = None,
         flock_timeout: int = 1,
         diff_file_list: list[Path] | None = None,
         *,
         cleanup: bool = False,
         release_files_save: bool = True,
-        compare_method: str | None = None,
+        compare_method: ComparisonMethod = ComparisonMethod.HASH,
         download_mirror: str | None = None,
         download_mirror_no_fallback: bool | None = False,
-        simple_format: SimpleFormat | str = "ALL",
+        simple_format: SimpleFormat = SimpleFormat.ALL,
     ) -> None:
-        super().__init__(master=master, workers=workers)
+        super().__init__(master=master, filters=filters, workers=workers)
         self.cleanup = cleanup
 
-        if storage_backend:
-            self.storage_backend = next(iter(storage_backend_plugins(storage_backend)))
-        else:
-            self.storage_backend = next(iter(storage_backend_plugins()))
+        self.storage_backend = storage_backend
         self.stop_on_error = stop_on_error
         self.loop = asyncio.get_event_loop()
-        if isinstance(homedir, WindowsPath):
-            self.homedir = self.storage_backend.PATH_BACKEND(homedir.as_posix())
-        else:
-            self.homedir = self.storage_backend.PATH_BACKEND(str(homedir))
+        self.homedir = self.storage_backend.PATH_BACKEND(homedir.as_posix())
         self.lockfile_path = self.homedir / ".lock"
         self.master = master
 
@@ -229,13 +225,12 @@ def __init__(
         # This is generally not necessary, but was added for the official internal
         # PyPI mirror, which requires serving packages from
         # https://files.pythonhosted.org
-        self.root_uri = root_uri or ""
-        self.diff_file = diff_file
+        self.root_uri = root_uri
         self.diff_append_epoch = diff_append_epoch
         self.diff_full_path = diff_full_path
         self.keep_index_versions = keep_index_versions
-        self.digest_name = digest_name if digest_name else "sha256"
-        self.compare_method = compare_method if compare_method else "hash"
+        self.digest_name = digest_name
+        self.compare_method = compare_method
         self.download_mirror = download_mirror
         self.download_mirror_no_fallback = download_mirror_no_fallback
         self.workers = workers
@@ -913,76 +908,102 @@ async def download_file(
         return path
 
 
+_T = TypeVar("_T")
+
+
+async def _run_in_storage_executor(
+    storage_plugin: Storage, func: Callable[..., _T], *args: Any
+) -> _T:
+    return await storage_plugin.loop.run_in_executor(
+        storage_plugin.executor, func, *args
+    )
+
+
+async def _setup_diff_file(
+    storage_plugin: Storage, configured_path: PurePath, append_epoch: bool
+) -> Path:
+    # use the storage backend to convert an abstract path to a concrete one
+    concrete_path = storage_plugin.PATH_BACKEND(configured_path)
+
+    # create parent directories if needed
+    await _run_in_storage_executor(
+        storage_plugin, lambda: concrete_path.parent.mkdir(exist_ok=True, parents=True)
+    )
+
+    # adjust the file/directory name if timestamps are enabled
+    if append_epoch:
+        epoch = int(time.time())
+        concrete_path = concrete_path.with_name(f"{concrete_path.name}-{epoch}")
+
+    # if the path is directory, adjust to write to a file inside it
+    if await _run_in_storage_executor(storage_plugin, concrete_path.is_dir):
+        concrete_path = concrete_path / "mirrored-files"
+
+    # if there is an existing file there then delete it
+    if await _run_in_storage_executor(storage_plugin, concrete_path.is_file):
+        concrete_path.unlink()
+
+    return concrete_path
+
+
 async def mirror(
-    config: configparser.ConfigParser,
+    config: BandersnatchConfig,
     specific_packages: list[str] | None = None,
     sync_simple_index: bool = True,
 ) -> int:
-    config_values = validate_config_values(config)
+    try:
+        mirror_options = config.get_validated(MirrorOptions)
+    except ConfigurationError as err:
+        logger.error("Configuration error: %s", str(err))
+        logger.debug("Configuration error: exception info:", exc_info=err)
+        return 1
 
     storage_plugin = next(
         iter(
             storage_backend_plugins(
-                config_values.storage_backend_name, config=config, clear_cache=True
+                config=config,
+                backend=mirror_options.storage_backend_name,
+                clear_cache=True,
             )
         )
     )
 
-    diff_file = storage_plugin.PATH_BACKEND(config_values.diff_file_path)
-    diff_full_path: Path | str
-    if diff_file:
-        diff_file.parent.mkdir(exist_ok=True, parents=True)
-        if config_values.diff_append_epoch:
-            diff_full_path = diff_file.with_name(f"{diff_file.name}-{int(time.time())}")
-        else:
-            diff_full_path = diff_file
-    else:
-        diff_full_path = ""
-
-    if diff_full_path:
-        if isinstance(diff_full_path, str):
-            diff_full_path = storage_plugin.PATH_BACKEND(diff_full_path)
-        if await storage_plugin.loop.run_in_executor(
-            storage_plugin.executor, diff_full_path.is_file
-        ):
-            diff_full_path.unlink()
-        elif await storage_plugin.loop.run_in_executor(
-            storage_plugin.executor, diff_full_path.is_dir
-        ):
-            diff_full_path = diff_full_path / "mirrored-files"
-
-    mirror_url = config.get("mirror", "master")
-    timeout = config.getfloat("mirror", "timeout")
-    global_timeout = config.getfloat("mirror", "global-timeout", fallback=None)
-    proxy = config.get("mirror", "proxy", fallback=None)
-    storage_backend = config_values.storage_backend_name
-    homedir = Path(config.get("mirror", "directory"))
+    diff_full_path: Path | None = None
+    if mirror_options.diff_file:
+        diff_full_path = await _setup_diff_file(
+            storage_plugin,
+            mirror_options.diff_file,
+            mirror_options.diff_append_epoch,
+        )
 
     # Always reference those classes here with the fully qualified name to
     # allow them being patched by mock libraries!
-    async with Master(mirror_url, timeout, global_timeout, proxy) as master:
+    async with Master(
+        mirror_options.master_url,
+        mirror_options.timeout,
+        mirror_options.global_timeout,
+        mirror_options.proxy_url,
+    ) as master:
         mirror = BandersnatchMirror(
-            homedir,
+            mirror_options.directory,
             master,
-            storage_backend=storage_backend,
-            stop_on_error=config.getboolean("mirror", "stop-on-error"),
-            workers=config.getint("mirror", "workers"),
-            hash_index=config.getboolean("mirror", "hash-index"),
-            json_save=config_values.json_save,
-            root_uri=config_values.root_uri,
-            digest_name=config_values.digest_name,
-            compare_method=config_values.compare_method,
-            keep_index_versions=config.getint(
-                "mirror", "keep_index_versions", fallback=0
-            ),
-            diff_file=diff_file,
-            diff_append_epoch=config_values.diff_append_epoch,
-            diff_full_path=diff_full_path if diff_full_path else None,
-            cleanup=config_values.cleanup,
-            release_files_save=config_values.release_files_save,
-            download_mirror=config_values.download_mirror,
-            download_mirror_no_fallback=config_values.download_mirror_no_fallback,
-            simple_format=config_values.simple_format,
+            storage_plugin,
+            LoadedFilters(config, load_all=True),
+            stop_on_error=mirror_options.stop_on_error,
+            workers=mirror_options.workers,
+            hash_index=mirror_options.hash_index,
+            json_save=mirror_options.save_json,
+            root_uri=mirror_options.root_uri,
+            digest_name=mirror_options.digest_name,
+            compare_method=mirror_options.compare_method,
+            keep_index_versions=mirror_options.keep_index_versions,
+            diff_append_epoch=mirror_options.diff_append_epoch,
+            diff_full_path=diff_full_path,
+            cleanup=mirror_options.cleanup,
+            release_files_save=mirror_options.save_release_files,
+            download_mirror=mirror_options.download_mirror_url,
+            download_mirror_no_fallback=mirror_options.download_mirror_no_fallback,
+            simple_format=mirror_options.simple_format,
         )
         changed_packages = await mirror.synchronize(
             specific_packages, sync_simple_index=sync_simple_index
@@ -997,14 +1018,13 @@ async def mirror(
         loggable_changes = [str(chg) for chg in package_changes]
         logger.debug(f"{package_name} added: {loggable_changes}")
 
-    if mirror.diff_full_path:
-        logger.info(f"Writing diff file to {mirror.diff_full_path}")
+    if diff_full_path:
+        logger.info(f"Writing diff file to '{diff_full_path}'")
         diff_text = f"{os.linesep}".join(
             [str(chg.absolute()) for chg in mirror.diff_file_list]
         )
-        diff_file = mirror.storage_backend.PATH_BACKEND(mirror.diff_full_path)
-        await storage_plugin.loop.run_in_executor(
-            storage_plugin.executor, diff_file.write_text, diff_text
+        await _run_in_storage_executor(
+            storage_plugin, diff_full_path.write_text, diff_text
         )
 
     return 0
diff --git a/src/bandersnatch/storage.py b/src/bandersnatch/storage.py
index d51665782..76ebaffcb 100644
--- a/src/bandersnatch/storage.py
+++ b/src/bandersnatch/storage.py
@@ -18,8 +18,6 @@
 import pkg_resources
 from packaging.utils import canonicalize_name
 
-from .configuration import BandersnatchConfig
-
 PATH_TYPES = pathlib.Path | str
 
 # The API_REVISION is incremented if the plugin class is modified in a
@@ -58,16 +56,11 @@ class Storage:
     def __init__(
         self,
         *args: Any,
-        config: configparser.ConfigParser | None = None,
+        config: configparser.ConfigParser,
         **kwargs: Any,
     ) -> None:
         self.flock_path: PATH_TYPES = ".lock"
-        if config is not None:
-            if isinstance(config, BandersnatchConfig):
-                config = config.config
-            self.configuration = config
-        else:
-            self.configuration = BandersnatchConfig().config
+        self.configuration = config
         try:
             storage_backend = self.configuration["mirror"]["storage-backend"]
         except (KeyError, TypeError):
@@ -317,8 +310,8 @@ class StoragePlugin(Storage):
 
 def load_storage_plugins(
     entrypoint_group: str,
+    config: configparser.ConfigParser,
     enabled_plugin: str | None = None,
-    config: configparser.ConfigParser | None = None,
     clear_cache: bool = False,
 ) -> set[Storage]:
     """
@@ -328,10 +321,10 @@ def load_storage_plugins(
     ==========
     entrypoint_group: str
         The entrypoint group name to load plugins from
+    config: configparser.ConfigParser
+        The configparser instance to use
     enabled_plugin: str
         The optional enabled storage plugin to search for
-    config: configparser.ConfigParser
-        The optional configparser instance to pass in
     clear_cache: bool
         Whether to clear the plugin cache
 
@@ -341,8 +334,6 @@ def load_storage_plugins(
         A list of objects derived from the Storage class
     """
     global loaded_storage_plugins
-    if config is None:
-        config = BandersnatchConfig().config
     if not enabled_plugin:
         try:
             enabled_plugin = config["mirror"]["storage-backend"]
@@ -379,19 +370,19 @@ def load_storage_plugins(
 
 
 def storage_backend_plugins(
-    backend: str | None = "filesystem",
-    config: configparser.ConfigParser | None = None,
+    config: configparser.ConfigParser,
+    backend: str = "filesystem",
     clear_cache: bool = False,
 ) -> Iterable[Storage]:
     """
-    Load and return the release filtering plugin objects
+    Load and return the storage backend plugin objects
 
     Parameters
     ==========
+    config: configparser.ConfigParser
+        The configparser instance to use
     backend: str
         The optional enabled storage plugin to search for
-    config: configparser.ConfigParser
-        The optional configparser instance to pass in
     clear_cache: bool
         Whether to clear the plugin cache
 
@@ -402,7 +393,7 @@ def storage_backend_plugins(
     """
     return load_storage_plugins(
         STORAGE_PLUGIN_RESOURCE,
-        enabled_plugin=backend,
         config=config,
+        enabled_plugin=backend,
         clear_cache=clear_cache,
     )
diff --git a/src/bandersnatch/tests/conftest.py b/src/bandersnatch/tests/conftest.py
index 268517281..4406cd2c6 100644
--- a/src/bandersnatch/tests/conftest.py
+++ b/src/bandersnatch/tests/conftest.py
@@ -1,9 +1,11 @@
 # flake8: noqa
 import os
 import unittest.mock as mock
-from collections.abc import Iterator
+from collections.abc import Callable, Generator, Iterator
+from configparser import ConfigParser
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict
+from threading import local
+from typing import TYPE_CHECKING, Any, Dict, TypeAlias
 
 import boto3
 import pytest
@@ -12,6 +14,9 @@
 from _pytest.monkeypatch import MonkeyPatch
 from s3path import PureS3Path, S3Path, _s3_accessor, register_configuration_parameter
 
+from bandersnatch.filter import LoadedFilters
+from bandersnatch.storage import Storage
+
 if TYPE_CHECKING:
     from bandersnatch.master import Master
     from bandersnatch.mirror import BandersnatchMirror
@@ -90,6 +95,39 @@ def package_json() -> dict[str, Any]:
     }
 
 
+StorageFactory: TypeAlias = Callable[[Path], Storage]
+
+
+@pytest.fixture
+def local_storage_factory() -> StorageFactory:
+    from bandersnatch.storage import storage_backend_plugins
+
+    def _local_storage(location: Path) -> Storage:
+        cfg_data = {
+            "mirror": {
+                "storage-backend": "filesystem",
+                "directory": location.as_posix(),
+                "workers": 2,
+            }
+        }
+        cfg = ConfigParser()
+        cfg.read_dict(cfg_data)
+        return next(iter(storage_backend_plugins(cfg, backend="filesystem")))
+
+    return _local_storage
+
+
+@pytest.fixture
+def local_storage(tmp_path: Path, local_storage_factory: StorageFactory) -> Storage:
+    return local_storage_factory(tmp_path)
+
+
+@pytest.fixture
+def empty_filters() -> LoadedFilters:
+    cfg = ConfigParser()
+    return LoadedFilters(cfg, load_all=True)
+
+
 @pytest.fixture
 def master(package_json: dict[str, Any]) -> "Master":
     from bandersnatch.master import Master
@@ -130,22 +168,38 @@ def session_side_effect(*args: Any, **kwargs: Any) -> Any:
 
 @pytest.fixture
 def mirror(
-    tmpdir: Path, master: "Master", monkeypatch: MonkeyPatch
+    tmp_path: Path,
+    master: "Master",
+    monkeypatch: MonkeyPatch,
+    empty_filters: LoadedFilters,
+    local_storage_factory: StorageFactory,
 ) -> "BandersnatchMirror":
-    monkeypatch.chdir(tmpdir)
+    monkeypatch.chdir(tmp_path)
     from bandersnatch.mirror import BandersnatchMirror
 
-    return BandersnatchMirror(tmpdir, master)
+    return BandersnatchMirror(
+        tmp_path, master, local_storage_factory(tmp_path), empty_filters
+    )
 
 
 @pytest.fixture
 def mirror_hash_index(
-    tmpdir: Path, master: "Master", monkeypatch: MonkeyPatch
+    tmp_path: Path,
+    master: "Master",
+    monkeypatch: MonkeyPatch,
+    empty_filters: LoadedFilters,
+    local_storage_factory: StorageFactory,
 ) -> "BandersnatchMirror":
-    monkeypatch.chdir(tmpdir)
+    monkeypatch.chdir(tmp_path)
     from bandersnatch.mirror import BandersnatchMirror
 
-    return BandersnatchMirror(tmpdir, master, hash_index=True)
+    return BandersnatchMirror(
+        tmp_path,
+        master,
+        local_storage_factory(tmp_path),
+        empty_filters,
+        hash_index=True,
+    )
 
 
 @pytest.fixture
@@ -187,7 +241,7 @@ def reset_configuration_cache() -> Iterator[None]:
 
 
 @pytest.fixture()
-def s3_mock(reset_configuration_cache: None) -> S3Path:
+def s3_mock(reset_configuration_cache: None) -> Generator[S3Path, None, None]:
     if os.environ.get("os") != "ubuntu-latest" and os.environ.get("CI"):
         pytest.skip("Skip s3 test on non-posix server in github action")
     register_configuration_parameter(
diff --git a/src/bandersnatch/tests/mock_config.py b/src/bandersnatch/tests/mock_config.py
index b9830aecb..9dbb4ce5c 100644
--- a/src/bandersnatch/tests/mock_config.py
+++ b/src/bandersnatch/tests/mock_config.py
@@ -1,4 +1,4 @@
-from bandersnatch.configuration import BandersnatchConfig
+from bandersnatch.config import BandersnatchConfig
 
 
 def mock_config(contents: str, filename: str = "test.conf") -> BandersnatchConfig:
@@ -6,10 +6,7 @@ def mock_config(contents: str, filename: str = "test.conf") -> BandersnatchConfi
     Creates a config file with contents and loads them into a
     BandersnatchConfig instance.
     """
-    with open(filename, "w") as fd:
-        fd.write(contents)
 
     instance = BandersnatchConfig()
-    instance.config_file = filename
-    instance.load_configuration()
+    instance.read_string(contents)
     return instance
diff --git a/src/bandersnatch/tests/plugins/test_allowlist_name.py b/src/bandersnatch/tests/plugins/test_allowlist_name.py
index 7a870cc53..6cd92fab1 100644
--- a/src/bandersnatch/tests/plugins/test_allowlist_name.py
+++ b/src/bandersnatch/tests/plugins/test_allowlist_name.py
@@ -6,10 +6,9 @@
 
 import bandersnatch.filter
 import bandersnatch.storage
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 
 
 class TestAllowListProject(TestCase):
@@ -30,7 +29,7 @@ def tearDown(self) -> None:
             self.tempdir.cleanup()
 
     def test__plugin__loads__explicitly_enabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             contents="""\
 [mirror]
 storage-backend = filesystem
@@ -42,13 +41,13 @@ def test__plugin__loads__explicitly_enabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["allowlist_project"])
         self.assertEqual(len(plugins), 1)
 
     def test__plugin__loads__default(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -58,7 +57,7 @@ def test__plugin__loads__default(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("allowlist_project", names)
 
@@ -79,14 +78,14 @@ def test__filter__matches__package(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror()
         mirror.packages_to_sync = {"foo": ""}
         mirror._filter_packages()
 
         self.assertIn("foo", mirror.packages_to_sync.keys())
 
     def test__filter__nomatch_package(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -102,7 +101,7 @@ def test__filter__nomatch_package(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo": "", "foo2": ""}
         mirror._filter_packages()
 
@@ -110,7 +109,7 @@ def test__filter__nomatch_package(self) -> None:
         self.assertNotIn("foo2", mirror.packages_to_sync.keys())
 
     def test__filter__name_only(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -126,7 +125,7 @@ def test__filter__name_only(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo": "", "foo2": ""}
         mirror._filter_packages()
 
@@ -134,7 +133,7 @@ def test__filter__name_only(self) -> None:
         self.assertNotIn("foo2", mirror.packages_to_sync.keys())
 
     def test__filter__varying__specifiers(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -150,7 +149,7 @@ def test__filter__varying__specifiers(self) -> None:
     bar~=3.0,<=1.5
 """
         )
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {
             "foo": "",
             "bar": "",
@@ -161,7 +160,7 @@ def test__filter__varying__specifiers(self) -> None:
         self.assertEqual({"foo": "", "bar": ""}, mirror.packages_to_sync)
 
     def test__filter__commented__out(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -177,7 +176,7 @@ def test__filter__commented__out(self) -> None:
 #    bar
 """
         )
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {
             "foo": "",
             "bar": "",
@@ -205,7 +204,7 @@ def tearDown(self) -> None:
             self.tempdir.cleanup()
 
     def test__plugin__loads__explicitly_enabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -213,13 +212,13 @@ def test__plugin__loads__explicitly_enabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["allowlist_release"])
         self.assertEqual(len(plugins), 1)
 
     def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -231,12 +230,12 @@ def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("allowlist_release", names)
 
     def test__filter__matches__release(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -251,7 +250,7 @@ def test__filter__matches__release(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -263,7 +262,7 @@ def test__filter__matches__release(self) -> None:
         self.assertEqual(pkg.releases, {"1.2.0": {}})
 
     def test__filter__matches__release__commented__inline(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -278,7 +277,7 @@ def test__filter__matches__release__commented__inline(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -290,7 +289,7 @@ def test__filter__matches__release__commented__inline(self) -> None:
         self.assertEqual(pkg.releases, {"1.2.0": {}})
 
     def test__dont__filter__prereleases(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -305,7 +304,7 @@ def test__dont__filter__prereleases(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -324,7 +323,7 @@ def test__dont__filter__prereleases(self) -> None:
         self.assertEqual(pkg.releases, {"1.1.0a2": {}, "1.1.1beta1": {}, "1.2.0": {}})
 
     def test__casing__no__affect(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -339,7 +338,7 @@ def test__casing__no__affect(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -368,7 +367,7 @@ def tearDown(self) -> None:
             self.tempdir.cleanup()
 
     def test__plugin__loads__explicitly_enabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -380,13 +379,13 @@ def test__plugin__loads__explicitly_enabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["project_requirements_pinned"])
         self.assertEqual(len(plugins), 1)
 
     def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -398,7 +397,7 @@ def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("project_requirements", names)
 
@@ -412,7 +411,7 @@ def test__filter__matches__release(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -429,7 +428,7 @@ def test__filter__matches__release(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -448,7 +447,7 @@ def test__filter__matches__release_latest(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -467,7 +466,7 @@ def test__filter__matches__release_latest(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -489,7 +488,7 @@ def test__filter__find_files(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -504,7 +503,7 @@ def test__filter__find_files(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         mirror.packages_to_sync = {
             "foo": "",
@@ -525,7 +524,7 @@ def test__filter__requirements__pip__options(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -540,7 +539,7 @@ def test__filter__requirements__pip__options(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         mirror.packages_to_sync = {
             "foo": "",
@@ -575,7 +574,7 @@ def test__filter__find__glob__files(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -592,7 +591,7 @@ def test__filter__find__glob__files(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         mirror.packages_to_sync = {
             "foo": "",
@@ -620,7 +619,7 @@ def test__filter__requirements__utf16__encoding(self) -> None:
 """
             )
 
-        mock_config(
+        bc = mock_config(
             f"""\
 [mirror]
 storage-backend = filesystem
@@ -635,7 +634,7 @@ def test__filter__requirements__utf16__encoding(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         mirror.packages_to_sync = {
             "foo": "",
diff --git a/src/bandersnatch/tests/plugins/test_blocklist_name.py b/src/bandersnatch/tests/plugins/test_blocklist_name.py
index 983d8b257..7f8c5c255 100644
--- a/src/bandersnatch/tests/plugins/test_blocklist_name.py
+++ b/src/bandersnatch/tests/plugins/test_blocklist_name.py
@@ -1,13 +1,11 @@
 import os
-from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 
 
 class TestBlockListProject(TestCase):
@@ -31,7 +29,7 @@ def tearDown(self) -> None:
             self.tempdir = None
 
     def test__plugin__loads__explicitly_enabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -39,13 +37,13 @@ def test__plugin__loads__explicitly_enabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["blocklist_project"])
         self.assertEqual(len(plugins), 1)
 
     def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -53,23 +51,23 @@ def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("blocklist_project", names)
 
     def test__plugin__loads__default(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [blocklist]
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("blocklist_project", names)
 
     def test__filter__matches__package(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -80,14 +78,14 @@ def test__filter__matches__package(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo": ""}
         mirror._filter_packages()
 
         self.assertNotIn("foo", mirror.packages_to_sync.keys())
 
     def test__filter__nomatch_package(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
         [blocklist]
         plugins =
@@ -97,14 +95,14 @@ def test__filter__nomatch_package(self) -> None:
         """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo2": ""}
         mirror._filter_packages()
 
         self.assertIn("foo2", mirror.packages_to_sync.keys())
 
     def test__filter__name_only(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -119,7 +117,7 @@ def test__filter__name_only(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo": "", "foo2": ""}
         mirror._filter_packages()
 
@@ -127,7 +125,7 @@ def test__filter__name_only(self) -> None:
         self.assertIn("foo2", mirror.packages_to_sync.keys())
 
     def test__filter__varying__specifiers(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [mirror]
 storage-backend = filesystem
@@ -143,7 +141,7 @@ def test__filter__varying__specifiers(self) -> None:
     snu
 """
         )
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {
             "foo": "",
             "foo2": "",
@@ -176,7 +174,7 @@ def tearDown(self) -> None:
             self.tempdir = None
 
     def test__plugin__loads__explicitly_enabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -184,13 +182,13 @@ def test__plugin__loads__explicitly_enabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["blocklist_release"])
         self.assertEqual(len(plugins), 1)
 
     def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -198,12 +196,12 @@ def test__plugin__doesnt_load__explicitly__disabled(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertNotIn("blocklist_release", names)
 
     def test__filter__matches__release(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -214,7 +212,7 @@ def test__filter__matches__release(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -226,7 +224,7 @@ def test__filter__matches__release(self) -> None:
         self.assertEqual(pkg.releases, {"1.2.1": {}})
 
     def test__dont__filter__prereleases(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -237,7 +235,7 @@ def test__dont__filter__prereleases(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
@@ -256,7 +254,7 @@ def test__dont__filter__prereleases(self) -> None:
         self.assertEqual(pkg.releases, {"1.2.1": {}, "1.2.2alpha3": {}, "1.2.3rc1": {}})
 
     def test__casing__no__affect(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -267,7 +265,7 @@ def test__casing__no__affect(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo"},
diff --git a/src/bandersnatch/tests/plugins/test_filename.py b/src/bandersnatch/tests/plugins/test_filename.py
index cc42faf54..e6b52121d 100644
--- a/src/bandersnatch/tests/plugins/test_filename.py
+++ b/src/bandersnatch/tests/plugins/test_filename.py
@@ -1,13 +1,11 @@
 import os
-from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 from bandersnatch_filter_plugins import filename_name
 
 
@@ -47,9 +45,9 @@ class TestExcludePlatformFilter(BasePluginTestCase):
 """
 
     def test_plugin_compiles_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_file_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_file_plugins()
 
         assert any(
             type(plugin) is filename_name.ExcludePlatformFilter for plugin in plugins
@@ -62,9 +60,9 @@ def test_exclude_platform(self) -> None:
         freebsd and macos packages while only dropping linux-armv7l from
         linux packages
         """
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foobar", 1)
         pkg._metadata = {
             "info": {"name": "foobar", "version": "1.0"},
diff --git a/src/bandersnatch/tests/plugins/test_latest_release.py b/src/bandersnatch/tests/plugins/test_latest_release.py
index a42446f4e..d52fcc9bc 100644
--- a/src/bandersnatch/tests/plugins/test_latest_release.py
+++ b/src/bandersnatch/tests/plugins/test_latest_release.py
@@ -1,13 +1,11 @@
 import os
-from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 from bandersnatch_filter_plugins import latest_name
 
 
@@ -39,9 +37,9 @@ class TestLatestReleaseFilter(BasePluginTestCase):
 """
 
     def test_plugin_compiles_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
 
         assert any(
             type(plugin) is latest_name.LatestReleaseFilter for plugin in plugins
@@ -54,9 +52,9 @@ def test_plugin_compiles_patterns(self) -> None:
         assert plugin.keep == 2
 
     def test_latest_releases_keep_latest(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo", "version": "2.0.0"},
@@ -75,9 +73,9 @@ def test_latest_releases_keep_latest(self) -> None:
         assert pkg.releases == {"1.1.3": {}, "2.0.0": {}}
 
     def test_latest_releases_keep_latest_time(self) -> None:
-        mock_config(self.config_contents + "\nsort_by = time")
+        bc = mock_config(self.config_contents + "\nsort_by = time")
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo", "version": "2.0.0"},
@@ -100,9 +98,9 @@ def test_latest_releases_keep_latest_time(self) -> None:
         }
 
     def test_latest_releases_keep_stable(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo", "version": "2.0.0"},  # stable version
@@ -127,9 +125,9 @@ def test_latest_releases_ensure_reusable(self) -> None:
         Tests the filter multiple times to ensure no state is preserved and
         thus is reusable between packages
         """
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg1 = Package("foo", 1)
         pkg1._metadata = {
             "info": {"name": "foo", "version": "2.0.0"},
@@ -173,9 +171,9 @@ class TestLatestReleaseFilterUninitialized(BasePluginTestCase):
 """
 
     def test_plugin_compiles_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
 
         assert any(
             type(plugin) is latest_name.LatestReleaseFilter for plugin in plugins
@@ -190,7 +188,7 @@ def test_plugin_compiles_patterns(self) -> None:
     def test_latest_releases_uninitialized(self) -> None:
         mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror()
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo", "version": "2.0.0"},
diff --git a/src/bandersnatch/tests/plugins/test_metadata_plugins.py b/src/bandersnatch/tests/plugins/test_metadata_plugins.py
index be4573f54..1efb5687a 100644
--- a/src/bandersnatch/tests/plugins/test_metadata_plugins.py
+++ b/src/bandersnatch/tests/plugins/test_metadata_plugins.py
@@ -1,14 +1,12 @@
 import os
-from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import cast
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 from bandersnatch_filter_plugins.metadata_filter import SizeProjectMetadataFilter
 
 
@@ -29,7 +27,7 @@ def tearDown(self) -> None:
             self.tempdir.cleanup()
 
     def test__size__plugin__loads__and__initializes(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -40,7 +38,7 @@ def test__size__plugin__loads__and__initializes(self) -> None:
 """
         )
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_metadata_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_metadata_plugins()
         names = [plugin.name for plugin in plugins]
         self.assertListEqual(names, ["size_project_metadata"])
         self.assertEqual(len(plugins), 1)
@@ -49,7 +47,7 @@ def test__size__plugin__loads__and__initializes(self) -> None:
         self.assertTrue(plugin.initialized)
 
     def test__filter__size__only(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -60,7 +58,7 @@ def test__filter__size__only(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         # Test that under-sized project is allowed
         pkg = Package("foo", 1)
@@ -79,7 +77,7 @@ def test__filter__size__only(self) -> None:
         self.assertFalse(pkg.filter_metadata(mirror.filters.filter_metadata_plugins()))
 
     def test__filter__size__or__allowlist(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -94,7 +92,7 @@ def test__filter__size__or__allowlist(self) -> None:
 """
         )
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
 
         # Test that under-sized, allowlisted project is allowed
         pkg = Package("foo", 1)
diff --git a/src/bandersnatch/tests/plugins/test_prerelease_name.py b/src/bandersnatch/tests/plugins/test_prerelease_name.py
index cf615643b..4c277912c 100644
--- a/src/bandersnatch/tests/plugins/test_prerelease_name.py
+++ b/src/bandersnatch/tests/plugins/test_prerelease_name.py
@@ -1,14 +1,13 @@
 import os
 import re
-from pathlib import Path
+from configparser import ConfigParser
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 from bandersnatch_filter_plugins import prerelease_name
 
 
@@ -42,9 +41,9 @@ class TestRegexReleaseFilter(BasePluginTestCase):
 """
 
     def test_plugin_includes_predefined_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
 
         assert any(
             type(plugin) is prerelease_name.PreReleaseFilter for plugin in plugins
@@ -59,8 +58,8 @@ def test_plugin_includes_predefined_patterns(self) -> None:
         ]
         assert plugin.patterns == expected_patterns
 
-    def _check_filter(self, package: str) -> bool:
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+    def _check_filter(self, package: str, cfg: ConfigParser) -> bool:
+        mirror = make_test_mirror(config=cfg)
         pkg = Package(package, serial=1)
         pkg._metadata = {
             "info": {"name": package, "version": "1.2.0"},
@@ -80,11 +79,11 @@ def _check_filter(self, package: str) -> bool:
         return bool(pkg.releases == {"1.2.0": {}})
 
     def test_plugin_filter_all(self) -> None:
-        mock_config(self.config_contents)
-        assert self._check_filter("foo") is True
-        assert self._check_filter("duckdb") is True
+        bc = mock_config(self.config_contents)
+        assert self._check_filter("foo", bc) is True
+        assert self._check_filter("duckdb", bc) is True
 
     def test_plugin_filter_packages(self) -> None:
-        mock_config(self.config_contents + self.config_match_package)
-        assert self._check_filter("foo") is False
-        assert self._check_filter("duckdb") is True
+        bc = mock_config(self.config_contents + self.config_match_package)
+        assert self._check_filter("foo", bc) is False
+        assert self._check_filter("duckdb", bc) is True
diff --git a/src/bandersnatch/tests/plugins/test_regex_name.py b/src/bandersnatch/tests/plugins/test_regex_name.py
index d2973284b..f364b6ad4 100644
--- a/src/bandersnatch/tests/plugins/test_regex_name.py
+++ b/src/bandersnatch/tests/plugins/test_regex_name.py
@@ -1,14 +1,12 @@
 import os
 import re
-from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
 import bandersnatch.filter
-from bandersnatch.master import Master
-from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
 from bandersnatch.tests.mock_config import mock_config
+from bandersnatch.tests.plugins.util import make_test_mirror
 from bandersnatch_filter_plugins import regex_name
 
 
@@ -42,9 +40,9 @@ class TestRegexReleaseFilter(BasePluginTestCase):
 """
 
     def test_plugin_compiles_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_release_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_release_plugins()
 
         assert any(type(plugin) is regex_name.RegexReleaseFilter for plugin in plugins)
         plugin = next(
@@ -55,9 +53,9 @@ def test_plugin_compiles_patterns(self) -> None:
         assert plugin.patterns == [re.compile(r".+rc\d$"), re.compile(r".+alpha\d$")]
 
     def test_plugin_check_match(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         pkg = Package("foo", 1)
         pkg._metadata = {
             "info": {"name": "foo", "version": "foo-1.2.0"},
@@ -82,9 +80,9 @@ class TestRegexProjectFilter(BasePluginTestCase):
 """
 
     def test_plugin_compiles_patterns(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        plugins = bandersnatch.filter.LoadedFilters().filter_project_plugins()
+        plugins = bandersnatch.filter.LoadedFilters(bc).filter_project_plugins()
 
         assert any(type(plugin) is regex_name.RegexProjectFilter for plugin in plugins)
         plugin = next(
@@ -95,9 +93,9 @@ def test_plugin_compiles_patterns(self) -> None:
         assert plugin.patterns == [re.compile(r".+-evil$"), re.compile(r".+-neutral$")]
 
     def test_plugin_check_match(self) -> None:
-        mock_config(self.config_contents)
+        bc = mock_config(self.config_contents)
 
-        mirror = BandersnatchMirror(Path("."), Master(url="https://foo.bar.com"))
+        mirror = make_test_mirror(config=bc)
         mirror.packages_to_sync = {"foo-good": "", "foo-evil": "", "foo-neutral": ""}
         mirror._filter_packages()
 
diff --git a/src/bandersnatch/tests/plugins/test_storage_plugin_s3.py b/src/bandersnatch/tests/plugins/test_storage_plugin_s3.py
index 1a02c0389..79ebd155b 100644
--- a/src/bandersnatch/tests/plugins/test_storage_plugin_s3.py
+++ b/src/bandersnatch/tests/plugins/test_storage_plugin_s3.py
@@ -1,3 +1,4 @@
+from configparser import ConfigParser
 from datetime import datetime
 
 from s3path import S3Path
@@ -5,16 +6,18 @@
 from bandersnatch.tests.mock_config import mock_config
 from bandersnatch_storage_plugins import s3
 
+_empty_cfg = ConfigParser()
+
 
 def test_rewrite(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     with backend.rewrite(f"/{s3_mock.bucket}/test") as fp:
         fp.write("testcontent\n")
     assert s3.S3Path("/test-bucket/test").read_text() == "testcontent\n"
 
 
 def test_update_safe(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     with backend.update_safe(
         f"/{s3_mock.bucket}/todo", mode="w+", encoding="utf-8"
     ) as fp:
@@ -46,7 +49,7 @@ def test_path_glob(s3_mock: S3Path) -> None:
 
 
 def test_lock(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     s3lock = backend.get_lock(f"/{s3_mock.bucket}/.lock")
     with s3lock.acquire(timeout=30):
         assert s3lock.is_locked is True
@@ -54,7 +57,7 @@ def test_lock(s3_mock: S3Path) -> None:
 
 
 def test_compare_files(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.write_file(f"/{s3_mock.bucket}/file1", "test")
     backend.write_file(f"/{s3_mock.bucket}/file2", "test")
     assert (
@@ -64,14 +67,14 @@ def test_compare_files(s3_mock: S3Path) -> None:
 
 
 def test_read_write_file(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.write_file(f"/{s3_mock.bucket}/file1", "test")
 
     assert backend.read_file(f"/{s3_mock.bucket}/file1", text=True) == "test"
 
 
 def test_delete_file(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     sample_file = backend.PATH_BACKEND(f"/{s3_mock.bucket}/file1")
     sample_file.touch()
     assert sample_file.exists() is True
@@ -81,7 +84,7 @@ def test_delete_file(s3_mock: S3Path) -> None:
 
 
 def test_delete_path(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.PATH_BACKEND(f"/{s3_mock.bucket}/folder1/file1").touch()
     backend.PATH_BACKEND(f"/{s3_mock.bucket}/folder2/file2").touch()
     backend.PATH_BACKEND(f"/{s3_mock.bucket}/folder2/file3").touch()
@@ -114,7 +117,7 @@ def test_delete_path(s3_mock: S3Path) -> None:
 
 
 def test_mkdir_rmdir(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.mkdir(f"/{s3_mock.bucket}/test_folder")
 
     assert backend.is_dir(f"/{s3_mock.bucket}/test_folder")
@@ -125,7 +128,7 @@ def test_mkdir_rmdir(s3_mock: S3Path) -> None:
 
 
 def test_scandir(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.mkdir(f"/{s3_mock.bucket}/test_folder")
     backend.mkdir(f"/{s3_mock.bucket}/test_folder/sub_dir")
     backend.write_file(f"/{s3_mock.bucket}/test_folder/sub_file", "test")
@@ -141,7 +144,7 @@ def test_scandir(s3_mock: S3Path) -> None:
 
 
 def test_plugin_init(s3_mock: S3Path) -> None:
-    config_loader = mock_config(
+    config = mock_config(
         """
 [mirror]
 directory = /tmp/pypi
@@ -164,14 +167,14 @@ def test_plugin_init(s3_mock: S3Path) -> None:
 signature_version = s3v4
 """
     )
-    backend = s3.S3Storage(config=config_loader.config)
+    backend = s3.S3Storage(config=config)
     backend.initialize_plugin()
 
     path = s3.S3Path("/tmp/pypi")
     resource, _ = path._accessor.configuration_map.get_configuration(path)
     assert resource.meta.client.meta.endpoint_url == "http://localhost:9090"
 
-    config_loader = mock_config(
+    config = mock_config(
         """
 [mirror]
 directory = /tmp/pypi
@@ -190,7 +193,7 @@ def test_plugin_init(s3_mock: S3Path) -> None:
 endpoint_url = http://localhost:9090
 """
     )
-    backend = s3.S3Storage(config=config_loader.config)
+    backend = s3.S3Storage(config=config)
     backend.initialize_plugin()
 
     path = s3.S3Path("/tmp/pypi")
@@ -199,7 +202,7 @@ def test_plugin_init(s3_mock: S3Path) -> None:
 
 
 def test_upload_time(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.PATH_BACKEND(f"/{s3_mock.bucket}/folder1/file1").touch()
 
     assert backend.get_upload_time(f"/{s3_mock.bucket}/folder1/file1").second == 0
@@ -214,13 +217,13 @@ def test_upload_time(s3_mock: S3Path) -> None:
 
 
 def test_file_size(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.write_file(f"/{s3_mock.bucket}/file1", b"1234")
     assert backend.get_file_size(f"/{s3_mock.bucket}/file1") == 4
 
 
 def test_copy_file(s3_mock: S3Path) -> None:
-    backend = s3.S3Storage()
+    backend = s3.S3Storage(config=_empty_cfg)
     backend.write_file(f"/{s3_mock.bucket}/file1", b"1234")
 
     backend.copy_file(f"/{s3_mock.bucket}/file1", f"/{s3_mock.bucket}/file2")
diff --git a/src/bandersnatch/tests/plugins/test_storage_plugins.py b/src/bandersnatch/tests/plugins/test_storage_plugins.py
index 57787f6d5..29bf265b1 100644
--- a/src/bandersnatch/tests/plugins/test_storage_plugins.py
+++ b/src/bandersnatch/tests/plugins/test_storage_plugins.py
@@ -11,15 +11,17 @@
 import tempfile
 import unittest
 from collections.abc import Iterator
+from configparser import ConfigParser
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 from unittest import TestCase, mock
 
 import bandersnatch.storage
+from bandersnatch.filter import LoadedFilters
 from bandersnatch.master import Master
 from bandersnatch.mirror import BandersnatchMirror
 from bandersnatch.package import Package
-from bandersnatch.storage import PATH_TYPES
+from bandersnatch.storage import PATH_TYPES, Storage
 from bandersnatch.tests.mock_config import mock_config
 from bandersnatch_storage_plugins import filesystem, swift
 
@@ -416,7 +418,9 @@ def setUp_backEnd(self) -> None:
 
     def setUp_mirror(self) -> None:
         self.master = Master(url="https://foo.bar.com")
-        self.mirror = BandersnatchMirror(self.mirror_path, self.master, self.backend)
+        self.mirror = BandersnatchMirror(
+            self.mirror_path, self.master, self.plugin, LoadedFilters(ConfigParser())
+        )
         pkg = Package("foobar", serial=1)
         pkg._metadata = {
             "info": {"name": "foobar", "version": "1.0"},
@@ -425,13 +429,14 @@ def setUp_mirror(self) -> None:
         self.pkgs.append(pkg)
 
     def setUp_plugin(self) -> None:
-        self.plugin = next(
-            iter(
-                bandersnatch.storage.storage_backend_plugins(
-                    self.backend, clear_cache=True
+        if self.backend is not None:
+            self.plugin: Storage = next(
+                iter(
+                    bandersnatch.storage.storage_backend_plugins(
+                        self.config_data, self.backend, clear_cache=True
+                    )
                 )
             )
-        )
 
     def setUp_mirrorDirs(self) -> None:
         pypi_dir = (
@@ -614,7 +619,7 @@ def test_plugin_type(self) -> None:
         self.assertTrue(self.plugin.PATH_BACKEND is self.path_backends[self.backend])
 
     def test_json_paths(self) -> None:
-        config = mock_config(self.config_contents).config
+        config = mock_config(self.config_contents)
         mirror_dir = self.plugin.PATH_BACKEND(config.get("mirror", "directory"))
         packages = {
             "bandersnatch": [
diff --git a/src/bandersnatch/tests/plugins/util.py b/src/bandersnatch/tests/plugins/util.py
new file mode 100644
index 000000000..fa4edac91
--- /dev/null
+++ b/src/bandersnatch/tests/plugins/util.py
@@ -0,0 +1,33 @@
+from configparser import ConfigParser
+from pathlib import Path
+
+from bandersnatch.filter import LoadedFilters
+from bandersnatch.master import Master
+from bandersnatch.mirror import BandersnatchMirror
+from bandersnatch.storage import storage_backend_plugins
+
+
+def make_test_mirror(
+    location: Path | None = None,
+    url: str = "https://foo.bar.com",
+    config: ConfigParser | None = None,
+) -> BandersnatchMirror:
+    location = location or Path(".")
+    local_config = config or ConfigParser()
+    local_config.read_dict(
+        {
+            "mirror": {
+                "storage-backend": "filesystem",
+                "directory": location.as_posix(),
+                "workers": 2,
+            }
+        }
+    )
+    if config:
+        local_config.read_dict(config)
+    return BandersnatchMirror(
+        location or Path("."),
+        Master(url=url),
+        next(iter(storage_backend_plugins(config=local_config))),
+        LoadedFilters(local_config, load_all=True),
+    )
diff --git a/src/bandersnatch/tests/test_configuration.py b/src/bandersnatch/tests/test_configuration.py
index 92b8d384f..c32644b9f 100644
--- a/src/bandersnatch/tests/test_configuration.py
+++ b/src/bandersnatch/tests/test_configuration.py
@@ -1,200 +1,94 @@
-import configparser
-import importlib.resources
-import os
-import unittest
-from tempfile import TemporaryDirectory
-from unittest import TestCase
-
-from bandersnatch.configuration import (
-    BandersnatchConfig,
-    SetConfigValues,
-    Singleton,
-    validate_config_values,
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from bandersnatch.config import BandersnatchConfig
+
+
+def cfg_from_str(content: str) -> BandersnatchConfig:
+    config = BandersnatchConfig()
+    config.read_string(content)
+    return config
+
+
+def test_validated_options_are_reused() -> None:
+    # leaking implementation detail: get_validated assumes its argument is a class and caches initialized objects by the class's __qualname__.
+    # Mock/MagicMock raise an AttributeError for __qualname__ (and __name__) unless you specifically set the attribute.
+    MockOptionsType = mock.Mock(__qualname__="MockOptionsType")
+
+    config = BandersnatchConfig()
+    options1 = config.get_validated(MockOptionsType)  # type: ignore
+    options2 = config.get_validated(MockOptionsType)  # type: ignore
+
+    # the factory method should only be called once, the first time 'get_validated' is called
+    MockOptionsType.from_config_parser.assert_called_once_with(config)
+    # both calls to 'get_validated' should return the same object b/c the second call returns the cached object
+    assert options1 is options2
+
+
+def test_validated_option_types_are_distinct() -> None:
+    MockOptionsTypeA = mock.Mock(__qualname__="MockOptionsTypeA")
+    MockOptionsTypeB = mock.Mock(__qualname__="MockOptionsTypeB")
+
+    config = BandersnatchConfig()
+    options_a = config.get_validated(MockOptionsTypeA)  # type: ignore
+    options_b = config.get_validated(MockOptionsTypeB)  # type: ignore
+
+    assert options_a is not options_b
+
+
+@pytest.mark.parametrize(
+    "option_name",
+    ["test_option_name", "test-option-name", "Test-Option-Name", "TEST_OPTION_NAME"],
 )
-from bandersnatch.simple import SimpleFormat
+def test_option_names_are_normalized(option_name: str) -> None:
+    content = f"""\
+    [test]
+    {option_name} = expected value
+    """
+    config = cfg_from_str(content)
+    assert config.get("test", "test_option_name") == "expected value"
 
 
-class TestBandersnatchConf(TestCase):
+def test_supports_extended_interpolation() -> None:
+    content = """\
+    [paths]
+    root = /opt/stuff
+
+    [test]
+    option_a = ${paths:root}
+    option_b = ${option_a}/example.txt
     """
-    Tests for the BandersnatchConf singleton class
+    config = cfg_from_str(content)
+    assert config.get("test", "option_a") == "/opt/stuff"
+    assert config.get("test", "option_b") == "/opt/stuff/example.txt"
+
+
+def test_can_read_from_path(tmp_path: Path) -> None:
+    content = """\
+    [A]
+    one = one fish
+    two = two fish
+    [B]
+    three = red fish, blue fish
     """
+    tmp_file = tmp_path / "test.cfg"
+    tmp_file.write_text(content)
+
+    config1 = BandersnatchConfig()
+    config1.read_path(tmp_file)
+
+    config2 = BandersnatchConfig()
+    with tmp_file.open() as cfg_file:
+        config2.read_file(cfg_file)
+
+    assert config1.sections() == config2.sections()
+    assert config1.items("A") == config2.items("A")
+
 
-    tempdir = None
-    cwd = None
-
-    def setUp(self) -> None:
-        self.cwd = os.getcwd()
-        self.tempdir = TemporaryDirectory()
-        os.chdir(self.tempdir.name)
-        # Hack to ensure each test gets fresh instance if needed
-        # We have a dedicated test to ensure we're creating a singleton
-        Singleton._instances = {}
-
-    def tearDown(self) -> None:
-        if self.tempdir:
-            assert self.cwd
-            os.chdir(self.cwd)
-            self.tempdir.cleanup()
-            self.tempdir = None
-
-    def test_is_singleton(self) -> None:
-        instance1 = BandersnatchConfig()
-        instance2 = BandersnatchConfig()
-        self.assertEqual(id(instance1), id(instance2))
-
-    def test_single_config__default__all_sections_present(self) -> None:
-        config_file = str(importlib.resources.files("bandersnatch") / "unittest.conf")
-        instance = BandersnatchConfig(str(config_file))
-        # All default values should at least be present and be the write types
-        for section in ["mirror", "plugins", "blocklist"]:
-            self.assertIn(section, instance.config.sections())
-
-    def test_single_config__default__mirror__setting_attributes(self) -> None:
-        instance = BandersnatchConfig()
-        options = [option for option in instance.config["mirror"]]
-        options.sort()
-        self.assertListEqual(
-            options,
-            [
-                "cleanup",
-                "compare-method",
-                "directory",
-                "global-timeout",
-                "hash-index",
-                "json",
-                "master",
-                "release-files",
-                "simple-format",
-                "stop-on-error",
-                "storage-backend",
-                "timeout",
-                "verifiers",
-                "workers",
-            ],
-        )
-
-    def test_single_config__default__mirror__setting__types(self) -> None:
-        """
-        Make sure all default mirror settings will cast to the correct types
-        """
-        instance = BandersnatchConfig()
-        for option, option_type in [
-            ("directory", str),
-            ("hash-index", bool),
-            ("json", bool),
-            ("master", str),
-            ("stop-on-error", bool),
-            ("storage-backend", str),
-            ("timeout", int),
-            ("global-timeout", int),
-            ("workers", int),
-            ("compare-method", str),
-        ]:
-            self.assertIsInstance(
-                option_type(instance.config["mirror"].get(option)), option_type
-            )
-
-    def test_single_config_custom_setting_boolean(self) -> None:
-        with open("test.conf", "w") as testconfig_handle:
-            testconfig_handle.write("[mirror]\nhash-index=false\n")
-        instance = BandersnatchConfig()
-        instance.config_file = "test.conf"
-        instance.load_configuration()
-        self.assertFalse(instance.config["mirror"].getboolean("hash-index"))
-
-    def test_single_config_custom_setting_int(self) -> None:
-        with open("test.conf", "w") as testconfig_handle:
-            testconfig_handle.write("[mirror]\ntimeout=999\n")
-        instance = BandersnatchConfig()
-        instance.config_file = "test.conf"
-        instance.load_configuration()
-        self.assertEqual(int(instance.config["mirror"]["timeout"]), 999)
-
-    def test_single_config_custom_setting_str(self) -> None:
-        with open("test.conf", "w") as testconfig_handle:
-            testconfig_handle.write("[mirror]\nmaster=https://foo.bar.baz\n")
-        instance = BandersnatchConfig()
-        instance.config_file = "test.conf"
-        instance.load_configuration()
-        self.assertEqual(instance.config["mirror"]["master"], "https://foo.bar.baz")
-
-    def test_multiple_instances_custom_setting_str(self) -> None:
-        with open("test.conf", "w") as testconfig_handle:
-            testconfig_handle.write("[mirror]\nmaster=https://foo.bar.baz\n")
-        instance1 = BandersnatchConfig()
-        instance1.config_file = "test.conf"
-        instance1.load_configuration()
-
-        instance2 = BandersnatchConfig()
-        self.assertEqual(instance2.config["mirror"]["master"], "https://foo.bar.baz")
-
-    def test_validate_config_values(self) -> None:
-        default_values = SetConfigValues(
-            False,
-            "",
-            "",
-            False,
-            "sha256",
-            "filesystem",
-            False,
-            True,
-            "hash",
-            "",
-            False,
-            SimpleFormat.ALL,
-        )
-        no_options_configparser = configparser.ConfigParser()
-        no_options_configparser["mirror"] = {}
-        self.assertEqual(
-            default_values, validate_config_values(no_options_configparser)
-        )
-
-    def test_validate_config_values_release_files_false_sets_root_uri(self) -> None:
-        default_values = SetConfigValues(
-            False,
-            "https://files.pythonhosted.org",
-            "",
-            False,
-            "sha256",
-            "filesystem",
-            False,
-            False,
-            "hash",
-            "",
-            False,
-            SimpleFormat.ALL,
-        )
-        release_files_false_configparser = configparser.ConfigParser()
-        release_files_false_configparser["mirror"] = {"release-files": "false"}
-        self.assertEqual(
-            default_values, validate_config_values(release_files_false_configparser)
-        )
-
-    def test_validate_config_values_download_mirror_false_sets_no_fallback(
-        self,
-    ) -> None:
-        default_values = SetConfigValues(
-            False,
-            "",
-            "",
-            False,
-            "sha256",
-            "filesystem",
-            False,
-            True,
-            "hash",
-            "",
-            False,
-            SimpleFormat.ALL,
-        )
-        release_files_false_configparser = configparser.ConfigParser()
-        release_files_false_configparser["mirror"] = {
-            "download-mirror-no-fallback": "true",
-        }
-        self.assertEqual(
-            default_values, validate_config_values(release_files_false_configparser)
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
+def test_reading_missing_path_raises(tmp_path: Path) -> None:
+    no_file = tmp_path / "test.cfg"
+    config = BandersnatchConfig()
+    with pytest.raises(IOError):
+        config.read_path(no_file)
diff --git a/src/bandersnatch/tests/test_delete.py b/src/bandersnatch/tests/test_delete.py
index f120a4bb3..e837942ba 100644
--- a/src/bandersnatch/tests/test_delete.py
+++ b/src/bandersnatch/tests/test_delete.py
@@ -1,5 +1,6 @@
 import os
 from argparse import Namespace
+from collections.abc import Callable
 from configparser import ConfigParser
 from json import loads
 from pathlib import Path
@@ -14,6 +15,7 @@
 from bandersnatch.delete import delete_packages, delete_path, delete_simple_page
 from bandersnatch.master import Master
 from bandersnatch.mirror import BandersnatchMirror
+from bandersnatch.storage import Storage
 from bandersnatch.utils import find
 
 EXPECTED_WEB_BEFORE_DELETION = """\
@@ -76,24 +78,25 @@ def _fake_config() -> ConfigParser:
 
 
 @pytest.mark.asyncio
-async def test_delete_path() -> None:
+async def test_delete_path(local_storage_factory: Callable[[Path], Storage]) -> None:
     with TemporaryDirectory() as td:
         td_path = Path(td)
+        storage_backend = local_storage_factory(td_path)
         fake_path = td_path / "unittest-file.tgz"
         with patch("bandersnatch.delete.logger.info") as mock_log:
-            assert await delete_path(fake_path, True) == 0
+            assert await delete_path(fake_path, storage_backend, True) == 0
             assert mock_log.call_count == 1
 
         with patch("bandersnatch.delete.logger.debug") as mock_log:
-            assert await delete_path(fake_path, False) == 0
+            assert await delete_path(fake_path, storage_backend, False) == 0
             assert mock_log.call_count == 1
 
         fake_path.touch()
         # Remove file
-        assert await delete_path(fake_path, False) == 0
+        assert await delete_path(fake_path, storage_backend, False) == 0
         # File should be gone - We should log that via debug
         with patch("bandersnatch.delete.logger.debug") as mock_log:
-            assert await delete_path(fake_path, False) == 0
+            assert await delete_path(fake_path, storage_backend, False) == 0
             assert mock_log.call_count == 1
 
 
diff --git a/src/bandersnatch/tests/test_filter.py b/src/bandersnatch/tests/test_filter.py
index 4932db05c..2c5afd003 100644
--- a/src/bandersnatch/tests/test_filter.py
+++ b/src/bandersnatch/tests/test_filter.py
@@ -1,10 +1,11 @@
 import os
 import sys
 import unittest
+from configparser import ConfigParser
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
-from bandersnatch.configuration import BandersnatchConfig
+from bandersnatch.config import BandersnatchConfig
 from bandersnatch.tests.mock_config import mock_config
 
 from bandersnatch.filter import (  # isort:skip
@@ -38,7 +39,7 @@ def tearDown(self) -> None:
             self.tempdir = None
 
     def test__filter_project_plugins__loads(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled = all
@@ -50,13 +51,13 @@ def test__filter_project_plugins__loads(self) -> None:
             "allowlist_project",
         ]
 
-        plugins = LoadedFilters().filter_project_plugins()
+        plugins = LoadedFilters(bc).filter_project_plugins()
         names = [plugin.name for plugin in plugins]
         for name in builtin_plugin_names:
             self.assertIn(name, names)
 
     def test__filter_release_plugins__loads(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled = all
@@ -69,31 +70,31 @@ def test__filter_release_plugins__loads(self) -> None:
             "latest_release",
         ]
 
-        plugins = LoadedFilters().filter_release_plugins()
+        plugins = LoadedFilters(bc).filter_release_plugins()
         names = [plugin.name for plugin in plugins]
         for name in builtin_plugin_names:
             self.assertIn(name, names)
 
     def test__filter_no_plugin(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
 """
         )
 
-        plugins = LoadedFilters().filter_release_plugins()
+        plugins = LoadedFilters(bc).filter_release_plugins()
         self.assertEqual(len(plugins), 0)
 
-        plugins = LoadedFilters().filter_project_plugins()
+        plugins = LoadedFilters(bc).filter_project_plugins()
         self.assertEqual(len(plugins), 0)
 
     def test__filter_base_clases(self) -> None:
         """
         Test the base filter classes
         """
-
-        plugin = Filter()
+        empty_config = ConfigParser()
+        plugin = Filter(config=empty_config)
         self.assertEqual(plugin.name, "filter")
         try:
             plugin.initialize_plugin()
@@ -102,7 +103,7 @@ def test__filter_base_clases(self) -> None:
             error = True
         self.assertFalse(error)
 
-        plugin = FilterReleasePlugin()
+        plugin = FilterReleasePlugin(config=empty_config)
         self.assertIsInstance(plugin, Filter)
         self.assertEqual(plugin.name, "release_plugin")
         try:
@@ -112,7 +113,7 @@ def test__filter_base_clases(self) -> None:
             error = True
         self.assertFalse(error)
 
-        plugin = FilterProjectPlugin()
+        plugin = FilterProjectPlugin(config=empty_config)
         self.assertIsInstance(plugin, Filter)
         self.assertEqual(plugin.name, "project_plugin")
         try:
@@ -124,17 +125,15 @@ def test__filter_base_clases(self) -> None:
         self.assertFalse(error)
 
     def test_deprecated_keys(self) -> None:
-        with open("test.conf", "w") as f:
-            f.write("[allowlist]\npackages=foo\n[blocklist]\npackages=bar\n")
         instance = BandersnatchConfig()
-        instance.config_file = "test.conf"
-        instance.load_configuration()
-        plugin = Filter()
+        instance.read_string("[allowlist]\npackages=foo\n[blocklist]\npackages=bar\n")
+
+        plugin = Filter(config=instance)
         assert plugin.allowlist.name == "allowlist"
         assert plugin.blocklist.name == "blocklist"
 
     def test__filter_project_blocklist_allowlist__pep503_normalize(self) -> None:
-        mock_config(
+        bc = mock_config(
             """\
 [plugins]
 enabled =
@@ -154,7 +153,7 @@ def test__filter_project_blocklist_allowlist__pep503_normalize(self) -> None:
         )
 
         plugins = {
-            plugin.name: plugin for plugin in LoadedFilters().filter_project_plugins()
+            plugin.name: plugin for plugin in LoadedFilters(bc).filter_project_plugins()
         }
 
         self.assertTrue(plugins["blocklist_project"].check_match(name="sampleproject"))
diff --git a/src/bandersnatch/tests/test_main.py b/src/bandersnatch/tests/test_main.py
index e42eef061..31a18859f 100644
--- a/src/bandersnatch/tests/test_main.py
+++ b/src/bandersnatch/tests/test_main.py
@@ -12,9 +12,9 @@
 
 import bandersnatch.mirror
 import bandersnatch.storage
-from bandersnatch.configuration import Singleton
+from bandersnatch.config.comparison_method import ComparisonMethod
 from bandersnatch.main import main
-from bandersnatch.simple import SimpleFormat
+from bandersnatch.simple import SimpleDigest, SimpleFormat
 
 if TYPE_CHECKING:
     from bandersnatch.mirror import BandersnatchMirror
@@ -24,11 +24,6 @@ async def empty_dict(*args: Any, **kwargs: Any) -> dict:
     return {}
 
 
-def setup() -> None:
-    """simple setup function to clear Singleton._instances before each test"""
-    Singleton._instances = {}
-
-
 def test_main_help(capfd: CaptureFixture) -> None:
     sys.argv = ["bandersnatch", "--help"]
     with pytest.raises(SystemExit):
@@ -76,7 +71,7 @@ def test_main_reads_config_values(mirror_mock: mock.MagicMock, tmpdir: Path) ->
     sys.argv = ["bandersnatch", "-c", str(config_path), "mirror"]
     assert config_path.exists()
     main(asyncio.new_event_loop())
-    (homedir, master), kwargs = mirror_mock.call_args_list[0]
+    (homedir, master, _storage, _filters), kwargs = mirror_mock.call_args_list[0]
 
     assert Path("/srv/pypi") == homedir
     assert isinstance(master, bandersnatch.master.Master)
@@ -86,16 +81,14 @@ def test_main_reads_config_values(mirror_mock: mock.MagicMock, tmpdir: Path) ->
         "workers": 3,
         "root_uri": "",
         "json_save": False,
-        "digest_name": "sha256",
+        "digest_name": SimpleDigest.SHA256,
         "keep_index_versions": 0,
         "release_files_save": True,
-        "storage_backend": "filesystem",
-        "diff_file": diff_file,
         "diff_append_epoch": False,
         "diff_full_path": diff_file,
         "cleanup": False,
-        "compare_method": "hash",
-        "download_mirror": "",
+        "compare_method": ComparisonMethod.HASH,
+        "download_mirror": None,
         "download_mirror_no_fallback": False,
         "simple_format": SimpleFormat.ALL,
     } == kwargs
@@ -104,18 +97,16 @@ def test_main_reads_config_values(mirror_mock: mock.MagicMock, tmpdir: Path) ->
 def test_main_reads_custom_config_values(
     mirror_mock: "BandersnatchMirror", logging_mock: mock.MagicMock, customconfig: Path
 ) -> None:
-    setup()
     conffile = str(customconfig / "bandersnatch.conf")
     sys.argv = ["bandersnatch", "-c", conffile, "mirror"]
     main(asyncio.new_event_loop())
     (log_config, _kwargs) = logging_mock.call_args_list[0]
-    assert log_config == (str(customconfig / "bandersnatch-log.conf"),)
+    assert log_config == ((customconfig / "bandersnatch-log.conf"),)
 
 
-def test_main_throws_exception_on_unsupported_digest_name(
-    customconfig: Path,
+def test_main_logs_error_on_unsupported_digest_name(
+    customconfig: Path, caplog: pytest.LogCaptureFixture
 ) -> None:
-    setup()
     conffile = str(customconfig / "bandersnatch.conf")
     parser = configparser.ConfigParser()
     parser.read(conffile)
@@ -125,10 +116,9 @@ def test_main_throws_exception_on_unsupported_digest_name(
         parser.write(fp)
     sys.argv = ["bandersnatch", "-c", conffile, "mirror"]
 
-    with pytest.raises(ValueError) as e:
-        main(asyncio.new_event_loop())
-
-    assert "foobar is not a valid" in str(e.value)
+    rv = main(asyncio.new_event_loop())
+    assert rv != 0
+    assert any("foobar is not a valid" in msg for msg in caplog.messages)
 
 
 @pytest.fixture
diff --git a/src/bandersnatch/tests/test_mirror.py b/src/bandersnatch/tests/test_mirror.py
index a55c86e8c..e80f9504e 100644
--- a/src/bandersnatch/tests/test_mirror.py
+++ b/src/bandersnatch/tests/test_mirror.py
@@ -1,7 +1,7 @@
 import os.path
 import sys
 import unittest.mock as mock
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from os import sep
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -11,11 +11,14 @@
 from freezegun import freeze_time
 
 from bandersnatch import utils
-from bandersnatch.configuration import BandersnatchConfig, Singleton
+from bandersnatch.config import BandersnatchConfig
+from bandersnatch.filter import LoadedFilters
 from bandersnatch.master import Master
 from bandersnatch.mirror import BandersnatchMirror
+from bandersnatch.mirror import mirror as mirror_cmd
 from bandersnatch.package import Package
 from bandersnatch.simple import SimpleFormats
+from bandersnatch.storage import Storage
 from bandersnatch.tests.test_simple_fixtures import SIXTYNINE_METADATA
 from bandersnatch.utils import WINDOWS, make_time_stamp
 
@@ -72,148 +75,244 @@ def touch_files(paths: list[Path]) -> None:
             pfp.close()
 
 
-def test_limit_workers() -> None:
+def test_limit_workers(
+    empty_filters: LoadedFilters, local_storage_factory: Callable[[Path], Storage]
+) -> None:
     try:
-        BandersnatchMirror(Path("/tmp"), mock.Mock(), workers=11)
+        basedir = Path("/tmp")
+        BandersnatchMirror(
+            basedir,
+            mock.Mock(),
+            local_storage_factory(basedir),
+            empty_filters,
+            workers=11,
+        )
     except ValueError:
         pass
 
 
-def test_mirror_loads_serial(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("5")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    m = BandersnatchMirror(tmpdir, mock.Mock())
+def test_mirror_loads_serial(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "generation").write_text("5")
+    (tmp_path / "status").write_text("1234")
+    m = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
     assert m.synced_serial == 1234
 
 
-def test_mirror_recovers_from_inconsistent_serial(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    m = BandersnatchMirror(tmpdir, mock.Mock())
+def test_mirror_recovers_from_inconsistent_serial(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "generation").write_text("")
+    (tmp_path / "status").write_text("1234")
+    m = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
     assert m.synced_serial == 0
 
 
-def test_mirror_generation_3_resets_status_files(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("2")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    with open(str(tmpdir / "todo"), "w") as status:
-        status.write("asdf")
+def test_mirror_generation_3_resets_status_files(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "generation").write_text("2")
+    (tmp_path / "status").write_text("1234")
+    (tmp_path / "todo").write_text("asdf")
+
+    m = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
 
-    m = BandersnatchMirror(tmpdir, mock.Mock())
     assert m.synced_serial == 0
-    assert not os.path.exists(str(tmpdir / "todo"))
-    assert not os.path.exists(str(tmpdir / "status"))
-    assert open(str(tmpdir / "generation")).read() == "5"
+    assert not (tmp_path / "todo").exists()
+    assert not (tmp_path / "status").exists()
+    assert (tmp_path / "generation").read_text() == "5"
 
 
-def test_mirror_generation_4_resets_status_files(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("4")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    with open(str(tmpdir / "todo"), "w") as status:
-        status.write("asdf")
+def test_mirror_generation_4_resets_status_files(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "generation").write_text("4")
+    (tmp_path / "status").write_text("1234")
+    (tmp_path / "todo").write_text("asdf")
+
+    m = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
 
-    m = BandersnatchMirror(tmpdir, mock.Mock())
     assert m.synced_serial == 0
-    assert not os.path.exists(str(tmpdir / "todo"))
-    assert not os.path.exists(str(tmpdir / "status"))
-    assert open(str(tmpdir / "generation")).read() == "5"
+    assert not (tmp_path / "todo").exists()
+    assert not (tmp_path / "status").exists()
+    assert (tmp_path / "generation").read_text() == "5"
 
 
-def test_mirror_filter_packages_match(tmpdir: Path) -> None:
+def test_mirror_filter_packages_match(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
     """
     Packages that exist in the blocklist should be removed from the list of
     packages to sync.
     """
     test_configuration = """\
-[plugins]
-enabled =
-    blocklist_project
-[blocklist]
-packages =
-    example1
-"""
-    Singleton._instances = {}
-    with open("test.conf", "w") as testconfig_handle:
-        testconfig_handle.write(test_configuration)
-    BandersnatchConfig("test.conf")
-    m = BandersnatchMirror(tmpdir, mock.Mock())
+    [plugins]
+    enabled =
+        blocklist_project
+    [blocklist]
+    packages =
+        example1
+    """
+
+    bc = BandersnatchConfig()
+    bc.read_string(test_configuration)
+
+    m = BandersnatchMirror(
+        tmp_path, mock.Mock(), local_storage, LoadedFilters(bc, load_all=True)
+    )
     m.packages_to_sync = {"example1": "", "example2": ""}
     m._filter_packages()
     assert "example1" not in m.packages_to_sync.keys()
 
 
-def test_mirror_filter_packages_nomatch_package_with_spec(tmpdir: Path) -> None:
+def test_mirror_filter_packages_nomatch_package_with_spec(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
     """
     Package lines with a PEP440 spec on them should not be filtered from the
     list of packages.
     """
     test_configuration = """\
-[plugins]
-enable =
-    blocklist_project
-[blocklist]
-packages =
-    example3>2.0.0
-"""
-    Singleton._instances = {}
-    with open("test.conf", "w") as testconfig_handle:
-        testconfig_handle.write(test_configuration)
-    BandersnatchConfig("test.conf")
-    m = BandersnatchMirror(tmpdir, mock.Mock())
+    [plugins]
+    enable =
+        blocklist_project
+    [blocklist]
+    packages =
+        example3>2.0.0
+    """
+    bc = BandersnatchConfig()
+    bc.read_string(test_configuration)
+
+    m = BandersnatchMirror(
+        tmp_path, mock.Mock(), local_storage, LoadedFilters(config=bc)
+    )
     m.packages_to_sync = {"example1": "", "example3": ""}
     m._filter_packages()
     assert "example3" in m.packages_to_sync.keys()
 
 
-def test_mirror_removes_empty_todo_list(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("3")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    with open(str(tmpdir / "todo"), "w") as status:
-        status.write("")
-    BandersnatchMirror(tmpdir, mock.Mock())
-    assert not os.path.exists(str(tmpdir / "todo"))
+def test_mirror_removes_empty_todo_list(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+
+    (tmp_path / "generation").write_text("3")
+    (tmp_path / "status").write_text("1234")
+    (tmp_path / "todo").write_text("")
+
+    _ = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
+    assert not (tmp_path / "todo").exists()
+
+
+def test_mirror_removes_broken_todo_list(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "generation").write_text("3")
+    (tmp_path / "status").write_text("1234")
+    (tmp_path / "todo").write_text("foo")
+
+    _ = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
+
+    assert not os.path.exists(tmp_path / "todo")
+
+
+def test_mirror_removes_old_status_and_todo_inits_generation(
+    tmp_path: Path, empty_filters: LoadedFilters, local_storage: Storage
+) -> None:
+    (tmp_path / "status").write_text("1234")
+    (tmp_path / "todo").write_text("foo")
+
+    _ = BandersnatchMirror(tmp_path, mock.Mock(), local_storage, empty_filters)
+
+    assert not os.path.exists(tmp_path / "todo")
+    assert not os.path.exists(tmp_path / "status")
+    assert (tmp_path / "generation").read_text().strip() == "5"
+
+
+# This is a test to check that a diff file is NOT created when 'diff-file' isn't set in
+# configuration. Obviously we can't exhaustively assert a negative - the regression
+# being checked for here is a diff file being created at a 'default' location
+# ($directory/mirrored-files) when diff-file isn't configured.
+@pytest.mark.asyncio
+async def test_mirror_subcommand_only_creates_diff_file_if_configured(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    # Setup 1 - create a configuration for the 'mirror' subcommand
+    # (Configuration is passed as a parameter, so we don't need to fiddle with Singleton)
+    config = BandersnatchConfig()
+    config.read_dict(
+        {
+            "mirror": {
+                "master": "https://pypi.org",
+                "directory": (tmp_path / "mirror").as_posix(),
+                "timeout": 15,
+                "stop-on-error": False,
+                "workers": 1,
+                "hash-index": False,
+            },
+            "plugins": {"enabled": ["allowlist_project"]},
+            "allowlist": {"packages": ["black", "ruff", "autopep8"]},
+        }
+    )
+
+    # Setup 2 - patch 'Mirror.synchronize' with a stub returning fixed data
+    # Normally it returns 'self.altered_packages', and those are what get written into
+    # the diff file. Non-empty fixed content here means a diff-file should exist and
+    # have content IF it is configured.
+    async def mock_synchronize(
+        self: Any,
+        specific_packages: list[str] | None = None,
+        sync_simple_index: bool = True,
+    ) -> dict[str, set[str]]:
+        return {
+            "ruff": {"fake/file/path/1", "fake/file/path/2"},
+            "black": {"fake/file/path/3"},
+        }
+
+    monkeypatch.setattr(BandersnatchMirror, "synchronize", mock_synchronize)
 
+    # Execute the 'mirror' subcommand. Because 'synchronize' is patched, this is pretty
+    # much running the body of the 'mirror' function, including creating Master and
+    # Mirror instances, but doesn't perform any actual package syncing at all.
+    await mirror_cmd(config=config)
 
-def test_mirror_removes_broken_todo_list(tmpdir: Path) -> None:
-    with open(str(tmpdir / "generation"), "w") as generation:
-        generation.write("3")
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    with open(str(tmpdir / "todo"), "w") as status:
-        status.write("foo")
-    BandersnatchMirror(tmpdir, mock.Mock())
-    assert not os.path.exists(str(tmpdir / "todo"))
+    # An 'info'-level message is always logged after 'synchronize' completes. It should
+    # be consistent with the static data returned from our mock method.
+    expected_message = "2 packages had changes"
+    assert any(
+        m == expected_message for m in caplog.messages
+    ), f"Logged '{expected_message}'"
 
+    # Because BandersnatchMirror's 'bootstrap' runs, this directory should exist;
+    # this is just sanity checking that some disk IO happened...
+    web_folder = tmp_path / "mirror" / "web"
+    assert web_folder.is_dir(), f"The folder '{web_folder}' was created"
 
-def test_mirror_removes_old_status_and_todo_inits_generation(tmpdir: Path) -> None:
-    with open(str(tmpdir / "status"), "w") as status:
-        status.write("1234")
-    with open(str(tmpdir / "todo"), "w") as status:
-        status.write("foo")
-    BandersnatchMirror(tmpdir, mock.Mock())
-    assert not os.path.exists(str(tmpdir / "todo"))
-    assert not os.path.exists(str(tmpdir / "status"))
-    assert open(str(tmpdir / "generation")).read().strip() == "5"
+    # But there should NOT be a diff file:
+    absent_diff_file = tmp_path / "mirror" / "mirrored-files"
+    assert not absent_diff_file.exists(), f"there is no diff file at {absent_diff_file}"
 
 
 def test_mirror_with_same_homedir_needs_lock(
-    mirror: BandersnatchMirror, tmpdir: Path
+    mirror: BandersnatchMirror,
+    empty_filters: LoadedFilters,
+    local_storage_factory: Callable[[Path], Storage],
 ) -> None:
     try:
-        BandersnatchMirror(mirror.homedir, mirror.master)
+        BandersnatchMirror(
+            mirror.homedir,
+            mirror.master,
+            local_storage_factory(mirror.homedir),
+            empty_filters,
+        )
     except RuntimeError:
         pass
-    BandersnatchMirror(mirror.homedir / "test", mirror.master)
+    BandersnatchMirror(
+        mirror.homedir / "test",
+        mirror.master,
+        local_storage_factory(mirror.homedir / "test"),
+        empty_filters,
+    )
 
 
 @pytest.mark.asyncio
@@ -641,7 +740,11 @@ async def test_metadata_404_keeps_package_on_non_deleting_mirror(
         assert path.exists()
 
 
-def test_find_package_indexes_in_dir_threaded(mirror: BandersnatchMirror) -> None:
+def test_find_package_indexes_in_dir_threaded(
+    mirror: BandersnatchMirror,
+    empty_filters: LoadedFilters,
+    local_storage_factory: Callable[[Path], Storage],
+) -> None:
     directories = (
         "web/simple/peerme",
         "web/simple/click",
@@ -660,7 +763,11 @@ def test_find_package_indexes_in_dir_threaded(mirror: BandersnatchMirror) -> Non
         # Create local mirror first so we '_bootstrap'
         mirror_base = Path(td)
         local_mirror = BandersnatchMirror(
-            mirror_base, mirror.master, stop_on_error=True
+            mirror_base,
+            mirror.master,
+            local_storage_factory(mirror_base),
+            empty_filters,
+            stop_on_error=True,
         )
         # Create fake file system objects
         for directory in directories:
@@ -693,12 +800,18 @@ def test_find_package_indexes_in_dir_threaded(mirror: BandersnatchMirror) -> Non
         assert packages[0] == "click"  # Check sorted - click should be first
 
 
-def test_validate_todo(mirror: BandersnatchMirror) -> None:
+def test_validate_todo(
+    mirror: BandersnatchMirror,
+    empty_filters: LoadedFilters,
+    local_storage_factory: Callable[[Path], Storage],
+) -> None:
     valid_todo = "69\ncooper 69\ndan 1\n"
     invalid_todo = "cooper l33t\ndan n00b\n"
 
     with TemporaryDirectory() as td:
-        test_mirror = BandersnatchMirror(Path(td), mirror.master)
+        test_mirror = BandersnatchMirror(
+            Path(td), mirror.master, local_storage_factory(Path(td)), empty_filters
+        )
         for todo_data in (valid_todo, invalid_todo):
             with test_mirror.todolist.open("w") as tdfp:
                 tdfp.write(todo_data)
@@ -1058,9 +1171,17 @@ async def test_package_sync_replaces_mismatching_local_files(
 @pytest.mark.asyncio
 async def test_package_sync_handles_non_pep_503_in_packages_to_sync(
     master: Master,
+    empty_filters: LoadedFilters,
+    local_storage_factory: Callable[[Path], Storage],
 ) -> None:
     with TemporaryDirectory() as td:
-        mirror = BandersnatchMirror(Path(td), master, stop_on_error=True)
+        mirror = BandersnatchMirror(
+            Path(td),
+            master,
+            local_storage_factory(Path(td)),
+            empty_filters,
+            stop_on_error=True,
+        )
         mirror.packages_to_sync = {"Foo": 1}
         await mirror.sync_packages()
         assert not mirror.errors
diff --git a/src/bandersnatch/tests/test_mirror_options.py b/src/bandersnatch/tests/test_mirror_options.py
new file mode 100644
index 000000000..1c1867c89
--- /dev/null
+++ b/src/bandersnatch/tests/test_mirror_options.py
@@ -0,0 +1,228 @@
+from collections.abc import Iterable
+from contextlib import nullcontext
+from pathlib import PurePath
+from typing import Any
+
+import pytest
+
+from bandersnatch.config import (
+    BandersnatchConfig,
+    ConfigurationError,
+    InvalidValueError,
+    MirrorOptions,
+    MissingOptionError,
+)
+from bandersnatch.config.diff_file_reference import eval_legacy_config_ref
+
+
+def config_with(content: dict[str, Any] | None = None) -> BandersnatchConfig:
+    base = {"mirror": {"directory": "/test"}}
+    config = BandersnatchConfig()
+    config.read_dict(base)
+    if content:
+        config.read_dict(content)
+    return config
+
+
+def test_empty_config_raises() -> None:
+    config = BandersnatchConfig()
+    with pytest.raises(ConfigurationError, match="missing required section"):
+        _ = config.get_validated(MirrorOptions)
+
+
+def test_empty_section_raises() -> None:
+    config = BandersnatchConfig()
+    config.read_dict({"mirror": {}})
+    with pytest.raises(MissingOptionError, match="missing required option"):
+        _ = config.get_validated(MirrorOptions)
+
+
+def test_minimal_mirror_options_are_valid() -> None:
+    config = config_with()
+    expected_options = MirrorOptions(directory=PurePath("/test"))
+    validated_options = config.get_validated(MirrorOptions)
+    assert validated_options == expected_options
+
+
+@pytest.mark.parametrize(
+    ("cfg_data", "expected"),
+    [
+        (
+            {
+                "mirror": {
+                    "diff-file": r"{{mirror_directory}}",
+                }
+            },
+            "/test",
+        ),
+        (
+            {
+                "mirror": {
+                    "diff-file": r"{{ mirror_directory }}",
+                }
+            },
+            "/test",
+        ),
+        (
+            {
+                "mirror": {
+                    "diff-file": r"{{ mirror_directory }}/diffs/new-files",
+                }
+            },
+            "/test/diffs/new-files",
+        ),
+        (
+            {
+                "strings": {"test": "TESTING"},
+                "mirror": {
+                    "diff-file": r"/var/log/{{ strings_test }}",
+                },
+            },
+            "/var/log/TESTING",
+        ),
+        (
+            {
+                "strings": {"test": "TESTING"},
+                "mirror": {
+                    "diff-file": r"/var/log/{{ strings_test }}/diffs",
+                },
+            },
+            "/var/log/TESTING/diffs",
+        ),
+    ],
+)
+def test_legacy_diff_file_ref_resolves(cfg_data: dict, expected: str) -> None:
+    config = config_with(cfg_data)
+    mirror_opts = config.get_validated(MirrorOptions)
+    assert mirror_opts.diff_file == PurePath(expected)
+
+
+@pytest.mark.parametrize(
+    ("option_value", "expected_message"),
+    [
+        (
+            r"{{ missing.underscore }}/foo",
+            "Unable to parse config option reference",
+        ),
+        (r"/var/{{ mirror_woops }}/foo", "No option 'woops' in section: 'mirror'"),
+    ],
+)
+def test_invalid_legacy_diff_file_ref_raises(
+    option_value: str, expected_message: str
+) -> None:
+    config = config_with({"mirror": {"diff-file": option_value}})
+    with pytest.raises(ValueError, match=expected_message):
+        _ = eval_legacy_config_ref(config, option_value)
+
+
+@pytest.mark.parametrize(
+    ("release_files_option", "expected_root_uri"),
+    [
+        ("", ""),
+        ("true", ""),
+        ("false", "https://files.pythonhosted.org"),
+    ],
+)
+def test_release_files_off_sets_default_root_uri(
+    release_files_option: str,
+    expected_root_uri: str,
+) -> None:
+    cfg_data = (
+        {"mirror": {"release-files": release_files_option}}
+        if release_files_option
+        else {}
+    )
+    config = config_with(cfg_data)
+    mirror_opts = config.get_validated(MirrorOptions)
+    assert mirror_opts.root_uri == expected_root_uri
+
+
+def _permutate_case(*texts: str) -> Iterable[str]:
+    for t in texts:
+        yield t
+        yield t.upper()
+        yield t.capitalize()
+
+
+@pytest.mark.parametrize(
+    ("config_value", "expected"),
+    [
+        *((v, True) for v in _permutate_case("on", "yes", "true")),
+        *((v, False) for v in _permutate_case("no", "off", "false")),
+    ],
+)
+def test_friendly_boolean_is_valid(config_value: str, expected: bool) -> None:
+    content = {"mirror": {"diff-append-epoch": config_value}}
+    config = config_with(content)
+    mirror_opts = config.get_validated(MirrorOptions)
+    assert mirror_opts.diff_append_epoch == expected
+
+
+@pytest.mark.parametrize(
+    ("timeout_value", "expected_timeout"),
+    [
+        ("-1", pytest.raises(InvalidValueError)),
+        ("0", pytest.raises(InvalidValueError)),
+        ("1.9", nullcontext(1.9)),
+        ("1000.0", nullcontext(1000.0)),
+    ],
+)
+def test_non_positive_timeouts_are_rejected(
+    timeout_value: str, expected_timeout: Any
+) -> None:
+    content = {"mirror": {"timeout": timeout_value}}
+    config = config_with(content)
+    with expected_timeout as e:
+        mirror_opts = config.get_validated(MirrorOptions)
+        assert mirror_opts.timeout == pytest.approx(e)
+
+
+@pytest.mark.parametrize(
+    ("workers_value", "expected_workers"),
+    [
+        ("-1", pytest.raises(InvalidValueError)),
+        ("0", pytest.raises(InvalidValueError)),
+        ("1", nullcontext(1)),
+        ("10", nullcontext(10)),
+        ("11", pytest.raises(InvalidValueError)),
+    ],
+)
+def test_out_of_range_worker_counts_are_rejected(
+    workers_value: str, expected_workers: Any
+) -> None:
+    content = {"mirror": {"workers": workers_value}}
+    config = config_with(content)
+    with expected_workers as e:
+        mirror_opts = config.get_validated(MirrorOptions)
+        assert mirror_opts.workers == e
+
+
+_int_convert_error_pattern = r"can't convert option .+ to expected type 'int'"
+
+
+@pytest.mark.parametrize(
+    ("workers_value", "expected_workers"),
+    [
+        ("1", nullcontext(1)),
+        ("01", nullcontext(1)),
+        ("0_1", nullcontext(1)),
+        ("1_", pytest.raises(InvalidValueError, match=_int_convert_error_pattern)),
+        (
+            "fooey",
+            pytest.raises(InvalidValueError, match=_int_convert_error_pattern),
+        ),
+        (
+            "no",
+            pytest.raises(InvalidValueError, match=_int_convert_error_pattern),
+        ),
+    ],
+)
+def test_integer_option_string_conversion(
+    workers_value: str,
+    expected_workers: Any,
+) -> None:
+    content = {"mirror": {"workers": workers_value}}
+    config = config_with(content)
+    with expected_workers as e:
+        mirror_opts = config.get_validated(MirrorOptions)
+        assert mirror_opts.workers == e
diff --git a/src/bandersnatch/tests/test_simple.py b/src/bandersnatch/tests/test_simple.py
index 4ac9de7c1..f48a7f96a 100644
--- a/src/bandersnatch/tests/test_simple.py
+++ b/src/bandersnatch/tests/test_simple.py
@@ -6,7 +6,7 @@
 import pytest
 
 from bandersnatch import utils
-from bandersnatch.configuration import validate_config_values
+from bandersnatch.config import BandersnatchConfig, MirrorOptions
 from bandersnatch.package import Package
 from bandersnatch.simple import (
     InvalidDigestFormat,
@@ -25,37 +25,40 @@
 from bandersnatch_storage_plugins.filesystem import FilesystemStorage
 
 
-def test_format_invalid() -> None:
+def test_format_invalid(local_storage: Storage) -> None:
     with pytest.raises(InvalidSimpleFormat):
-        SimpleAPI(Storage(), "l33t", [], "sha256", False, None)
+        SimpleAPI(local_storage, "l33t", [], "sha256", False, None)
 
 
-def test_format_valid() -> None:
-    s = SimpleAPI(Storage(), "ALL", [], "sha256", False, None)
+def test_format_valid(local_storage: Storage) -> None:
+    s = SimpleAPI(local_storage, "ALL", [], "sha256", False, None)
     assert s.format == SimpleFormat.ALL
 
 
-def test_digest_invalid() -> None:
+def test_digest_invalid(local_storage: Storage) -> None:
     with pytest.raises(InvalidDigestFormat):
-        SimpleAPI(Storage(), "ALL", [], "digest", False, None)
+        SimpleAPI(local_storage, "ALL", [], "digest", False, None)
 
 
-def test_digest_valid() -> None:
-    s = SimpleAPI(Storage(), "ALL", [], "md5", False, None)
+def test_digest_valid(local_storage: Storage) -> None:
+    s = SimpleAPI(local_storage, "ALL", [], "md5", False, None)
     assert s.digest_name == SimpleDigest.MD5
 
 
-def test_digest_config_default() -> None:
-    c = ConfigParser()
-    c.add_section("mirror")
-    config = validate_config_values(c)
-    s = SimpleAPI(Storage(), "ALL", [], config.digest_name, False, None)
-    assert config.digest_name.upper() in [v.name for v in SimpleDigest]
+def test_digest_config_default(local_storage: Storage) -> None:
+    c = BandersnatchConfig()
+    c.read_dict({"mirror": {"directory": "/"}})
+
+    config = c.get_validated(MirrorOptions)
+    s = SimpleAPI(local_storage, "ALL", [], config.digest_name, False, None)
+    assert config.digest_name in [v for v in SimpleDigest]
     assert s.digest_name == SimpleDigest.SHA256
 
 
-def test_json_package_page() -> None:
-    s = SimpleAPI(Storage(), SimpleFormat.JSON, [], SimpleDigest.SHA256, False, None)
+def test_json_package_page(local_storage: Storage) -> None:
+    s = SimpleAPI(
+        local_storage, SimpleFormat.JSON, [], SimpleDigest.SHA256, False, None
+    )
     p = Package("69")
     p._metadata = SIXTYNINE_METADATA
     assert EXPECTED_SIMPLE_SIXTYNINE_JSON_1_1 == s.generate_json_simple_page(p)
diff --git a/src/bandersnatch/verify.py b/src/bandersnatch/verify.py
index 4d20c7376..b0094f19f 100644
--- a/src/bandersnatch/verify.py
+++ b/src/bandersnatch/verify.py
@@ -155,7 +155,7 @@ async def verify(
         return
 
     # apply releases filter plugins like class Package
-    for plugin in LoadedFilters().filter_release_plugins() or []:
+    for plugin in LoadedFilters(config).filter_release_plugins() or []:
         plugin.filter(pkg)
 
     deferred_exception = None