fix: handle missing events and imprecise date parsing in meetup_query

- Catch TypeError alongside KeyError in format_response so null
  intermediate API fields (memberEvents, events) return empty DataFrame
  instead of crashing
- Use .get() for safer navigation of groupByUrlname and events fields
- Fix year-boundary bug in sort_json and prepare_events where
  year-less human-readable dates (e.g. "Thu 1/2 6:00 pm") got assigned
  the wrong year near Dec/Jan boundary
- Add 7 unit tests covering empty event lists, null API fields, and
  year-boundary date parsing for both ISO and human-readable formats

Closes: TASK-017

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pythoninthegrass

app/meetup_query.py

@@ -285,16 +285,18 @@ def format_response(response, location: str = "Oklahoma City", exclusions: str =
             data = response_json['data']['self']['memberEvents']['edges']
             if data and len(data) > 0 and data[0]['node']['group']['city'] != location:
                 print(f"{Fore.YELLOW}{warning:<10}{Fore.RESET}Skipping event outside of {location}")
-        except KeyError:
+        except (KeyError, TypeError):
             try:
-                if response_json['data'].get('groupByUrlname') is None:
+                group = response_json['data'].get('groupByUrlname')
+                if group is None:
                     data = ""
                     print(f"{Fore.YELLOW}{warning:<10}{Fore.RESET}Skipping group due to empty response")
                 else:
-                    data = response_json['data']['groupByUrlname']['events']['edges']
-                    if response_json['data']['groupByUrlname']['city'] != location:
+                    events = group.get('events')
+                    data = events['edges'] if events else ""
+                    if data and group.get('city') != location:
                         print(f"{Fore.RED}{error:<10}{Fore.RESET}No data for {location} found")
-            except KeyError as e:
+            except (KeyError, TypeError) as e:
                 print(f"{Fore.RED}{error:<10}{Fore.RESET}KeyError accessing GraphQL data: {e}")
                 print(f"{Fore.RED}{error:<10}{Fore.RESET}Response structure: {json.dumps(response_json, indent=2)[:500]}")
                 data = ""
@@ -390,7 +392,10 @@ def sort_json(filename) -> None:
             try:
                 parsed = arrow.get(value, 'ddd M/D h:mm a')
                 if parsed.year == 1:
-                    parsed = parsed.replace(year=arrow.now(tz).year)
+                    now = arrow.now(tz)
+                    parsed = parsed.replace(year=now.year)
+                    if parsed < now.shift(months=-6):
+                        parsed = parsed.replace(year=now.year + 1)
                 dates[key] = parsed.format('YYYY-MM-DDTHH:mm:ss')
             except ParserError:
                 try:
@@ -443,7 +448,10 @@ def prepare_events(df) -> list[dict]:
             try:
                 parsed = arrow.get(value, 'ddd M/D h:mm a')
                 if parsed.year == 1:
-                    parsed = parsed.replace(year=arrow.now(tz).year)
+                    now = arrow.now(tz)
+                    parsed = parsed.replace(year=now.year)
+                    if parsed < now.shift(months=-6):
+                        parsed = parsed.replace(year=now.year + 1)
                 dates[key] = parsed.format('YYYY-MM-DDTHH:mm:ss')
             except ParserError:
                 try:

tests/test_unit.py

@@ -1031,6 +1031,125 @@ def test_prepare_events_empty():
     assert prepare_events(df) == []
 
 
+@pytest.mark.unit
+def test_format_response_empty_edges():
+    """format_response returns empty DataFrame when edges list is empty."""
+    response = json.dumps({"data": {"self": {"memberEvents": {"edges": []}}}})
+    with patch("arrow.now", return_value=arrow.get("2024-09-18").to("America/Chicago")):
+        df = format_response(response)
+    assert df.empty
+
+
+@pytest.mark.unit
+def test_format_response_null_member_events():
+    """format_response returns empty DataFrame when memberEvents is null."""
+    response = json.dumps({"data": {"self": {"memberEvents": None}}})
+    with patch("arrow.now", return_value=arrow.get("2024-09-18").to("America/Chicago")):
+        df = format_response(response)
+    assert df.empty
+
+
+@pytest.mark.unit
+def test_format_response_null_group_events():
+    """format_response returns empty DataFrame when groupByUrlname events is null."""
+    response = json.dumps({"data": {"groupByUrlname": {"events": None, "city": "Oklahoma City"}}})
+    with patch("arrow.now", return_value=arrow.get("2024-09-18").to("America/Chicago")):
+        df = format_response(response)
+    assert df.empty
+
+
+@pytest.mark.unit
+def test_sort_json_year_boundary(tmp_path):
+    """sort_json preserves year from ISO 8601 dates near year boundaries."""
+    test_json = tmp_path / "test.json"
+    data = [
+        {"date": "2025-01-02T18:00:00", "eventUrl": "url1"},
+        {"date": "2024-12-30T10:00:00", "eventUrl": "url2"},
+    ]
+    with open(test_json, "w") as f:
+        json.dump(data, f)
+
+    with (
+        patch("meetup_query.json_fn", str(test_json)),
+        patch("arrow.now", return_value=arrow.get("2024-12-29")),
+    ):
+        sort_json(test_json)
+
+    with open(test_json) as f:
+        sorted_data = json.load(f)
+
+    assert len(sorted_data) == 2
+    assert sorted_data[0]["eventUrl"] == "url2"
+    assert sorted_data[1]["eventUrl"] == "url1"
+    assert "12/30" in sorted_data[0]["date"]
+    assert "1/2" in sorted_data[1]["date"]
+
+
+@pytest.mark.unit
+def test_sort_json_human_readable_year_boundary(tmp_path):
+    """sort_json with human-readable dates near year boundary should not guess wrong year."""
+    test_json = tmp_path / "test.json"
+    data = [
+        {"date": "Thu 1/2 6:00 pm", "eventUrl": "url1"},
+        {"date": "Mon 12/30 10:00 am", "eventUrl": "url2"},
+    ]
+    with open(test_json, "w") as f:
+        json.dump(data, f)
+
+    with (
+        patch("meetup_query.json_fn", str(test_json)),
+        patch("arrow.now", return_value=arrow.get("2024-12-29")),
+    ):
+        sort_json(test_json)
+
+    with open(test_json) as f:
+        sorted_data = json.load(f)
+
+    assert len(sorted_data) == 2
+    assert sorted_data[0]["eventUrl"] == "url2"
+    assert sorted_data[1]["eventUrl"] == "url1"
+
+
+@pytest.mark.unit
+def test_prepare_events_human_readable_year_boundary():
+    """prepare_events with human-readable dates near year boundary should not guess wrong year."""
+    df = pd.DataFrame({
+        "name": ["Group A", "Group B"],
+        "date": ["Thu 1/2 6:00 pm", "Mon 12/30 10:00 am"],
+        "title": ["Jan Event", "Dec Event"],
+        "description": ["desc", "desc"],
+        "city": ["OKC", "OKC"],
+        "eventUrl": ["url1", "url2"],
+    })
+    with patch("arrow.now", return_value=arrow.get("2024-12-29")):
+        result = prepare_events(df)
+
+    assert len(result) == 2
+    assert result[0]["eventUrl"] == "url2"
+    assert result[1]["eventUrl"] == "url1"
+
+
+@pytest.mark.unit
+def test_prepare_events_year_boundary():
+    """prepare_events preserves year from ISO 8601 dates near year boundaries."""
+    df = pd.DataFrame({
+        "name": ["Group A", "Group B"],
+        "date": ["2025-01-02T18:00:00", "2024-12-30T10:00:00"],
+        "title": ["Jan Event", "Dec Event"],
+        "description": ["desc", "desc"],
+        "city": ["OKC", "OKC"],
+        "eventUrl": ["url1", "url2"],
+    })
+    with patch("arrow.now", return_value=arrow.get("2024-12-29")):
+        result = prepare_events(df)
+
+    assert len(result) == 2
+    assert result[0]["eventUrl"] == "url2"
+    assert result[1]["eventUrl"] == "url1"
+    assert "12/30" in result[0]["date"]
+    assert "1/2" in result[1]["date"]
+
+
 @pytest.mark.unit
 @patch("meetup_query.gen_token")
 @patch("meetup_query.send_request")