@theihtisham/dev-pulse 1.0.0

package/tests/test_database.py

@@ -0,0 +1,255 @@
+"""Tests for the Database layer."""
+
+import json
+from datetime import datetime
+
+import pytest
+
+from devpulse.core.database import Database
+
+
+class TestDatabaseInit:
+    """Test database initialization."""
+
+    def test_creates_tables(self, db):
+        """Database should initialize with all required tables."""
+        conn = db._connect()
+        tables = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+        ).fetchall()
+        table_names = {t["name"] for t in tables}
+        conn.close()
+
+        expected = {
+            "commits", "pull_requests", "issues", "reviews",
+            "goals", "reports", "sprint_snapshots", "code_quality",
+        }
+        assert expected.issubset(table_names), f"Missing tables: {expected - table_names}"
+
+    def test_idempotent_init(self, db):
+        """Running _init_db twice should not fail."""
+        db._init_db()
+        db._init_db()  # Should not raise
+
+
+class TestCommitOperations:
+    """Test commit CRUD operations."""
+
+    def test_insert_and_retrieve_commits(self, db, sample_commits):
+        count = db.upsert_commits(sample_commits)
+        assert count == 4
+
+        commits = db.get_commits()
+        assert len(commits) == 4
+
+    def test_upsert_commits_idempotent(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        # Re-upserting same data should not duplicate rows
+        db.upsert_commits(sample_commits)
+
+        commits = db.get_commits()
+        assert len(commits) == 4  # No duplicates
+
+    def test_filter_by_repo(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        commits = db.get_commits(repo="testorg/testrepo")
+        assert len(commits) == 4
+
+        commits = db.get_commits(repo="nonexistent/repo")
+        assert len(commits) == 0
+
+    def test_filter_by_author(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        alice = db.get_commits(author="Alice")
+        assert len(alice) == 3
+
+        bob = db.get_commits(author="Bob")
+        assert len(bob) == 1
+
+    def test_filter_by_date_range(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        commits = db.get_commits(since="2026-04-02", until="2026-04-02")
+        assert len(commits) == 1
+        assert commits[0]["author"] == "Bob"
+
+    def test_commit_count_by_day(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        counts = db.get_commit_count_by_day(days=30)
+        assert len(counts) == 3  # 3 unique dates
+        # April 1 should have 2 commits
+        apr1 = [c for c in counts if c["day"] == "2026-04-01"]
+        assert len(apr1) == 1
+        assert apr1[0]["count"] == 2
+
+    def test_commit_limit(self, db, sample_commits):
+        db.upsert_commits(sample_commits)
+        commits = db.get_commits(limit=2)
+        assert len(commits) == 2
+
+
+class TestPullRequestOperations:
+    """Test pull request CRUD operations."""
+
+    def test_insert_and_retrieve_prs(self, db, sample_prs):
+        count = db.upsert_pull_requests(sample_prs)
+        assert count == 3
+
+        prs = db.get_pull_requests()
+        assert len(prs) == 3
+
+    def test_filter_prs_by_state(self, db, sample_prs):
+        db.upsert_pull_requests(sample_prs)
+        merged = db.get_pull_requests(state="merged")
+        assert len(merged) == 2
+
+    def test_filter_prs_by_author(self, db, sample_prs):
+        db.upsert_pull_requests(sample_prs)
+        alice = db.get_pull_requests(author="Alice")
+        assert len(alice) == 2
+
+
+class TestIssueOperations:
+    """Test issue CRUD operations."""
+
+    def test_insert_and_retrieve_issues(self, db, sample_issues):
+        count = db.upsert_issues(sample_issues)
+        assert count == 3
+
+        issues = db.get_issues()
+        assert len(issues) == 3
+
+    def test_filter_issues_by_state(self, db, sample_issues):
+        db.upsert_issues(sample_issues)
+        open_issues = db.get_issues(state="open")
+        assert len(open_issues) == 2
+
+        closed_issues = db.get_issues(state="closed")
+        assert len(closed_issues) == 1
+
+    def test_issue_labels_stored_as_json(self, db, sample_issues):
+        db.upsert_issues(sample_issues)
+        issues = db.get_issues()
+        bug_issue = [i for i in issues if i["number"] == 12][0]
+        labels = json.loads(bug_issue["labels"])
+        assert "bug" in labels
+        assert "priority:high" in labels
+
+
+class TestReviewOperations:
+    """Test review CRUD operations."""
+
+    def test_insert_and_retrieve_reviews(self, db, sample_reviews):
+        count = db.upsert_reviews(sample_reviews)
+        assert count == 2
+
+        reviews = db.get_reviews()
+        assert len(reviews) == 2
+
+    def test_filter_reviews_by_author(self, db, sample_reviews):
+        db.upsert_reviews(sample_reviews)
+        bob_reviews = db.get_reviews(author="Bob")
+        assert len(bob_reviews) == 1
+        assert bob_reviews[0]["state"] == "APPROVED"
+
+
+class TestGoalOperations:
+    """Test goal CRUD operations."""
+
+    def test_create_and_list_goals(self, db):
+        gid = db.upsert_goal({
+            "title": "10 commits/day",
+            "target_value": 10,
+            "metric": "commits_per_day",
+            "deadline": "2026-05-01",
+        })
+        assert isinstance(gid, int)
+        assert gid > 0
+
+        goals = db.get_goals()
+        assert len(goals) == 1
+        assert goals[0]["title"] == "10 commits/day"
+
+    def test_update_goal(self, db):
+        gid = db.upsert_goal({
+            "title": "10 commits/day",
+            "target_value": 10,
+            "metric": "commits_per_day",
+        })
+        db.upsert_goal({
+            "id": gid,
+            "title": "10 commits/day",
+            "target_value": 10,
+            "current_value": 5,
+            "metric": "commits_per_day",
+        })
+
+        goals = db.get_goals()
+        assert goals[0]["current_value"] == 5
+
+    def test_delete_goal(self, db):
+        gid = db.upsert_goal({
+            "title": "Test goal",
+            "target_value": 5,
+            "metric": "test",
+        })
+        assert db.delete_goal(gid) is True
+        assert db.delete_goal(9999) is False  # Non-existent
+
+    def test_filter_goals_by_status(self, db):
+        db.upsert_goal({"title": "Active", "target_value": 5, "metric": "test", "status": "active"})
+        db.upsert_goal({"title": "Done", "target_value": 5, "metric": "test", "status": "completed"})
+
+        active = db.get_goals(status="active")
+        assert len(active) == 1
+        assert active[0]["title"] == "Active"
+
+
+class TestReportCache:
+    """Test report caching."""
+
+    def test_save_and_get_report(self, db):
+        db.save_report("daily", "2026-04-01", "# Daily Report\nContent here")
+        content = db.get_report("daily", "2026-04-01")
+        assert content is not None
+        assert "Daily Report" in content
+
+    def test_get_nonexistent_report(self, db):
+        content = db.get_report("daily", "1999-01-01")
+        assert content is None
+
+    def test_overwrite_report(self, db):
+        db.save_report("daily", "2026-04-01", "Version 1")
+        db.save_report("daily", "2026-04-01", "Version 2")
+        content = db.get_report("daily", "2026-04-01")
+        assert "Version 2" in content
+
+
+class TestSprintSnapshots:
+    """Test sprint snapshot operations."""
+
+    def test_save_and_get_snapshots(self, db):
+        db.save_sprint_snapshot({
+            "sprint_name": "Sprint 1",
+            "total_points": 30,
+            "completed_points": 10,
+            "remaining_points": 20,
+            "added_points": 0,
+        })
+        snapshots = db.get_sprint_snapshots("Sprint 1")
+        assert len(snapshots) == 1
+        assert snapshots[0]["total_points"] == 30
+
+
+class TestCodeQuality:
+    """Test code quality snapshot operations."""
+
+    def test_save_and_get_quality(self, db):
+        db.save_quality_snapshot({
+            "repo": "testorg/testrepo",
+            "test_coverage": 0.85,
+            "open_bugs": 3,
+            "tech_debt_score": 4.2,
+        })
+        snapshots = db.get_quality_snapshots(repo="testorg/testrepo")
+        assert len(snapshots) == 1
+        assert snapshots[0]["test_coverage"] == 0.85

package/tests/test_models.py

@@ -0,0 +1,107 @@
+"""Tests for Pydantic models."""
+
+import pytest
+
+from devpulse.core.models import (
+    Commit,
+    PullRequest,
+    Issue,
+    Review,
+    DeveloperMetrics,
+    SprintData,
+    TeamHealth,
+    CodeQuality,
+    Goal,
+    DailyReport,
+    WeeklyReport,
+)
+
+
+class TestCommit:
+    def test_create_commit(self):
+        c = Commit(sha="abc123", repo="org/repo", author="Alice", author_date="2026-04-01T10:00:00Z")
+        assert c.sha == "abc123"
+        assert c.additions == 0
+
+    def test_commit_defaults(self):
+        c = Commit(sha="abc", repo="r", author="a", author_date="d")
+        assert c.message == ""
+        assert c.url == ""
+
+
+class TestPullRequest:
+    def test_create_pr(self):
+        pr = PullRequest(number=1, repo="org/repo")
+        assert pr.state == "open"
+        assert pr.merged_at is None
+
+    def test_pr_with_merge(self):
+        pr = PullRequest(number=1, repo="org/repo", state="merged", merged_at="2026-04-02")
+        assert pr.state == "merged"
+
+
+class TestIssue:
+    def test_create_issue(self):
+        issue = Issue(number=10, repo="org/repo")
+        assert issue.labels == []
+        assert issue.state == "open"
+
+
+class TestDeveloperMetrics:
+    def test_create_metrics(self):
+        m = DeveloperMetrics(author="Alice")
+        assert m.commits_count == 0
+        assert m.avg_pr_merge_time_hours == 0.0
+
+    def test_metrics_serialization(self):
+        m = DeveloperMetrics(author="Bob", commits_count=5, active_days=3)
+        d = m.model_dump()
+        assert d["author"] == "Bob"
+        assert d["commits_count"] == 5
+
+
+class TestTeamHealth:
+    def test_create_team_health(self):
+        th = TeamHealth()
+        assert th.overall_score == 0.0
+        assert th.recommendations == []
+
+    def test_team_health_with_burnout(self):
+        th = TeamHealth(
+            overall_score=75.5,
+            burnout_risk={"Alice": 0.3, "Bob": 0.7},
+            velocity_trend="stable",
+        )
+        assert th.burnout_risk["Bob"] == 0.7
+
+
+class TestGoal:
+    def test_create_goal(self):
+        g = Goal(title="Test", target_value=10, metric="commits")
+        assert g.id is None
+        assert g.status == "active"
+
+    def test_goal_with_id(self):
+        g = Goal(id=1, title="Test", target_value=10, metric="commits")
+        assert g.id == 1
+
+
+class TestSprintData:
+    def test_create_sprint(self):
+        s = SprintData(name="Sprint 1")
+        assert s.total_points == 0
+        assert s.scope_creep_pct == 0
+
+
+class TestDailyReport:
+    def test_create_daily_report(self):
+        r = DailyReport(date="2026-04-01", author="Alice")
+        assert r.commits == 0
+        assert r.summary == ""
+
+
+class TestWeeklyReport:
+    def test_create_weekly_report(self):
+        r = WeeklyReport(week_start="2026-04-01", week_end="2026-04-07")
+        assert r.total_commits == 0
+        assert r.insights == []

package/tests/test_report_generator.py

@@ -0,0 +1,173 @@
+"""Tests for the ReportGenerator."""
+
+import json
+import os
+
+import pytest
+
+from devpulse.core.report_generator import ReportGenerator, _md_to_html
+
+
+class TestDailyReport:
+    """Test daily report generation."""
+
+    def test_daily_report_basic(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.daily_report(target_date="2026-04-01")
+
+        assert report["date"] == "2026-04-01"
+        assert report["commits"] == 2  # Alice's 2 commits on April 1
+        assert report["prs_opened"] >= 0
+        assert "summary" in report
+
+    def test_daily_report_with_author(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.daily_report(target_date="2026-04-01", author="Alice")
+
+        assert report["author"] == "Alice"
+        assert report["commits"] == 2
+
+    def test_daily_report_no_activity(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.daily_report(target_date="2020-01-01")
+
+        assert report["commits"] == 0
+        assert report["summary"]  # Should still have a summary
+
+
+class TestWeeklyReport:
+    """Test weekly report generation."""
+
+    def test_weekly_report_basic(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.weekly_report(week_start="2026-03-30")
+
+        assert report["week_start"] == "2026-03-30"
+        assert report["week_end"] == "2026-04-05"
+        assert report["total_commits"] >= 0
+        assert isinstance(report["top_contributors"], list)
+
+    def test_weekly_report_has_insights(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.weekly_report(week_start="2026-03-30")
+
+        assert isinstance(report["insights"], list)
+        assert isinstance(report["recommendations"], list)
+
+
+class TestMonthlyReport:
+    """Test monthly report generation."""
+
+    def test_monthly_report_basic(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.monthly_report(year=2026, month=4)
+
+        assert report["period"] == "2026-04"
+        assert report["total_commits"] >= 0
+        assert "team_health_score" in report
+        assert "velocity_trend" in report
+
+    def test_monthly_report_default_period(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        report = gen.monthly_report()
+
+        assert len(report["period"]) == 7  # YYYY-MM format
+
+
+class TestOutputFormats:
+    """Test report output format conversions."""
+
+    def test_to_markdown_daily(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        md = gen.to_markdown(data, "daily")
+
+        assert "# Daily Report" in md
+        assert "2026-04-01" in md
+        assert "## Metrics" in md
+
+    def test_to_markdown_weekly(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.weekly_report(week_start="2026-03-30")
+        md = gen.to_markdown(data, "weekly")
+
+        assert "# Weekly Report" in md
+        assert "Top Contributors" in md
+
+    def test_to_markdown_monthly(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.monthly_report(year=2026, month=4)
+        md = gen.to_markdown(data, "monthly")
+
+        assert "# Monthly Report" in md
+        assert "Team Health Score" in md
+
+    def test_to_json(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        j = gen.to_json(data)
+
+        parsed = json.loads(j)
+        assert parsed["date"] == "2026-04-01"
+
+    def test_to_html(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        html = gen.to_html(data, "daily")
+
+        assert "<!DOCTYPE html>" in html
+        assert "DevPulse" in html
+        assert "<table>" in html or "<h1>" in html
+
+
+class TestMdToHtml:
+    """Test the markdown-to-HTML converter."""
+
+    def test_headers(self):
+        html = _md_to_html("# Title\n## Subtitle")
+        assert "<h1>Title</h1>" in html
+        assert "<h2>Subtitle</h2>" in html
+
+    def test_list_items(self):
+        html = _md_to_html("- Item 1\n- Item 2")
+        assert "<ul>" in html
+        assert "<li>" in html
+        assert "Item 1" in html
+
+    def test_bold_text(self):
+        html = _md_to_html("- **Bold** text")
+        assert "<strong>Bold</strong>" in html
+
+
+class TestSaveReport:
+    """Test report file saving."""
+
+    def test_save_markdown_report(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        path = gen.save_report(data, "daily", "markdown")
+
+        assert os.path.exists(path)
+        assert path.endswith(".md")
+        with open(path) as f:
+            content = f.read()
+        assert "Daily Report" in content
+
+    def test_save_json_report(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        path = gen.save_report(data, "daily", "json")
+
+        assert os.path.exists(path)
+        assert path.endswith(".json")
+
+    def test_save_html_report(self, populated_db):
+        gen = ReportGenerator(db=populated_db)
+        data = gen.daily_report(target_date="2026-04-01")
+        path = gen.save_report(data, "daily", "html")
+
+        assert os.path.exists(path)
+        assert path.endswith(".html")
+        with open(path) as f:
+            content = f.read()
+        assert "<!DOCTYPE html>" in content