workstream-cli 0.0.1__py3-none-any.whl

workstream/test/test_web.py

@@ -0,0 +1,606 @@
+"""Tests for workstream.web — HTML dashboard generation and clastic app."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from workstream.models import BranchRef, PlanRef, ThreadEntry, Workstream
+from workstream.web import (
+    _format_idle_text,
+    _format_relative_date,
+    _idle_css_class,
+    _nest_group,
+    build_dashboard_context,
+    generate_dashboard_file,
+    render_dashboard_html,
+)
+
+
+# ── Fixtures ─────────────────────────────────────────────────────────
+
+def _make_workstream(**overrides) -> Workstream:
+    """Build a Workstream with sensible defaults, applying overrides."""
+    defaults = {
+        'id': '2026-03-28-abcdef1234',
+        'title': 'Test WS',
+        'status': 'active',
+        'size': 'day',
+        'tags': ['code'],
+        'created': '2026-03-28',
+        'updated': '2026-03-28',
+        'last_activity': '2026-03-28',
+    }
+    defaults.update(overrides)
+    return Workstream(**defaults)
+
+
+@pytest.fixture()
+def sample_workstreams() -> list[Workstream]:
+    """A mixed set of workstreams covering all statuses."""
+    return [
+        _make_workstream(
+            id='ws-active-1', title='Alpha', status='active', size='week',
+            tags=['code', 'backend'],
+            updated='2026-03-27', last_activity='2026-03-27',
+            thread=[ThreadEntry(date='2026-03-27', body='Made progress.')],
+            next_actions=['Deploy v2'],
+            plans=[PlanRef(repo='myapp', path='alpha-plan.md', status='active', title='Alpha Plan', date='2026-03-25')],
+            branches=[BranchRef(repo='myapp', branch='feature/alpha', ahead=5)],
+        ),
+        _make_workstream(
+            id='ws-active-2', title='Beta', status='active', size='day',
+            tags=['code'],
+            updated='2026-03-26', last_activity='2026-03-26',
+            thread=[ThreadEntry(date='2026-03-26', body='Sketching design.')],
+        ),
+        _make_workstream(
+            id='ws-snoozed-1', title='Gamma', status='snoozed', size='day',
+            tags=['business'],
+            snooze_reason='Waiting on feedback',
+            thread=[ThreadEntry(date='2026-03-20', body='Submitted proposal.')],
+        ),
+        _make_workstream(
+            id='ws-snoozed-2', title='Delta', status='snoozed', size='hour',
+            tags=['foss'],
+            snooze_reason='Not urgent yet',
+        ),
+        _make_workstream(
+            id='ws-completed-1', title='Epsilon', status='completed', size='day',
+            tags=['code'],
+            thread=[ThreadEntry(date='2026-03-15', body='Shipped.')],
+        ),
+    ]
+
+
+# ── Context building ─────────────────────────────────────────────────
+
+def test_build_dashboard_context_counts(sample_workstreams):
+    """Context contains correct counts for each status."""
+    ctx = build_dashboard_context(sample_workstreams)
+    assert ctx['total_count'] == 5
+    assert ctx['active_count'] == 2
+    assert ctx['snoozed_count'] == 2
+    assert ctx['completed_count'] == 1
+
+
+def test_build_dashboard_context_groups_order(sample_workstreams):
+    """Status groups appear in the canonical order."""
+    ctx = build_dashboard_context(sample_workstreams)
+    group_labels = [g['status_label'] for g in ctx['status_groups']]
+    assert group_labels == ['Active', 'Snoozed', 'Completed']
+
+
+def test_build_dashboard_context_empty():
+    """Empty workstream list produces zero counts and no groups."""
+    ctx = build_dashboard_context([])
+    assert ctx['total_count'] == 0
+    assert ctx['status_groups'] == []
+
+
+def test_build_dashboard_context_active_sorted_by_recency(sample_workstreams):
+    """Active workstreams are sorted most-recently-active first."""
+    ctx = build_dashboard_context(sample_workstreams)
+    active_group = ctx['status_groups'][0]
+    assert active_group['status_label'] == 'Active'
+    titles = [ws['title'] for ws in active_group['workstreams']]
+    # Alpha (2026-03-27) is more recent than Beta (2026-03-26)
+    assert titles.index('Alpha') < titles.index('Beta')
+
+
+def test_build_dashboard_context_workstream_fields(sample_workstreams, monkeypatch):
+    """Each workstream dict has the expected shape."""
+    # Freeze date.today() to one day after fixture dates so relative
+    # date formatting is deterministic regardless of when tests run.
+    from datetime import date as _date
+    class _FakeDate(_date):
+        @classmethod
+        def today(cls):
+            return _date(2026, 3, 28)
+    monkeypatch.setattr('workstream.web.date', _FakeDate)
+
+    ctx = build_dashboard_context(sample_workstreams)
+    active = ctx['status_groups'][0]['workstreams']
+    alpha = next(ws for ws in active if ws['title'] == 'Alpha')
+
+    assert alpha['id'] == 'ws-active-1'
+    assert alpha['status'] == 'active'
+    assert alpha['size'] == 'week'
+    assert alpha['tags'] == ['code', 'backend']
+    assert alpha['last_thread_date'] == 'yesterday'
+    assert alpha['last_thread_iso'] == '2026-03-27'
+    assert 'Made progress' in alpha['last_thread_body']
+    assert alpha['next_actions'] == ['Deploy v2']
+    assert len(alpha['plans']) == 1
+    assert alpha['plans'][0]['repo'] == 'myapp'
+    assert len(alpha['branches']) == 1
+    assert alpha['branches'][0]['ahead'] == 5
+
+
+def test_build_dashboard_context_snooze_reason(sample_workstreams):
+    """Snoozed workstreams include their snooze reason."""
+    ctx = build_dashboard_context(sample_workstreams)
+    snoozed_group = next(g for g in ctx['status_groups'] if g['status_label'] == 'Snoozed')
+    gamma = next(ws for ws in snoozed_group['workstreams'] if ws['title'] == 'Gamma')
+    assert gamma['snooze_reason'] == 'Waiting on feedback'
+
+
+# ── HTML rendering ───────────────────────────────────────────────────
+
+def test_render_dashboard_html(sample_workstreams):
+    """render_dashboard_html produces valid HTML with expected content."""
+    html = render_dashboard_html(sample_workstreams)
+
+    assert '<!doctype html>' in html
+    assert 'Workstreams Dashboard' in html
+
+    # Status badges
+    assert 'badge-active' in html
+    assert 'badge-snoozed' in html
+    assert 'badge-completed' in html
+
+    # Workstream titles
+    assert 'Alpha' in html
+    assert 'Beta' in html
+    assert 'Gamma' in html
+    assert 'Delta' in html
+    assert 'Epsilon' in html
+
+    # Thread content
+    assert 'Made progress' in html
+    assert 'Sketching design' in html
+
+    # Snooze reason
+    assert 'Waiting on feedback' in html
+
+    # Next actions
+    assert 'Deploy v2' in html
+
+    # Plans and branches
+    assert 'Alpha Plan' in html
+    assert 'feature/alpha' in html
+
+
+def test_render_dashboard_html_empty():
+    """Empty workstream list renders without error."""
+    html = render_dashboard_html([])
+    assert '<!doctype html>' in html
+    assert '0 workstreams' in html
+
+
+# ── File generation ──────────────────────────────────────────────────
+
+def test_generate_dashboard_file(tmp_path: Path, sample_workstreams):
+    """generate_dashboard_file writes dashboard.html to the target directory."""
+    out_path = generate_dashboard_file(tmp_path, sample_workstreams)
+
+    assert out_path == tmp_path / 'dashboard.html'
+    assert out_path.exists()
+
+    content = out_path.read_text(encoding='utf-8')
+    assert 'Workstreams Dashboard' in content
+    assert 'Alpha' in content
+
+
+# ── Clastic app ──────────────────────────────────────────────────────
+
+def test_create_app(tmp_path: Path, sample_workstreams):
+    """create_app returns a functioning WSGI application."""
+    from workstream.config import Config
+    from workstream.markdown import save_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+
+    # Save workstream files so the app can load them
+    for ws in sample_workstreams:
+        save_workstream(ws, ws_dir / ws.filename)
+
+    config = Config(workstreams_dir=str(ws_dir))
+
+    from workstream.web import create_app
+    app = create_app(config)
+
+    # Use clastic's local client
+    client = app.get_local_client()
+
+    # Test HTML route
+    resp = client.get('/')
+    assert resp.status_code == 200
+    assert b'Workstreams Dashboard' in resp.data
+    assert b'Alpha' in resp.data
+
+    # Test JSON route
+    resp_json = client.get('/json/')
+    assert resp_json.status_code == 200
+    import json
+    data = json.loads(resp_json.data)
+    assert data['total_count'] == 5
+    assert 'workstreams' in data
+
+
+
+def test_detail_view(tmp_path: Path, sample_workstreams):
+    """Detail route renders full workstream data."""
+    from workstream.config import Config
+    from workstream.markdown import save_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    for ws in sample_workstreams:
+        save_workstream(ws, ws_dir / ws.filename)
+
+    config = Config(workstreams_dir=str(ws_dir))
+
+    from workstream.web import create_app
+    app = create_app(config)
+    client = app.get_local_client()
+
+    # Get Alpha by ID
+    resp = client.get('/ws/ws-active-1/')
+    assert resp.status_code == 200
+    assert b'Alpha' in resp.data
+    assert b'Made progress' in resp.data
+    assert b'Deploy v2' in resp.data
+
+    # JSON detail
+    import json
+    resp_json = client.get('/ws/ws-active-1/json/')
+    data = json.loads(resp_json.data)
+    assert data['title'] == 'Alpha'
+    assert len(data['thread']) == 1
+    assert data['thread'][0]['date'] == '2026-03-27'
+
+
+def test_detail_view_not_found(tmp_path: Path):
+    """Invalid workstream ID returns error context."""
+    from workstream.config import Config
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+
+    config = Config(workstreams_dir=str(ws_dir))
+
+    from workstream.web import create_app
+    app = create_app(config)
+    client = app.get_local_client()
+
+    resp = client.get('/ws/nonexistent-id/')
+    assert resp.status_code == 200
+    assert b'not found' in resp.data.lower()
+
+
+# ── Idle text helper ──────────────────────────────────────────────────
+
+class TestFormatIdleText:
+    def test_zero_returns_empty(self):
+        assert _format_idle_text(0) == ''
+
+    def test_negative_returns_empty(self):
+        assert _format_idle_text(-1) == ''
+
+    def test_one_day(self):
+        assert _format_idle_text(1) == '1 day idle'
+
+    def test_days_under_two_weeks(self):
+        assert _format_idle_text(5) == '5 days idle'
+        assert _format_idle_text(13) == '13 days idle'
+
+    def test_weeks_range(self):
+        assert _format_idle_text(14) == '~2 weeks idle'
+        assert _format_idle_text(21) == '~3 weeks idle'
+        assert _format_idle_text(29) == '~4 weeks idle'
+
+    def test_months_range(self):
+        assert _format_idle_text(30) == '~1 months idle'
+        assert _format_idle_text(60) == '~2 months idle'
+        assert _format_idle_text(90) == '~3 months idle'
+
+
+class TestFormatRelativeDate:
+    def test_empty_returns_empty_pair(self):
+        assert _format_relative_date('') == ('', '')
+
+    def test_today(self):
+        from datetime import date
+        today = date.today().isoformat()
+        display, iso = _format_relative_date(today)
+        assert display == 'today'
+        assert iso == today
+
+    def test_yesterday(self):
+        from datetime import date, timedelta
+        d = (date.today() - timedelta(days=1)).isoformat()
+        display, iso = _format_relative_date(d)
+        assert display == 'yesterday'
+        assert iso == d
+
+    def test_n_days_ago(self):
+        from datetime import date, timedelta
+        d = (date.today() - timedelta(days=5)).isoformat()
+        display, iso = _format_relative_date(d)
+        assert display == '5 days ago'
+        assert iso == d
+
+    def test_exactly_seven_days_shows_relative(self):
+        from datetime import date, timedelta
+        d = (date.today() - timedelta(days=7)).isoformat()
+        display, iso = _format_relative_date(d)
+        assert display == '7 days ago'
+        assert iso == d
+
+    def test_eight_days_shows_date(self):
+        from datetime import date, timedelta
+        d = (date.today() - timedelta(days=8)).isoformat()
+        display, iso = _format_relative_date(d)
+        assert display == d    # absolute date
+        assert iso == d
+
+    def test_future_date_shows_date(self):
+        from datetime import date, timedelta
+        d = (date.today() + timedelta(days=3)).isoformat()
+        display, iso = _format_relative_date(d)
+        assert display == d
+        assert iso == d
+
+    def test_iso_is_always_raw_date(self):
+        """iso_title must always equal the raw input, regardless of display form."""
+        from datetime import date, timedelta
+        for days in [0, 1, 3, 7, 14, 60]:
+            d = (date.today() - timedelta(days=days)).isoformat()
+            _, iso = _format_relative_date(d)
+            assert iso == d
+
+    def test_just_now(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(seconds=30)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == 'just now'
+        assert iso == d
+
+    def test_minutes_ago(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(minutes=45)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == '45 minutes ago'
+        assert iso == d
+
+    def test_one_minute_ago(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(minutes=1)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == '1 minute ago'
+
+    def test_hours_ago(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(hours=3)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == '3 hours ago'
+        assert iso == d
+
+    def test_one_hour_ago(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(hours=1)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == '1 hour ago'
+
+    def test_datetime_yesterday(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(days=1, hours=2)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == 'yesterday'
+
+    def test_datetime_days_ago(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(days=5)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == '5 days ago'
+
+    def test_datetime_over_week_shows_date(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() - timedelta(days=10)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == d[:10]   # YYYY-MM-DD portion
+        assert iso == d
+
+    def test_datetime_future_shows_date(self):
+        from datetime import datetime, timedelta
+        d = (datetime.now() + timedelta(days=2)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == d[:10]
+
+    def test_datetime_near_future_shows_just_now(self):
+        """Small negative deltas (< 24h) are timezone skew, not real future."""
+        from datetime import datetime, timedelta
+        d = (datetime.now() + timedelta(hours=2)).isoformat(timespec='seconds')
+        display, iso = _format_relative_date(d)
+        assert display == 'just now'
+
+
+class TestIdleCssClass:
+    def test_fresh(self):
+        assert _idle_css_class(0) == ''
+        assert _idle_css_class(13) == ''
+
+    def test_warn(self):
+        assert _idle_css_class(14) == 'idle-warn'
+        assert _idle_css_class(29) == 'idle-warn'
+
+    def test_stale(self):
+        assert _idle_css_class(30) == 'idle-stale'
+        assert _idle_css_class(100) == 'idle-stale'
+
+
+# ── Nest group helper ─────────────────────────────────────────────────
+
+class TestNestGroup:
+    def test_flat_list_roots_only(self):
+        """All root items returned, each with empty children list."""
+        items = [
+            {'id': 'a', 'parent': '', 'title': 'A'},
+            {'id': 'b', 'parent': '', 'title': 'B'},
+        ]
+        result = _nest_group(items)
+        assert [d['id'] for d in result] == ['a', 'b']
+        assert all(d['children'] == [] for d in result)
+
+    def test_child_nested_inside_parent(self):
+        """Child appears in parent's children list, not in top-level result."""
+        items = [
+            {'id': 'parent', 'parent': '', 'title': 'Parent'},
+            {'id': 'child', 'parent': 'parent', 'title': 'Child'},
+        ]
+        result = _nest_group(items)
+        assert len(result) == 1
+        assert result[0]['id'] == 'parent'
+        assert len(result[0]['children']) == 1
+        assert result[0]['children'][0]['id'] == 'child'
+
+    def test_cross_group_parent_treated_as_root(self):
+        """A child whose parent is in a different status group appears as root."""
+        items = [
+            {'id': 'orphan', 'parent': 'not-in-group', 'title': 'Orphan'},
+        ]
+        result = _nest_group(items)
+        assert len(result) == 1
+        assert result[0]['id'] == 'orphan'
+        assert result[0]['children'] == []
+
+    def test_grandchild_nested(self):
+        """Grandchild nested inside child inside root."""
+        items = [
+            {'id': 'root', 'parent': '', 'title': 'Root'},
+            {'id': 'child', 'parent': 'root', 'title': 'Child'},
+            {'id': 'grandchild', 'parent': 'child', 'title': 'Grandchild'},
+        ]
+        result = _nest_group(items)
+        assert len(result) == 1
+        root = result[0]
+        assert root['id'] == 'root'
+        assert len(root['children']) == 1
+        child = root['children'][0]
+        assert child['id'] == 'child'
+        assert len(child['children']) == 1
+        assert child['children'][0]['id'] == 'grandchild'
+
+# ── Dashboard context: new fields ─────────────────────────────────────
+
+def test_dashboard_context_has_all_tags(sample_workstreams):
+    ctx = build_dashboard_context(sample_workstreams)
+    assert 'all_tags' in ctx
+    # sample tags: code, backend, business, foss
+    assert set(ctx['all_tags']) == {'code', 'backend', 'business', 'foss'}
+    # sorted
+    assert ctx['all_tags'] == sorted(ctx['all_tags'])
+
+
+def test_dashboard_context_active_tag_default(sample_workstreams):
+    ctx = build_dashboard_context(sample_workstreams)
+    assert ctx['active_tag'] == ''
+
+
+def test_dashboard_context_active_tag_set(sample_workstreams):
+    ctx = build_dashboard_context(sample_workstreams, active_tag='code')
+    assert ctx['active_tag'] == 'code'
+
+
+def test_dashboard_context_has_idle_text(sample_workstreams):
+    ctx = build_dashboard_context(sample_workstreams)
+    active_group = ctx['status_groups'][0]
+    for ws in active_group['workstreams']:
+        assert 'idle_text' in ws
+        assert 'idle_class' in ws
+
+
+def test_dashboard_context_nesting_fields(sample_workstreams):
+    """Every root workstream dict has a children key."""
+    ctx = build_dashboard_context(sample_workstreams)
+    for group in ctx['status_groups']:
+        for ws in group['workstreams']:
+            assert 'children' in ws
+
+# ── Tag route ─────────────────────────────────────────────────────────
+
+def test_tag_route(tmp_path: Path, sample_workstreams):
+    """The /tag/<name>/ route filters workstreams to those with the tag."""
+    from workstream.config import Config
+    from workstream.markdown import save_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    for ws in sample_workstreams:
+        save_workstream(ws, ws_dir / ws.filename)
+
+    config = Config(workstreams_dir=str(ws_dir))
+
+    from workstream.web import create_app
+    app = create_app(config)
+    client = app.get_local_client()
+
+    # 'code' tag is on Alpha, Beta, Epsilon
+    resp = client.get('/tag/code/')
+    assert resp.status_code == 200
+    assert b'Alpha' in resp.data
+    assert b'Beta' in resp.data
+    # Gamma has 'business' tag, not 'code'
+    assert b'Gamma' not in resp.data
+    # Should show active_tag in banner
+    assert b'#code' in resp.data
+
+
+def test_tag_route_empty(tmp_path: Path, sample_workstreams):
+    """Tag route with no matching workstreams returns empty dashboard."""
+    from workstream.config import Config
+    from workstream.markdown import save_workstream
+
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+    for ws in sample_workstreams:
+        save_workstream(ws, ws_dir / ws.filename)
+
+    config = Config(workstreams_dir=str(ws_dir))
+
+    from workstream.web import create_app
+    app = create_app(config)
+    client = app.get_local_client()
+
+    resp = client.get('/tag/nonexistent/')
+    assert resp.status_code == 200
+    assert b'0 workstreams' in resp.data
+
+
+def test_dashboard_html_has_clickable_tags(sample_workstreams):
+    """Rendered HTML contains tag links, not plain spans."""
+    html = render_dashboard_html(sample_workstreams)
+    assert '<a class="tag" href="/tag/code/">#code</a>' in html
+    assert '<span class="tag">' not in html
+
+
+def test_dashboard_html_has_inline_children(sample_workstreams):
+    """Parent card contains inline child rows; old indent class is gone."""
+    parent = _make_workstream(id='ws-parent', title='Parent WS', parent='')
+    child = _make_workstream(id='ws-child', title='Child WS', parent='ws-parent')
+    html = render_dashboard_html([parent, child])
+    assert 'ws-child-row' in html
+    assert 'ws-card-child' not in html