stapler/tests/test_registry.py

import logging
import typing
import unittest
import unittest.mock

from stapler.page import Page
from stapler.params import Parameters
from stapler.registry import Registry

from . import BaseTestCase


class TestRegistry(BaseTestCase):
    @typing.override
    def setUp(self) -> None:
        self.registry = Registry(Parameters())
        self.registry.logger = unittest.mock.Mock(logging.Logger)
        self.data_dir = self.registry.data_dir = self.new_mock()
        super().setUp()

    def test_load_pages(self) -> None:
        with (
            self.mock_call(self.data_dir.list_paths, [], ["test_1", "test_2"]),
            self.mock_calls(
                self.data_dir.has_index, [["test_1"], ["test_2"]], [True, False]
            ),
            self.mock_calls(
                self.data_dir.get_file,
                [
                    ["test_1", Registry.HOST_FILE],
                    ["test_1", Registry.HOST_ONLY_FILE],
                    ["test_1", Registry.TOKEN_FILE],
                    ["test_1", Registry.REDIRECT_FILE],
                    ["test_1", Registry.PROXY_FILE],
                    ["test_1", Registry.SPA_FILE],
                    ["test_2", Registry.HOST_FILE],
                    ["test_2", Registry.HOST_ONLY_FILE],
                    ["test_2", Registry.TOKEN_FILE],
                    ["test_2", Registry.REDIRECT_FILE],
                    ["test_2", Registry.PROXY_FILE],
                    ["test_2", Registry.SPA_FILE],
                ],
                [
                    None,
                    "test_1_host",
                    "test_1_token",
                    None,
                    None,
                    None,
                    None,
                    None,
                    "test_2_token",
                    "test_2_redirect",
                    None,
                    None,
                ],
            ),
            self.seal_mocks(),
        ):
            self.registry.load_pages()
        self.assertEqual(len(self.registry.pages), 2)
        self.assertEqual(list(self.registry.pages.keys()), ["test_1", "test_2"])
        self.assertEqual(
            self.registry.pages["test_1"],
            Page(
                "test_1",
                True,  # noqa: FBT003
                "test_1_host",
                True,  # noqa: FBT003
                "test_1_token",
                None,
            ),
        )
        self.assertEqual(
            self.registry.pages["test_2"],
            Page(
                "test_2",
                False,  # noqa: FBT003
                None,
                False,  # noqa: FBT003
                "test_2_token",
                "test_2_redirect",
            ),
        )

    def test_get_hosts(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            host="test_1_host",
        )
        self.registry.pages["test_2"] = Page(
            "test_2",
            host="test_2_host",
        )
        self.registry.pages["test_3"] = Page(
            "test_3",
            host=None,
        )
        self.seal_mocks()
        self.assertEqual(self.registry.get_hosts(), ["test_1_host", "test_2_host"])

    def test_set_host(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            host="test_1_host",
        )
        with (
            self.mock_call(
                self.data_dir.set_file, ["test_1", Registry.HOST_FILE, "new_value"]
            ),
            self.mock_call(
                self.data_dir.remove_file, ["test_1", Registry.HOST_ONLY_FILE]
            ),
            self.seal_mocks(),
        ):
            self.registry.set_host("test_1", "new_value")
        self.assertEqual(self.registry.pages["test_1"].host, "new_value")
        assert not self.registry.pages["test_1"].host_only

    def test_set_host_only(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            host="test_1_host",
        )
        with (
            self.mock_call(
                self.data_dir.set_file, ["test_1", Registry.HOST_ONLY_FILE, "new_value"]
            ),
            self.mock_call(self.data_dir.remove_file, ["test_1", Registry.HOST_FILE]),
            self.seal_mocks(),
        ):
            self.registry.set_host_only("test_1", "new_value")
        self.assertEqual(self.registry.pages["test_1"].host, "new_value")
        assert self.registry.pages["test_1"].host_only

    def test_set_token_hash(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            token_hash=None,
        )
        with (
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.TOKEN_FILE, "new_value", 0o600],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_token_hash("test_1", "new_value")
        self.assertEqual(self.registry.pages["test_1"].token_hash, "new_value")

    def test_set_token_hash_no_change(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            token_hash="secret",  # noqa: S106
        )
        with (
            self.seal_mocks(),
        ):
            self.registry.set_token_hash("test_1", "secret")
        self.assertEqual(self.registry.pages["test_1"].token_hash, "secret")

    def test_set_token_hash_not_found(self) -> None:
        with (
            self.seal_mocks(),
        ):
            self.registry.set_token_hash("test_1", "secret")

    def test_set_redirect(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            redirect="https://example.com",
        )
        with (
            self.mock_call(
                self.data_dir.empty,
                ["test_1"],
            ),
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.REDIRECT_FILE, "https://new-example.com"],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_redirect("test_1", "https://new-example.com")
        self.assertEqual(
            self.registry.pages["test_1"].redirect, "https://new-example.com"
        )

    def test_set_redirect_no_change(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            redirect="https://example.com",
        )
        with (
            self.seal_mocks(),
        ):
            self.registry.set_redirect("test_1", "https://example.com")
        self.assertEqual(self.registry.pages["test_1"].redirect, "https://example.com")

    def test_set_redirect_not_found(self) -> None:
        with (
            self.mock_call(
                self.data_dir.empty,
                ["test_1"],
            ),
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.REDIRECT_FILE, "https://new-example.com"],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_redirect("test_1", "https://new-example.com")
        self.assertIn("test_1", self.registry.pages)
        self.assertEqual(
            self.registry.pages["test_1"].redirect, "https://new-example.com"
        )

    def test_set_proxy(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            proxy="https://example.com",
        )
        with (
            self.mock_call(
                self.data_dir.empty,
                ["test_1"],
            ),
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.PROXY_FILE, "https://new-example.com"],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_proxy("test_1", "https://new-example.com")
        self.assertEqual(self.registry.pages["test_1"].proxy, "https://new-example.com")

    def test_set_proxy_no_change(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            proxy="https://example.com",
        )
        with (
            self.seal_mocks(),
        ):
            self.registry.set_proxy("test_1", "https://example.com")
        self.assertEqual(self.registry.pages["test_1"].proxy, "https://example.com")

    def test_set_proxy_not_found(self) -> None:
        with (
            self.mock_call(
                self.data_dir.empty,
                ["test_1"],
            ),
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.PROXY_FILE, "https://new-example.com"],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_proxy("test_1", "https://new-example.com")
        self.assertIn("test_1", self.registry.pages)
        self.assertEqual(self.registry.pages["test_1"].proxy, "https://new-example.com")

    def test_set_spa(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            spa=None,
        )
        with (
            self.mock_call(
                self.data_dir.set_file,
                ["test_1", Registry.SPA_FILE, "new_value"],
            ),
            self.seal_mocks(),
        ):
            self.registry.set_spa("test_1", "new_value")
        self.assertEqual(self.registry.pages["test_1"].spa, "new_value")

    def test_set_spa_no_change(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
            spa="value",
        )
        with (
            self.seal_mocks(),
        ):
            self.registry.set_spa("test_1", "value")
        self.assertEqual(self.registry.pages["test_1"].spa, "value")

    def test_set_spa_not_found(self) -> None:
        with (
            self.seal_mocks(),
        ):
            self.registry.set_spa("test_1", "value")

    def test_remove(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
        )
        self.seal_mocks()
        self.registry.remove("test_1")
        self.assertNotIn("test_1", self.registry.pages)

    def test_get_from_path(self) -> None:
        self.registry.pages["test_1"] = (
            target := Page(
                "test_1",
            )
        )
        self.registry.pages["test_2"] = Page(
            "test_2",
        )
        self.seal_mocks()
        self.assertEqual(self.registry.get_from_path("test_1"), target)

    def test_get_from_path_not_found(self) -> None:
        self.registry.pages["test_1"] = Page(
            "test_1",
        )
        self.registry.pages["test_2"] = Page(
            "test_2",
        )
        self.seal_mocks()
        self.assertIsNone(self.registry.get_from_path("test_3"))

    def test_get_from_host(self) -> None:
        self.registry.pages["test_1"] = (target := Page("test_1", host="host_1"))
        self.registry.pages["test_2"] = Page("test_2", host="host_2")
        self.seal_mocks()
        self.assertEqual(self.registry.get_from_host("host_1"), target)

    def test_get_from_host_not_found(self) -> None:
        self.registry.pages["test_1"] = Page("test_1", host="host_1")
        self.registry.pages["test_2"] = Page("test_2", host="host_2")
        self.seal_mocks()
        self.assertIsNone(self.registry.get_from_host("host_3"))