eligibility-signposting-api/tests/unit/common/test_cache_manager.py at 60c896be4eefe5a75506b12fdd24c88e892ca2dd · NHSDigital/eligibility-signposting-api · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
"""Unit tests for cache_manager module."""

from eligibility_signposting_api.common.cache_manager import (
    FLASK_APP_CACHE_KEY,
    cache_manager,
)


class TestCacheManager:
    """Test the cache manager functionality."""

    def setup_method(self):
        """Clean up cache before each test."""
        cache_manager.clear_all()

    def test_set_and_get_cache(self):
        """Test basic cache set and get operations."""
        test_key = "test_key"
        test_value = "test_value"

        # Set cache
        cache_manager.set(test_key, test_value)

        # Get cache
        result = cache_manager.get(test_key)
        assert result == test_value

    def test_get_cache_nonexistent_key(self):
        """Test getting a non-existent cache key returns None."""
        result = cache_manager.get("non_existent_key")
        assert result is None

    def test_clear_cache_existing_key(self):
        """Test clearing an existing cache key."""
        test_key = "test_key"
        test_value = "test_value"

        cache_manager.set(test_key, test_value)
        assert cache_manager.get(test_key) == test_value

        # Clear cache
        result = cache_manager.clear(test_key)
        assert result is True  # Should return True if key existed
        assert cache_manager.get(test_key) is None

    def test_clear_cache_nonexistent_key(self):
        """Test clearing a non-existent cache key."""
        # This should not raise an exception
        result = cache_manager.clear("non_existent_key")
        assert result is False  # Should return False if key didn't exist

    def test_clear_all_caches(self):
        """Test clearing all caches."""
        cache_manager.set("key1", "value1")
        cache_manager.set("key2", "value2")
        cache_manager.set("key3", "value3")

        # Verify keys exist
        assert cache_manager.get("key1") == "value1"
        assert cache_manager.get("key2") == "value2"
        assert cache_manager.get("key3") == "value3"

        # Clear all caches
        cache_manager.clear_all()

        # Verify all keys are gone
        assert cache_manager.get("key1") is None
        assert cache_manager.get("key2") is None
        assert cache_manager.get("key3") is None

    def test_get_cache_info_with_len_objects(self):
        """Test cache info with objects that have __len__."""
        test_list = [1, 2, 3, 4, 5]
        test_dict = {"a": 1, "b": 2, "c": 3}

        cache_manager.set("list_key", test_list)
        cache_manager.set("dict_key", test_dict)

        cache_info = cache_manager.get_cache_info()
        assert cache_info["list_key"] == len(test_list)
        assert cache_info["dict_key"] == len(test_dict)

    def test_get_cache_info_with_non_len_objects(self):
        """Test cache info with objects that don't have __len__."""
        test_int = 42
        test_str = "test"
        expected_int_size = 1  # Default for non-len objects

        cache_manager.set("int_key", test_int)
        cache_manager.set("str_key", test_str)

        cache_info = cache_manager.get_cache_info()
        assert cache_info["int_key"] == expected_int_size  # Default for non-len objects
        assert cache_info["str_key"] == len(test_str)

    def test_flask_app_cache_key_constant(self):
        """Test that the Flask app cache key constant is available."""
        assert FLASK_APP_CACHE_KEY == "flask_app"

    def test_cache_overwrites_existing_value(self):
        """Test that setting a cache key overwrites existing value."""
        cache_manager.set("key", "original_value")
        assert cache_manager.get("key") == "original_value"

        cache_manager.set("key", "new_value")
        assert cache_manager.get("key") == "new_value"

    def test_cache_info_empty_cache(self):
        """Test cache info when cache is empty."""
        cache_info = cache_manager.get_cache_info()
        assert cache_info == {}

    def test_cache_handles_none_values(self):
        """Test that cache can handle None values."""
        cache_manager.set("none_key", None)
        result = cache_manager.get("none_key")
        assert result is None

        # Verify the key actually exists (not just returning None for missing key)
        assert cache_manager.has("none_key") is True

    def test_has_method(self):
        """Test the has() method."""
        assert cache_manager.has("nonexistent") is False

        cache_manager.set("test_key", "test_value")
        assert cache_manager.has("test_key") is True

        cache_manager.clear("test_key")
        assert cache_manager.has("test_key") is False

    def test_size_method(self):
        """Test the size() method."""
        empty_cache_size = 0
        single_item_size = 1
        two_items_size = 2

        assert cache_manager.size() == empty_cache_size

        cache_manager.set("key1", "value1")
        assert cache_manager.size() == single_item_size

        cache_manager.set("key2", "value2")
        assert cache_manager.size() == two_items_size

        cache_manager.clear("key1")
        assert cache_manager.size() == single_item_size

        cache_manager.clear_all()
        assert cache_manager.size() == empty_cache_size