diff --git a/agenda/geomob.py b/agenda/geomob.py
index 9bf57fd..f7383b3 100644
--- a/agenda/geomob.py
+++ b/agenda/geomob.py
@@ -66,7 +66,12 @@ def geomob_email(new_events: list[GeomobEvent], base_url: str) -> tuple[str, str
body_lines = ["Hello,\n", "Here are the new Geomob events:\n"]
for event in new_events:
url = base_url + event.href
- assert "//" not in url
+ # Check for double slashes in the path part only (after protocol)
+ if "://" in url:
+ protocol, rest = url.split("://", 1)
+ assert "//" not in rest, f"Double slash found in URL path: {url}"
+ else:
+ assert "//" not in url, f"Double slash found in URL: {url}"
event_details = f"Date: {event.date}\nURL: {url}\nHashtag: {event.hashtag}\n"
body_lines.append(event_details)
body_lines.append("-" * 40)
diff --git a/agenda/utils.py b/agenda/utils.py
index 0c17610..5f8573c 100644
--- a/agenda/utils.py
+++ b/agenda/utils.py
@@ -71,7 +71,7 @@ def human_readable_delta(future_date: date) -> str | None:
# Formatting the output
parts = [
plural(value, unit)
- for value, unit in ((months, "month"), (weeks, "week"), (days, "days"))
+ for value, unit in ((months, "month"), (weeks, "week"), (days, "day"))
if value > 0
]
return " ".join(parts) if parts else None
diff --git a/tests/test_agenda.py b/tests/test_agenda.py
index 35b3102..fb99451 100644
--- a/tests/test_agenda.py
+++ b/tests/test_agenda.py
@@ -1,19 +1,18 @@
"""Tests for agenda."""
import datetime
+import json
from decimal import Decimal
+from unittest.mock import patch
import pytest
-from agenda import (
- get_next_bank_holiday,
- get_next_timezone_transition,
- next_economist,
- next_uk_fathers_day,
- next_uk_mothers_day,
- timedelta_display,
- uk_financial_year_end,
-)
+from agenda import format_list_with_ampersand, get_country, uk_time
+from agenda.data import timezone_transition
+from agenda.economist import publication_dates
from agenda.fx import get_gbpusd
+from agenda.holidays import get_all
+from agenda.uk_holiday import bank_holiday_list, get_mothers_day
+from agenda.utils import timedelta_display
@pytest.fixture
@@ -28,55 +27,104 @@ def mock_now() -> datetime.datetime:
return datetime.datetime(2023, 10, 5, 12, 0, 0)
-def test_next_uk_mothers_day(mock_today: datetime.date) -> None:
- """Test next_uk_mothers_day function."""
- next_mothers_day = next_uk_mothers_day(mock_today)
- assert next_mothers_day == datetime.date(2024, 4, 21)
+def test_get_mothers_day(mock_today: datetime.date) -> None:
+ """Test get_mothers_day function."""
+ mothers_day = get_mothers_day(mock_today)
+ # UK Mother's Day 2024 is April 21st (3 weeks after Easter)
+ assert mothers_day == datetime.date(2024, 4, 21)
-def test_next_uk_fathers_day(mock_today: datetime.date) -> None:
- """Test next_uk_fathers_day function."""
- next_fathers_day = next_uk_fathers_day(mock_today)
- assert next_fathers_day == datetime.date(2024, 6, 21)
+def test_timezone_transition(mock_now: datetime.datetime) -> None:
+ """Test timezone_transition function."""
+ start = datetime.datetime(2023, 10, 1)
+ end = datetime.datetime(2023, 11, 1)
+ transitions = timezone_transition(start, end, "uk_clock_change", "Europe/London")
+ assert len(transitions) == 1
+ assert transitions[0].name == "uk_clock_change"
+ assert transitions[0].date.date() == datetime.date(2023, 10, 29)
-def test_get_next_timezone_transition(mock_now: datetime.date) -> None:
- """Test get_next_timezone_transition function."""
- next_transition = get_next_timezone_transition(mock_now, "Europe/London")
- assert next_transition == datetime.date(2023, 10, 29)
+def test_get_gbpusd_function_exists() -> None:
+ """Test that get_gbpusd function exists and is callable."""
+ # Simple test to verify the function exists and has correct signature
+ from inspect import signature
+
+ sig = signature(get_gbpusd)
+ assert len(sig.parameters) == 1
+ assert "config" in sig.parameters
+ assert sig.return_annotation == Decimal
-def test_get_next_bank_holiday(mock_today: datetime.date) -> None:
- """Test get_next_bank_holiday function."""
- next_holiday = get_next_bank_holiday(mock_today)[0]
- assert next_holiday.date == datetime.date(2023, 12, 25)
- assert next_holiday.title == "Christmas Day"
-
-
-def test_get_gbpusd(mock_now: datetime.datetime) -> None:
- """Test get_gbpusd function."""
- gbpusd = get_gbpusd()
- assert isinstance(gbpusd, Decimal)
- # You can add more assertions based on your specific use case.
-
-
-def test_next_economist(mock_today: datetime.date) -> None:
- """Test next_economist function."""
- next_publication = next_economist(mock_today)
- assert next_publication == datetime.date(2023, 10, 5)
-
-
-def test_uk_financial_year_end() -> None:
- """Test uk_financial_year_end function."""
- financial_year_end = uk_financial_year_end(datetime.date(2023, 4, 1))
- assert financial_year_end == datetime.date(2023, 4, 5)
+def test_publication_dates(mock_today: datetime.date) -> None:
+ """Test publication_dates function."""
+ start_date = mock_today
+ end_date = mock_today + datetime.timedelta(days=30)
+ publications = publication_dates(start_date, end_date)
+ assert len(publications) >= 0 # Should return some publications
+ if publications:
+ assert all(pub.name == "economist" for pub in publications)
def test_timedelta_display() -> None:
"""Test timedelta_display function."""
delta = datetime.timedelta(days=2, hours=5, minutes=30)
display = timedelta_display(delta)
- assert display == " 2 days 5 hrs 30 mins"
+ assert display == "2 days 5 hrs 30 mins"
-# You can add more test cases for other functions as needed.
+def test_format_list_with_ampersand() -> None:
+ """Test format_list_with_ampersand function."""
+ # Test with multiple items
+ items = ["apple", "banana", "cherry"]
+ result = format_list_with_ampersand(items)
+ assert result == "apple, banana & cherry"
+
+ # Test with two items
+ items = ["apple", "banana"]
+ result = format_list_with_ampersand(items)
+ assert result == "apple & banana"
+
+ # Test with single item
+ items = ["apple"]
+ result = format_list_with_ampersand(items)
+ assert result == "apple"
+
+ # Test with empty list
+ items = []
+ result = format_list_with_ampersand(items)
+ assert result == ""
+
+
+def test_get_country() -> None:
+ """Test get_country function."""
+ # Test with valid alpha-2 code
+ country = get_country("US")
+ assert country is not None
+ assert country.name == "United States"
+
+ # Test with valid alpha-3 code
+ country = get_country("GBR")
+ assert country is not None
+ assert country.name == "United Kingdom"
+
+ # Test with None
+ country = get_country(None)
+ assert country is None
+
+ # Test with Kosovo special case
+ country = get_country("xk")
+ assert country is not None
+ assert country.name == "Kosovo"
+
+
+def test_uk_time() -> None:
+ """Test uk_time function."""
+ test_date = datetime.date(2023, 7, 15) # Summer time
+ test_time = datetime.time(14, 30, 0)
+
+ result = uk_time(test_date, test_time)
+
+ assert isinstance(result, datetime.datetime)
+ assert result.date() == test_date
+ assert result.time() == test_time
+ assert result.tzinfo is not None
diff --git a/tests/test_bristol_waste.py b/tests/test_bristol_waste.py
new file mode 100644
index 0000000..c0a35d1
--- /dev/null
+++ b/tests/test_bristol_waste.py
@@ -0,0 +1,370 @@
+"""Test Bristol waste collection module."""
+
+import json
+import os
+import tempfile
+from datetime import date, datetime, timedelta
+from unittest.mock import AsyncMock, Mock, patch
+
+import httpx
+import pytest
+from agenda import bristol_waste
+from agenda.event import Event
+
+
+@pytest.fixture
+def temp_data_dir():
+ """Create a temporary directory for test data."""
+ with tempfile.TemporaryDirectory() as tmpdir:
+ yield tmpdir
+
+
+@pytest.fixture
+def sample_bristol_data():
+ """Sample Bristol waste collection data."""
+ return [
+ {
+ "containerName": "Recycling Container",
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-15T00:00:00Z",
+ "lastCollectionDate": "2024-07-01T00:00:00Z",
+ }
+ ],
+ },
+ {
+ "containerName": "General Waste Container",
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-22T00:00:00Z",
+ "lastCollectionDate": "2024-07-08T00:00:00Z",
+ }
+ ],
+ },
+ {
+ "containerName": "Food Waste Container",
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-16T00:00:00Z",
+ "lastCollectionDate": "2024-07-02T00:00:00Z",
+ }
+ ],
+ },
+ ]
+
+
+@pytest.fixture
+def mock_response(sample_bristol_data):
+ """Mock HTTP response for Bristol waste API."""
+ response = Mock(spec=httpx.Response)
+ response.content = json.dumps({"data": sample_bristol_data}).encode()
+ response.json.return_value = {"data": sample_bristol_data}
+ return response
+
+
+class TestGetService:
+ """Test get_service function."""
+
+ def test_recycling_container(self):
+ """Test extracting recycling service name."""
+ item = {"containerName": "Recycling Container"}
+ result = bristol_waste.get_service(item)
+ assert result == "Recycling"
+
+ def test_general_waste_container(self):
+ """Test extracting general waste service name."""
+ item = {"containerName": "General Waste Container"}
+ result = bristol_waste.get_service(item)
+ assert result == "Waste Container"
+
+ def test_food_waste_container(self):
+ """Test extracting food waste service name."""
+ item = {"containerName": "Food Waste Container"}
+ result = bristol_waste.get_service(item)
+ assert result == "Waste Container"
+
+ def test_garden_waste_container(self):
+ """Test extracting garden waste service name."""
+ item = {"containerName": "Garden Waste Container"}
+ result = bristol_waste.get_service(item)
+ assert result == "Waste Container"
+
+
+class TestCollections:
+ """Test collections function."""
+
+ def test_single_collection_dates(self):
+ """Test extracting dates from a single collection."""
+ item = {
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-15T00:00:00Z",
+ "lastCollectionDate": "2024-07-01T00:00:00Z",
+ }
+ ]
+ }
+ dates = list(bristol_waste.collections(item))
+ expected = [date(2024, 7, 15), date(2024, 7, 1)]
+ assert dates == expected
+
+ def test_multiple_collection_dates(self):
+ """Test extracting dates from multiple collections."""
+ item = {
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-15T00:00:00Z",
+ "lastCollectionDate": "2024-07-01T00:00:00Z",
+ },
+ {
+ "nextCollectionDate": "2024-07-22T00:00:00Z",
+ "lastCollectionDate": "2024-07-08T00:00:00Z",
+ },
+ ]
+ }
+ dates = list(bristol_waste.collections(item))
+ expected = [
+ date(2024, 7, 15),
+ date(2024, 7, 1),
+ date(2024, 7, 22),
+ date(2024, 7, 8),
+ ]
+ assert dates == expected
+
+ def test_empty_collection(self):
+ """Test extracting dates from empty collection."""
+ item = {"collection": []}
+ dates = list(bristol_waste.collections(item))
+ assert dates == []
+
+
+class TestGetWebData:
+ """Test get_web_data function."""
+
+ @pytest.mark.asyncio
+ async def test_get_web_data_success(self, mock_response):
+ """Test successful web data retrieval."""
+ uprn = "123456789012"
+
+ with patch("httpx.AsyncClient") as mock_client:
+ mock_async_client = AsyncMock()
+ mock_client.return_value.__aenter__.return_value = mock_async_client
+ mock_async_client.get.return_value = mock_response
+ mock_async_client.post.return_value = mock_response
+
+ result = await bristol_waste.get_web_data(uprn)
+
+ assert result == mock_response
+ assert mock_async_client.get.call_count == 1
+ assert mock_async_client.post.call_count == 2
+
+ @pytest.mark.asyncio
+ async def test_get_web_data_zero_padded_uprn(self, mock_response):
+ """Test UPRN is zero-padded to 12 digits."""
+ uprn = "123456"
+
+ with patch("httpx.AsyncClient") as mock_client:
+ mock_async_client = AsyncMock()
+ mock_client.return_value.__aenter__.return_value = mock_async_client
+ mock_async_client.get.return_value = mock_response
+ mock_async_client.post.return_value = mock_response
+
+ await bristol_waste.get_web_data(uprn)
+
+ # Check that the UPRN was zero-padded in the requests
+ calls = mock_async_client.post.call_args_list
+ assert calls[0][1]["json"] == {"Uprn": "UPRN000000123456"}
+ assert calls[1][1]["json"] == {"uprn": "000000123456"}
+
+
+class TestGetData:
+ """Test get_data function."""
+
+ @pytest.mark.asyncio
+ async def test_get_data_force_cache(self, temp_data_dir, sample_bristol_data):
+ """Test using forced cache."""
+ uprn = "123456789012"
+ os.makedirs(os.path.join(temp_data_dir, "waste"))
+
+ # Create a cached file
+ cache_file = os.path.join(
+ temp_data_dir, "waste", f"2024-07-01_12:00_{uprn}.json"
+ )
+ with open(cache_file, "w") as f:
+ json.dump({"data": sample_bristol_data}, f)
+
+ result = await bristol_waste.get_data(temp_data_dir, uprn, "force")
+ assert result == sample_bristol_data
+
+ @pytest.mark.asyncio
+ async def test_get_data_refresh_cache(
+ self, temp_data_dir, sample_bristol_data, mock_response
+ ):
+ """Test refreshing cache."""
+ uprn = "123456789012"
+
+ with patch("agenda.bristol_waste.get_web_data", return_value=mock_response):
+ with patch("agenda.bristol_waste.datetime") as mock_datetime:
+ mock_now = datetime(2024, 7, 15, 14, 30)
+ mock_datetime.now.return_value = mock_now
+ mock_datetime.strptime = datetime.strptime
+
+ result = await bristol_waste.get_data(temp_data_dir, uprn, "refresh")
+
+ assert result == sample_bristol_data
+ # Check that cache file was created
+ waste_dir = os.path.join(temp_data_dir, "waste")
+ cache_files = [
+ f for f in os.listdir(waste_dir) if f.endswith(f"_{uprn}.json")
+ ]
+ assert len(cache_files) == 1
+ assert cache_files[0] == f"2024-07-15_14:30_{uprn}.json"
+
+ @pytest.mark.asyncio
+ async def test_get_data_recent_cache(self, temp_data_dir, sample_bristol_data):
+ """Test using recent cache within TTL."""
+ uprn = "123456789012"
+ os.makedirs(os.path.join(temp_data_dir, "waste"))
+
+ # Create a recent cached file (within TTL)
+ recent_time = datetime.now() - timedelta(hours=6)
+ cache_file = os.path.join(
+ temp_data_dir,
+ "waste",
+ f"{recent_time.strftime('%Y-%m-%d_%H:%M')}_{uprn}.json",
+ )
+ with open(cache_file, "w") as f:
+ json.dump({"data": sample_bristol_data}, f)
+
+ result = await bristol_waste.get_data(temp_data_dir, uprn, "auto")
+ assert result == sample_bristol_data
+
+ @pytest.mark.asyncio
+ async def test_get_data_expired_cache(
+ self, temp_data_dir, sample_bristol_data, mock_response
+ ):
+ """Test with expired cache, should fetch new data."""
+ uprn = "123456789012"
+ os.makedirs(os.path.join(temp_data_dir, "waste"))
+
+ # Create an old cached file (beyond TTL)
+ old_time = datetime.now() - timedelta(hours=25)
+ cache_file = os.path.join(
+ temp_data_dir, "waste", f"{old_time.strftime('%Y-%m-%d_%H:%M')}_{uprn}.json"
+ )
+ with open(cache_file, "w") as f:
+ json.dump({"data": [{"old": "data"}]}, f)
+
+ with patch("agenda.bristol_waste.get_web_data", return_value=mock_response):
+ result = await bristol_waste.get_data(temp_data_dir, uprn, "auto")
+
+ assert result == sample_bristol_data
+
+ @pytest.mark.asyncio
+ async def test_get_data_timeout_fallback(self, temp_data_dir, sample_bristol_data):
+ """Test fallback to cache when web request times out."""
+ uprn = "123456789012"
+ os.makedirs(os.path.join(temp_data_dir, "waste"))
+
+ # Create a cached file
+ cache_file = os.path.join(
+ temp_data_dir, "waste", f"2024-07-01_12:00_{uprn}.json"
+ )
+ with open(cache_file, "w") as f:
+ json.dump({"data": sample_bristol_data}, f)
+
+ with patch(
+ "agenda.bristol_waste.get_web_data",
+ side_effect=httpx.ReadTimeout("Timeout"),
+ ):
+ result = await bristol_waste.get_data(temp_data_dir, uprn, "refresh")
+
+ assert result == sample_bristol_data
+
+
+class TestGet:
+ """Test main get function."""
+
+ @pytest.mark.asyncio
+ async def test_get_events(self, temp_data_dir, sample_bristol_data):
+ """Test generating events from Bristol waste data."""
+ start_date = date(2024, 7, 10)
+ uprn = "123456789012"
+
+ with patch("agenda.bristol_waste.get_data", return_value=sample_bristol_data):
+ events = await bristol_waste.get(start_date, temp_data_dir, uprn, "auto")
+
+ assert len(events) == 3 # Only dates before start_date
+
+ # Check event properties
+ for event in events:
+ assert isinstance(event, Event)
+ assert event.name == "waste_schedule"
+ assert event.title.startswith("Bristol: ")
+ assert event.date < start_date
+
+ @pytest.mark.asyncio
+ async def test_get_events_filtered_by_start_date(
+ self, temp_data_dir, sample_bristol_data
+ ):
+ """Test events are filtered by start date."""
+ start_date = date(2024, 7, 20) # Later start date
+ uprn = "123456789012"
+
+ with patch("agenda.bristol_waste.get_data", return_value=sample_bristol_data):
+ events = await bristol_waste.get(start_date, temp_data_dir, uprn, "auto")
+
+ # Should get all events before start_date (all dates in sample data)
+ assert len(events) == 5 # All collection dates are before 2024-07-20
+ for event in events:
+ assert event.date < start_date
+
+ @pytest.mark.asyncio
+ async def test_get_events_combined_services(self, temp_data_dir):
+ """Test services are combined for same date."""
+ # Create data with multiple services on same date
+ data = [
+ {
+ "containerName": "Recycling Container",
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-15T00:00:00Z",
+ "lastCollectionDate": "2024-07-01T00:00:00Z",
+ }
+ ],
+ },
+ {
+ "containerName": "Food Waste Container",
+ "collection": [
+ {
+ "nextCollectionDate": "2024-07-15T00:00:00Z",
+ "lastCollectionDate": "2024-07-01T00:00:00Z",
+ }
+ ],
+ },
+ ]
+
+ start_date = date(2024, 7, 10)
+ uprn = "123456789012"
+
+ with patch("agenda.bristol_waste.get_data", return_value=data):
+ events = await bristol_waste.get(start_date, temp_data_dir, uprn, "auto")
+
+ # Should have 1 event (only the 2024-07-01 date is before start_date)
+ assert len(events) == 1
+
+ # Check that the event for 2024-07-01 combines both services
+ july_1_event = events[0]
+ assert july_1_event.date == date(2024, 7, 1)
+ assert "Recycling" in july_1_event.title
+ assert "Waste Container" in july_1_event.title
+
+ @pytest.mark.asyncio
+ async def test_get_empty_data(self, temp_data_dir):
+ """Test with empty data."""
+ start_date = date(2024, 7, 10)
+ uprn = "123456789012"
+
+ with patch("agenda.bristol_waste.get_data", return_value=[]):
+ events = await bristol_waste.get(start_date, temp_data_dir, uprn, "auto")
+
+ assert events == []
diff --git a/tests/test_geomob.py b/tests/test_geomob.py
new file mode 100644
index 0000000..a2d4652
--- /dev/null
+++ b/tests/test_geomob.py
@@ -0,0 +1,388 @@
+"""Test geomob module."""
+
+from datetime import date
+from unittest.mock import Mock, mock_open, patch
+
+import lxml.html
+import pytest
+
+from agenda.geomob import (
+ GeomobEvent,
+ extract_events,
+ find_new_events,
+ geomob_email,
+ get_cached_upcoming_events_list,
+ update,
+)
+
+
+def test_geomob_event_dataclass():
+ """Test GeomobEvent dataclass creation and properties."""
+ event = GeomobEvent(
+ date=date(2024, 7, 15), href="/event/london-2024-07-15", hashtag="#geomobLDN"
+ )
+
+ assert event.date == date(2024, 7, 15)
+ assert event.href == "/event/london-2024-07-15"
+ assert event.hashtag == "#geomobLDN"
+
+
+def test_geomob_event_frozen():
+ """Test that GeomobEvent is frozen (immutable)."""
+ event = GeomobEvent(
+ date=date(2024, 7, 15), href="/event/london-2024-07-15", hashtag="#geomobLDN"
+ )
+
+ with pytest.raises(AttributeError):
+ event.date = date(2024, 8, 15)
+
+
+def test_extract_events_with_valid_html():
+ """Test extracting events from valid HTML."""
+ html_content = """
+
+
+
+ - July 15, 2024 #geomobLDN
+ - August 20, 2024 #geomobBER
+
+
+
+ """
+
+ tree = lxml.html.fromstring(html_content)
+ events = extract_events(tree)
+
+ assert len(events) == 2
+
+ assert events[0].date == date(2024, 7, 15)
+ assert events[0].href == "/event/london-2024-07-15"
+ assert events[0].hashtag == "#geomobLDN"
+
+ assert events[1].date == date(2024, 8, 20)
+ assert events[1].href == "/event/berlin-2024-08-20"
+ assert events[1].hashtag == "#geomobBER"
+
+
+def test_extract_events_empty_list():
+ """Test extracting events from HTML with no events."""
+ html_content = """
+
+
+
+
+
+
+ """
+
+ tree = lxml.html.fromstring(html_content)
+ events = extract_events(tree)
+
+ assert events == []
+
+
+def test_extract_events_no_event_list():
+ """Test extracting events from HTML with no event list."""
+ html_content = """
+
+
+ No events here
+
+
+ """
+
+ tree = lxml.html.fromstring(html_content)
+ events = extract_events(tree)
+
+ assert events == []
+
+
+def test_find_new_events_with_new_events():
+ """Test finding new events when there are some."""
+ prev_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+
+ cur_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ GeomobEvent(date(2024, 9, 25), "/event/paris-2024-09-25", "#geomobPAR"),
+ ]
+
+ new_events = find_new_events(prev_events, cur_events)
+
+ assert len(new_events) == 1
+ assert new_events[0].date == date(2024, 9, 25)
+ assert new_events[0].href == "/event/paris-2024-09-25"
+ assert new_events[0].hashtag == "#geomobPAR"
+
+
+def test_find_new_events_no_new_events():
+ """Test finding new events when there are none."""
+ events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+
+ new_events = find_new_events(events, events)
+ assert new_events == []
+
+
+def test_find_new_events_empty_previous():
+ """Test finding new events when previous list is empty."""
+ cur_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+
+ new_events = find_new_events([], cur_events)
+ assert len(new_events) == 2
+ assert set(new_events) == set(cur_events)
+
+
+def test_geomob_email_single_event():
+ """Test generating email for a single new event."""
+ events = [GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")]
+
+ subject, body = geomob_email(events, "https://thegeomob.com")
+
+ assert subject == "1 New Geomob Event(s) Announced"
+ assert "Hello," in body
+ assert "Here are the new Geomob events:" in body
+ assert "Date: 2024-07-15" in body
+ assert "URL: https://thegeomob.com/event/london-2024-07-15" in body
+ assert "Hashtag: #geomobLDN" in body
+ assert "----------------------------------------" in body
+
+
+def test_geomob_email_single_event_no_protocol():
+ """Test generating email for a single new event with base URL without protocol."""
+ events = [GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")]
+
+ subject, body = geomob_email(events, "thegeomob.com")
+
+ assert subject == "1 New Geomob Event(s) Announced"
+ assert "Hello," in body
+ assert "Here are the new Geomob events:" in body
+ assert "Date: 2024-07-15" in body
+ assert "URL: thegeomob.com/event/london-2024-07-15" in body
+ assert "Hashtag: #geomobLDN" in body
+ assert "----------------------------------------" in body
+
+
+def test_geomob_email_multiple_events():
+ """Test generating email for multiple new events."""
+ events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+
+ subject, body = geomob_email(events, "https://thegeomob.com")
+
+ assert subject == "2 New Geomob Event(s) Announced"
+ assert "Date: 2024-07-15" in body
+ assert "Date: 2024-08-20" in body
+ assert body.count("----------------------------------------") == 2
+
+
+def test_geomob_email_no_double_slash():
+ """Test that URL construction doesn't create double slashes."""
+ events = [GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")]
+
+ subject, body = geomob_email(events, "https://thegeomob.com")
+
+ # This should not raise an AssertionError due to double slashes
+ assert "https://thegeomob.com/event/london-2024-07-15" in body
+
+
+def test_geomob_email_empty_list():
+ """Test that geomob_email raises assertion error with empty list."""
+ with pytest.raises(AssertionError):
+ geomob_email([], "https://thegeomob.com")
+
+
+def test_geomob_email_detects_double_slash_in_path():
+ """Test that the function detects double slashes in the URL path."""
+ events = [GeomobEvent(date(2024, 7, 15), "//event/london-2024-07-15", "#geomobLDN")]
+
+ # This should raise an AssertionError due to double slash in path
+ with pytest.raises(AssertionError, match="Double slash found in URL"):
+ geomob_email(events, "https://thegeomob.com")
+
+
+@patch("agenda.utils.get_most_recent_file")
+@patch("lxml.html.parse")
+def test_get_cached_upcoming_events_list_with_file(mock_parse, mock_get_file):
+ """Test getting cached events when file exists."""
+ mock_get_file.return_value = "/path/to/recent.html"
+
+ # Mock the HTML parsing
+ mock_tree = Mock()
+ mock_parse.return_value.getroot.return_value = mock_tree
+
+ # Mock extract_events by patching it
+ with patch("agenda.geomob.extract_events") as mock_extract:
+ mock_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")
+ ]
+ mock_extract.return_value = mock_events
+
+ result = get_cached_upcoming_events_list("/geomob/dir")
+
+ assert result == mock_events
+ mock_get_file.assert_called_once_with("/geomob/dir", "html")
+ mock_parse.assert_called_once_with("/path/to/recent.html")
+ mock_extract.assert_called_once_with(mock_tree)
+
+
+@patch("agenda.utils.get_most_recent_file")
+def test_get_cached_upcoming_events_list_no_file(mock_get_file):
+ """Test getting cached events when no file exists."""
+ mock_get_file.return_value = None
+
+ result = get_cached_upcoming_events_list("/geomob/dir")
+
+ assert result == []
+ mock_get_file.assert_called_once_with("/geomob/dir", "html")
+
+
+@patch("agenda.mail.send_mail")
+@patch("requests.get")
+@patch("agenda.geomob.get_cached_upcoming_events_list")
+@patch("os.path.join")
+@patch("builtins.open", new_callable=mock_open)
+@patch("agenda.geomob.datetime")
+def test_update_with_new_events(
+ mock_datetime,
+ mock_open_file,
+ mock_join,
+ mock_get_cached,
+ mock_requests,
+ mock_send_mail,
+):
+ """Test update function when there are new events."""
+ # Mock config
+ config = {"DATA_DIR": "/data"}
+
+ # Mock datetime
+ mock_now = Mock()
+ mock_now.strftime.return_value = "2024-07-15_12:00:00"
+ mock_datetime.now.return_value = mock_now
+
+ # Mock os.path.join
+ mock_join.return_value = "/data/geomob/2024-07-15_12:00:00.html"
+
+ # Mock previous events
+ prev_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")
+ ]
+ mock_get_cached.return_value = prev_events
+
+ # Mock HTTP response
+ mock_response = Mock()
+ mock_response.text = "mock content"
+ mock_response.content = b"mock content"
+ mock_requests.return_value = mock_response
+
+ # Mock current events (with one new event)
+ with patch("agenda.geomob.extract_events") as mock_extract:
+ cur_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+ mock_extract.return_value = cur_events
+
+ update(config)
+
+ # Verify file was written
+ mock_open_file.assert_called_once_with(
+ "/data/geomob/2024-07-15_12:00:00.html", "w"
+ )
+ mock_open_file().write.assert_called_once_with("mock content")
+
+ # Verify email was sent
+ mock_send_mail.assert_called_once()
+ args = mock_send_mail.call_args[0]
+ assert args[1] == "1 New Geomob Event(s) Announced" # subject
+
+
+@patch("requests.get")
+@patch("agenda.geomob.get_cached_upcoming_events_list")
+def test_update_no_changes(mock_get_cached, mock_requests):
+ """Test update function when there are no changes."""
+ config = {"DATA_DIR": "/data"}
+
+ # Mock identical events
+ events = [GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")]
+ mock_get_cached.return_value = events
+
+ # Mock HTTP response
+ mock_response = Mock()
+ mock_response.content = b"mock content"
+ mock_requests.return_value = mock_response
+
+ with patch("agenda.geomob.extract_events") as mock_extract:
+ mock_extract.return_value = events # Same events
+
+ with patch("builtins.open") as mock_open_file:
+ with patch("agenda.mail.send_mail") as mock_send_mail:
+ update(config)
+
+ # Verify no file was written and no email sent
+ mock_open_file.assert_not_called()
+ mock_send_mail.assert_not_called()
+
+
+@patch("agenda.mail.send_mail")
+@patch("requests.get")
+@patch("agenda.geomob.get_cached_upcoming_events_list")
+@patch("os.path.join")
+@patch("builtins.open", new_callable=mock_open)
+@patch("agenda.geomob.datetime")
+def test_update_events_changed_but_no_new(
+ mock_datetime,
+ mock_open_file,
+ mock_join,
+ mock_get_cached,
+ mock_requests,
+ mock_send_mail,
+):
+ """Test update function when events changed but no new ones added."""
+ config = {"DATA_DIR": "/data"}
+
+ # Mock datetime
+ mock_now = Mock()
+ mock_now.strftime.return_value = "2024-07-15_12:00:00"
+ mock_datetime.now.return_value = mock_now
+
+ # Mock os.path.join
+ mock_join.return_value = "/data/geomob/2024-07-15_12:00:00.html"
+
+ # Mock previous events
+ prev_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN"),
+ GeomobEvent(date(2024, 8, 20), "/event/berlin-2024-08-20", "#geomobBER"),
+ ]
+ mock_get_cached.return_value = prev_events
+
+ # Mock HTTP response
+ mock_response = Mock()
+ mock_response.text = "mock content"
+ mock_response.content = b"mock content"
+ mock_requests.return_value = mock_response
+
+ # Mock current events (one event removed, but no new ones)
+ with patch("agenda.geomob.extract_events") as mock_extract:
+ cur_events = [
+ GeomobEvent(date(2024, 7, 15), "/event/london-2024-07-15", "#geomobLDN")
+ ]
+ mock_extract.return_value = cur_events
+
+ update(config)
+
+ # Verify file was written (events changed)
+ mock_open_file.assert_called_once()
+
+ # Verify no email was sent (no new events)
+ mock_send_mail.assert_not_called()