@theihtisham/dev-pulse 1.0.0

package/tests/test_api.py

@@ -0,0 +1,313 @@
+"""Tests for the FastAPI web API."""
+
+import json
+
+import pytest
+from httpx import AsyncClient, ASGITransport
+
+from devpulse.api.app import app
+
+
+@pytest.fixture
+def client(populated_db):
+    """Provide a test client with populated database."""
+    # Override DB in the app to use test DB
+    from devpulse.api import app as app_module
+
+    original_get_db = app_module._get_db
+    original_get_engine = app_module._get_engine
+    original_get_gen = app_module._get_report_gen
+
+    app_module._get_db = lambda: populated_db
+    app_module._get_engine = lambda: __import__("devpulse.core.analytics", fromlist=["AnalyticsEngine"]).AnalyticsEngine(db=populated_db)
+    app_module._get_report_gen = lambda: __import__("devpulse.core.report_generator", fromlist=["ReportGenerator"]).ReportGenerator(db=populated_db)
+
+    transport = ASGITransport(app=app)
+    yield AsyncClient(transport=transport, base_url="http://test")
+
+    app_module._get_db = original_get_db
+    app_module._get_engine = original_get_engine
+    app_module._get_gen = original_get_gen
+
+
+class TestHealthCheck:
+    """Test API health check endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_root(self, client):
+        async with client as c:
+            response = await c.get("/")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["name"] == "DevPulse API"
+        assert data["status"] == "healthy"
+        assert "version" in data
+
+
+class TestCommitEndpoints:
+    """Test commit API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_list_commits(self, client):
+        async with client as c:
+            response = await c.get("/api/commits")
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 4
+
+    @pytest.mark.asyncio
+    async def test_filter_commits_by_author(self, client):
+        async with client as c:
+            response = await c.get("/api/commits", params={"author": "Alice"})
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 3
+
+    @pytest.mark.asyncio
+    async def test_commit_heatmap(self, client):
+        async with client as c:
+            response = await c.get("/api/commits/heatmap", params={"days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) >= 0
+
+
+class TestPullRequestEndpoints:
+    """Test pull request API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_list_prs(self, client):
+        async with client as c:
+            response = await c.get("/api/pull-requests")
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 3
+
+    @pytest.mark.asyncio
+    async def test_filter_prs_by_state(self, client):
+        async with client as c:
+            response = await c.get("/api/pull-requests", params={"state": "merged"})
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 2
+
+
+class TestIssueEndpoints:
+    """Test issue API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_list_issues(self, client):
+        async with client as c:
+            response = await c.get("/api/issues")
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 3
+
+    @pytest.mark.asyncio
+    async def test_filter_issues_by_state(self, client):
+        async with client as c:
+            response = await c.get("/api/issues", params={"state": "open"})
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 2
+
+
+class TestMetricsEndpoints:
+    """Test metrics API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_developer_metrics(self, client):
+        async with client as c:
+            response = await c.get("/api/metrics/Alice", params={"days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["author"] == "Alice"
+        assert data["commits_count"] == 3
+
+    @pytest.mark.asyncio
+    async def test_team_metrics(self, client):
+        async with client as c:
+            response = await c.get("/api/metrics", params={"days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) >= 2
+
+
+class TestHealthEndpoint:
+    """Test team health API endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_team_health(self, client):
+        async with client as c:
+            response = await c.get("/api/health", params={"days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert "overall_score" in data
+        assert "burnout_risk" in data
+        assert "recommendations" in data
+
+
+class TestInsightsEndpoint:
+    """Test AI insights API endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_get_insights(self, client):
+        async with client as c:
+            response = await c.get("/api/insights", params={"days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert len(data) > 0
+        for insight in data:
+            assert "message" in insight
+            assert "recommendation" in insight
+
+
+class TestGoalEndpoints:
+    """Test goals API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_create_goal(self, client):
+        async with client as c:
+            response = await c.post("/api/goals", json={
+                "title": "Test goal",
+                "target_value": 10,
+                "metric": "commits_per_day",
+            })
+        assert response.status_code == 201
+        data = response.json()
+        assert data["title"] == "Test goal"
+
+    @pytest.mark.asyncio
+    async def test_list_goals(self, client):
+        async with client as c:
+            # Create first
+            await c.post("/api/goals", json={
+                "title": "Goal 1",
+                "target_value": 5,
+                "metric": "test",
+            })
+            # Then list
+            response = await c.get("/api/goals")
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) >= 1
+
+    @pytest.mark.asyncio
+    async def test_delete_goal(self, client):
+        async with client as c:
+            create = await c.post("/api/goals", json={
+                "title": "Delete me",
+                "target_value": 1,
+                "metric": "test",
+            })
+            goal_id = create.json()["id"]
+            response = await c.delete(f"/api/goals/{goal_id}")
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent_goal(self, client):
+        async with client as c:
+            response = await c.delete("/api/goals/99999")
+        assert response.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_goal_coaching(self, client):
+        async with client as c:
+            response = await c.get("/api/goals/coach")
+        assert response.status_code == 200
+
+
+class TestSprintEndpoints:
+    """Test sprint API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_create_sprint_snapshot(self, client):
+        async with client as c:
+            response = await c.post("/api/sprints/snapshot", json={
+                "sprint_name": "Sprint 1",
+                "total_points": 30,
+                "completed_points": 10,
+                "added_points": 0,
+            })
+        assert response.status_code == 201
+
+    @pytest.mark.asyncio
+    async def test_sprint_burndown(self, client):
+        async with client as c:
+            # Create snapshot first
+            await c.post("/api/sprints/snapshot", json={
+                "sprint_name": "Sprint B",
+                "total_points": 20,
+                "completed_points": 5,
+            })
+            response = await c.get("/api/sprints/Sprint B/burndown")
+        assert response.status_code == 200
+
+
+class TestQualityEndpoints:
+    """Test code quality API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_create_quality_snapshot(self, client):
+        async with client as c:
+            response = await c.post("/api/quality/snapshot", json={
+                "repo": "testorg/testrepo",
+                "test_coverage": 0.85,
+                "open_bugs": 3,
+                "tech_debt_score": 4.2,
+            })
+        assert response.status_code == 201
+
+    @pytest.mark.asyncio
+    async def test_quality_trends(self, client):
+        async with client as c:
+            response = await c.get("/api/quality", params={"days": 90})
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_quality_score(self, client):
+        async with client as c:
+            response = await c.get("/api/quality/score", params={"repo": "testorg/testrepo", "days": 30})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["repo"] == "testorg/testrepo"
+
+
+class TestReportEndpoints:
+    """Test report generation API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_daily_report_json(self, client):
+        async with client as c:
+            response = await c.get("/api/reports/daily", params={"date": "2026-04-01"})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["date"] == "2026-04-01"
+
+    @pytest.mark.asyncio
+    async def test_daily_report_markdown(self, client):
+        async with client as c:
+            response = await c.get("/api/reports/daily", params={"date": "2026-04-01", "format": "markdown"})
+        assert response.status_code == 200
+        data = response.json()
+        assert "markdown" in data
+
+    @pytest.mark.asyncio
+    async def test_daily_report_html(self, client):
+        async with client as c:
+            response = await c.get("/api/reports/daily", params={"date": "2026-04-01", "format": "html"})
+        assert response.status_code == 200
+        assert "<!DOCTYPE html>" in response.text
+
+    @pytest.mark.asyncio
+    async def test_weekly_report(self, client):
+        async with client as c:
+            response = await c.get("/api/reports/weekly", params={"week_start": "2026-03-30"})
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_monthly_report(self, client):
+        async with client as c:
+            response = await c.get("/api/reports/monthly", params={"year": 2026, "month": 4})
+        assert response.status_code == 200

package/tests/test_cli.py

@@ -0,0 +1,204 @@
+"""Tests for CLI commands."""
+
+import json
+from unittest.mock import patch, MagicMock
+
+import pytest
+from click.testing import CliRunner
+
+from devpulse.cli.main import cli
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+class TestCLIBase:
+    """Test CLI base commands."""
+
+    def test_version(self, runner):
+        result = runner.invoke(cli, ["--version"])
+        assert result.exit_code == 0
+        assert "1.0.0" in result.output
+
+    def test_help(self, runner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "DevPulse" in result.output
+        assert "sync" in result.output
+        assert "daily" in result.output
+        assert "metrics" in result.output
+
+
+class TestSyncCommand:
+    """Test sync command (without actual GitHub)."""
+
+    def test_sync_no_token(self, runner, monkeypatch):
+        monkeypatch.delenv("DEVPULSE_GITHUB_TOKEN", raising=False)
+        monkeypatch.setenv("DEVPULSE_GITHUB_TOKEN", "")
+        from devpulse.core.config import reset_settings
+        reset_settings()
+
+        result = runner.invoke(cli, ["sync"])
+        assert result.exit_code != 0 or "DEVPULSE_GITHUB_TOKEN" in result.output
+
+
+class TestReportCommands:
+    """Test report generation CLI commands."""
+
+    def test_daily_report_terminal(self, runner, populated_db):
+        with patch("devpulse.core.report_generator.ReportGenerator", return_value=MagicMock(
+            daily_report=MagicMock(return_value={
+                "date": "2026-04-01",
+                "author": "all",
+                "commits": 2,
+                "prs_opened": 0,
+                "prs_merged": 0,
+                "issues_opened": 0,
+                "issues_closed": 0,
+                "reviews_given": 0,
+                "lines_changed": 80,
+                "summary": "2 commit(s)",
+                "commit_details": [],
+            }),
+        )):
+            result = runner.invoke(cli, ["daily", "--date", "2026-04-01"])
+            # Should not crash (may print to console)
+
+    def test_daily_report_json(self, runner, populated_db):
+        with patch("devpulse.core.report_generator.ReportGenerator", return_value=MagicMock(
+            daily_report=MagicMock(return_value={
+                "date": "2026-04-01",
+                "author": "all",
+                "commits": 2,
+                "prs_opened": 0,
+                "prs_merged": 0,
+                "issues_opened": 0,
+                "issues_closed": 0,
+                "reviews_given": 0,
+                "lines_changed": 80,
+                "summary": "2 commits",
+                "commit_details": [],
+            }),
+            to_json=MagicMock(return_value='{"date": "2026-04-01"}'),
+        )):
+            result = runner.invoke(cli, ["daily", "--format", "json"])
+            # Should output JSON
+
+    def test_weekly_report_help(self, runner):
+        result = runner.invoke(cli, ["weekly", "--help"])
+        assert result.exit_code == 0
+        assert "--week-start" in result.output
+
+    def test_monthly_report_help(self, runner):
+        result = runner.invoke(cli, ["monthly", "--help"])
+        assert result.exit_code == 0
+        assert "--year" in result.output
+
+
+class TestMetricsCommand:
+    """Test metrics CLI commands."""
+
+    def test_metrics_help(self, runner):
+        result = runner.invoke(cli, ["metrics", "--help"])
+        assert result.exit_code == 0
+        assert "--author" in result.output
+        assert "--days" in result.output
+
+
+class TestInsightsCommand:
+    """Test insights CLI command."""
+
+    def test_insights_help(self, runner):
+        result = runner.invoke(cli, ["insights", "--help"])
+        assert result.exit_code == 0
+        assert "--days" in result.output
+
+
+class TestHealthCommand:
+    """Test health CLI command."""
+
+    def test_health_help(self, runner):
+        result = runner.invoke(cli, ["health", "--help"])
+        assert result.exit_code == 0
+        assert "--days" in result.output
+
+
+class TestHeatmapCommand:
+    """Test heatmap CLI command."""
+
+    def test_heatmap_help(self, runner):
+        result = runner.invoke(cli, ["heatmap", "--help"])
+        assert result.exit_code == 0
+        assert "--author" in result.output
+        assert "--days" in result.output
+
+
+class TestGoalsCommands:
+    """Test goals CLI commands."""
+
+    def test_goals_help(self, runner):
+        result = runner.invoke(cli, ["goals", "--help"])
+        assert result.exit_code == 0
+
+    def test_goals_add_help(self, runner):
+        result = runner.invoke(cli, ["goals", "add", "--help"])
+        assert result.exit_code == 0
+        assert "--title" in result.output
+
+    def test_goals_list_help(self, runner):
+        result = runner.invoke(cli, ["goals", "list", "--help"])
+        assert result.exit_code == 0
+
+    def test_goals_coach_help(self, runner):
+        result = runner.invoke(cli, ["goals", "coach", "--help"])
+        assert result.exit_code == 0
+
+
+class TestSprintCommands:
+    """Test sprint CLI commands."""
+
+    def test_sprint_help(self, runner):
+        result = runner.invoke(cli, ["sprint", "--help"])
+        assert result.exit_code == 0
+
+    def test_sprint_snapshot_help(self, runner):
+        result = runner.invoke(cli, ["sprint", "snapshot", "--help"])
+        assert result.exit_code == 0
+        assert "--name" in result.output
+
+    def test_sprint_burndown_help(self, runner):
+        result = runner.invoke(cli, ["sprint", "burndown", "--help"])
+        assert result.exit_code == 0
+
+    def test_sprint_predict_help(self, runner):
+        result = runner.invoke(cli, ["sprint", "predict", "--help"])
+        assert result.exit_code == 0
+
+
+class TestQualityCommand:
+    """Test quality CLI command."""
+
+    def test_quality_help(self, runner):
+        result = runner.invoke(cli, ["quality", "--help"])
+        assert result.exit_code == 0
+        assert "--repo" in result.output
+
+
+class TestServeCommand:
+    """Test serve CLI command."""
+
+    def test_serve_help(self, runner):
+        result = runner.invoke(cli, ["serve", "--help"])
+        assert result.exit_code == 0
+        assert "--port" in result.output
+
+
+class TestDashboardCommand:
+    """Test dashboard CLI command."""
+
+    def test_dashboard_help(self, runner):
+        result = runner.invoke(cli, ["dashboard", "--help"])
+        assert result.exit_code == 0
+        assert "--author" in result.output

package/tests/test_config.py

@@ -0,0 +1,47 @@
+"""Tests for configuration management."""
+
+import os
+import pytest
+
+from devpulse.core.config import Settings, get_settings, reset_settings
+
+
+class TestSettings:
+    """Test settings loading."""
+
+    def test_default_settings(self):
+        reset_settings()
+        # Create Settings directly to check defaults (env vars are set by conftest)
+        s = Settings(github_token="", github_username="")
+        assert s.api_port == 8742
+        assert s.log_level == "INFO"
+        assert s.redact_sensitive is True
+
+    def test_env_override(self, monkeypatch):
+        reset_settings()
+        monkeypatch.setenv("DEVPULSE_GITHUB_TOKEN", "ghp_test123")
+        monkeypatch.setenv("DEVPULSE_API_PORT", "9999")
+        settings = Settings()
+        assert settings.github_token == "ghp_test123"
+        assert settings.api_port == 9999
+
+    def test_get_settings_caches(self):
+        reset_settings()
+        s1 = get_settings()
+        s2 = get_settings()
+        assert s1 is s2
+
+    def test_reset_settings(self):
+        reset_settings()
+        s1 = get_settings()
+        reset_settings()
+        s2 = get_settings()
+        assert s1 is not s2
+
+    def test_database_path_default(self):
+        settings = Settings()
+        assert "devpulse.db" in settings.database_path
+
+    def test_burnout_threshold(self):
+        settings = Settings()
+        assert 0 < settings.burnout_threshold < 1