mdan-cli 2.5.1 → 2.5.2

package/tests/scenarios/cis/design-thinking-coach.test.py

@@ -0,0 +1,177 @@
+"""
+Scenario tests for Design Thinking Coach agent
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.design_thinking_coach import (
+    DesignThinkingCoach,
+    DesignThinkingCoachRequest,
+)
+
+
+async def test_design_thinking_full_process():
+    """Test full design thinking process."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(
+        challenge="Improve online shopping experience", phase="full"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["agent"] == "Maya"
+    assert result["challenge"] == "Improve online shopping experience"
+    assert result["phase"] == "full"
+    assert "process" in result
+    assert "activities" in result
+    print("✓ test_design_thinking_full_process passed")
+
+
+async def test_design_thinking_empathize_phase():
+    """Test design thinking with empathize phase."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(
+        challenge="Redesign mobile app navigation",
+        phase="empathize",
+        target_users="Millennial shoppers",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["phase"] == "empathize"
+    assert result["target_users"] == "Millennial shoppers"
+    # Check that empathize activities are included
+    activities = result["activities"]
+    assert any(a["phase"] == "Empathize" for a in activities)
+    print("✓ test_design_thinking_empathize_phase passed")
+
+
+async def test_design_thinking_ideate_phase():
+    """Test design thinking with ideate phase."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(
+        challenge="Create new product features", phase="ideate"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["phase"] == "ideate"
+    # Check that ideate activities are included
+    activities = result["activities"]
+    assert any(a["phase"] == "Ideate" for a in activities)
+    print("✓ test_design_thinking_ideate_phase passed")
+
+
+async def test_design_thinking_with_constraints():
+    """Test design thinking with constraints."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(
+        challenge="Design sustainable packaging",
+        phase="full",
+        constraints="Budget limited, must use recycled materials",
+        goals="Reduce environmental impact",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["constraints"] == "Budget limited, must use recycled materials"
+    assert result["goals"] == "Reduce environmental impact"
+    print("✓ test_design_thinking_with_constraints passed")
+
+
+async def test_design_thinking_process_structure():
+    """Test that process structure is generated correctly."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(challenge="Improve customer service")
+    result = await agent.process(request)
+    assert result["success"] == True
+    process = result["process"]
+    assert "approach" in process
+    if result["phase"] == "full":
+        assert "phases" in process
+        phases = process["phases"]
+        assert "empathize" in phases
+        assert "define" in phases
+        assert "ideate" in phases
+        assert "prototype" in phases
+        assert "test" in phases
+    print("✓ test_design_thinking_process_structure passed")
+
+
+async def test_design_thinking_activities():
+    """Test that activities are created for each phase."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(
+        challenge="Create new user onboarding flow", phase="full"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    activities = result["activities"]
+    assert len(activities) >= 5
+    # Check activity structure
+    for activity in activities:
+        assert "phase" in activity
+        assert "activity" in activity
+        assert "description" in activity
+        assert "duration" in activity
+    print("✓ test_design_thinking_activities passed")
+
+
+async def test_design_thinking_facilitation():
+    """Test that facilitation guidance is provided."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(challenge="Redesign website homepage")
+    result = await agent.process(request)
+    assert result["success"] == True
+    facilitation = result["facilitation"]
+    assert "mindset" in facilitation
+    assert "tips" in facilitation
+    assert "common_pitfalls" in facilitation
+    assert "success_metrics" in facilitation
+    assert len(facilitation["mindset"]) > 0
+    assert len(facilitation["tips"]) > 0
+    print("✓ test_design_thinking_facilitation passed")
+
+
+async def test_design_thinking_principles():
+    """Test that design thinking principles are included."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(challenge="Improve product usability")
+    result = await agent.process(request)
+    assert result["success"] == True
+    principles = result["principles"]
+    assert len(principles) > 0
+    assert "Design is about THEM not us" in principles
+    print("✓ test_design_thinking_principles passed")
+
+
+async def test_design_thinking_missing_challenge():
+    """Test design thinking with missing challenge."""
+    agent = DesignThinkingCoach()
+    request = DesignThinkingCoachRequest(challenge="")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_design_thinking_missing_challenge passed")
+
+
+async def main():
+    """Run all tests."""
+    print("Running Design Thinking Coach agent tests...\n")
+
+    await test_design_thinking_full_process()
+    await test_design_thinking_empathize_phase()
+    await test_design_thinking_ideate_phase()
+    await test_design_thinking_with_constraints()
+    await test_design_thinking_process_structure()
+    await test_design_thinking_activities()
+    await test_design_thinking_facilitation()
+    await test_design_thinking_principles()
+    await test_design_thinking_missing_challenge()
+
+    print("\n✅ All Design Thinking Coach tests passed!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

package/tests/scenarios/cis/innovation-strategist.test.py

@@ -0,0 +1,191 @@
+"""
+Scenario tests for Innovation Strategist agent
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.innovation_strategist import (
+    InnovationStrategist,
+    InnovationStrategistRequest,
+)
+
+
+async def test_innovation_strategy_basic():
+    """Test basic innovation strategy."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="E-commerce industry", goals="disruption"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["agent"] == "Victor"
+    assert result["market_context"] == "E-commerce industry"
+    assert result["goals"] == "disruption"
+    assert "market_analysis" in result
+    assert "framework_analysis" in result
+    assert "opportunities" in result
+    print("✓ test_innovation_strategy_basic passed")
+
+
+async def test_innovation_strategy_with_offering():
+    """Test innovation strategy with current offering."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="Food delivery market",
+        current_offering="Traditional restaurant delivery service",
+        goals="disruption",
+        timeframe="medium-term",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["current_offering"] == "Traditional restaurant delivery service"
+    assert result["timeframe"] == "medium-term"
+    print("✓ test_innovation_strategy_with_offering passed")
+
+
+async def test_innovation_strategy_short_term():
+    """Test innovation strategy with short-term timeframe."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="Mobile app market", goals="growth", timeframe="short-term"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["timeframe"] == "short-term"
+    roadmap = result["roadmap"]
+    assert "focus" in roadmap
+    assert "phases" in roadmap
+    print("✓ test_innovation_strategy_short_term passed")
+
+
+async def test_innovation_strategy_long_term():
+    """Test innovation strategy with long-term timeframe."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="Automotive industry",
+        goals="transformation",
+        timeframe="long-term",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["timeframe"] == "long-term"
+    roadmap = result["roadmap"]
+    assert "focus" in roadmap
+    assert "phases" in roadmap
+    print("✓ test_innovation_strategy_long_term passed")
+
+
+async def test_innovation_strategy_with_constraints():
+    """Test innovation strategy with constraints."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="Healthcare technology",
+        current_offering="Basic telemedicine platform",
+        goals="disruption",
+        constraints="Regulatory compliance required, limited funding",
+        timeframe="medium-term",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["constraints"] == "Regulatory compliance required, limited funding"
+    print("✓ test_innovation_strategy_with_constraints passed")
+
+
+async def test_innovation_strategy_frameworks():
+    """Test that strategic frameworks are applied."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(market_context="SaaS market")
+    result = await agent.process(request)
+    assert result["success"] == True
+    frameworks = result["framework_analysis"]
+    assert "jobs_to_be_done" in frameworks
+    assert "blue_ocean_strategy" in frameworks
+    assert "business_model_innovation" in frameworks
+    print("✓ test_innovation_strategy_frameworks passed")
+
+
+async def test_innovation_strategy_opportunities():
+    """Test that innovation opportunities are identified."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(market_context="Fintech industry")
+    result = await agent.process(request)
+    assert result["success"] == True
+    opportunities = result["opportunities"]
+    assert len(opportunities) > 0
+    # Check opportunity structure
+    for opportunity in opportunities:
+        assert "opportunity" in opportunity
+        assert "description" in opportunity
+        assert "potential_impact" in opportunity
+        assert "feasibility" in opportunity
+        assert "time_to_market" in opportunity
+    print("✓ test_innovation_strategy_opportunities passed")
+
+
+async def test_innovation_strategy_roadmap():
+    """Test that strategic roadmap is created."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(
+        market_context="Retail industry", timeframe="medium-term"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    roadmap = result["roadmap"]
+    assert "focus" in roadmap
+    assert "phases" in roadmap
+    phases = roadmap["phases"]
+    assert len(phases) > 0
+    # Check phase structure
+    for phase in phases:
+        assert "phase" in phase
+        assert "activities" in phase
+    print("✓ test_innovation_strategy_roadmap passed")
+
+
+async def test_innovation_strategy_principles():
+    """Test that innovation principles are included."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(market_context="Technology sector")
+    result = await agent.process(request)
+    assert result["success"] == True
+    principles = result["principles"]
+    assert len(principles) > 0
+    assert "Markets reward genuine new value" in principles
+    print("✓ test_innovation_strategy_principles passed")
+
+
+async def test_innovation_strategy_missing_context():
+    """Test innovation strategy with missing market context."""
+    agent = InnovationStrategist()
+    request = InnovationStrategistRequest(market_context="")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_innovation_strategy_missing_context passed")
+
+
+async def main():
+    """Run all tests."""
+    print("Running Innovation Strategist agent tests...\n")
+
+    await test_innovation_strategy_basic()
+    await test_innovation_strategy_with_offering()
+    await test_innovation_strategy_short_term()
+    await test_innovation_strategy_long_term()
+    await test_innovation_strategy_with_constraints()
+    await test_innovation_strategy_frameworks()
+    await test_innovation_strategy_opportunities()
+    await test_innovation_strategy_roadmap()
+    await test_innovation_strategy_principles()
+    await test_innovation_strategy_missing_context()
+
+    print("\n✅ All Innovation Strategist tests passed!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

package/tests/scenarios/cis/presentation-master.test.py

@@ -0,0 +1,240 @@
+"""
+Scenario tests for Presentation Master agent
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
+
+from app.cis.agents.presentation_master import (
+    PresentationMaster,
+    PresentationMasterRequest,
+)
+
+
+async def test_presentation_slide_deck():
+    """Test slide deck presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="slide-deck",
+        topic="Company quarterly review",
+        audience="Board of directors",
+        style="professional",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["agent"] == "Caravaggio"
+    assert result["presentation_type"] == "slide-deck"
+    assert result["topic"] == "Company quarterly review"
+    assert result["audience"] == "Board of directors"
+    assert "structure" in result
+    assert "visual_design" in result
+    print("✓ test_presentation_slide_deck passed")
+
+
+async def test_presentation_youtube_explainer():
+    """Test YouTube explainer presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="youtube-explainer",
+        topic="How blockchain works",
+        audience="General public",
+        style="engaging",
+        length=8,
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "youtube-explainer"
+    assert result["length"] == 8
+    structure = result["structure"]
+    assert structure["type"] == "Video explainer layout"
+    print("✓ test_presentation_youtube_explainer passed")
+
+
+async def test_presentation_pitch_deck():
+    """Test pitch deck presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="pitch-deck",
+        topic="AI-powered health monitoring app",
+        audience="Venture capitalists",
+        style="bold",
+        key_messages=[
+            "Revolutionary technology",
+            "Large market opportunity",
+            "Strong team",
+        ],
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "pitch-deck"
+    assert result["key_messages"] == [
+        "Revolutionary technology",
+        "Large market opportunity",
+        "Strong team",
+    ]
+    structure = result["structure"]
+    assert structure["type"] == "Investor pitch presentation"
+    print("✓ test_presentation_pitch_deck passed")
+
+
+async def test_presentation_conference_talk():
+    """Test conference talk presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="conference-talk",
+        topic="The future of remote work",
+        audience="HR professionals",
+        style="professional",
+        length=30,
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "conference-talk"
+    assert result["length"] == 30
+    structure = result["structure"]
+    assert structure["type"] == "Conference or workshop presentation"
+    print("✓ test_presentation_conference_talk passed")
+
+
+async def test_presentation_infographic():
+    """Test infographic presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="infographic",
+        topic="Climate change statistics",
+        audience="General public",
+        style="bold",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "infographic"
+    structure = result["structure"]
+    assert structure["type"] == "Information visualization"
+    print("✓ test_presentation_infographic passed")
+
+
+async def test_presentation_visual_metaphor():
+    """Test visual metaphor presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="visual-metaphor",
+        topic="Software development process",
+        audience="New developers",
+        style="playful",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "visual-metaphor"
+    structure = result["structure"]
+    assert structure["type"] == "Conceptual illustration"
+    print("✓ test_presentation_visual_metaphor passed")
+
+
+async def test_presentation_concept_visual():
+    """Test concept visual presentation."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="concept-visual",
+        topic="Team collaboration",
+        audience="Company employees",
+        style="engaging",
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    assert result["presentation_type"] == "concept-visual"
+    structure = result["structure"]
+    assert structure["type"] == "Single expressive image"
+    print("✓ test_presentation_concept_visual passed")
+
+
+async def test_presentation_visual_design():
+    """Test that visual design guidelines are provided."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="slide-deck", topic="Product launch"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    visual_design = result["visual_design"]
+    assert "visual_hierarchy" in visual_design
+    assert "color_palette" in visual_design
+    assert "typography" in visual_design
+    assert "layout_principles" in visual_design
+    print("✓ test_presentation_visual_design passed")
+
+
+async def test_presentation_content_guidance():
+    """Test that content guidance is provided."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="slide-deck", topic="Marketing strategy"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    content_guidance = result["content_guidance"]
+    assert "storytelling" in content_guidance
+    assert "content_principles" in content_guidance
+    assert "engagement_techniques" in content_guidance
+    print("✓ test_presentation_content_guidance passed")
+
+
+async def test_presentation_principles():
+    """Test that presentation principles are included."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(
+        presentation_type="slide-deck", topic="Annual report"
+    )
+    result = await agent.process(request)
+    assert result["success"] == True
+    principles = result["principles"]
+    assert len(principles) > 0
+    assert "Know your audience" in principles[0]
+    print("✓ test_presentation_principles passed")
+
+
+async def test_presentation_missing_type():
+    """Test presentation with missing type."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(presentation_type="", topic="Some topic")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_presentation_missing_type passed")
+
+
+async def test_presentation_missing_topic():
+    """Test presentation with missing topic."""
+    agent = PresentationMaster()
+    request = PresentationMasterRequest(presentation_type="slide-deck", topic="")
+    result = await agent.process(request)
+    assert result["success"] == False
+    assert "error" in result
+    print("✓ test_presentation_missing_topic passed")
+
+
+async def main():
+    """Run all tests."""
+    print("Running Presentation Master agent tests...\n")
+
+    await test_presentation_slide_deck()
+    await test_presentation_youtube_explainer()
+    await test_presentation_pitch_deck()
+    await test_presentation_conference_talk()
+    await test_presentation_infographic()
+    await test_presentation_visual_metaphor()
+    await test_presentation_concept_visual()
+    await test_presentation_visual_design()
+    await test_presentation_content_guidance()
+    await test_presentation_principles()
+    await test_presentation_missing_type()
+    await test_presentation_missing_topic()
+
+    print("\n✅ All Presentation Master tests passed!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())