mdan-cli 2.5.1 → 2.5.2

package/tests/scenarios/mmm/dev.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the Dev agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.dev.agent import Dev
+
+
+async def test_dev_feature_implementation():
+    """Test feature implementation capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Implement a user authentication feature with login and registration"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "implement" in result.lower() or "code" in result.lower()
+    print("✓ test_dev_feature_implementation passed")
+
+
+async def test_dev_bug_fixing():
+    """Test bug fixing capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Fix a bug where the application crashes when uploading large files"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "fix" in result.lower() or "bug" in result.lower()
+    print("✓ test_dev_bug_fixing passed")
+
+
+async def test_dev_code_refactoring():
+    """Test code refactoring capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Refactor a monolithic user service into smaller, more maintainable modules"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "refactor" in result.lower() or "improve" in result.lower()
+    print("✓ test_dev_code_refactoring passed")
+
+
+async def test_dev_api_development():
+    """Test API development capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Develop RESTful API endpoints for managing products in an e-commerce system"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "api" in result.lower() or "endpoint" in result.lower()
+    print("✓ test_dev_api_development passed")
+
+
+async def test_dev_database_integration():
+    """Test database integration capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Integrate PostgreSQL database with a Node.js application using Prisma ORM"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "database" in result.lower() or "integration" in result.lower()
+    print("✓ test_dev_database_integration passed")
+
+
+async def test_dev_testing():
+    """Test testing capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Write unit tests for a user service with authentication and authorization"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "test" in result.lower() or "testing" in result.lower()
+    print("✓ test_dev_testing passed")
+
+
+async def test_dev_code_review():
+    """Test code review capability."""
+    agent = Dev()
+
+    result = await agent.process(
+        "Review a pull request for a new feature and provide feedback on code quality and best practices"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "review" in result.lower() or "feedback" in result.lower()
+    print("✓ test_dev_code_review passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Dev agent scenario tests...\n")
+
+    tests = [
+        test_dev_feature_implementation,
+        test_dev_bug_fixing,
+        test_dev_code_refactoring,
+        test_dev_api_development,
+        test_dev_database_integration,
+        test_dev_testing,
+        test_dev_code_review,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Dev agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/pm.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the PM agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.pm.agent import PM
+
+
+async def test_pm_project_planning():
+    """Test project planning capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Create a project plan for building a mobile banking application with a 6-month timeline"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "project" in result.lower() or "plan" in result.lower()
+    print("✓ test_pm_project_planning passed")
+
+
+async def test_pm_backlog_management():
+    """Test backlog management capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Organize and prioritize the product backlog for an e-commerce platform"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "backlog" in result.lower() or "priorit" in result.lower()
+    print("✓ test_pm_backlog_management passed")
+
+
+async def test_pm_sprint_planning():
+    """Test sprint planning capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Plan a 2-week sprint for a development team working on a task management application"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "sprint" in result.lower() or "iteration" in result.lower()
+    print("✓ test_pm_sprint_planning passed")
+
+
+async def test_pm_stakeholder_communication():
+    """Test stakeholder communication capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Prepare a status report for stakeholders on the progress of a healthcare system project"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "stakeholder" in result.lower() or "report" in result.lower()
+    print("✓ test_pm_stakeholder_communication passed")
+
+
+async def test_pm_risk_management():
+    """Test risk management capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Identify and mitigate risks for a critical financial system migration project"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "risk" in result.lower() or "mitigat" in result.lower()
+    print("✓ test_pm_risk_management passed")
+
+
+async def test_pm_resource_allocation():
+    """Test resource allocation capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Allocate resources for a team of 8 developers working on multiple concurrent projects"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "resource" in result.lower() or "team" in result.lower()
+    print("✓ test_pm_resource_allocation passed")
+
+
+async def test_pm_roadmap_creation():
+    """Test roadmap creation capability."""
+    agent = PM()
+
+    result = await agent.process(
+        "Create a product roadmap for a SaaS platform for the next 12 months"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "roadmap" in result.lower() or "timeline" in result.lower()
+    print("✓ test_pm_roadmap_creation passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running PM agent scenario tests...\n")
+
+    tests = [
+        test_pm_project_planning,
+        test_pm_backlog_management,
+        test_pm_sprint_planning,
+        test_pm_stakeholder_communication,
+        test_pm_risk_management,
+        test_pm_resource_allocation,
+        test_pm_roadmap_creation,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll PM agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/qa.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the QA agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.qa.agent import QA
+
+
+async def test_qa_test_plan_creation():
+    """Test test plan creation capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Create a comprehensive test plan for a user authentication system"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "test plan" in result.lower() or "testing" in result.lower()
+    print("✓ test_qa_test_plan_creation passed")
+
+
+async def test_qa_test_case_design():
+    """Test test case design capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Design test cases for a shopping cart feature with various edge cases"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "test case" in result.lower() or "scenario" in result.lower()
+    print("✓ test_qa_test_case_design passed")
+
+
+async def test_qa_automated_testing():
+    """Test automated testing capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Create automated tests for a REST API using Cypress or Playwright"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "automated" in result.lower() or "automation" in result.lower()
+    print("✓ test_qa_automated_testing passed")
+
+
+async def test_qa_bug_reporting():
+    """Test bug reporting capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Report a bug found during testing with detailed steps to reproduce"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "bug" in result.lower() or "issue" in result.lower()
+    print("✓ test_qa_bug_reporting passed")
+
+
+async def test_qa_regression_testing():
+    """Test regression testing capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Design a regression testing strategy for a major application update"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "regression" in result.lower() or "regress" in result.lower()
+    print("✓ test_qa_regression_testing passed")
+
+
+async def test_qa_performance_testing():
+    """Test performance testing capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Design performance tests for a high-traffic e-commerce website"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "performance" in result.lower() or "load" in result.lower()
+    print("✓ test_qa_performance_testing passed")
+
+
+async def test_qa_security_testing():
+    """Test security testing capability."""
+    agent = QA()
+
+    result = await agent.process(
+        "Design security tests for a financial application handling sensitive data"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "security" in result.lower() or "vulnerability" in result.lower()
+    print("✓ test_qa_security_testing passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running QA agent scenario tests...\n")
+
+    tests = [
+        test_qa_test_plan_creation,
+        test_qa_test_case_design,
+        test_qa_automated_testing,
+        test_qa_bug_reporting,
+        test_qa_regression_testing,
+        test_qa_performance_testing,
+        test_qa_security_testing,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll QA agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/quick-flow-solo-dev.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the Quick Flow Solo Dev agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.quick_flow_solo_dev.agent import QuickFlowSoloDev
+
+
+async def test_quick_flow_full_feature():
+    """Test full feature development capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Build a complete user authentication feature with login, registration, and password reset"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "feature" in result.lower() or "implement" in result.lower()
+    print("✓ test_quick_flow_full_feature passed")
+
+
+async def test_quick_flow_rapid_prototyping():
+    """Test rapid prototyping capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Create a quick prototype for a dashboard with charts and data visualization"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "prototype" in result.lower() or "dashboard" in result.lower()
+    print("✓ test_quick_flow_rapid_prototyping passed")
+
+
+async def test_quick_flow_mvp_development():
+    """Test MVP development capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Build an MVP for a task management application with basic CRUD operations"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "mvp" in result.lower() or "minimum viable" in result.lower()
+    print("✓ test_quick_flow_mvp_development passed")
+
+
+async def test_quick_flow_end_to_end():
+    """Test end-to-end development capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Develop a complete blog application from backend to frontend with authentication"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "end-to-end" in result.lower() or "complete" in result.lower()
+    print("✓ test_quick_flow_end_to_end passed")
+
+
+async def test_quick_flow_bug_fixing():
+    """Test quick bug fixing capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Quickly fix a critical bug preventing users from logging in to the application"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "fix" in result.lower() or "bug" in result.lower()
+    print("✓ test_quick_flow_bug_fixing passed")
+
+
+async def test_quick_flow_feature_iteration():
+    """Test feature iteration capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Iterate on an existing feature to add new functionality based on user feedback"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "iterate" in result.lower() or "improve" in result.lower()
+    print("✓ test_quick_flow_feature_iteration passed")
+
+
+async def test_quick_flow_deployment():
+    """Test deployment capability."""
+    agent = QuickFlowSoloDev()
+
+    result = await agent.process(
+        "Prepare and deploy a web application to production with proper configuration"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "deploy" in result.lower() or "production" in result.lower()
+    print("✓ test_quick_flow_deployment passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Quick Flow Solo Dev agent scenario tests...\n")
+
+    tests = [
+        test_quick_flow_full_feature,
+        test_quick_flow_rapid_prototyping,
+        test_quick_flow_mvp_development,
+        test_quick_flow_end_to_end,
+        test_quick_flow_bug_fixing,
+        test_quick_flow_feature_iteration,
+        test_quick_flow_deployment,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Quick Flow Solo Dev agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/tests/scenarios/mmm/sm.test.py

@@ -0,0 +1,138 @@
+"""Scenario tests for the Scrum Master agent."""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the app directory to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "app"))
+
+from mmm.agents.sm.agent import SM
+
+
+async def test_sm_sprint_facilitation():
+    """Test sprint facilitation capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Facilitate a sprint planning meeting for a team of 6 developers"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "sprint" in result.lower() or "planning" in result.lower()
+    print("✓ test_sm_sprint_facilitation passed")
+
+
+async def test_sm_daily_standup():
+    """Test daily standup facilitation capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Facilitate a daily standup meeting and help the team identify blockers"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "standup" in result.lower() or "daily" in result.lower()
+    print("✓ test_sm_daily_standup passed")
+
+
+async def test_sm_retrospective():
+    """Test retrospective facilitation capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Facilitate a sprint retrospective to help the team improve their processes"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "retrospective" in result.lower() or "improve" in result.lower()
+    print("✓ test_sm_retrospective passed")
+
+
+async def test_sm_team_coaching():
+    """Test team coaching capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Coach a team on agile best practices and help them become more self-organizing"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "coach" in result.lower() or "agile" in result.lower()
+    print("✓ test_sm_team_coaching passed")
+
+
+async def test_sm_blocker_resolution():
+    """Test blocker resolution capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Help the team identify and resolve blockers preventing them from completing their sprint goals"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "blocker" in result.lower() or "impediment" in result.lower()
+    print("✓ test_sm_blocker_resolution passed")
+
+
+async def test_sm_velocity_tracking():
+    """Test velocity tracking capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Track and analyze team velocity to help with future sprint planning"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "velocity" in result.lower() or "metric" in result.lower()
+    print("✓ test_sm_velocity_tracking passed")
+
+
+async def test_sm_process_improvement():
+    """Test process improvement capability."""
+    agent = SM()
+
+    result = await agent.process(
+        "Identify areas for process improvement and suggest changes to make the team more efficient"
+    )
+
+    assert result is not None
+    assert len(result) > 0
+    assert "process" in result.lower() or "improvement" in result.lower()
+    print("✓ test_sm_process_improvement passed")
+
+
+async def main():
+    """Run all scenario tests."""
+    print("Running Scrum Master agent scenario tests...\n")
+
+    tests = [
+        test_sm_sprint_facilitation,
+        test_sm_daily_standup,
+        test_sm_retrospective,
+        test_sm_team_coaching,
+        test_sm_blocker_resolution,
+        test_sm_velocity_tracking,
+        test_sm_process_improvement,
+    ]
+
+    for test in tests:
+        try:
+            await test()
+        except Exception as e:
+            print(f"✗ {test.__name__} failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\nAll Scrum Master agent scenario tests completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())