mdan-cli 2.5.1 → 2.5.2

package/tests/scenarios/packs/db-optimization/query-optimizer.test.py

@@ -0,0 +1,106 @@
+"""Scenario tests for Query Optimizer 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.db_optimization.agents.query_optimizer.agent import QueryOptimizerAgent
+
+
+def test_query_optimizer_basic_info():
+    """Test that Query Optimizer provides basic information."""
+    agent = QueryOptimizerAgent()
+    result = agent.get_info()
+    assert result is not None
+    assert "name" in result
+    assert result["name"] == "Query Optimizer"
+    assert "capabilities" in result
+    assert len(result["capabilities"]) > 0
+
+
+def test_query_optimizer_analyze():
+    """Test that Query Optimizer can analyze queries."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("analyze")
+    assert result is not None
+    assert len(result) > 0
+    assert "analysis" in result or "query" in result
+
+
+def test_query_optimizer_optimize():
+    """Test that Query Optimizer can optimize queries."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("optimize")
+    assert result is not None
+    assert len(result) > 0
+    assert "optimized" in result or "optimization" in result
+
+
+def test_query_optimizer_rewrite():
+    """Test that Query Optimizer can rewrite queries."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("rewrite")
+    assert result is not None
+    assert len(result) > 0
+    assert "rewrite" in result or "rewritten" in result
+
+
+def test_query_optimizer_explain():
+    """Test that Query Optimizer can explain execution plans."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("explain")
+    assert result is not None
+    assert len(result) > 0
+    assert "plan" in result or "execution" in result
+
+
+def test_query_optimizer_index():
+    """Test that Query Optimizer can design indexes."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("index")
+    assert result is not None
+    assert len(result) > 0
+    assert "index" in result or "indexes" in result
+
+
+def test_query_optimizer_select_star():
+    """Test that Query Optimizer can handle SELECT * issues."""
+    agent = QueryOptimizerAgent()
+    result = agent.process("analyze")
+    assert result is not None
+    assert len(result) > 0
+    # Check that the response contains relevant information
+    assert "query" in str(result).lower() or "performance" in str(result).lower()
+
+
+if __name__ == "__main__":
+    print("Running Query Optimizer Agent Scenario Tests...")
+    print()
+
+    tests = [
+        ("Basic Info", test_query_optimizer_basic_info),
+        ("Analyze Query", test_query_optimizer_analyze),
+        ("Optimize Query", test_query_optimizer_optimize),
+        ("Rewrite Query", test_query_optimizer_rewrite),
+        ("Explain Plan", test_query_optimizer_explain),
+        ("Design Indexes", test_query_optimizer_index),
+        ("SELECT * Issue", test_query_optimizer_select_star),
+    ]
+
+    passed = 0
+    failed = 0
+
+    for name, test_func in tests:
+        try:
+            test_func()
+            print(f"✓ {name}")
+            passed += 1
+        except Exception as e:
+            print(f"✗ {name}: {e}")
+            failed += 1
+
+    print()
+    print(f"Results: {passed} passed, {failed} failed")
+    sys.exit(0 if failed == 0 else 1)

package/tests/scenarios/packs/devops-azure/azure-specialist.test.py

@@ -0,0 +1,125 @@
+"""Scenario tests for Azure Specialist 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.devops_azure.agents.azure_specialist.agent import AzureSpecialistAgent
+
+
+def test_azure_specialist_basic_info():
+    """Test that Azure Specialist provides basic information."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("What is Microsoft Azure?")
+    assert result is not None
+    assert len(result) > 0
+    assert "Azure" in result or "Microsoft" in result or "cloud" in result.lower()
+
+
+def test_azure_specialist_vm():
+    """Test that Azure Specialist can discuss Virtual Machines."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("How do I create an Azure VM?")
+    assert result is not None
+    assert len(result) > 0
+    assert "VM" in result or "virtual machine" in result.lower() or "Azure" in result
+
+
+def test_azure_specialist_storage():
+    """Test that Azure Specialist can discuss Azure Storage."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("What storage options does Azure offer?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "storage" in result.lower()
+        or "blob" in result.lower()
+        or "disk" in result.lower()
+    )
+
+
+def test_azure_specialist_functions():
+    """Test that Azure Specialist can discuss Azure Functions."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("What are Azure Functions?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Function" in result
+        or "serverless" in result.lower()
+        or "compute" in result.lower()
+    )
+
+
+def test_azure_specialist_cosmos_db():
+    """Test that Azure Specialist can discuss Cosmos DB."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("Tell me about Azure Cosmos DB")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Cosmos" in result
+        or "database" in result.lower()
+        or "NoSQL" in result
+        or "SQL" in result
+    )
+
+
+def test_azure_specialist_networking():
+    """Test that Azure Specialist can discuss Azure Networking."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("How do I set up a VNet in Azure?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "VNet" in result
+        or "virtual network" in result.lower()
+        or "network" in result.lower()
+    )
+
+
+def test_azure_specialist_security():
+    """Test that Azure Specialist can discuss Azure Security."""
+    agent = AzureSpecialistAgent()
+    result = agent.process("What security features does Azure provide?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "security" in result.lower()
+        or "IAM" in result
+        or "RBAC" in result
+        or "firewall" in result.lower()
+    )
+
+
+if __name__ == "__main__":
+    print("Running Azure Specialist Agent Scenario Tests...")
+    print()
+
+    tests = [
+        ("Basic Info", test_azure_specialist_basic_info),
+        ("Virtual Machines", test_azure_specialist_vm),
+        ("Storage", test_azure_specialist_storage),
+        ("Azure Functions", test_azure_specialist_functions),
+        ("Cosmos DB", test_azure_specialist_cosmos_db),
+        ("Networking", test_azure_specialist_networking),
+        ("Security", test_azure_specialist_security),
+    ]
+
+    passed = 0
+    failed = 0
+
+    for name, test_func in tests:
+        try:
+            test_func()
+            print(f"✓ {name}")
+            passed += 1
+        except Exception as e:
+            print(f"✗ {name}: {e}")
+            failed += 1
+
+    print()
+    print(f"Results: {passed} passed, {failed} failed")
+    sys.exit(0 if failed == 0 else 1)

package/tests/scenarios/packs/devops-azure/cicd-architect.test.py

@@ -0,0 +1,122 @@
+"""Scenario tests for CI/CD Architect 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.devops_azure.agents.cicd_architect.agent import CICDArchitectAgent
+
+
+def test_cicd_architect_basic_info():
+    """Test that CI/CD Architect provides basic information."""
+    agent = CICDArchitectAgent()
+    result = agent.process("What is CI/CD architecture?")
+    assert result is not None
+    assert len(result) > 0
+    assert "CI" in result or "CD" in result or "architecture" in result.lower()
+
+
+def test_cicd_architect_github_actions():
+    """Test that CI/CD Architect can discuss GitHub Actions."""
+    agent = CICDArchitectAgent()
+    result = agent.process("How do I set up GitHub Actions?")
+    assert result is not None
+    assert len(result) > 0
+    assert "GitHub" in result or "Actions" in result or "workflow" in result.lower()
+
+
+def test_cicd_architect_azure_devops():
+    """Test that CI/CD Architect can discuss Azure DevOps."""
+    agent = CICDArchitectAgent()
+    result = agent.process("Explain Azure DevOps pipelines")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Azure DevOps" in result
+        or "pipeline" in result.lower()
+        or "build" in result.lower()
+    )
+
+
+def test_cicd_architect_jenkins():
+    """Test that CI/CD Architect can discuss Jenkins."""
+    agent = CICDArchitectAgent()
+    result = agent.process("How do I configure Jenkins?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Jenkins" in result or "pipeline" in result.lower() or "job" in result.lower()
+    )
+
+
+def test_cicd_architect_best_practices():
+    """Test that CI/CD Architect can discuss best practices."""
+    agent = CICDArchitectAgent()
+    result = agent.process("What are CI/CD best practices?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "best practice" in result.lower()
+        or "practice" in result.lower()
+        or "recommend" in result.lower()
+    )
+
+
+def test_cicd_architect_testing():
+    """Test that CI/CD Architect can discuss testing in CI/CD."""
+    agent = CICDArchitectAgent()
+    result = agent.process("How do I integrate automated testing?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "test" in result.lower()
+        or "automated" in result.lower()
+        or "unit" in result.lower()
+    )
+
+
+def test_cicd_architect_deployment_strategies():
+    """Test that CI/CD Architect can discuss deployment strategies."""
+    agent = CICDArchitectAgent()
+    result = agent.process("What deployment strategies should I use?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "deploy" in result.lower()
+        or "strategy" in result.lower()
+        or "blue" in result.lower()
+        or "canary" in result.lower()
+    )
+
+
+if __name__ == "__main__":
+    print("Running CI/CD Architect Agent Scenario Tests...")
+    print()
+
+    tests = [
+        ("Basic Info", test_cicd_architect_basic_info),
+        ("GitHub Actions", test_cicd_architect_github_actions),
+        ("Azure DevOps", test_cicd_architect_azure_devops),
+        ("Jenkins", test_cicd_architect_jenkins),
+        ("Best Practices", test_cicd_architect_best_practices),
+        ("Testing", test_cicd_architect_testing),
+        ("Deployment Strategies", test_cicd_architect_deployment_strategies),
+    ]
+
+    passed = 0
+    failed = 0
+
+    for name, test_func in tests:
+        try:
+            test_func()
+            print(f"✓ {name}")
+            passed += 1
+        except Exception as e:
+            print(f"✗ {name}: {e}")
+            failed += 1
+
+    print()
+    print(f"Results: {passed} passed, {failed} failed")
+    sys.exit(0 if failed == 0 else 1)

package/tests/scenarios/packs/devops-azure/devops-engineer.test.py

@@ -0,0 +1,128 @@
+"""Scenario tests for DevOps Engineer 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.devops_azure.agents.devops_engineer.agent import DevOpsEngineerAgent
+
+
+def test_devops_engineer_basic_info():
+    """Test that DevOps Engineer provides basic information."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("What is DevOps?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "DevOps" in result
+        or "development" in result.lower()
+        or "operations" in result.lower()
+    )
+
+
+def test_devops_engineer_ci_cd():
+    """Test that DevOps Engineer can explain CI/CD."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("Explain CI/CD pipeline")
+    assert result is not None
+    assert len(result) > 0
+    assert "CI" in result or "CD" in result or "pipeline" in result.lower()
+
+
+def test_devops_engineer_docker():
+    """Test that DevOps Engineer can discuss Docker."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("How do I create a Dockerfile?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Docker" in result
+        or "dockerfile" in result.lower()
+        or "container" in result.lower()
+    )
+
+
+def test_devops_engineer_kubernetes():
+    """Test that DevOps Engineer can discuss Kubernetes."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("What is Kubernetes?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "Kubernetes" in result
+        or "k8s" in result.lower()
+        or "orchestration" in result.lower()
+    )
+
+
+def test_devops_engineer_monitoring():
+    """Test that DevOps Engineer can discuss monitoring."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("What monitoring tools do you recommend?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "monitor" in result.lower()
+        or "prometheus" in result.lower()
+        or "grafana" in result.lower()
+    )
+
+
+def test_devops_engineer_automation():
+    """Test that DevOps Engineer can discuss automation."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("How can I automate deployments?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "automat" in result.lower()
+        or "deploy" in result.lower()
+        or "script" in result.lower()
+    )
+
+
+def test_devops_engineer_troubleshooting():
+    """Test that DevOps Engineer can help with troubleshooting."""
+    agent = DevOpsEngineerAgent()
+    result = agent.process("My deployment is failing, what should I check?")
+    assert result is not None
+    assert len(result) > 0
+    assert (
+        "check" in result.lower()
+        or "log" in result.lower()
+        or "error" in result.lower()
+        or "debug" in result.lower()
+    )
+
+
+if __name__ == "__main__":
+    print("Running DevOps Engineer Agent Scenario Tests...")
+    print()
+
+    tests = [
+        ("Basic Info", test_devops_engineer_basic_info),
+        ("CI/CD", test_devops_engineer_ci_cd),
+        ("Docker", test_devops_engineer_docker),
+        ("Kubernetes", test_devops_engineer_kubernetes),
+        ("Monitoring", test_devops_engineer_monitoring),
+        ("Automation", test_devops_engineer_automation),
+        ("Troubleshooting", test_devops_engineer_troubleshooting),
+    ]
+
+    passed = 0
+    failed = 0
+
+    for name, test_func in tests:
+        try:
+            test_func()
+            print(f"✓ {name}")
+            passed += 1
+        except Exception as e:
+            print(f"✗ {name}: {e}")
+            failed += 1
+
+    print()
+    print(f"Results: {passed} passed, {failed} failed")
+    sys.exit(0 if failed == 0 else 1)

package/tests/scenarios/packs/fintech/compliance-officer.test.py

@@ -0,0 +1,165 @@
+"""Scenario tests for Compliance Officer 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.compliance_officer.agent import ComplianceOfficer
+
+
+def test_regulatory_assessment():
+    """Test regulatory compliance assessment capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Assess regulatory compliance requirements",
+        "jurisdiction": "United States",
+        "industry": "Banking",
+        "company_size": "Medium (500-1000 employees)",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "compliance" in result.lower()
+    assert "regulatory" in result.lower()
+    print("✓ Regulatory assessment test passed")
+
+
+def test_gdpr_compliance():
+    """Test GDPR compliance assessment capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Assess GDPR compliance",
+        "data_types": ["Personal data", "Financial data", "Contact information"],
+        "data_processing": ["Storage", "Transfer", "Analysis"],
+        "eu_residents": True,
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "gdpr" in result.lower() or "data protection" in result.lower()
+    assert "consent" in result.lower() or "rights" in result.lower()
+    print("✓ GDPR compliance test passed")
+
+
+def test_aml_compliance():
+    """Test AML compliance assessment capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Assess Anti-Money Laundering compliance",
+        "transaction_types": [
+            "Wire transfers",
+            "Cash deposits",
+            "International transfers",
+        ],
+        "customer_types": ["Individuals", "Businesses", "High-net-worth individuals"],
+        "transaction_volume": "High",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "aml" in result.lower() or "anti-money laundering" in result.lower()
+    assert "kyc" in result.lower() or "know your customer" in result.lower()
+    print("✓ AML compliance test passed")
+
+
+def test_policy_development():
+    """Test compliance policy development capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Develop compliance policy",
+        "policy_type": "Data Privacy Policy",
+        "scope": "All employees and contractors",
+        "regulations": ["GDPR", "CCPA", "HIPAA"],
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "policy" in result.lower()
+    assert "procedures" in result.lower() or "guidelines" in result.lower()
+    print("✓ Policy development test passed")
+
+
+def test_audit_preparation():
+    """Test audit preparation capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Prepare for regulatory audit",
+        "audit_type": "SOC 2 Type II",
+        "audit_scope": ["Security", "Availability", "Processing Integrity"],
+        "audit_date": "2026-06-01",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "audit" in result.lower()
+    assert "preparation" in result.lower() or "readiness" in result.lower()
+    print("✓ Audit preparation test passed")
+
+
+def test_risk_assessment():
+    """Test compliance risk assessment capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Assess compliance risks",
+        "business_areas": [
+            "Data handling",
+            "Financial reporting",
+            "Third-party vendors",
+        ],
+        "regulations": ["SOX", "GDPR", "PCI DSS"],
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "risk" in result.lower()
+    assert "mitigation" in result.lower() or "controls" in result.lower()
+    print("✓ Risk assessment test passed")
+
+
+def test_training_program():
+    """Test compliance training program development capability."""
+    agent = ComplianceOfficer()
+
+    input_data = {
+        "task": "Develop compliance training program",
+        "target_audience": "All employees",
+        "topics": ["Data privacy", "Anti-corruption", "Insider trading"],
+        "duration": "Annual",
+    }
+
+    result = agent.process(input_data)
+
+    assert result is not None
+    assert "training" in result.lower()
+    assert "program" in result.lower() or "curriculum" in result.lower()
+    print("✓ Training program test passed")
+
+
+if __name__ == "__main__":
+    print("Running Compliance Officer scenario tests...")
+    print()
+
+    test_regulatory_assessment()
+    test_gdpr_compliance()
+    test_aml_compliance()
+    test_policy_development()
+    test_audit_preparation()
+    test_risk_assessment()
+    test_training_program()
+
+    print()
+    print("All Compliance Officer tests passed! ✓")