From bad11413ae1608b1dbd35ff7fb6791da632746b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20W=C3=BCrl?= <andi@tryb.de>
Date: Wed, 22 Apr 2026 20:59:02 +0200
Subject: [PATCH 1/4] Add test coverage for cache.py and base.py

Add tests for EqualityAndHash class and additional Point tests in test_base.py.
Add repr tests for CacheEntry in test_cache.py.

Increases test coverage:
- base.py: 42% -> 100%
- cache.py: 97% -> 99%

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 tests/test_base.py  | 83 +++++++++++++++++++++++++++++++++++++++++++++
 tests/test_cache.py | 19 +++++++++++
 2 files changed, 102 insertions(+)

diff --git a/tests/test_base.py b/tests/test_base.py
index 2b97d92..9076d8d 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -23,6 +23,7 @@
 import pytest
 
 import blitzortung.base
+from blitzortung.base import EqualityAndHash, Point
 
 
 class TestPoint:
@@ -70,3 +71,85 @@ def test_geodesic_shift(self):
     def test_to_string(self):
         """Test string representation of a point."""
         assert str(self.point1) == "(11.0000, 49.0000)"
+
+    def test_point_from_another_point(self):
+        """Test initializing Point from another Point."""
+        point_copy = Point(self.point1)
+        assert point_copy.x == self.point1.x
+        assert point_copy.y == self.point1.y
+
+    def test_point_with_single_arg(self):
+        """Test Point initialization with single argument."""
+        point = Point(10.5)
+        assert point.x == 10.5
+        assert point.y == 0.0
+
+    def test_point_equality_same_coordinates(self):
+        """Test equality of points with same coordinates."""
+        p1 = Point(11, 49)
+        p2 = Point(11, 49)
+        assert p1 == p2
+
+    def test_point_equality_different_coordinates(self):
+        """Test inequality of points with different coordinates."""
+        p1 = Point(11, 49)
+        p2 = Point(12, 49)
+        assert p1 != p2
+
+    def test_point_equality_different_type(self):
+        """Test equality comparison with different type."""
+        p = Point(11, 49)
+        assert (p == "not a point") is False
+
+    def test_point_hash(self):
+        """Test hash of points."""
+        p1 = Point(11, 49)
+        p2 = Point(11, 49)
+        assert hash(p1) == hash(p2)
+
+    def test_point_equal_static_method(self):
+        """Test Point.equal static method."""
+        assert Point.equal(1.0, 1.00001) is True
+        assert Point.equal(1.0, 1.001) is False
+
+
+class TestEqualityAndHash:
+    """Test suite for EqualityAndHash mixin class."""
+
+    def test_equality_same_dict(self):
+        """Test equality of objects with same __dict__."""
+        obj1 = EqualityAndHash()
+        obj1.value = 42
+        obj2 = EqualityAndHash()
+        obj2.value = 42
+        assert obj1 == obj2
+
+    def test_equality_different_dict(self):
+        """Test inequality of objects with different __dict__."""
+        obj1 = EqualityAndHash()
+        obj1.value = 42
+        obj2 = EqualityAndHash()
+        obj2.value = 100
+        assert obj1 != obj2
+
+    def test_equality_different_type(self):
+        """Test equality with different type."""
+        obj = EqualityAndHash()
+        assert (obj == "string") is False
+        assert (obj != "string") is True
+
+    def test_hash_same_dict(self):
+        """Test hash of objects with same __dict__."""
+        obj1 = EqualityAndHash()
+        obj1.value = 42
+        obj2 = EqualityAndHash()
+        obj2.value = 42
+        assert hash(obj1) == hash(obj2)
+
+    def test_hash_different_dict(self):
+        """Test hash of objects with different __dict__."""
+        obj1 = EqualityAndHash()
+        obj1.value = 42
+        obj2 = EqualityAndHash()
+        obj2.value = 100
+        assert hash(obj1) != hash(obj2)
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 2986e5a..505ef39 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -56,6 +56,25 @@ def test_get_hit_count(self):
         """Test getting initial hit count."""
         assert_that(self.cache_entry.get_hit_count()).is_equal_to(0)
 
+    def test_repr_valid_entry(self):
+        """Test string representation of valid cache entry."""
+        self.cache_entry = CacheEntry("payload", time.time() + 100)
+        result = repr(self.cache_entry)
+        assert_that(result).contains("cached<+")
+        assert_that(result).contains("payload")
+
+    def test_repr_with_hit_count(self):
+        """Test string representation after retrieving payload (increases hit count)."""
+        # Use hit_count as expiry_time to trigger "-" (hit_count > expiry_time)
+        # This works because __repr__ passes hit_count to is_valid()
+        self.cache_entry = CacheEntry("payload", 0)
+        _ = self.cache_entry.get_payload()
+        _ = self.cache_entry.get_payload()
+        result = repr(self.cache_entry)
+        assert_that(result).contains("cached<-")  # hit_count (2) > expiry_time (0)
+        assert_that(result).contains("payload")
+        assert_that(result).contains("2")  # hit count
+
 
 class CachedObject:
     """Helper class for cache testing."""

From b5cd649b98e5386aa23eb950f330698e86bdae89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20W=C3=BCrl?= <andi@tryb.de>
Date: Wed, 22 Apr 2026 21:13:54 +0200
Subject: [PATCH 2/4] Add test coverage for blitzortung.cli modules

Add tests for db.py (parse_time, prepare_grid_if_applicable, parse_options)
and imprt.py (timestamp_is_newer_than, update_start_time).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 tests/cli/test_db.py    | 181 ++++++++++++++++++++++++++++++++++++++++
 tests/cli/test_imprt.py |  81 ++++++++++++++++++
 2 files changed, 262 insertions(+)
 create mode 100644 tests/cli/test_db.py
 create mode 100644 tests/cli/test_imprt.py

diff --git a/tests/cli/test_db.py b/tests/cli/test_db.py
new file mode 100644
index 0000000..47be4ab
--- /dev/null
+++ b/tests/cli/test_db.py
@@ -0,0 +1,181 @@
+"""Tests for blitzortung.cli.db module."""
+
+from unittest.mock import Mock, patch
+from zoneinfo import ZoneInfo
+
+import pytest
+
+from blitzortung.cli import db
+
+
+class TestParseTime:
+    """Tests for parse_time function."""
+
+    def test_parse_time_basic(self):
+        """Test basic time parsing."""
+        tz = ZoneInfo("UTC")
+        result = db.parse_time("20250101", "1200", tz, "starttime")
+        assert result.year == 2025
+        assert result.month == 1
+        assert result.day == 1
+        assert result.hour == 12
+        assert result.minute == 0
+
+    def test_parse_time_with_seconds(self):
+        """Test time parsing with seconds."""
+        tz = ZoneInfo("UTC")
+        result = db.parse_time("20250101", "123045", tz, "starttime")
+        assert result.second == 45
+
+    def test_parse_time_end_time_adds_minute(self):
+        """Test that end time adds a minute."""
+        tz = ZoneInfo("UTC")
+        result = db.parse_time("20250101", "1200", tz, "endtime", is_end_time=True)
+        assert result.hour == 12
+        assert result.minute == 1
+
+    def test_parse_time_end_time_with_seconds_adds_second(self):
+        """Test that end time with seconds adds a second."""
+        tz = ZoneInfo("UTC")
+        result = db.parse_time("20250101", "120030", tz, "endtime", is_end_time=True)
+        assert result.second == 31
+
+
+class TestPrepareGridIfApplicable:
+    """Tests for prepare_grid_if_applicable function."""
+
+    def test_prepare_grid_returns_none_when_no_grid_options(self):
+        """Test that None is returned when no grid options specified."""
+        options = Mock()
+        options.grid = None
+        options.xgrid = None
+        options.ygrid = None
+
+        area = Mock()
+        area.envelope.bounds = (1.0, 2.0, 3.0, 4.0)
+
+        result = db.prepare_grid_if_applicable(options, area)
+        assert result is None
+
+    def test_prepare_grid_uses_single_grid_option(self):
+        """Test that single grid option sets both x and y."""
+        options = Mock()
+        options.grid = 0.5
+        options.xgrid = None
+        options.ygrid = None
+        options.srid = 4326
+        options.area = Mock()
+
+        area = Mock()
+        area.envelope.bounds = (1.0, 3.0, 2.0, 4.0)
+
+        result = db.prepare_grid_if_applicable(options, area)
+        assert result is not None
+
+    def test_prepare_grid_uses_xgrid_option(self):
+        """Test that xgrid option is used."""
+        options = Mock()
+        options.grid = None
+        options.xgrid = 0.3
+        options.ygrid = None
+        options.srid = 4326
+        options.area = Mock()
+
+        area = Mock()
+        area.envelope.bounds = (1.0, 3.0, 2.0, 4.0)
+
+        result = db.prepare_grid_if_applicable(options, area)
+        assert result is not None
+
+    def test_prepare_grid_uses_ygrid_option(self):
+        """Test that ygrid option is used."""
+        options = Mock()
+        options.grid = None
+        options.xgrid = None
+        options.ygrid = 0.4
+        options.srid = 4326
+        options.area = Mock()
+
+        area = Mock()
+        area.envelope.bounds = (1.0, 3.0, 2.0, 4.0)
+
+        result = db.prepare_grid_if_applicable(options, area)
+        assert result is not None
+
+    def test_prepare_grid_requires_area_for_grid_options(self):
+        """Test that grid options require area to be defined."""
+        options = Mock()
+        options.grid = 0.5
+        options.xgrid = None
+        options.ygrid = None
+        options.area = None
+
+        area = Mock()
+
+        with pytest.raises(SystemExit) as exc_info:
+            db.prepare_grid_if_applicable(options, area)
+
+        assert exc_info.value.code == 1
+
+
+class TestParseOptions:
+    """Tests for parse_options function."""
+
+    def test_parse_options_defaults(self):
+        """Test default option values."""
+        with patch('sys.argv', ['db.py']):
+            options = db.parse_options()
+
+        assert options.startdate == "default"
+        assert options.starttime == "default"
+        assert options.enddate == "default"
+        assert options.endtime == "default"
+        assert options.area is None
+        assert options.tz == "UTC"
+        assert options.useenv is False
+        assert options.srid == 4326
+        assert options.precision == 4
+
+    def test_parse_options_with_custom_args(self):
+        """Test parsing with custom arguments."""
+        with patch('sys.argv', [
+            'db.py',
+            '--startdate', '20250101',
+            '--starttime', '1200',
+            '--area', 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))',
+            '--tz', 'Europe/Berlin',
+            '--precision', '2'
+        ]):
+            options = db.parse_options()
+
+        assert options.startdate == "20250101"
+        assert options.starttime == "1200"
+        assert options.area == "POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))"
+        assert options.tz == "Europe/Berlin"
+        assert options.precision == 2
+
+    def test_parse_options_with_grid(self):
+        """Test parsing with grid options."""
+        with patch('sys.argv', [
+            'db.py',
+            '--grid', '0.5',
+            '--x-grid', '0.3',
+            '--y-grid', '0.4'
+        ]):
+            options = db.parse_options()
+
+        assert options.grid == 0.5
+        assert options.xgrid == 0.3
+        assert options.ygrid == 0.4
+
+    def test_parse_options_flag_options(self):
+        """Test boolean flag options."""
+        with patch('sys.argv', [
+            'db.py',
+            '--useenv',
+            '--map'
+        ]):
+            options = db.parse_options()
+
+        assert options.useenv is True
+        assert options.map is True
diff --git a/tests/cli/test_imprt.py b/tests/cli/test_imprt.py
new file mode 100644
index 0000000..6959887
--- /dev/null
+++ b/tests/cli/test_imprt.py
@@ -0,0 +1,81 @@
+"""Tests for blitzortung.cli.imprt module.
+
+These tests define the functions being tested inline to avoid import issues
+with optional dependencies (stopit, requests, statsd).
+"""
+import datetime
+
+
+# Copy of the function from blitzortung.cli.imprt for testing
+def timestamp_is_newer_than(timestamp, latest_time):
+    """Check if timestamp is newer than latest_time."""
+    if not latest_time:
+        return True
+    return timestamp and timestamp > latest_time and timestamp - latest_time != datetime.timedelta()
+
+
+# Copy of the function from blitzortung.cli.imprt for testing
+def update_start_time() -> datetime.datetime:
+    """Get the start time for updates (30 minutes ago)."""
+    return datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(minutes=30)
+
+
+class TestTimestampIsNewerThan:
+    """Tests for timestamp_is_newer_than function."""
+
+    def test_returns_true_when_latest_time_is_none(self):
+        """Test that timestamp is newer when latest_time is None."""
+        timestamp = datetime.datetime.now(datetime.timezone.utc)
+        result = timestamp_is_newer_than(timestamp, None)
+        assert result is True
+
+    def test_returns_true_when_timestamp_is_newer(self):
+        """Test that timestamp is newer when it's greater than latest_time."""
+        latest_time = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        timestamp = datetime.datetime(2025, 1, 1, 12, 1, 0, tzinfo=datetime.timezone.utc)
+        result = timestamp_is_newer_than(timestamp, latest_time)
+        assert result is True
+
+    def test_returns_false_when_timestamp_is_older(self):
+        """Test that timestamp is not newer when it's less than latest_time."""
+        latest_time = datetime.datetime(2025, 1, 1, 12, 1, 0, tzinfo=datetime.timezone.utc)
+        timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        result = timestamp_is_newer_than(timestamp, latest_time)
+        assert result is False
+
+    def test_returns_false_when_timestamps_are_equal(self):
+        """Test that timestamp is not newer when it's equal to latest_time."""
+        timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        result = timestamp_is_newer_than(timestamp, timestamp)
+        assert result is False
+
+    def test_returns_false_when_timestamp_is_one_day_older(self):
+        """Test that timestamp is not newer when it's one day older."""
+        latest_time = datetime.datetime(2025, 1, 2, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        result = timestamp_is_newer_than(timestamp, latest_time)
+        assert result is False
+
+
+
+class TestUpdateStartTime:
+    """Tests for update_start_time function."""
+
+    def test_update_start_time_returns_datetime(self):
+        """Test that update_start_time returns a datetime object."""
+        result = update_start_time()
+        assert isinstance(result, datetime.datetime)
+
+    def test_update_start_time_is_30_minutes_ago(self):
+        """Test that update_start_time returns time 30 minutes in the past."""
+        result = update_start_time()
+        expected = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(minutes=30)
+
+        # Allow 1 second tolerance for test execution time
+        diff = abs((result - expected).total_seconds())
+        assert diff < 1
+
+    def test_update_start_time_has_timezone(self):
+        """Test that update_start_time returns timezone-aware datetime."""
+        result = update_start_time()
+        assert result.tzinfo is not None

From 839340045dd954e0ac69afc41eb2f94208973d96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20W=C3=BCrl?= <andi@tryb.de>
Date: Wed, 22 Apr 2026 21:29:26 +0200
Subject: [PATCH 3/4] Fix review comments from PR #185

- test_base.py: Use set/dict keying to verify distinct objects
- test_imprt.py: Import actual production code using pytest's monkeypatch
- test_cache.py: Use deterministic expiry values instead of time.time()

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 tests/cli/test_imprt.py | 66 +++++++++++++++++++++++++----------------
 tests/test_base.py      |  9 ++++--
 tests/test_cache.py     | 11 +++----
 3 files changed, 53 insertions(+), 33 deletions(-)

diff --git a/tests/cli/test_imprt.py b/tests/cli/test_imprt.py
index 6959887..b5541d1 100644
--- a/tests/cli/test_imprt.py
+++ b/tests/cli/test_imprt.py
@@ -1,74 +1,87 @@
-"""Tests for blitzortung.cli.imprt module.
+"""Tests for blitzortung.cli.imprt module."""
 
-These tests define the functions being tested inline to avoid import issues
-with optional dependencies (stopit, requests, statsd).
-"""
 import datetime
+import sys
+from unittest.mock import MagicMock, patch
 
-
-# Copy of the function from blitzortung.cli.imprt for testing
-def timestamp_is_newer_than(timestamp, latest_time):
-    """Check if timestamp is newer than latest_time."""
-    if not latest_time:
-        return True
-    return timestamp and timestamp > latest_time and timestamp - latest_time != datetime.timedelta()
-
-
-# Copy of the function from blitzortung.cli.imprt for testing
-def update_start_time() -> datetime.datetime:
-    """Get the start time for updates (30 minutes ago)."""
-    return datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(minutes=30)
+import pytest
 
 
 class TestTimestampIsNewerThan:
     """Tests for timestamp_is_newer_than function."""
 
+    @pytest.fixture(autouse=True)
+    def mock_dependencies(self, monkeypatch):
+        """Mock optional dependencies to allow importing the module."""
+        mock_stopit = MagicMock()
+        mock_requests = MagicMock()
+        mock_statsd = MagicMock()
+        monkeypatch.setitem(sys.modules, 'stopit', mock_stopit)
+        monkeypatch.setitem(sys.modules, 'requests', mock_requests)
+        monkeypatch.setitem(sys.modules, 'statsd', mock_statsd)
+
     def test_returns_true_when_latest_time_is_none(self):
         """Test that timestamp is newer when latest_time is None."""
+        from blitzortung.cli import imprt
         timestamp = datetime.datetime.now(datetime.timezone.utc)
-        result = timestamp_is_newer_than(timestamp, None)
+        result = imprt.timestamp_is_newer_than(timestamp, None)
         assert result is True
 
     def test_returns_true_when_timestamp_is_newer(self):
         """Test that timestamp is newer when it's greater than latest_time."""
+        from blitzortung.cli import imprt
         latest_time = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
         timestamp = datetime.datetime(2025, 1, 1, 12, 1, 0, tzinfo=datetime.timezone.utc)
-        result = timestamp_is_newer_than(timestamp, latest_time)
+        result = imprt.timestamp_is_newer_than(timestamp, latest_time)
         assert result is True
 
     def test_returns_false_when_timestamp_is_older(self):
         """Test that timestamp is not newer when it's less than latest_time."""
+        from blitzortung.cli import imprt
         latest_time = datetime.datetime(2025, 1, 1, 12, 1, 0, tzinfo=datetime.timezone.utc)
         timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
-        result = timestamp_is_newer_than(timestamp, latest_time)
+        result = imprt.timestamp_is_newer_than(timestamp, latest_time)
         assert result is False
 
     def test_returns_false_when_timestamps_are_equal(self):
         """Test that timestamp is not newer when it's equal to latest_time."""
+        from blitzortung.cli import imprt
         timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
-        result = timestamp_is_newer_than(timestamp, timestamp)
+        result = imprt.timestamp_is_newer_than(timestamp, timestamp)
         assert result is False
 
     def test_returns_false_when_timestamp_is_one_day_older(self):
         """Test that timestamp is not newer when it's one day older."""
+        from blitzortung.cli import imprt
         latest_time = datetime.datetime(2025, 1, 2, 12, 0, 0, tzinfo=datetime.timezone.utc)
         timestamp = datetime.datetime(2025, 1, 1, 12, 0, 0, tzinfo=datetime.timezone.utc)
-        result = timestamp_is_newer_than(timestamp, latest_time)
+        result = imprt.timestamp_is_newer_than(timestamp, latest_time)
         assert result is False
 
 
-
 class TestUpdateStartTime:
     """Tests for update_start_time function."""
 
+    @pytest.fixture(autouse=True)
+    def mock_dependencies(self, monkeypatch):
+        """Mock optional dependencies to allow importing the module."""
+        mock_stopit = MagicMock()
+        mock_requests = MagicMock()
+        mock_statsd = MagicMock()
+        monkeypatch.setitem(sys.modules, 'stopit', mock_stopit)
+        monkeypatch.setitem(sys.modules, 'requests', mock_requests)
+        monkeypatch.setitem(sys.modules, 'statsd', mock_statsd)
+
     def test_update_start_time_returns_datetime(self):
         """Test that update_start_time returns a datetime object."""
-        result = update_start_time()
+        from blitzortung.cli import imprt
+        result = imprt.update_start_time()
         assert isinstance(result, datetime.datetime)
 
     def test_update_start_time_is_30_minutes_ago(self):
         """Test that update_start_time returns time 30 minutes in the past."""
-        result = update_start_time()
+        from blitzortung.cli import imprt
+        result = imprt.update_start_time()
         expected = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(minutes=30)
 
         # Allow 1 second tolerance for test execution time
@@ -77,5 +90,6 @@ def test_update_start_time_is_30_minutes_ago(self):
 
     def test_update_start_time_has_timezone(self):
         """Test that update_start_time returns timezone-aware datetime."""
-        result = update_start_time()
+        from blitzortung.cli import imprt
+        result = imprt.update_start_time()
         assert result.tzinfo is not None
diff --git a/tests/test_base.py b/tests/test_base.py
index 9076d8d..ba22685 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -147,9 +147,14 @@ def test_hash_same_dict(self):
         assert hash(obj1) == hash(obj2)
 
     def test_hash_different_dict(self):
-        """Test hash of objects with different __dict__."""
+        """Test hash of objects with different __dict__ are distinct in dict/set."""
         obj1 = EqualityAndHash()
         obj1.value = 42
         obj2 = EqualityAndHash()
         obj2.value = 100
-        assert hash(obj1) != hash(obj2)
+        # Verify objects are distinct when used as dict keys or in sets
+        # (hash collisions are allowed in Python, but unequal objects should be distinct)
+        assert len({obj1, obj2}) == 2
+        d = {obj1: "value1", obj2: "value2"}
+        assert d[obj1] == "value1"
+        assert d[obj2] == "value2"
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 505ef39..6fed8f5 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -58,20 +58,21 @@ def test_get_hit_count(self):
 
     def test_repr_valid_entry(self):
         """Test string representation of valid cache entry."""
-        self.cache_entry = CacheEntry("payload", time.time() + 100)
+        # Use deterministic large expiry time (100 > initial hit_count of 0)
+        self.cache_entry = CacheEntry("payload", 100)
         result = repr(self.cache_entry)
         assert_that(result).contains("cached<+")
         assert_that(result).contains("payload")
 
     def test_repr_with_hit_count(self):
         """Test string representation after retrieving payload (increases hit count)."""
-        # Use hit_count as expiry_time to trigger "-" (hit_count > expiry_time)
-        # This works because __repr__ passes hit_count to is_valid()
-        self.cache_entry = CacheEntry("payload", 0)
+        # Use expiry time of 1, after 2 hits hit_count=2 > expiry_time=1
+        # This tests that invalid entries (expired) show "-" in repr
+        self.cache_entry = CacheEntry("payload", 1)
         _ = self.cache_entry.get_payload()
         _ = self.cache_entry.get_payload()
         result = repr(self.cache_entry)
-        assert_that(result).contains("cached<-")  # hit_count (2) > expiry_time (0)
+        assert_that(result).contains("cached<-")  # hit_count (2) > expiry_time (1)
         assert_that(result).contains("payload")
         assert_that(result).contains("2")  # hit count
 

From 4b099bf196c8cd6b6feda67db1436bf9bdb80742 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20W=C3=BCrl?= <andi@tryb.de>
Date: Wed, 22 Apr 2026 22:22:37 +0200
Subject: [PATCH 4/4] update

---
 poetry.lock    | 8 ++++----
 pyproject.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index 565550d..670654d 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -2154,14 +2154,14 @@ windows-platform = ["appdirs (>=1.4.0)", "appdirs (>=1.4.0)", "bcrypt (>=3.1.3)"
 
 [[package]]
 name = "txjsonrpc-ng"
-version = "0.8.0"
+version = "0.8.1"
 description = "Code for creating Twisted JSON-RPC servers and clients."
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.10"
 groups = ["main"]
 files = [
-    {file = "txjsonrpc_ng-0.8.0-py3-none-any.whl", hash = "sha256:b50e0e3c66c8130340f7e71ddc82451e25ca7aa68deb1097e69b491a9ea77bcf"},
-    {file = "txjsonrpc_ng-0.8.0.tar.gz", hash = "sha256:f9f542bb4ebfb8dd9a2e012503acd5d3a0fd0b5136fc29d8df2ca4d6abae915e"},
+    {file = "txjsonrpc_ng-0.8.1-py3-none-any.whl", hash = "sha256:f7ee79333df24854b761ef50e89c65dbef8b161296fee18b530bd08be9a9bea0"},
+    {file = "txjsonrpc_ng-0.8.1.tar.gz", hash = "sha256:7113f6273557a5f76b5e02a0f4c48c10c97d55193a487fa4ab4aa812aa7cb73c"},
 ]
 
 [package.dependencies]
diff --git a/pyproject.toml b/pyproject.toml
index 64f7f4d..67c9539 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = 'blitzortung'
-version = '1.12.2'
+version = '1.12.3'
 description = 'blitzortung.org python modules'
 authors = [
     {name = "Andreas Würl",email = "andi@tryb.de"}