43495bf170
✅ Architecture Audit & Rewire Completed - Fixed Python code path references in tests and miner files - Updated SystemD service ReadWritePaths to use system logs - Removed remaining production data and log directories - Updated .gitignore for additional runtime patterns - Created proper system directory structure - Restarted all services for configuration changes ✅ FHS Compliance Achieved - Data: /var/lib/aitbc/data ✅ - Config: /etc/aitbc ✅ - Logs: /var/log/aitbc ✅ - Repository: Clean of runtime files ✅ ✅ Code References Fixed - 0 repository data references ✅ - 0 repository config references ✅ - 0 repository log references ✅ ✅ Services Operational - Marketplace: Active and responding ✅ - Blockchain HTTP: Active and responding ✅ - All services using system paths ✅ 🚀 AITBC system architecture is now fully FHS compliant!
680 lines
27 KiB
Python
680 lines
27 KiB
Python
"""
|
|
Phase Integration Tests
|
|
Tests integration between different phases of the mesh network transition
|
|
"""
|
|
|
|
import pytest
|
|
import asyncio
|
|
import time
|
|
import json
|
|
from unittest.mock import Mock, patch, AsyncMock
|
|
from decimal import Decimal
|
|
|
|
# Test integration between Phase 1 (Consensus) and Phase 2 (Network)
|
|
class TestConsensusNetworkIntegration:
|
|
"""Test integration between consensus and network layers"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_consensus_with_network_discovery(self):
|
|
"""Test consensus validators using network discovery"""
|
|
# Mock network discovery
|
|
mock_discovery = Mock()
|
|
mock_discovery.get_peer_count.return_value = 10
|
|
mock_discovery.get_peer_list.return_value = [
|
|
Mock(node_id=f"validator_{i}", address=f"10.0.0.{i}", port=8000)
|
|
for i in range(10)
|
|
]
|
|
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.validators = {}
|
|
|
|
# Test that consensus can discover validators through network
|
|
peers = mock_discovery.get_peer_list()
|
|
assert len(peers) == 10
|
|
|
|
# Add network-discovered validators to consensus
|
|
for peer in peers:
|
|
mock_consensus.validators[peer.node_id] = Mock(
|
|
address=peer.address,
|
|
port=peer.port,
|
|
stake=1000.0
|
|
)
|
|
|
|
assert len(mock_consensus.validators) == 10
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_network_partition_consensus_handling(self):
|
|
"""Test how consensus handles network partitions"""
|
|
# Mock partition detection
|
|
mock_partition_manager = Mock()
|
|
mock_partition_manager.is_partitioned.return_value = True
|
|
mock_partition_manager.get_local_partition_size.return_value = 3
|
|
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.min_validators = 5
|
|
mock_consensus.current_validators = 3
|
|
|
|
# Test consensus response to partition
|
|
if mock_partition_manager.is_partitioned():
|
|
local_size = mock_partition_manager.get_local_partition_size()
|
|
if local_size < mock_consensus.min_validators:
|
|
# Should enter safe mode or pause consensus
|
|
mock_consensus.enter_safe_mode.assert_called_once()
|
|
assert True # Test passes if safe mode is called
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_peer_health_affects_consensus_participation(self):
|
|
"""Test that peer health affects consensus participation"""
|
|
# Mock health monitor
|
|
mock_health_monitor = Mock()
|
|
mock_health_monitor.get_healthy_peers.return_value = [
|
|
"validator_1", "validator_2", "validator_3"
|
|
]
|
|
mock_health_monitor.get_unhealthy_peers.return_value = [
|
|
"validator_4", "validator_5"
|
|
]
|
|
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.active_validators = ["validator_1", "validator_2", "validator_3", "validator_4", "validator_5"]
|
|
|
|
# Update consensus participation based on health
|
|
healthy_peers = mock_health_monitor.get_healthy_peers()
|
|
mock_consensus.active_validators = [
|
|
v for v in mock_consensus.active_validators
|
|
if v in healthy_peers
|
|
]
|
|
|
|
assert len(mock_consensus.active_validators) == 3
|
|
assert "validator_4" not in mock_consensus.active_validators
|
|
assert "validator_5" not in mock_consensus.active_validators
|
|
|
|
|
|
# Test integration between Phase 1 (Consensus) and Phase 3 (Economics)
|
|
class TestConsensusEconomicsIntegration:
|
|
"""Test integration between consensus and economic layers"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_staking_affects_consensus_weight(self):
|
|
"""Test that validator staking affects consensus weight"""
|
|
# Mock staking manager
|
|
mock_staking = Mock()
|
|
mock_staking.get_validator_stake_info.side_effect = lambda addr: Mock(
|
|
total_stake=Decimal('1000.0') if addr == "validator_1" else Decimal('500.0')
|
|
)
|
|
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.validators = ["validator_1", "validator_2"]
|
|
|
|
# Calculate consensus weights based on stake
|
|
validator_weights = {}
|
|
for validator in mock_consensus.validators:
|
|
stake_info = mock_staking.get_validator_stake_info(validator)
|
|
validator_weights[validator] = float(stake_info.total_stake)
|
|
|
|
assert validator_weights["validator_1"] == 1000.0
|
|
assert validator_weights["validator_2"] == 500.0
|
|
assert validator_weights["validator_1"] > validator_weights["validator_2"]
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_slashing_affects_consensus_participation(self):
|
|
"""Test that slashing affects consensus participation"""
|
|
# Mock slashing manager
|
|
mock_slashing = Mock()
|
|
mock_slashing.get_slashed_validators.return_value = ["validator_2"]
|
|
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.active_validators = ["validator_1", "validator_2", "validator_3"]
|
|
|
|
# Remove slashed validators from consensus
|
|
slashed_validators = mock_slashing.get_slashed_validators()
|
|
mock_consensus.active_validators = [
|
|
v for v in mock_consensus.active_validators
|
|
if v not in slashed_validators
|
|
]
|
|
|
|
assert "validator_2" not in mock_consensus.active_validators
|
|
assert len(mock_consensus.active_validators) == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rewards_distributed_based_on_consensus_participation(self):
|
|
"""Test that rewards are distributed based on consensus participation"""
|
|
# Mock consensus
|
|
mock_consensus = Mock()
|
|
mock_consensus.get_participation_record.return_value = {
|
|
"validator_1": 0.9, # 90% participation
|
|
"validator_2": 0.7, # 70% participation
|
|
"validator_3": 0.5 # 50% participation
|
|
}
|
|
|
|
# Mock reward distributor
|
|
mock_rewards = Mock()
|
|
total_reward = Decimal('100.0')
|
|
|
|
# Distribute rewards based on participation
|
|
participation = mock_consensus.get_participation_record()
|
|
total_participation = sum(participation.values())
|
|
|
|
for validator, rate in participation.items():
|
|
reward_share = total_reward * (rate / total_participation)
|
|
mock_rewards.distribute_reward(validator, reward_share)
|
|
|
|
# Verify reward distribution calls
|
|
assert mock_rewards.distribute_reward.call_count == 3
|
|
|
|
# Check that higher participation gets higher reward
|
|
calls = mock_rewards.distribute_reward.call_args_list
|
|
validator_1_reward = calls[0][0][1] # First call, second argument
|
|
validator_3_reward = calls[2][0][1] # Third call, second argument
|
|
assert validator_1_reward > validator_3_reward
|
|
|
|
|
|
# Test integration between Phase 2 (Network) and Phase 4 (Agents)
|
|
class TestNetworkAgentIntegration:
|
|
"""Test integration between network and agent layers"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_discovery_through_network(self):
|
|
"""Test that agents discover each other through network layer"""
|
|
# Mock network discovery
|
|
mock_network = Mock()
|
|
mock_network.find_agents_by_capability.return_value = [
|
|
Mock(agent_id="agent_1", capabilities=["text_generation"]),
|
|
Mock(agent_id="agent_2", capabilities=["image_generation"])
|
|
]
|
|
|
|
# Mock agent registry
|
|
mock_registry = Mock()
|
|
|
|
# Agent discovers other agents through network
|
|
text_agents = mock_network.find_agents_by_capability("text_generation")
|
|
image_agents = mock_network.find_agents_by_capability("image_generation")
|
|
|
|
assert len(text_agents) == 1
|
|
assert len(image_agents) == 1
|
|
assert text_agents[0].agent_id == "agent_1"
|
|
assert image_agents[0].agent_id == "agent_2"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_communication_uses_network_protocols(self):
|
|
"""Test that agent communication uses network protocols"""
|
|
# Mock communication protocol
|
|
mock_protocol = Mock()
|
|
mock_protocol.send_message.return_value = (True, "success", "msg_123")
|
|
|
|
# Mock agents
|
|
mock_agent = Mock()
|
|
mock_agent.agent_id = "agent_1"
|
|
mock_agent.communication_protocol = mock_protocol
|
|
|
|
# Agent sends message using network protocol
|
|
success, message, msg_id = mock_agent.communication_protocol.send_message(
|
|
"agent_2", "job_offer", {"job_id": "job_001", "requirements": {}}
|
|
)
|
|
|
|
assert success is True
|
|
assert msg_id == "msg_123"
|
|
mock_protocol.send_message.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_network_health_affects_agent_reputation(self):
|
|
"""Test that network health affects agent reputation"""
|
|
# Mock network health monitor
|
|
mock_health = Mock()
|
|
mock_health.get_agent_health.return_value = {
|
|
"agent_1": {"latency": 50, "availability": 0.95},
|
|
"agent_2": {"latency": 500, "availability": 0.7}
|
|
}
|
|
|
|
# Mock reputation manager
|
|
mock_reputation = Mock()
|
|
|
|
# Update reputation based on network health
|
|
health_data = mock_health.get_agent_health()
|
|
for agent_id, health in health_data.items():
|
|
if health["latency"] > 200 or health["availability"] < 0.8:
|
|
mock_reputation.update_reputation(agent_id, -0.1)
|
|
else:
|
|
mock_reputation.update_reputation(agent_id, 0.05)
|
|
|
|
# Verify reputation updates
|
|
assert mock_reputation.update_reputation.call_count == 2
|
|
mock_reputation.update_reputation.assert_any_call("agent_2", -0.1)
|
|
mock_reputation.update_reputation.assert_any_call("agent_1", 0.05)
|
|
|
|
|
|
# Test integration between Phase 3 (Economics) and Phase 5 (Contracts)
|
|
class TestEconomicsContractsIntegration:
|
|
"""Test integration between economic and contract layers"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_escrow_fees_contribute_to_economic_rewards(self):
|
|
"""Test that escrow fees contribute to economic rewards"""
|
|
# Mock escrow manager
|
|
mock_escrow = Mock()
|
|
mock_escrow.get_total_fees_collected.return_value = Decimal('10.0')
|
|
|
|
# Mock reward distributor
|
|
mock_rewards = Mock()
|
|
|
|
# Distribute rewards from escrow fees
|
|
total_fees = mock_escrow.get_total_fees_collected()
|
|
if total_fees > 0:
|
|
mock_rewards.distribute_platform_rewards(total_fees)
|
|
|
|
mock_rewards.distribute_platform_rewards.assert_called_once_with(Decimal('10.0'))
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_gas_costs_affect_agent_economics(self):
|
|
"""Test that gas costs affect agent economics"""
|
|
# Mock gas manager
|
|
mock_gas = Mock()
|
|
mock_gas.calculate_transaction_fee.return_value = Mock(
|
|
total_fee=Decimal('0.001')
|
|
)
|
|
|
|
# Mock agent economics
|
|
mock_agent = Mock()
|
|
mock_agent.wallet_balance = Decimal('10.0')
|
|
|
|
# Agent pays gas for transaction
|
|
fee_info = mock_gas.calculate_transaction_fee("job_execution", {})
|
|
mock_agent.wallet_balance -= fee_info.total_fee
|
|
|
|
assert mock_agent.wallet_balance == Decimal('9.999')
|
|
mock_gas.calculate_transaction_fee.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_staking_requirements_for_contract_execution(self):
|
|
"""Test staking requirements for contract execution"""
|
|
# Mock staking manager
|
|
mock_staking = Mock()
|
|
mock_staking.get_stake.return_value = Decimal('1000.0')
|
|
|
|
# Mock contract
|
|
mock_contract = Mock()
|
|
mock_contract.min_stake_required = Decimal('500.0')
|
|
|
|
# Check if agent has sufficient stake
|
|
agent_stake = mock_staking.get_stake("agent_1")
|
|
can_execute = agent_stake >= mock_contract.min_stake_required
|
|
|
|
assert can_execute is True
|
|
assert agent_stake >= mock_contract.min_stake_required
|
|
|
|
|
|
# Test integration between Phase 4 (Agents) and Phase 5 (Contracts)
|
|
class TestAgentContractsIntegration:
|
|
"""Test integration between agent and contract layers"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agents_participate_in_escrow_contracts(self):
|
|
"""Test that agents participate in escrow contracts"""
|
|
# Mock agent
|
|
mock_agent = Mock()
|
|
mock_agent.agent_id = "agent_1"
|
|
mock_agent.capabilities = ["text_generation"]
|
|
|
|
# Mock escrow manager
|
|
mock_escrow = Mock()
|
|
mock_escrow.create_contract.return_value = (True, "success", "contract_123")
|
|
|
|
# Agent creates escrow contract for job
|
|
success, message, contract_id = mock_escrow.create_contract(
|
|
job_id="job_001",
|
|
client_address="0xclient",
|
|
agent_address=mock_agent.agent_id,
|
|
amount=Decimal('100.0')
|
|
)
|
|
|
|
assert success is True
|
|
assert contract_id == "contract_123"
|
|
mock_escrow.create_contract.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_reputation_affects_dispute_outcomes(self):
|
|
"""Test that agent reputation affects dispute outcomes"""
|
|
# Mock agent
|
|
mock_agent = Mock()
|
|
mock_agent.agent_id = "agent_1"
|
|
|
|
# Mock reputation manager
|
|
mock_reputation = Mock()
|
|
mock_reputation.get_reputation_score.return_value = Mock(overall_score=0.9)
|
|
|
|
# Mock dispute resolver
|
|
mock_dispute = Mock()
|
|
|
|
# High reputation agent gets favorable dispute resolution
|
|
reputation = mock_reputation.get_reputation_score(mock_agent.agent_id)
|
|
if reputation.overall_score > 0.8:
|
|
resolution = {"winner": "agent", "agent_payment": 0.8}
|
|
else:
|
|
resolution = {"winner": "client", "client_refund": 0.8}
|
|
|
|
mock_dispute.resolve_dispute.return_value = (True, "resolved", resolution)
|
|
|
|
assert resolution["winner"] == "agent"
|
|
assert resolution["agent_payment"] == 0.8
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_capabilities_determine_contract_requirements(self):
|
|
"""Test that agent capabilities determine contract requirements"""
|
|
# Mock agent
|
|
mock_agent = Mock()
|
|
mock_agent.capabilities = [
|
|
Mock(capability_type="text_generation", cost_per_use=Decimal('0.001'))
|
|
]
|
|
|
|
# Mock contract
|
|
mock_contract = Mock()
|
|
|
|
# Contract requirements based on agent capabilities
|
|
for capability in mock_agent.capabilities:
|
|
mock_contract.add_requirement(
|
|
capability_type=capability.capability_type,
|
|
max_cost=capability.cost_per_use * 2 # 2x agent cost
|
|
)
|
|
|
|
# Verify contract requirements
|
|
assert mock_contract.add_requirement.call_count == 1
|
|
call_args = mock_contract.add_requirement.call_args[0]
|
|
assert call_args[0] == "text_generation"
|
|
assert call_args[1] == Decimal('0.002')
|
|
|
|
|
|
# Test full system integration
|
|
class TestFullSystemIntegration:
|
|
"""Test integration across all phases"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_end_to_end_job_execution_workflow(self):
|
|
"""Test complete job execution workflow across all phases"""
|
|
# 1. Client creates job (Phase 5: Contracts)
|
|
mock_escrow = Mock()
|
|
mock_escrow.create_contract.return_value = (True, "success", "contract_123")
|
|
|
|
success, _, contract_id = mock_escrow.create_contract(
|
|
job_id="job_001",
|
|
client_address="0xclient",
|
|
agent_address="0xagent",
|
|
amount=Decimal('100.0')
|
|
)
|
|
assert success is True
|
|
|
|
# 2. Fund contract (Phase 5: Contracts)
|
|
mock_escrow.fund_contract.return_value = (True, "funded")
|
|
success, _ = mock_escrow.fund_contract(contract_id, "tx_hash")
|
|
assert success is True
|
|
|
|
# 3. Find suitable agent (Phase 4: Agents)
|
|
mock_agent_registry = Mock()
|
|
mock_agent_registry.find_agents_by_capability.return_value = [
|
|
Mock(agent_id="agent_1", reputation=0.9)
|
|
]
|
|
|
|
agents = mock_agent_registry.find_agents_by_capability("text_generation")
|
|
assert len(agents) == 1
|
|
selected_agent = agents[0]
|
|
|
|
# 4. Network communication (Phase 2: Network)
|
|
mock_protocol = Mock()
|
|
mock_protocol.send_message.return_value = (True, "success", "msg_123")
|
|
|
|
success, _, _ = mock_protocol.send_message(
|
|
selected_agent.agent_id, "job_offer", {"contract_id": contract_id}
|
|
)
|
|
assert success is True
|
|
|
|
# 5. Agent accepts job (Phase 4: Agents)
|
|
mock_protocol.send_message.return_value = (True, "success", "msg_124")
|
|
|
|
success, _, _ = mock_protocol.send_message(
|
|
"0xclient", "job_accept", {"contract_id": contract_id, "agent_id": selected_agent.agent_id}
|
|
)
|
|
assert success is True
|
|
|
|
# 6. Consensus validates transaction (Phase 1: Consensus)
|
|
mock_consensus = Mock()
|
|
mock_consensus.validate_transaction.return_value = (True, "valid")
|
|
|
|
valid, _ = mock_consensus.validate_transaction({
|
|
"type": "job_accept",
|
|
"contract_id": contract_id,
|
|
"agent_id": selected_agent.agent_id
|
|
})
|
|
assert valid is True
|
|
|
|
# 7. Execute job and complete milestone (Phase 5: Contracts)
|
|
mock_escrow.complete_milestone.return_value = (True, "completed")
|
|
mock_escrow.verify_milestone.return_value = (True, "verified")
|
|
|
|
success, _ = mock_escrow.complete_milestone(contract_id, "milestone_1")
|
|
assert success is True
|
|
|
|
success, _ = mock_escrow.verify_milestone(contract_id, "milestone_1", True)
|
|
assert success is True
|
|
|
|
# 8. Release payment (Phase 5: Contracts)
|
|
mock_escrow.release_full_payment.return_value = (True, "released")
|
|
|
|
success, _ = mock_escrow.release_full_payment(contract_id)
|
|
assert success is True
|
|
|
|
# 9. Distribute rewards (Phase 3: Economics)
|
|
mock_rewards = Mock()
|
|
mock_rewards.distribute_agent_reward.return_value = (True, "distributed")
|
|
|
|
success, _ = mock_rewards.distribute_agent_reward(
|
|
selected_agent.agent_id, Decimal('95.0') # After fees
|
|
)
|
|
assert success is True
|
|
|
|
# 10. Update reputation (Phase 4: Agents)
|
|
mock_reputation = Mock()
|
|
mock_reputation.add_reputation_event.return_value = (True, "added")
|
|
|
|
success, _ = mock_reputation.add_reputation_event(
|
|
"job_completed", selected_agent.agent_id, contract_id, "Excellent work"
|
|
)
|
|
assert success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_system_resilience_to_failures(self):
|
|
"""Test system resilience to various failure scenarios"""
|
|
# Test network partition resilience
|
|
mock_partition_manager = Mock()
|
|
mock_partition_manager.detect_partition.return_value = True
|
|
mock_partition_manager.initiate_recovery.return_value = (True, "recovery_started")
|
|
|
|
partition_detected = mock_partition_manager.detect_partition()
|
|
if partition_detected:
|
|
success, _ = mock_partition_manager.initiate_recovery()
|
|
assert success is True
|
|
|
|
# Test consensus failure handling
|
|
mock_consensus = Mock()
|
|
mock_consensus.get_active_validators.return_value = 2 # Below minimum
|
|
mock_consensus.enter_safe_mode.return_value = (True, "safe_mode")
|
|
|
|
active_validators = mock_consensus.get_active_validators()
|
|
if active_validators < 3: # Minimum required
|
|
success, _ = mock_consensus.enter_safe_mode()
|
|
assert success is True
|
|
|
|
# Test economic incentive resilience
|
|
mock_economics = Mock()
|
|
mock_economics.get_total_staked.return_value = Decimal('1000.0')
|
|
mock_economics.emergency_measures.return_value = (True, "measures_applied")
|
|
|
|
total_staked = mock_economics.get_total_staked()
|
|
if total_staked < Decimal('5000.0'): # Minimum economic security
|
|
success, _ = mock_economics.emergency_measures()
|
|
assert success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_performance_under_load(self):
|
|
"""Test system performance under high load"""
|
|
# Simulate high transaction volume
|
|
transaction_count = 1000
|
|
start_time = time.time()
|
|
|
|
# Mock consensus processing
|
|
mock_consensus = Mock()
|
|
mock_consensus.process_transaction.return_value = (True, "processed")
|
|
|
|
# Process transactions
|
|
for i in range(transaction_count):
|
|
success, _ = mock_consensus.process_transaction(f"tx_{i}")
|
|
assert success is True
|
|
|
|
processing_time = time.time() - start_time
|
|
throughput = transaction_count / processing_time
|
|
|
|
# Should handle at least 100 transactions per second
|
|
assert throughput >= 100
|
|
|
|
# Test network performance
|
|
mock_network = Mock()
|
|
mock_network.broadcast_message.return_value = (True, "broadcasted")
|
|
|
|
start_time = time.time()
|
|
for i in range(100): # 100 broadcasts
|
|
success, _ = mock_network.broadcast_message(f"msg_{i}")
|
|
assert success is True
|
|
|
|
broadcast_time = time.time() - start_time
|
|
broadcast_throughput = 100 / broadcast_time
|
|
|
|
# Should handle at least 50 broadcasts per second
|
|
assert broadcast_throughput >= 50
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cross_phase_data_consistency(self):
|
|
"""Test data consistency across all phases"""
|
|
# Mock data stores for each phase
|
|
consensus_data = {"validators": ["v1", "v2", "v3"]}
|
|
network_data = {"peers": ["p1", "p2", "p3"]}
|
|
economics_data = {"stakes": {"v1": 1000, "v2": 1000, "v3": 1000}}
|
|
agent_data = {"agents": ["a1", "a2", "a3"]}
|
|
contract_data = {"contracts": ["c1", "c2", "c3"]}
|
|
|
|
# Test validator consistency between consensus and economics
|
|
consensus_validators = set(consensus_data["validators"])
|
|
staked_validators = set(economics_data["stakes"].keys())
|
|
|
|
assert consensus_validators == staked_validators, "Validators should be consistent between consensus and economics"
|
|
|
|
# Test agent-capability consistency
|
|
mock_agents = Mock()
|
|
mock_agents.get_all_agents.return_value = [
|
|
Mock(agent_id="a1", capabilities=["text_gen"]),
|
|
Mock(agent_id="a2", capabilities=["img_gen"]),
|
|
Mock(agent_id="a3", capabilities=["text_gen"])
|
|
]
|
|
|
|
mock_contracts = Mock()
|
|
mock_contracts.get_active_contracts.return_value = [
|
|
Mock(required_capability="text_gen"),
|
|
Mock(required_capability="img_gen")
|
|
]
|
|
|
|
agents = mock_agents.get_all_agents()
|
|
contracts = mock_contracts.get_active_contracts()
|
|
|
|
# Check that required capabilities are available
|
|
required_capabilities = set(c.required_capability for c in contracts)
|
|
available_capabilities = set()
|
|
for agent in agents:
|
|
available_capabilities.update(agent.capabilities)
|
|
|
|
assert required_capabilities.issubset(available_capabilities), "All required capabilities should be available"
|
|
|
|
|
|
# Test configuration and deployment integration
|
|
class TestConfigurationIntegration:
|
|
"""Test configuration integration across phases"""
|
|
|
|
def test_configuration_file_consistency(self):
|
|
"""Test that configuration files are consistent across phases"""
|
|
import os
|
|
|
|
config_dir = "/etc/aitbc"
|
|
configs = {
|
|
"consensus_test.json": {"min_validators": 3, "block_time": 30},
|
|
"network_test.json": {"max_peers": 50, "discovery_interval": 30},
|
|
"economics_test.json": {"min_stake": 1000, "reward_rate": 0.05},
|
|
"agent_network_test.json": {"max_agents": 1000, "reputation_threshold": 0.5},
|
|
"smart_contracts_test.json": {"escrow_fee": 0.025, "dispute_timeout": 604800}
|
|
}
|
|
|
|
for config_file, expected_values in configs.items():
|
|
config_path = os.path.join(config_dir, config_file)
|
|
assert os.path.exists(config_path), f"Missing config file: {config_file}"
|
|
|
|
with open(config_path, 'r') as f:
|
|
config_data = json.load(f)
|
|
|
|
# Check that expected keys exist
|
|
for key, expected_value in expected_values.items():
|
|
assert key in config_data, f"Missing key {key} in {config_file}"
|
|
# Don't check exact values as they may be different, just existence
|
|
|
|
def test_deployment_script_integration(self):
|
|
"""Test that deployment scripts work together"""
|
|
import os
|
|
|
|
scripts_dir = "/opt/aitbc/scripts/plan"
|
|
scripts = [
|
|
"01_consensus_setup.sh",
|
|
"02_network_infrastructure.sh",
|
|
"03_economic_layer.sh",
|
|
"04_agent_network_scaling.sh",
|
|
"05_smart_contracts.sh"
|
|
]
|
|
|
|
# Check all scripts exist and are executable
|
|
for script in scripts:
|
|
script_path = os.path.join(scripts_dir, script)
|
|
assert os.path.exists(script_path), f"Missing script: {script}"
|
|
assert os.access(script_path, os.X_OK), f"Script not executable: {script}"
|
|
|
|
def test_service_dependencies(self):
|
|
"""Test that service dependencies are correctly configured"""
|
|
# This would test that services start in the correct order
|
|
# and that dependencies are properly handled
|
|
|
|
# Expected service startup order:
|
|
# 1. Consensus service
|
|
# 2. Network service
|
|
# 3. Economic service
|
|
# 4. Agent service
|
|
# 5. Contract service
|
|
|
|
startup_order = [
|
|
"aitbc-consensus",
|
|
"aitbc-network",
|
|
"aitbc-economics",
|
|
"aitbc-agents",
|
|
"aitbc-contracts"
|
|
]
|
|
|
|
# Verify order logic
|
|
for i, service in enumerate(startup_order):
|
|
if i > 0:
|
|
# Each service should depend on the previous one
|
|
assert i > 0, f"Service {service} should depend on {startup_order[i-1]}"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pytest.main([
|
|
__file__,
|
|
"-v",
|
|
"--tb=short",
|
|
"--maxfail=3"
|
|
])
|