Implement config unit testing #516

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Open

MattyTheHacker wants to merge 167 commits into main from 515-implement-config-unit-testing

Member

MattyTheHacker commented May 30, 2025

No description provided.

MattyTheHacker added 2 commits

May 30, 2025 09:15


          rename generate url

2b714b9


          Implement config tests

5f2761e

MattyTheHacker self-assigned this

MattyTheHacker added the test suite label

MattyTheHacker linked an issue

that may be closed by this pull request

Implement config unit testing #515

Open

pre-commit-ci-lite bot and others added 6 commits

May 30, 2025 09:02


          [pre-commit.ci lite] apply automatic fixes

41320a1


          fix ruff

9f34872


          Fix testing dependencies

6028aa5


          [pre-commit.ci lite] apply automatic fixes

e498a68


          Fix workflow

eb2f0d1

fix

82ab336

codecov bot commented May 30, 2025 •

edited

Loading

❌ 28 Tests Failed:

Tests completed	Failed	Passed	Skipped
413	28	385	0

View the top 3 failed test(s) by shortest run time

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_default_send_introduction_reminders_delay

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a5820>

    def test_default_send_introduction_reminders_delay(self) -> None:
        """Test that a default value is used when no `SEND_INTRODUCTION_REMINDERS_DELAY`."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            assert os.environ.get("SEND_INTRODUCTION_REMINDERS_DELAY") is None
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS"] == "once"
E       AssertionError: assert False == 'once'

tests/test_config.py:2095: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_invalid_introduction_reminders_delay[3.5]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7b60>
test_invalid_introduction_reminders_delay = '3.5'

    @pytest.mark.parametrize(
        "test_invalid_introduction_reminders_delay",
        ("invalid_introduction_reminders_delay", "3.5", "3.5f", "3.5a"),
    )
    def test_invalid_introduction_reminders_delay(
        self, test_invalid_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` is invalid."""
        INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must contain the delay "
            "in any combination of seconds, minutes, hours, days or weeks."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
    
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_invalid_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2155: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_invalid_introduction_reminders_delay[3.5a]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7ce0>
test_invalid_introduction_reminders_delay = '3.5a'

    @pytest.mark.parametrize(
        "test_invalid_introduction_reminders_delay",
        ("invalid_introduction_reminders_delay", "3.5", "3.5f", "3.5a"),
    )
    def test_invalid_introduction_reminders_delay(
        self, test_invalid_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` is invalid."""
        INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must contain the delay "
            "in any combination of seconds, minutes, hours, days or weeks."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
    
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_invalid_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2155: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_invalid_introduction_reminders_delay[3.5f]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7c20>
test_invalid_introduction_reminders_delay = '3.5f'

    @pytest.mark.parametrize(
        "test_invalid_introduction_reminders_delay",
        ("invalid_introduction_reminders_delay", "3.5", "3.5f", "3.5a"),
    )
    def test_invalid_introduction_reminders_delay(
        self, test_invalid_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` is invalid."""
        INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must contain the delay "
            "in any combination of seconds, minutes, hours, days or weeks."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
    
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_invalid_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2155: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[1d]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a8350>
test_send_introduction_reminders_delay = '1d'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=1)
E        +  where datetime.timedelta(days=1) = timedelta(**{'days': 1.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[24h]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a8290>
test_send_introduction_reminders_delay = '24h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=1)
E        +  where datetime.timedelta(days=1) = timedelta(**{'hours': 24.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[2d]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a8410>
test_send_introduction_reminders_delay = '2d'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=2)
E        +  where datetime.timedelta(days=2) = timedelta(**{'days': 2.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[3d]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a84d0>
test_send_introduction_reminders_delay = '3d'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=3)
E        +  where datetime.timedelta(days=3) = timedelta(**{'days': 3.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[40h]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a81d0>
test_send_introduction_reminders_delay = '40h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=1, seconds=57600)
E        +  where datetime.timedelta(days=1, seconds=57600) = timedelta(**{'hours': 40.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_setup_introduction_reminders_delay_successful[48h]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7e90>
test_send_introduction_reminders_delay = '48h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_delay", ("48h", "40h", "24h", "1d", "2d", "3d")
    )
    def test_setup_introduction_reminders_delay_successful(
        self, test_send_introduction_reminders_delay: str
    ) -> None:
        """Test that the given `SEND_INTRODUCTION_REMINDERS_DELAY` is used when provided."""
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_send_introduction_reminders_delay
            )
    
            RuntimeSettings._setup_send_introduction_reminders_delay()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_DELAY"] == timedelta(
            **{
                key: float(value)
                for key, value in (
                    re.fullmatch(
                        r"\A(?:(?P<seconds>(?:\d*\.)?\d+)s)?(?:(?P<minutes>(?:\d*\.)?\d+)m)?(?:(?P<hours>(?:\d*\.)?\d+)h)?(?:(?P<days>(?:\d*\.)?\d+)d)?(?:(?P<weeks>(?:\d*\.)?\d+)w)?\Z",
                        test_send_introduction_reminders_delay.lower().strip(),
                    )
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
                if value
            },
        )
E       AssertionError: assert datetime.timedelta(0) == datetime.timedelta(days=2)
E        +  where datetime.timedelta(days=2) = timedelta(**{'hours': 48.0})

tests/test_config.py:2184: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[0.5s]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a76e0>
too_short_introduction_reminders_delay = '0.5s'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[0s]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a77a0>
too_short_introduction_reminders_delay = '0s'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[10m]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f6938637710>
too_short_introduction_reminders_delay = '10m'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[1h]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69398b90a0>
too_short_introduction_reminders_delay = '1h'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[1s]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7620>
too_short_introduction_reminders_delay = '1s'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[2h]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a5ee0>
too_short_introduction_reminders_delay = '2h'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[30m]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a3710>
too_short_introduction_reminders_delay = '30m'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[3s]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a4e90>
too_short_introduction_reminders_delay = '3s'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[5m]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a59a0>
too_short_introduction_reminders_delay = '5m'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_1]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a2720>
test_send_introduction_reminders_interval = '331.43s'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'seconds': 331.43}
E         
E         Left contains 1 more item:
E         {'hours': 6}
E         Right contains 1 more item:
E         {'seconds': 331.43}
E         
E         Full diff:
E           {
E         -     'seconds': 331.43,
E         +     'hours': 6,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_2]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a2930>
test_send_introduction_reminders_interval = '  467.202s   '

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'seconds': 467.202}
E         
E         Left contains 1 more item:
E         {'hours': 6}
E         Right contains 1 more item:
E         {'seconds': 467.202}
E         
E         Full diff:
E           {
E         -     'seconds': 467.202,
E         +     'hours': 6,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_3]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a29f0>
test_send_introduction_reminders_interval = '351m'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'minutes': 351.0}
E         
E         Left contains 1 more item:
E         {'hours': 6}
E         Right contains 1 more item:
E         {'minutes': 351.0}
E         
E         Full diff:
E           {
E         -     'minutes': 351.0,
E         +     'hours': 6,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_4]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a2ab0>
test_send_introduction_reminders_interval = '296.620h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'hours': 296.62}
E         
E         Differing items:
E         {'hours': 6} != {'hours': 296.62}
E         
E         Full diff:
E           {
E         -     'hours': 296.62,
E         ?              -- ---
E         +     'hours': 6,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_5]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a2b70>
test_send_introduction_reminders_interval = '624.486s816.606m501.855h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'hours': 501...nds': 624.486}
E         
E         Differing items:
E         {'hours': 6} != {'hours': 501.855}
E         Right contains 2 more items:
E         {'minutes': 816.606, 'seconds': 624.486}
E         
E         Full diff:
E           {
E         -     'hours': 501.855,
E         ?              ^^^^^^^
E         +     'hours': 6,
E         ?              ^
E         -     'minutes': 816.606,
E         -     'seconds': 624.486,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_6]

Stack Traces | 0.002s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a2c30>
test_send_introduction_reminders_interval = '163 s  971   m   142.407  h'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'hours': 142...conds': 163.0}
E         
E         Differing items:
E         {'hours': 6} != {'hours': 142.407}
E         Right contains 2 more items:
E         {'minutes': 971.0, 'seconds': 163.0}
E         
E         Full diff:
E           {
E         -     'hours': 142.407,
E         ?              ^^^^^^^
E         +     'hours': 6,
E         ?              ^
E         -     'minutes': 971.0,
E         -     'seconds': 163.0,
E           }

tests/test_config.py:1831: AssertionError

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_too_short_introduction_reminders_delay[5h]

Stack Traces | 0.005s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a5ac0>
too_short_introduction_reminders_delay = '5h'

    @pytest.mark.parametrize(
        "too_short_introduction_reminders_delay",
        ("5h", "2h", "1h", "30m", "10m", "5m", "3s", "1s", "0.5s", "0s"),
    )
    def test_too_short_introduction_reminders_delay(
        self, too_short_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` too short."""
        TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must be longer than or equal to 1 day."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                too_short_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=TOO_SHORT_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2123: Failed

tests.test_config.TestSetupSendIntroductionRemindersDelay::test_invalid_introduction_reminders_delay[invalid_introduction_reminders_delay]

Stack Traces | 0.007s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersDelay object at 0x7f69386a7950>
test_invalid_introduction_reminders_delay = 'invalid_introduction_reminders_delay'

    @pytest.mark.parametrize(
        "test_invalid_introduction_reminders_delay",
        ("invalid_introduction_reminders_delay", "3.5", "3.5f", "3.5a"),
    )
    def test_invalid_introduction_reminders_delay(
        self, test_invalid_introduction_reminders_delay: str
    ) -> None:
        """Test that an error is raised when `SEND_INTRODUCTION_REMINDERS_DELAY` is invalid."""
        INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE: Final[str] = (
            "SEND_INTRODUCTION_REMINDERS_DELAY must contain the delay "
            "in any combination of seconds, minutes, hours, days or weeks."
        )
    
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
    
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_DELAY"] = (
                test_invalid_introduction_reminders_delay
            )
    
>           with pytest.raises(
                ImproperlyConfiguredError,
                match=INVALID_SEND_INTRODUCTION_REMINDERS_DELAY_MESSAGE,
            ):
E           Failed: DID NOT RAISE <class 'exceptions.config_changes.ImproperlyConfiguredError'>

tests/test_config.py:2155: Failed

tests.test_config.TestSetupSendIntroductionRemindersInterval::test_setup_send_introduction_reminders_interval_successful[case_0]

Stack Traces | 0.009s run time

self = <tests.test_config.TestSetupSendIntroductionRemindersInterval object at 0x7f69386a1fd0>
test_send_introduction_reminders_interval = '213s'

    @pytest.mark.parametrize(
        "test_send_introduction_reminders_interval",
        (
            f"{random.randint(3, 999)}s",
            f"{random.randint(3, 999)}.{random.randint(0, 999)}s",
            (
                f"  {random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }s   "
            ),
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}m",
            f"{random.randint(1, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}h",
            (
                f"{random.randint(3, 999)}{random.choice(('', f'.{random.randint(0, 999)}'))}s{
                    random.randint(0, 999)
                }{random.choice(('', f'.{random.randint(0, 999)}'))}m{random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }h"
            ),
            (
                f"{random.randint(3, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                } s  {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }   m   {random.randint(0, 999)}{
                    random.choice(('', f'.{random.randint(0, 999)}'))
                }  h"
            ),
        ),
        ids=[f"case_{i}" for i in range(7)],
    )
    def test_setup_send_introduction_reminders_interval_successful(
        self, test_send_introduction_reminders_interval: str
    ) -> None:
        """
        Test that the given `SEND_INTRODUCTION_REMINDERS_INTERVAL` is used when provided.
    
        In this test, the provided `SEND_INTRODUCTION_REMINDERS_INTERVAL` is valid
        and so must be saved successfully.
        """
        RuntimeSettings: Final[type[Settings]] = config._settings_class_factory()
        RuntimeSettings._setup_send_introduction_reminders()
    
        with (
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_DELAY"),
            EnvVariableDeleter("SEND_INTRODUCTION_REMINDERS_INTERVAL"),
        ):
            os.environ["SEND_INTRODUCTION_REMINDERS_INTERVAL"] = (
                test_send_introduction_reminders_interval
            )
    
            RuntimeSettings._setup_send_introduction_reminders_interval()
    
        RuntimeSettings._is_env_variables_setup = True
    
>       assert RuntimeSettings()["SEND_INTRODUCTION_REMINDERS_INTERVAL"] == {
            key: float(value)
            for key, value in (
                re.match(
                    r"\A(?:(?P<seconds>(?:\d*\.)?\d+)\s*s)?\s*(?:(?P<minutes>(?:\d*\.)?\d+)\s*m)?\s*(?:(?P<hours>(?:\d*\.)?\d+)\s*h)?\Z",
                    test_send_introduction_reminders_interval.lower().strip(),
                )
                .groupdict()  # type: ignore[union-attr]
                .items()
            )
            if value
        }
E       AssertionError: assert {'hours': 6} == {'seconds': 213.0}
E         
E         Left contains 1 more item:
E         {'hours': 6}
E         Right contains 1 more item:
E         {'seconds': 213.0}
E         
E         Full diff:
E           {
E         -     'seconds': 213.0,
E         +     'hours': 6,
E           }

tests/test_config.py:1831: AssertionError

To view more test analytics, go to the Test Analytics Dashboard
_{📋 Got 3 mins? Take this short survey to help us improve Test Analytics.}

MattyTheHacker added 7 commits

May 30, 2025 17:52


          fix mypy error

aefb1ae


          Refactor utils

3948a48

fuc

2a348b9


          Fix ruff error

d0b54e5


          Minor bot token handling fix

6e7938d


          Fix variable name

9d16a10


          Fix ruff errors

782bcfd

MattyTheHacker force-pushed the 515-implement-config-unit-testing branch from 9c5a784 to 782bcfd Compare

May 30, 2025 17:49

MattyTheHacker and others added 10 commits

May 30, 2025 18:08


          Implement stripping discord guild id

cc7b68b


          Fix some stuff

d21ef38


          [pre-commit.ci lite] apply automatic fixes

b7376d2


          minor fixes

60a26a8


          improve perks url

e9e2d2e


          add url check

6e04b2e


          Fix easter egg bits

6b0839f


          refactor intro reminders

dde42e8


          Fix bad error codes

9456afa


          and more rules

3a2f56f

automatic-pr-updater bot added 5 commits

August 12, 2025 10:29


          Merge main into 515-implement-config-unit-testing

d2e65c1


          Merge main into 515-implement-config-unit-testing

cc9cdc6


          Merge main into 515-implement-config-unit-testing

253bdda


          Merge main into 515-implement-config-unit-testing


          Merge main into 515-implement-config-unit-testing

automatic-pr-updater bot temporarily deployed to publish

August 28, 2025 16:25

Inactive

automatic-pr-updater bot added 2 commits

August 29, 2025 22:31


          Merge main into 515-implement-config-unit-testing

b8cb9ae


          Merge main into 515-implement-config-unit-testing

e651241

automatic-pr-updater bot temporarily deployed to publish

August 29, 2025 22:34

Inactive


          Merge main into 515-implement-config-unit-testing

8c1af5b

automatic-pr-updater bot temporarily deployed to publish

August 29, 2025 22:57

Inactive


          Merge main into 515-implement-config-unit-testing

3b45be0

automatic-pr-updater bot temporarily deployed to publish

August 30, 2025 13:51

Inactive


          Merge main into 515-implement-config-unit-testing

3f95e7b

automatic-pr-updater bot temporarily deployed to publish

September 2, 2025 08:50

Inactive

automatic-pr-updater bot added 5 commits

September 2, 2025 21:20


          Merge main into 515-implement-config-unit-testing

e764b9f


          Merge main into 515-implement-config-unit-testing

458e8c7


          Merge main into 515-implement-config-unit-testing

55acebd


          Merge main into 515-implement-config-unit-testing

15b1e3a


          Merge main into 515-implement-config-unit-testing

a32fccc

automatic-pr-updater bot temporarily deployed to publish

September 5, 2025 06:52

Inactive

automatic-pr-updater bot added 2 commits

September 7, 2025 18:37


          Merge main into 515-implement-config-unit-testing


          Merge main into 515-implement-config-unit-testing

1f394c4

automatic-pr-updater bot temporarily deployed to publish

September 9, 2025 00:16

Inactive

automatic-pr-updater bot added 4 commits

September 9, 2025 17:23


          Merge main into 515-implement-config-unit-testing

c8f434e


          Merge main into 515-implement-config-unit-testing

1aa741e


          Merge main into 515-implement-config-unit-testing

df17b07


          Merge main into 515-implement-config-unit-testing

d68d170

automatic-pr-updater bot temporarily deployed to publish

September 13, 2025 10:11

Inactive


          Merge main into 515-implement-config-unit-testing

e5bde29

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

sync test suite