Test Scenarios for Agent Reputation System

# Scenario 1.1: Register new agent
def test_register_agent():
    marketplace = ReputationMarketplace()
    agent = marketplace.get_or_create_manager("agent_001", initial_rep=100.0)

    assert agent.agent_id == "agent_001"
    assert agent.total_reputation == 100.0
    assert agent.available_reputation == 100.0
    assert agent.staked_reputation == 0.0

# Scenario 1.2: Retrieve existing agent
def test_retrieve_existing_agent():
    marketplace = ReputationMarketplace()
    agent1 = marketplace.get_or_create_manager("agent_001")
    agent2 = marketplace.get_or_create_manager("agent_001")

    assert agent1 is agent2  # Same instance

# Scenario 2.1: Create task prediction market
def test_create_market():
    marketplace = ReputationMarketplace()
    market = marketplace.create_market(
        prediction_type=PredictionType.TASK_SUCCESS,
        subject_agent="claude_opus",
        task_id="task_001",
        task_description="Implement feature X"
    )

    assert market.market_id is not None
    assert market.prediction_type == PredictionType.TASK_SUCCESS
    assert market.is_resolved == False
    assert market.total_staked == 0.0

# Scenario 2.2: Market with deadline
def test_market_with_deadline():
    market = create_market(closes_in_minutes=30)

    assert market.closes_at is not None
    assert market.closes_at > datetime.now()

# Scenario 3.1: Successful stake placement
def test_place_stake():
    marketplace = ReputationMarketplace()
    marketplace.get_or_create_manager("bettor_001", initial_rep=100.0)
    market = marketplace.create_market(...)

    stake = marketplace.place_prediction(
        agent_id="bettor_001",
        market_id=market.market_id,
        prediction=True,
        stake_amount=20.0,
        confidence=0.8
    )

    assert stake is not None
    assert stake.stake_amount == 20.0
    assert stake.confidence <= 0.8  # May be adjusted

# Scenario 3.2: Insufficient funds
def test_insufficient_funds():
    marketplace = ReputationMarketplace()
    marketplace.get_or_create_manager("poor_agent", initial_rep=10.0)
    market = marketplace.create_market(...)

    stake = marketplace.place_prediction(
        agent_id="poor_agent",
        market_id=market.market_id,
        prediction=True,
        stake_amount=50.0,  # More than balance
        confidence=0.9
    )

    assert stake is None  # Should fail

# Scenario 3.3: Closed market rejection
def test_closed_market():
    marketplace = ReputationMarketplace()
    market = marketplace.create_market(closes_in_minutes=0)
    time.sleep(1)  # Wait for market to close

    stake = marketplace.place_prediction(
        agent_id="agent_001",
        market_id=market.market_id,
        prediction=True,
        stake_amount=10.0,
        confidence=0.7
    )

    assert stake is None

# Scenario 4.1: Resolve with SUCCESS
def test_resolve_success():
    marketplace = ReputationMarketplace()
    setup_market_with_bets(marketplace)  # 3 agents bet

    results = marketplace.resolve_market(
        market_id="market_001",
        outcome=True  # SUCCESS
    )

    assert "payouts" in results
    assert len(results["payouts"]) == 3

    # Winners should have positive payout
    for payout in results["payouts"]:
        if payout["prediction"] == True:
            assert payout["payout"] > 0
        else:
            assert payout["payout"] <= 0

# Scenario 4.2: All bets on same outcome
def test_unanimous_betting():
    marketplace = ReputationMarketplace()
    market = create_market(marketplace)

    # All bet SUCCESS
    marketplace.place_prediction("a", market.market_id, True, 10, 0.9)
    marketplace.place_prediction("b", market.market_id, True, 20, 0.8)
    marketplace.place_prediction("c", market.market_id, True, 30, 0.7)

    results = marketplace.resolve_market(market.market_id, True)

    # All winners split pool proportionally
    total_staked = 60
    for payout in results["payouts"]:
        expected = (payout["stake"] / total_staked) * total_staked
        assert payout["payout"] == expected

# Scenario 4.3: Quality score affects continuous market
def test_quality_estimate_resolution():
    marketplace = ReputationMarketplace()
    market = create_market(PredictionType.QUALITY_ESTIMATE)

    marketplace.place_prediction("a", market.market_id, 0.8, 10, 0.9)  # Predicts 0.8
    marketplace.place_prediction("b", market.market_id, 0.5, 10, 0.7)  # Predicts 0.5

    results = marketplace.resolve_market(market.market_id, 0.85)  # Actual: 0.85

    # Agent A was closer, should get better payout
    payout_a = get_payout(results, "a")
    payout_b = get_payout(results, "b")
    assert payout_a > payout_b

# Scenario 5.1: Single-hop cascade
def test_single_hop_cascade():
    engine = CascadeEngine()

    # Build trust graph: A → B (0.8)
    engine.set_trust_edge("A", "B", 0.8)

    # Initiate cascade from A
    event = engine.initiate_cascade(
        origin_agent="A",
        delta=0.1,
        cascade_type=CascadeType.ENDORSEMENT
    )

    result = engine.run_full_cascade(event)

    assert "B" in event.agents_affected
    assert result["max_generation_reached"] == 1

    # B's delta should be attenuated
    b_trajectory = engine.get_trajectory("B")
    # delta_B = 0.1 * decay(0.5) * trust(0.8) = 0.04

# Scenario 5.2: Multi-hop cascade
def test_multi_hop_cascade():
    engine = CascadeEngine()

    # Build chain: A → B → C → D
    engine.set_trust_edge("A", "B", 0.9)
    engine.set_trust_edge("B", "C", 0.8)
    engine.set_trust_edge("C", "D", 0.7)

    event = engine.initiate_cascade("A", 0.2, CascadeType.TRUST_SURGE)
    result = engine.run_full_cascade(event)

    assert result["max_generation_reached"] == 3
    assert result["agents_affected"] == 4  # A, B, C, D

# Scenario 5.3: Cascade with trust threshold
def test_cascade_threshold():
    engine = CascadeEngine()

    # Low trust edge
    engine.set_trust_edge("A", "B", 0.2)  # Below GUILT_BY_ASSOCIATION threshold (0.5)

    event = engine.initiate_cascade("A", -0.2, CascadeType.GUILT_BY_ASSOCIATION)
    result = engine.run_full_cascade(event)

    # B should NOT be affected (trust too low)
    assert "B" not in event.agents_affected

# Scenario 6.1: Rising star detection
def test_rising_star_phase():
    engine = CascadeEngine()
    trajectory = engine.get_trajectory("agent_rising")

    # Add ascending snapshots
    for i in range(10):
        score = 0.3 + i * 0.06  # 0.3 → 0.84
        trajectory.add_snapshot(ReputationSnapshot(
            timestamp=datetime.now() - timedelta(days=10-i),
            score=score,
            confidence=0.8,
            sample_size=5
        ))

    assert trajectory.phase == TrajectoryPhase.RISING_STAR
    assert trajectory.trajectory.velocity > 0.05
    assert trajectory.trajectory.acceleration > 0

# Scenario 6.2: Declining phase detection
def test_declining_phase():
    trajectory = setup_declining_trajectory()

    assert trajectory.phase == TrajectoryPhase.DECLINING
    assert trajectory.trajectory.velocity < -0.05

# Scenario 6.3: Volatility detection
def test_volatile_phase():
    trajectory = ReputationTrajectory("volatile_agent")

    # Add erratic snapshots
    scores = [0.5, 0.8, 0.3, 0.9, 0.4, 0.7, 0.2, 0.8]
    for i, score in enumerate(scores):
        trajectory.add_snapshot(ReputationSnapshot(
            timestamp=datetime.now() - timedelta(days=8-i),
            score=score,
            confidence=0.5,
            sample_size=2
        ))

    assert trajectory.phase == TrajectoryPhase.VOLATILE
    assert trajectory.trajectory.trend_confidence < 0.3

# Scenario 7.1: Route by current best
def test_route_current_best():
    router = setup_router_with_agents()

    candidates = router.route_task(
        domain="coding",
        strategy=RoutingStrategy.CURRENT_BEST,
        top_n=1
    )

    assert len(candidates) == 1
    # Should be agent with highest current score

# Scenario 7.2: Route by rising stars
def test_route_rising_stars():
    engine = CascadeEngine()
    setup_diverse_trajectories(engine)
    router = TrajectoryRouter(engine)

    candidates = router.route_task(
        domain="coding",
        strategy=RoutingStrategy.RISING_STARS,
        top_n=3
    )

    # First candidate should have highest momentum
    assert candidates[0].momentum > candidates[1].momentum

# Scenario 7.3: Exclude low-confidence agents
def test_route_min_score():
    router = setup_router_with_agents()

    candidates = router.route_task(
        domain="coding",
        min_score=0.7,
        top_n=5
    )

    for c in candidates:
        assert c.current_score >= 0.7

# Scenario 8.1: Detect herding behavior
def test_herding_detection():
    market = ReputationPredictionMarket()
    pred_market = create_prediction_market(market)

    # All agents bet the same way
    for i in range(10):
        market.placeBet(
            pred_market.id,
            f"agent_{i}",
            OutcomeType.SUCCESS,
            10,
            0.9
        )

    # Should trigger cascade alert
    summary = market.getMarketSummary()
    assert len(summary.cascadeAlerts) > 0
    assert summary.cascadeAlerts[-1].type == "herding"

# Scenario 8.2: Self-betting restriction
def test_self_betting_restriction():
    market = ReputationPredictionMarket()
    alice = market.registerAgent("Alice", [Domain.CODING])

    pred_market = market.createPredictionMarket(
        "task_001", "Task", Domain.CODING, alice.id, deadline
    )

    # Alice should NOT be able to bet on her own task
    # (Implementation note: may need to add this rule)
    with pytest.raises(Exception):
        market.placeBet(pred_market.id, alice.id, OutcomeType.SUCCESS, 50, 0.99)

# Scenario 8.3: Arbitrage detection
def test_arbitrage_detection():
    market = ReputationPredictionMarket()
    agent = market.registerAgent("Undervalued", [Domain.CODING])

    # Artificially set low market price
    agent.domains.get(Domain.CODING).marketPrice = 30

    # Complete several successful tasks
    for _ in range(5):
        pm = market.createPredictionMarket("task", "", Domain.CODING, agent.id, deadline)
        market.resolveMarket(pm.id, OutcomeType.SUCCESS, 0.95)

    # Should detect arbitrage opportunity
    arb = market.detectArbitrage(agent.id, Domain.CODING)
    assert arb is not None
    assert arb.recommendation == "buy"
    assert arb.fundamentalValue > arb.marketPrice

# Scenario 9.1: Partial inheritance
def test_partial_inheritance():
    tree = LineageTree(default_inheritance_ratio=0.5)

    parent = tree.register_progenitor("parent", {
        ReputationGene.RELIABILITY: 0.8,
        ReputationGene.ACCURACY: 0.9
    })

    child = tree.spawn_child("parent", "child", InheritanceMode.PARTIAL_INHERIT)
    child_profile = tree.profiles["child"]

    # Child should have 50% of parent's genes
    assert child_profile.genes[ReputationGene.RELIABILITY] == pytest.approx(0.4, 0.1)
    assert child_profile.genes[ReputationGene.ACCURACY] == pytest.approx(0.45, 0.1)
    assert child_profile.generation == 1

# Scenario 9.2: Staked reputation
def test_staked_spawn():
    tree = LineageTree()
    tree.register_progenitor("parent", {gene: 0.7 for gene in ReputationGene})

    stake = tree.stake_for_spawn("parent", "child", stake_amount=0.3)

    # Parent's available rep should decrease
    parent_profile = tree.profiles["parent"]
    assert parent_profile.effective_reputation < 0.7

    # Resolve stake with success
    tree.resolve_stake(stake.stake_id, child_performance=0.8)

    # Parent should get bonus
    assert parent_profile.effective_reputation > 0.7

# Scenario 9.3: Lineage query
def test_lineage_query():
    tree = LineageTree()
    tree.register_progenitor("grandparent")
    tree.spawn_child("grandparent", "parent")
    tree.spawn_child("parent", "child1")
    tree.spawn_child("parent", "child2")

    # Query ancestors
    ancestors = tree.get_ancestors("child1")
    assert "parent" in ancestors
    assert "grandparent" in ancestors

    # Query descendants
    descendants = tree.get_descendants("grandparent")
    assert "parent" in descendants
    assert "child1" in descendants
    assert "child2" in descendants

# Scenario 10.1: High-volume market creation
def test_high_volume_markets():
    marketplace = ReputationMarketplace()

    start = time.time()
    for i in range(1000):
        marketplace.create_market(
            PredictionType.TASK_SUCCESS,
            f"agent_{i % 100}",
            f"task_{i}"
        )
    elapsed = time.time() - start

    assert elapsed < 5.0  # Should complete in < 5 seconds

# Scenario 10.2: Cascade propagation performance
def test_cascade_performance():
    engine = CascadeEngine()

    # Create dense trust network (100 agents, ~500 edges)
    for i in range(100):
        for j in range(5):
            target = (i + j + 1) % 100
            engine.set_trust_edge(f"agent_{i}", f"agent_{target}", 0.6)

    start = time.time()
    event = engine.initiate_cascade("agent_0", 0.1, CascadeType.TRUST_SURGE)
    result = engine.run_full_cascade(event)
    elapsed = time.time() - start

    assert elapsed < 2.0  # Should complete in < 2 seconds
    assert result["agents_affected"] > 50

# Scenario 10.3: Concurrent betting
def test_concurrent_betting():
    import threading

    marketplace = ReputationMarketplace()
    market = create_market(marketplace)

    errors = []

    def place_bet(agent_id):
        try:
            marketplace.place_prediction(agent_id, market.market_id, True, 1.0, 0.5)
        except Exception as e:
            errors.append(e)

    threads = [threading.Thread(target=place_bet, args=(f"agent_{i}",)) for i in range(100)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

    assert len(errors) == 0
    assert len(market.stakes) == 100