mdan-method 2.6.3

package/tests/scenarios/packs/fintech/financial-analyst.test.py

@@ -0,0 +1,184 @@
+"""Scenario tests for Financial Analyst agent."""
+
+import sys
+import os
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.packs.fintech.agents.financial_analyst.agent import FinancialAnalyst
+
+
+def test_financial_statement_analysis():
+    """Test financial statement analysis capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Analyze the following financial data",
+        "revenue": "5,000,000",
+        "cost_of_goods_sold": "3,000,000",
+        "operating_expenses": "1,000,000",
+        "interest_expense": "100,000",
+        "tax_rate": "25%",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "gross_profit" in result.lower() or "gross margin" in result.lower()
+    assert "operating_income" in result.lower() or "operating profit" in result.lower()
+    assert "net_income" in result.lower() or "net profit" in result.lower()
+    print("✓ Financial statement analysis test passed")
+
+
+def test_ratio_analysis():
+    """Test financial ratio analysis capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Calculate and analyze key financial ratios",
+        "current_assets": "2,000,000",
+        "current_liabilities": "1,000,000",
+        "total_assets": "10,000,000",
+        "total_liabilities": "4,000,000",
+        "net_income": "500,000",
+        "revenue": "5,000,000",
+        "shareholder_equity": "6,000,000",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "current_ratio" in result.lower() or "liquidity" in result.lower()
+    assert "debt_to_equity" in result.lower() or "leverage" in result.lower()
+    assert "return_on_equity" in result.lower() or "roe" in result.lower()
+    print("✓ Ratio analysis test passed")
+
+
+def test_investment_analysis():
+    """Test investment analysis capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Evaluate investment opportunity",
+        "company": "TechCorp Inc.",
+        "current_price": "100",
+        "target_price": "120",
+        "dividend_yield": "2.5%",
+        "pe_ratio": "25",
+        "industry_pe": "30",
+        "growth_rate": "15%",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "valuation" in result.lower() or "price" in result.lower()
+    assert (
+        "recommendation" in result.lower()
+        or "buy" in result.lower()
+        or "sell" in result.lower()
+        or "hold" in result.lower()
+    )
+    print("✓ Investment analysis test passed")
+
+
+def test_budget_forecasting():
+    """Test budget forecasting capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Create budget forecast for next year",
+        "current_revenue": "10,000,000",
+        "growth_rate": "10%",
+        "current_expenses": "8,000,000",
+        "inflation_rate": "3%",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "forecast" in result.lower() or "projection" in result.lower()
+    assert "revenue" in result.lower()
+    assert "expenses" in result.lower()
+    print("✓ Budget forecasting test passed")
+
+
+def test_cash_flow_analysis():
+    """Test cash flow analysis capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Analyze cash flow statement",
+        "operating_cash_flow": "1,500,000",
+        "investing_cash_flow": "-500,000",
+        "financing_cash_flow": "-200,000",
+        "beginning_cash": "500,000",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "cash_flow" in result.lower() or "cash flow" in result.lower()
+    assert "free_cash_flow" in result.lower() or "net_cash" in result.lower()
+    print("✓ Cash flow analysis test passed")
+
+
+def test_valuation():
+    """Test company valuation capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Value the company using DCF method",
+        "free_cash_flow": "1,000,000",
+        "growth_rate": "5%",
+        "discount_rate": "10%",
+        "terminal_growth_rate": "2%",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "valuation" in result.lower() or "value" in result.lower()
+    assert "present_value" in result.lower() or "npv" in result.lower()
+    print("✓ Valuation test passed")
+
+
+def test_financial_reporting():
+    """Test financial reporting capability."""
+    agent = FinancialAnalyst()
+
+    input_data = {
+        "task": "Prepare financial summary report",
+        "period": "Q4 2025",
+        "revenue": "15,000,000",
+        "expenses": "12,000,000",
+        "net_income": "3,000,000",
+        "assets": "50,000,000",
+        "liabilities": "20,000,000",
+        "equity": "30,000,000",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "summary" in result.lower() or "report" in result.lower()
+    assert "revenue" in result.lower()
+    assert "profitability" in result.lower() or "income" in result.lower()
+    print("✓ Financial reporting test passed")
+
+
+if __name__ == "__main__":
+    print("Running Financial Analyst scenario tests...")
+    print()
+
+    test_financial_statement_analysis()
+    test_ratio_analysis()
+    test_investment_analysis()
+    test_budget_forecasting()
+    test_cash_flow_analysis()
+    test_valuation()
+    test_financial_reporting()
+
+    print()
+    print("All Financial Analyst tests passed! ✓")

package/tests/scenarios/packs/fintech/risk-manager.test.py

@@ -0,0 +1,171 @@
+"""Scenario tests for Risk Manager agent."""
+
+import sys
+import os
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.packs.fintech.agents.risk_manager.agent import RiskManager
+
+
+def test_market_risk_assessment():
+    """Test market risk assessment capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Assess market risk for investment portfolio",
+        "portfolio": {
+            "equities": {"value": "10,000,000", "beta": 1.2},
+            "bonds": {"value": "5,000,000", "duration": 6.5},
+        },
+        "confidence_level": 95,
+        "time_horizon": "10 days",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "market_risk" in result.lower() or "market risk" in result.lower()
+    assert "var" in result.lower() or "value_at_risk" in result.lower()
+    print("✓ Market risk assessment test passed")
+
+
+def test_credit_risk_assessment():
+    """Test credit risk assessment capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Assess credit risk for lending portfolio",
+        "borrowers": [
+            {"name": "Company A", "exposure": "1,000,000", "credit_rating": "A"},
+            {"name": "Company B", "exposure": "500,000", "credit_rating": "BBB"},
+            {"name": "Company C", "exposure": "2,000,000", "credit_rating": "AA"},
+        ],
+        "industry_concentration": {
+            "Technology": 40,
+            "Healthcare": 30,
+            "Financials": 30,
+        },
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "credit_risk" in result.lower() or "credit risk" in result.lower()
+    assert "exposure" in result.lower()
+    print("✓ Credit risk assessment test passed")
+
+
+def test_operational_risk():
+    """Test operational risk assessment capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Assess operational risks",
+        "business_processes": ["Trading", "Settlement", "Customer Service"],
+        "risk_factors": ["System failures", "Human error", "Fraud", "External events"],
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "operational_risk" in result.lower() or "operational risk" in result.lower()
+    assert "mitigation" in result.lower() or "controls" in result.lower()
+    print("✓ Operational risk test passed")
+
+
+def test_stress_testing():
+    """Test stress testing capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Perform stress testing on portfolio",
+        "portfolio_value": "15,000,000",
+        "scenarios": [
+            {"name": "Market crash", "market_decline": "-20%"},
+            {"name": "Interest rate spike", "rate_increase": "+200bps"},
+            {"name": "Liquidity crisis", "liquidity_impact": "-30%"},
+        ],
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "stress_test" in result.lower() or "stress test" in result.lower()
+    assert "scenario" in result.lower()
+    print("✓ Stress testing test passed")
+
+
+def test_risk_mitigation():
+    """Test risk mitigation strategy development capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Develop risk mitigation strategies",
+        "identified_risks": [
+            {"type": "Market risk", "level": "High"},
+            {"type": "Credit risk", "level": "Medium"},
+            {"type": "Operational risk", "level": "Medium"},
+        ],
+        "risk_appetite": "Moderate",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "mitigation" in result.lower()
+    assert "strategy" in result.lower() or "strategies" in result.lower()
+    print("✓ Risk mitigation test passed")
+
+
+def test_risk_metrics():
+    """Test risk metrics development capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Develop risk metrics and KPIs",
+        "risk_types": ["Market", "Credit", "Operational", "Liquidity"],
+        "reporting_frequency": "Monthly",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "metrics" in result.lower() or "kpi" in result.lower()
+    assert "monitoring" in result.lower() or "reporting" in result.lower()
+    print("✓ Risk metrics test passed")
+
+
+def test_regulatory_compliance():
+    """Test regulatory compliance for risk management capability."""
+    agent = RiskManager()
+
+    input_data = {
+        "task": "Ensure risk management regulatory compliance",
+        "regulations": ["Basel III", "Solvency II", "FRTB"],
+        "organization_type": "Bank",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "compliance" in result.lower()
+    assert "regulatory" in result.lower()
+    print("✓ Regulatory compliance test passed")
+
+
+if __name__ == "__main__":
+    print("Running Risk Manager scenario tests...")
+    print()
+
+    test_market_risk_assessment()
+    test_credit_risk_assessment()
+    test_operational_risk()
+    test_stress_testing()
+    test_risk_mitigation()
+    test_risk_metrics()
+    test_regulatory_compliance()
+
+    print()
+    print("All Risk Manager tests passed! ✓")

package/tests/scenarios/tea/tea.test.py

@@ -0,0 +1,346 @@
+"""
+Scenario tests for TEA Agent (Murat)
+Tests the Master Test Architect's ability to provide testing guidance
+"""
+
+import asyncio
+import sys
+import os
+
+# Add the app directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.tea.agents.tea.agent import TEA, TEARequest
+
+
+class TestTEAAgent:
+    """Test suite for TEA Agent scenarios"""
+
+    def __init__(self):
+        self.agent = TEA()
+
+    async def test_initialization(self):
+        """Test 1: Agent initializes correctly"""
+        print("Test 1: Agent initialization...")
+
+        try:
+            assert self.agent is not None
+            assert hasattr(self.agent, "process")
+            assert hasattr(self.agent, "name")
+            assert self.agent.name == "Murat"
+            print("✓ Agent initializes correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Initialization failed: {e}")
+            return False
+
+    async def test_teach_me_testing(self):
+        """Test 2: Teach testing fundamentals"""
+        print("\nTest 2: Teach me testing...")
+
+        try:
+            request = TEARequest(
+                task="teach-me-testing", context="I want to learn testing from scratch"
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "sessions" in result["guidance"]
+            assert len(result["guidance"]["sessions"]) == 7
+            print("✓ Teach me testing works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Teach me testing failed: {e}")
+            return False
+
+    async def test_test_framework(self):
+        """Test 3: Initialize test framework"""
+        print("\nTest 3: Test framework initialization...")
+
+        try:
+            request = TEARequest(
+                task="test-framework",
+                context="Setting up test framework for a web app",
+                project_type="web",
+                tech_stack=["pytest", "playwright"],
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "architecture" in result["guidance"]
+            print("✓ Test framework initialization works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Test framework initialization failed: {e}")
+            return False
+
+    async def test_atdd(self):
+        """Test 4: Acceptance Test-Driven Development"""
+        print("\nTest 4: ATDD guidance...")
+
+        try:
+            request = TEARequest(task="atdd", context="User login feature")
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "acceptance_test_template" in result["guidance"]
+            assert "implementation_checklist" in result["guidance"]
+            print("✓ ATDD guidance works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ ATDD guidance failed: {e}")
+            return False
+
+    async def test_test_automate(self):
+        """Test 5: Test automation strategy"""
+        print("\nTest 5: Test automation strategy...")
+
+        try:
+            request = TEARequest(
+                task="test-automate",
+                context="Automate tests for payment feature",
+                risk_level="high",
+                scope="feature",
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "test_prioritization" in result["guidance"]
+            assert "definition_of_done" in result["guidance"]
+            print("✓ Test automation strategy works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Test automation strategy failed: {e}")
+            return False
+
+    async def test_test_design(self):
+        """Test 6: Test design and coverage strategy"""
+        print("\nTest 6: Test design strategy...")
+
+        try:
+            request = TEARequest(
+                task="test-design",
+                context="Design test strategy for e-commerce platform",
+                risk_level="high",
+                scope="epic",
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "risk_assessment" in result["guidance"]
+            assert "coverage_strategy" in result["guidance"]
+            print("✓ Test design strategy works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Test design strategy failed: {e}")
+            return False
+
+    async def test_test_trace(self):
+        """Test 7: Requirements to tests traceability"""
+        print("\nTest 7: Test traceability...")
+
+        try:
+            request = TEARequest(
+                task="test-trace", context="Map requirements to tests for release"
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "phase_1_traceability" in result["guidance"]
+            assert "phase_2_quality_gate" in result["guidance"]
+            print("✓ Test traceability works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Test traceability failed: {e}")
+            return False
+
+    async def test_nfr_assess(self):
+        """Test 8: Non-Functional Requirements assessment"""
+        print("\nTest 8: NFR assessment...")
+
+        try:
+            request = TEARequest(
+                task="nfr-assess", context="Assess NFRs for high-traffic API"
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "nfr_categories" in result["guidance"]
+            assert len(result["guidance"]["nfr_categories"]) >= 5
+            print("✓ NFR assessment works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ NFR assessment failed: {e}")
+            return False
+
+    async def test_continuous_integration(self):
+        """Test 9: CI/CD quality pipeline"""
+        print("\nTest 9: Continuous integration guidance...")
+
+        try:
+            request = TEARequest(
+                task="continuous-integration",
+                context="Set up CI/CD pipeline for microservices",
+                ci_platform="github-actions",
+                tech_stack=["pytest", "go-test"],
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "pipeline_stages" in result["guidance"]
+            assert "quality_gates" in result["guidance"]
+            print("✓ Continuous integration guidance works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Continuous integration guidance failed: {e}")
+            return False
+
+    async def test_test_review(self):
+        """Test 10: Test quality review"""
+        print("\nTest 10: Test quality review...")
+
+        try:
+            request = TEARequest(
+                task="test-review", context="Review test suite for quality issues"
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "review_criteria" in result["guidance"]
+            assert "common_issues" in result["guidance"]
+            print("✓ Test quality review works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Test quality review failed: {e}")
+            return False
+
+    async def test_risk_based_testing(self):
+        """Test 11: Risk-based testing approach"""
+        print("\nTest 11: Risk-based testing...")
+
+        try:
+            request = TEARequest(
+                task="test-design",
+                context="Apply risk-based testing to critical payment system",
+                risk_level="critical",
+                scope="system",
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            assert "risk_assessment" in result["guidance"]
+            print("✓ Risk-based testing works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ Risk-based testing failed: {e}")
+            return False
+
+    async def test_api_testing_focus(self):
+        """Test 12: API testing as first-class citizen"""
+        print("\nTest 12: API testing focus...")
+
+        try:
+            request = TEARequest(
+                task="test-automate",
+                context="Automate API tests for REST service",
+                project_type="api",
+                tech_stack=["pytest"],
+                risk_level="high",
+            )
+
+            result = await self.agent.process(request)
+
+            assert result is not None
+            assert isinstance(result, dict)
+            assert result["success"] == True
+            assert "guidance" in result
+            print("✓ API testing focus works correctly")
+            return True
+        except Exception as e:
+            print(f"✗ API testing focus failed: {e}")
+            return False
+
+
+async def run_all_tests():
+    """Run all scenario tests for TEA Agent"""
+    print("=" * 60)
+    print("TEA Agent (Murat) - Scenario Tests")
+    print("=" * 60)
+
+    test_suite = TestTEAAgent()
+
+    tests = [
+        test_suite.test_initialization(),
+        test_suite.test_teach_me_testing(),
+        test_suite.test_test_framework(),
+        test_suite.test_atdd(),
+        test_suite.test_test_automate(),
+        test_suite.test_test_design(),
+        test_suite.test_test_trace(),
+        test_suite.test_nfr_assess(),
+        test_suite.test_continuous_integration(),
+        test_suite.test_test_review(),
+        test_suite.test_risk_based_testing(),
+        test_suite.test_api_testing_focus(),
+    ]
+
+    results = await asyncio.gather(*tests)
+
+    passed = sum(results)
+    total = len(results)
+
+    print("\n" + "=" * 60)
+    print(f"Test Results: {passed}/{total} passed")
+    print("=" * 60)
+
+    if passed == total:
+        print("✓ All tests passed!")
+        return 0
+    else:
+        print(f"✗ {total - passed} test(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(run_all_tests())
+    sys.exit(exit_code)