oib/aitbc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(security): enhance environment configuration, CI workflows, and wallet daemon with security improvements

Browse Source 
- Restructure .env.example with security-focused documentation, service-specific environment file references, and AWS Secrets Manager integration
- Update CLI tests workflow to single Python 3.13 version, add pytest-mock dependency, and consolidate test execution with coverage
- Add comprehensive security validation to package publishing workflow with manual approval gates, secret scanning, and release
This commit is contained in:
oib
2026-03-03 10:33:46 +01:00
parent 00d00cb964
commit f353e00172
220 changed files with 42506 additions and 921 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
tests/e2e/README.md
View File

@@ -2,6 +2,21 @@
This directory contains comprehensive end-to-end tests for the AITBC enhanced services, validating complete workflows, performance benchmarks, and system integration.
## 📁 Directory Structure
```
tests/e2e/
├── fixtures/ # Test fixtures and mock data
│ ├── home/ # Mock agent home directories
│ │ ├── client1/ # Client agent home
│ │ └── miner1/ # Miner agent home
│ └── __init__.py # Fixture utilities and classes
├── conftest.py # Pytest configuration
├── conftest_fixtures.py # Extended fixture configuration
├── test_*.py # Individual test files
└── README.md # This file
```
## 🎯 Test Coverage
### Test Suites
@@ -22,6 +37,49 @@ This directory contains comprehensive end-to-end tests for the AITBC enhanced se
- **Marketplace Performance**: Transaction processing, royalty calculation times
- **Concurrent Performance**: Load testing with multiple concurrent requests
## 🔧 Test Fixtures
### Home Directory Fixtures
The `tests/e2e/fixtures/home/` directory contains mock home directories for testing agent scenarios:
```python
# Using fixture home directories
def test_agent_workflow(test_home_dirs):
client_home = test_home_dirs / "client1"
miner_home = test_home_dirs / "miner1"
# Test agent operations using mock home directories
```
### Available Fixtures
- **`test_home_dirs`**: Access to fixture home directories
- **`temp_home_dirs`**: Temporary home directories for isolated testing
- **`home_dir_fixture`**: Manager for creating custom home directory setups
- **`standard_test_agents`**: Pre-configured test agents (client1, client2, miner1, miner2, agent1, agent2)
- **`cross_container_test_setup`**: Agents configured for cross-container testing
### Fixture Usage Examples
```python
def test_with_standard_agents(standard_test_agents):
"""Test using pre-configured agents"""
client1_home = standard_test_agents["client1"]
miner1_home = standard_test_agents["miner1"]
# Test logic here
def test_custom_agent_setup(home_dir_fixture):
"""Test with custom agent configuration"""
agents = home_dir_fixture.create_multi_agent_setup([
{"name": "custom_client", "type": "client", "initial_balance": 5000},
{"name": "custom_miner", "type": "miner", "initial_balance": 10000}
])
# Test logic here
```
## 🚀 Quick Start
### Prerequisites

316
tests/e2e/conftest_fixtures.py Normal file
View File

@@ -0,0 +1,316 @@
"""
E2E Test Fixtures Configuration
Extended pytest configuration for home directory fixtures
and test data management for end-to-end testing.
"""
import pytest
import tempfile
import shutil
from pathlib import Path
from typing import Dict, List, Optional
import json
import yaml
@pytest.fixture(scope="session")
def fixture_base_path():
"""Base path for all test fixtures"""
return Path(__file__).parent / "fixtures"
@pytest.fixture(scope="session")
def test_home_dirs(fixture_base_path):
"""Access to test home directories"""
home_path = fixture_base_path / "home"
if not home_path.exists():
pytest.skip("Test home directories not found")
return home_path
@pytest.fixture
def temp_home_dirs():
"""Create temporary home directories for testing"""
with tempfile.TemporaryDirectory() as temp_dir:
base_path = Path(temp_dir)
# Create standard AITBC home structure
agents = {}
for agent_name in ["test_client", "test_miner", "test_agent"]:
agent_path = base_path / agent_name
agent_path.mkdir(exist_ok=True)
# Create AITBC directory structure
aitbc_dir = agent_path / ".aitbc"
aitbc_dir.mkdir(exist_ok=True)
(aitbc_dir / "wallets").mkdir(exist_ok=True)
(aitbc_dir / "config").mkdir(exist_ok=True)
(aitbc_dir / "cache").mkdir(exist_ok=True)
# Create default configuration
config_data = {
"agent": {
"name": agent_name,
"type": "client" if "client" in agent_name else "miner" if "miner" in agent_name else "agent",
"wallet_path": f"~/.aitbc/wallets/{agent_name}_wallet.json"
},
"node": {
"endpoint": "http://localhost:8082",
"timeout": 30
},
"coordinator": {
"url": "http://localhost:8000",
"api_key": None
}
}
config_file = aitbc_dir / "config.yaml"
with open(config_file, 'w') as f:
yaml.dump(config_data, f, default_flow_style=False)
agents[agent_name] = agent_path
yield agents
# Cleanup is handled by tempfile
@pytest.fixture
def mock_agent_wallet(temp_home_dirs):
"""Create a mock agent wallet for testing"""
agent_path = temp_home_dirs["test_client"]
wallet_path = agent_path / ".aitbc" / "wallets" / "test_client_wallet.json"
wallet_data = {
"address": "aitbc1testclient",
"balance": 1000,
"transactions": [],
"created_at": "2026-03-03T00:00:00Z"
}
with open(wallet_path, 'w') as f:
json.dump(wallet_data, f, indent=2)
return wallet_data
@pytest.fixture
def mock_miner_wallet(temp_home_dirs):
"""Create a mock miner wallet for testing"""
agent_path = temp_home_dirs["test_miner"]
wallet_path = agent_path / ".aitbc" / "wallets" / "test_miner_wallet.json"
wallet_data = {
"address": "aitbc1testminer",
"balance": 5000,
"transactions": [],
"created_at": "2026-03-03T00:00:00Z",
"mining_rewards": 2000
}
with open(wallet_path, 'w') as f:
json.dump(wallet_data, f, indent=2)
return wallet_data
class HomeDirFixture:
"""Helper class for managing home directory fixtures"""
def __init__(self, base_path: Path):
self.base_path = base_path
self.created_dirs: List[Path] = []
def create_agent_home(self,
agent_name: str,
agent_type: str = "agent",
initial_balance: int = 0) -> Path:
"""Create a new agent home directory with AITBC structure"""
agent_path = self.base_path / agent_name
agent_path.mkdir(exist_ok=True)
# Create AITBC directory structure
aitbc_dir = agent_path / ".aitbc"
aitbc_dir.mkdir(exist_ok=True)
(aitbc_dir / "wallets").mkdir(exist_ok=True)
(aitbc_dir / "config").mkdir(exist_ok=True)
(aitbc_dir / "cache").mkdir(exist_ok=True)
# Create configuration
config_data = {
"agent": {
"name": agent_name,
"type": agent_type,
"wallet_path": f"~/.aitbc/wallets/{agent_name}_wallet.json"
},
"node": {
"endpoint": "http://localhost:8082",
"timeout": 30
},
"coordinator": {
"url": "http://localhost:8000",
"api_key": None
}
}
config_file = aitbc_dir / "config.yaml"
with open(config_file, 'w') as f:
yaml.dump(config_data, f, default_flow_style=False)
# Create wallet
wallet_data = {
"address": f"aitbc1{agent_name}",
"balance": initial_balance,
"transactions": [],
"created_at": "2026-03-03T00:00:00Z"
}
wallet_file = aitbc_dir / "wallets" / f"{agent_name}_wallet.json"
with open(wallet_file, 'w') as f:
json.dump(wallet_data, f, indent=2)
self.created_dirs.append(agent_path)
return agent_path
def create_multi_agent_setup(self, agent_configs: List[Dict]) -> Dict[str, Path]:
"""Create multiple agent homes from configuration"""
agents = {}
for config in agent_configs:
agent_path = self.create_agent_home(
agent_name=config["name"],
agent_type=config["type"],
initial_balance=config.get("initial_balance", 0)
)
agents[config["name"]] = agent_path
return agents
def get_agent_config(self, agent_name: str) -> Optional[Dict]:
"""Get configuration for an agent"""
agent_path = self.base_path / agent_name
config_file = agent_path / ".aitbc" / "config.yaml"
if config_file.exists():
with open(config_file, 'r') as f:
return yaml.safe_load(f)
return None
def get_agent_wallet(self, agent_name: str) -> Optional[Dict]:
"""Get wallet data for an agent"""
agent_path = self.base_path / agent_name
wallet_file = agent_path / ".aitbc" / "wallets" / f"{agent_name}_wallet.json"
if wallet_file.exists():
with open(wallet_file, 'r') as f:
return json.load(f)
return None
def cleanup(self):
"""Clean up all created directories"""
for dir_path in self.created_dirs:
if dir_path.exists():
shutil.rmtree(dir_path)
self.created_dirs.clear()
@pytest.fixture
def home_dir_fixture(tmp_path):
"""Create a home directory fixture manager"""
fixture = HomeDirFixture(tmp_path)
yield fixture
fixture.cleanup()
@pytest.fixture
def standard_test_agents(home_dir_fixture):
"""Create standard test agents for E2E testing"""
agent_configs = [
{"name": "client1", "type": "client", "initial_balance": 1000},
{"name": "client2", "type": "client", "initial_balance": 500},
{"name": "miner1", "type": "miner", "initial_balance": 2000},
{"name": "miner2", "type": "miner", "initial_balance": 1500},
{"name": "agent1", "type": "agent", "initial_balance": 800},
{"name": "agent2", "type": "agent", "initial_balance": 1200}
]
return home_dir_fixture.create_multi_agent_setup(agent_configs)
@pytest.fixture
def cross_container_test_setup(home_dir_fixture):
"""Create test setup for cross-container E2E tests"""
# Create agents for different containers/sites
agent_configs = [
{"name": "localhost_client", "type": "client", "initial_balance": 1000},
{"name": "aitbc_client", "type": "client", "initial_balance": 2000},
{"name": "aitbc1_client", "type": "client", "initial_balance": 1500},
{"name": "localhost_miner", "type": "miner", "initial_balance": 3000},
{"name": "aitbc_miner", "type": "miner", "initial_balance": 2500},
{"name": "aitbc1_miner", "type": "miner", "initial_balance": 2800}
]
return home_dir_fixture.create_multi_agent_setup(agent_configs)
# Helper functions for test development
def create_test_transaction(from_addr: str, to_addr: str, amount: int, tx_hash: str = None) -> Dict:
"""Create a test transaction for wallet testing"""
import hashlib
if tx_hash is None:
tx_hash = hashlib.sha256(f"{from_addr}{to_addr}{amount}".encode()).hexdigest()
return {
"hash": tx_hash,
"from": from_addr,
"to": to_addr,
"amount": amount,
"timestamp": "2026-03-03T12:00:00Z",
"type": "transfer",
"status": "confirmed"
}
def add_transaction_to_wallet(wallet_path: Path, transaction: Dict):
"""Add a transaction to a wallet file"""
with open(wallet_path, 'r') as f:
wallet_data = json.load(f)
wallet_data["transactions"].append(transaction)
# Update balance for outgoing transactions
if transaction["from"] == wallet_data["address"]:
wallet_data["balance"] -= transaction["amount"]
# Update balance for incoming transactions
elif transaction["to"] == wallet_data["address"]:
wallet_data["balance"] += transaction["amount"]
with open(wallet_path, 'w') as f:
json.dump(wallet_data, f, indent=2)
def verify_wallet_state(wallet_path: Path, expected_balance: int, min_transactions: int = 0) -> bool:
"""Verify wallet state matches expectations"""
with open(wallet_path, 'r') as f:
wallet_data = json.load(f)
return (
wallet_data["balance"] == expected_balance and
len(wallet_data["transactions"]) >= min_transactions
)
# Pytest markers for categorizing E2E tests
pytest.mark.e2e_home_dirs = pytest.mark.e2e_home_dirs("Tests that use home directory fixtures")
pytest.mark.cross_container = pytest.mark.cross_container("Tests that span multiple containers")
pytest.mark.agent_simulation = pytest.mark.agent_simulation("Tests that simulate agent behavior")
pytest.mark.wallet_management = pytest.mark.wallet_management("Tests that focus on wallet operations")

222
tests/e2e/fixtures/__init__.py Normal file
View File

@@ -0,0 +1,222 @@
"""
E2E Test Fixtures
This package contains fixtures and test data for end-to-end testing,
including mock home directories for agents and users.
"""
import os
from pathlib import Path
from typing import Dict, List
import pytest
@pytest.fixture
def mock_home_dir():
"""Create a temporary mock home directory for testing"""
import tempfile
with tempfile.TemporaryDirectory() as temp_dir:
home_path = Path(temp_dir)
# Create standard AITBC home directory structure
(home_path / ".aitbc").mkdir(exist_ok=True)
(home_path / ".aitbc" / "wallets").mkdir(exist_ok=True)
(home_path / ".aitbc" / "config").mkdir(exist_ok=True)
(home_path / ".aitbc" / "cache").mkdir(exist_ok=True)
yield home_path
@pytest.fixture
def agent_home_dirs():
"""Create mock agent home directories for testing"""
import tempfile
with tempfile.TemporaryDirectory() as temp_dir:
base_path = Path(temp_dir)
# Create agent home directories
agents = {}
for agent_name in ["client1", "miner1", "agent1", "agent2"]:
agent_path = base_path / agent_name
agent_path.mkdir(exist_ok=True)
# Create AITBC structure
(agent_path / ".aitbc").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "wallets").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "config").mkdir(exist_ok=True)
# Create default config
config_file = agent_path / ".aitbc" / "config.yaml"
config_file.write_text(f"""
agent:
name: {agent_name}
type: {"client" if "client" in agent_name else "miner" if "miner" in agent_name else "agent"}
wallet_path: ~/.aitbc/wallets/{agent_name}_wallet.json
node:
endpoint: http://localhost:8082
timeout: 30
coordinator:
url: http://localhost:8000
api_key: null
""")
agents[agent_name] = agent_path
yield agents
@pytest.fixture
def fixture_home_dirs():
"""Access to the actual fixture home directories"""
fixture_path = Path(__file__).parent / "home"
if not fixture_path.exists():
pytest.skip("Fixture home directories not found")
return fixture_path
class HomeDirManager:
"""Manager for test home directories"""
def __init__(self, base_path: Path):
self.base_path = base_path
self.created_dirs: List[Path] = []
def create_agent_home(self, agent_name: str, agent_type: str = "agent") -> Path:
"""Create a new agent home directory"""
agent_path = self.base_path / agent_name
agent_path.mkdir(exist_ok=True)
# Create AITBC structure
(agent_path / ".aitbc").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "wallets").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "config").mkdir(exist_ok=True)
# Create default config
config_file = agent_path / ".aitbc" / "config.yaml"
config_file.write_text(f"""
agent:
name: {agent_name}
type: {agent_type}
wallet_path: ~/.aitbc/wallets/{agent_name}_wallet.json
node:
endpoint: http://localhost:8082
timeout: 30
coordinator:
url: http://localhost:8000
api_key: null
""")
self.created_dirs.append(agent_path)
return agent_path
def create_wallet(self, agent_name: str, address: str, balance: int = 0) -> Path:
"""Create a wallet file for an agent"""
agent_path = self.base_path / agent_name
wallet_path = agent_path / ".aitbc" / "wallets" / f"{agent_name}_wallet.json"
wallet_data = {
"address": address,
"balance": balance,
"transactions": [],
"created_at": "2026-03-03T00:00:00Z"
}
import json
wallet_path.write_text(json.dumps(wallet_data, indent=2))
return wallet_path
def cleanup(self):
"""Clean up created directories"""
for dir_path in self.created_dirs:
if dir_path.exists():
import shutil
shutil.rmtree(dir_path)
self.created_dirs.clear()
@pytest.fixture
def home_dir_manager(tmp_path):
"""Create a home directory manager for tests"""
manager = HomeDirManager(tmp_path)
yield manager
manager.cleanup()
# Constants for fixture paths
FIXTURE_HOME_PATH = Path(__file__).parent / "home"
CLIENT1_HOME_PATH = FIXTURE_HOME_PATH / "client1"
MINER1_HOME_PATH = FIXTURE_HOME_PATH / "miner1"
def get_fixture_home_path(agent_name: str) -> Path:
"""Get the path to a fixture home directory"""
return FIXTURE_HOME_PATH / agent_name
def fixture_home_exists(agent_name: str) -> bool:
"""Check if a fixture home directory exists"""
return get_fixture_home_path(agent_name).exists()
def create_test_wallet(agent_name: str, address: str, balance: int = 0) -> Dict:
"""Create test wallet data"""
return {
"address": address,
"balance": balance,
"transactions": [],
"created_at": "2026-03-03T00:00:00Z",
"agent_name": agent_name
}
def setup_fixture_homes():
"""Set up the fixture home directories if they don't exist"""
fixture_path = FIXTURE_HOME_PATH
if not fixture_path.exists():
fixture_path.mkdir(parents=True, exist_ok=True)
# Create standard agent homes
for agent_name, agent_type in [("client1", "client"), ("miner1", "miner")]:
agent_path = fixture_path / agent_name
agent_path.mkdir(exist_ok=True)
# Create AITBC structure
(agent_path / ".aitbc").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "wallets").mkdir(exist_ok=True)
(agent_path / ".aitbc" / "config").mkdir(exist_ok=True)
# Create default config
config_file = agent_path / ".aitbc" / "config.yaml"
config_file.write_text(f"""
agent:
name: {agent_name}
type: {agent_type}
wallet_path: ~/.aitbc/wallets/{agent_name}_wallet.json
node:
endpoint: http://localhost:8082
timeout: 30
coordinator:
url: http://localhost:8000
api_key: null
""")
# Create empty wallet
wallet_file = agent_path / ".aitbc" / "wallets" / f"{agent_name}_wallet.json"
wallet_data = create_test_wallet(agent_name, f"aitbc1{agent_name}", 1000)
import json
wallet_file.write_text(json.dumps(wallet_data, indent=2))
# Ensure fixture homes exist when this module is imported
setup_fixture_homes()

13
tests/e2e/fixtures/home/client1/.aitbc/config.yaml Normal file
View File

@@ -0,0 +1,13 @@
agent:
name: client1
type: client
wallet_path: ~/.aitbc/wallets/client1_wallet.json
node:
endpoint: http://localhost:8082
timeout: 30
coordinator:
url: http://localhost:8000
api_key: null

49
tests/e2e/fixtures/home/client1/answer.txt Normal file
View File

@@ -0,0 +1,49 @@
Okay, this is a hugely exciting and rapidly evolving area! The future of AI in decentralized systems is looking remarkably bright, and blockchain technology is a pivotal enabler. Here’s a breakdown of what we can expect, broken down into key areas:
**1. The Future Landscape of AI in Decentralized Systems**
* **Increased Automation & Scalability:** Current decentralized systems (like DAOs, DeFi, and gaming) often struggle with complex decision-making and scalability. AI will be crucial to automate these processes, making them more efficient and less reliant on human intervention. Think of AI-powered automated market makers, smart contracts executing complex scenarios, and personalized asset management.
* **Enhanced Data Analysis & Insights:** Decentralized data is invaluable. AI will be used to analyze this data – identifying patterns, anomalies, and opportunities – far more effectively than traditional methods. This will lead to smarter governance, optimized resource allocation, and better risk assessment.
* **Personalized & Adaptive Experiences:** AI will personalize user experiences within decentralized platforms. Instead of relying on rigid rules, AI will understand individual behavior and preferences to tailor everything from content recommendations to loan terms.
* **Novel AI Models & Architectures:** We’ll see the development of AI models specifically designed for decentralized environments. This includes models that are:
* **Federated Learning:** Allows models to be trained across multiple decentralized nodes without sharing raw data, improving privacy and model robustness.
* **Differential Privacy:** Protects individual data points while still allowing for analysis, which is critical for privacy-preserving AI.
* **Secure Multi-Party Computation (SMPC):** Enables multiple parties to jointly compute a result without revealing their individual inputs.
* **AI-Driven Governance & Decentralized Autonomous Organizations (DAOs):** AI will be integrated into DAOs to:
* **Automate Governance:** AI can analyze proposals, vote flows, and community sentiment to suggest optimal governance strategies.
* **Identify & Mitigate Risks:** AI can detect potential risks like collusion or malicious activity within a DAO.
* **Optimize Resource Allocation:** AI can allocate funds and resources to projects based on community demand and potential impact.
**2. How Blockchain Technology Enhances AI Model Sharing & Governance**
Blockchain is *absolutely* the key technology here. Here's how it’s transforming AI governance:
* **Immutable Record of AI Models:** Blockchain creates an immutable record of every step in the AI model lifecycle – training data, model versions, validation results, and even the model’s performance metrics. This ensures transparency and auditability.
* **Decentralized Model Sharing:** Instead of relying on centralized platforms like Hugging Face, models can be shared and distributed directly across the blockchain network. This creates a trustless ecosystem, reducing the risk of model manipulation or censorship.
* **Smart Contracts for Model Licensing & Royalty Payments:** Smart contracts can automate licensing agreements, distribute royalties to data providers, and manage intellectual property rights related to AI models. This is crucial for incentivizing collaboration and ensuring fair compensation.
* **Tokenization of AI Models:** Models can be tokenized (represented as unique digital assets) which can be used as collateral for loans, voting rights, or other incentives within the decentralized ecosystem. This unlocks new uses for AI assets.
* **Reputation Systems:** Blockchain-based reputation systems can reward contributors and penalize malicious behavior, fostering a more trustworthy and collaborative environment for AI model development.
* **Decentralized Verification & Validation:** The blockchain can be used to verify the accuracy and reliability of AI model outputs. Different parties can validate the results, building confidence in the model's output.
* **DAO Governance & Trust:** Blockchain-based DAOs allow for decentralized decision-making on AI model deployment, updates, and governance – shifting control away from a single entity.
**3. Challenges & Considerations**
* **Scalability:** Blockchain can be slow and expensive, hindering the scalability needed for large-scale AI deployments. Layer-2 solutions and alternative blockchains are being explored.
* **Regulation:** The legal and regulatory landscape surrounding AI is still evolving. Decentralized AI systems need to navigate these complexities.
* **Data Privacy:** While blockchain can enhance transparency, it’s crucial to implement privacy-preserving techniques to protect sensitive data within AI models.
* **Computational Costs:** Running AI models on blockchain can be resource-intensive. Optimization and efficient model design are essential.
**Resources for Further Learning:**
* **Blockchain and AI:** [https://www.blockchainandai.com/](https://www.blockchainandai.com/)
* **Decentralized AI:** [https://www.decentralizedai.com/](https://www.decentralizedai.com/)
* **Ethereum Foundation - AI:** [https://ethereumfoundation.org/news/ethereum-foundation-ai](https://ethereumfoundation.org/news/ethereum-foundation-ai)
To help me tailor my response further, could you tell me:
* What specific area of AI are you most interested in (e.g., Generative AI, Machine Learning, Blockchain integration)?
* What kind of decentralized system are you thinking of (e.g., DeFi, DAOs, Gaming, Supply Chain)?

13
tests/e2e/fixtures/home/miner1/.aitbc/config.yaml Normal file
View File

@@ -0,0 +1,13 @@
agent:
name: miner1
type: miner
wallet_path: ~/.aitbc/wallets/miner1_wallet.json
node:
endpoint: http://localhost:8082
timeout: 30
coordinator:
url: http://localhost:8000
api_key: null

1
tests/e2e/fixtures/home/miner1/question.txt Normal file
View File

@@ -0,0 +1 @@
What is the future of artificial intelligence in decentralized systems, and how will blockchain technology enhance AI model sharing and governance?

146
tests/e2e/test_fixture_verification.py Normal file
View File

@@ -0,0 +1,146 @@
"""
Test to verify the home directory fixture system works correctly
"""
import pytest
from pathlib import Path
from tests.e2e.fixtures import (
FIXTURE_HOME_PATH,
CLIENT1_HOME_PATH,
MINER1_HOME_PATH,
get_fixture_home_path,
fixture_home_exists
)
def test_fixture_paths_exist():
"""Test that all fixture paths exist"""
assert FIXTURE_HOME_PATH.exists(), f"Fixture home path {FIXTURE_HOME_PATH} does not exist"
assert CLIENT1_HOME_PATH.exists(), f"Client1 home path {CLIENT1_HOME_PATH} does not exist"
assert MINER1_HOME_PATH.exists(), f"Miner1 home path {MINER1_HOME_PATH} does not exist"
def test_fixture_helper_functions():
"""Test fixture helper functions work correctly"""
# Test get_fixture_home_path
client1_path = get_fixture_home_path("client1")
miner1_path = get_fixture_home_path("miner1")
assert client1_path == CLIENT1_HOME_PATH
assert miner1_path == MINER1_HOME_PATH
# Test fixture_home_exists
assert fixture_home_exists("client1") is True
assert fixture_home_exists("miner1") is True
assert fixture_home_exists("nonexistent") is False
def test_fixture_structure():
"""Test that fixture directories have the expected structure"""
# Check client1 structure
client1_aitbc = CLIENT1_HOME_PATH / ".aitbc"
assert client1_aitbc.exists(), "Client1 .aitbc directory should exist"
client1_wallets = client1_aitbc / "wallets"
client1_config = client1_aitbc / "config"
client1_cache = client1_aitbc / "cache"
assert client1_wallets.exists(), "Client1 wallets directory should exist"
assert client1_config.exists(), "Client1 config directory should exist"
assert client1_cache.exists(), "Client1 cache directory should exist"
# Check miner1 structure
miner1_aitbc = MINER1_HOME_PATH / ".aitbc"
assert miner1_aitbc.exists(), "Miner1 .aitbc directory should exist"
miner1_wallets = miner1_aitbc / "wallets"
miner1_config = miner1_aitbc / "config"
miner1_cache = miner1_aitbc / "cache"
assert miner1_wallets.exists(), "Miner1 wallets directory should exist"
assert miner1_config.exists(), "Miner1 config directory should exist"
assert miner1_cache.exists(), "Miner1 cache directory should exist"
def test_fixture_config_files():
"""Test that fixture config files exist and are readable"""
import yaml
# Check client1 config
client1_config_file = CLIENT1_HOME_PATH / ".aitbc" / "config.yaml"
assert client1_config_file.exists(), "Client1 config.yaml should exist"
with open(client1_config_file, 'r') as f:
client1_config = yaml.safe_load(f)
assert "agent" in client1_config, "Client1 config should have agent section"
assert client1_config["agent"]["name"] == "client1", "Client1 config should have correct name"
# Check miner1 config
miner1_config_file = MINER1_HOME_PATH / ".aitbc" / "config.yaml"
assert miner1_config_file.exists(), "Miner1 config.yaml should exist"
with open(miner1_config_file, 'r') as f:
miner1_config = yaml.safe_load(f)
assert "agent" in miner1_config, "Miner1 config should have agent section"
assert miner1_config["agent"]["name"] == "miner1", "Miner1 config should have correct name"
def test_fixture_wallet_files():
"""Test that fixture wallet files exist and have correct structure"""
import json
# Check client1 wallet
client1_wallet_file = CLIENT1_HOME_PATH / ".aitbc" / "wallets" / "client1_wallet.json"
assert client1_wallet_file.exists(), "Client1 wallet file should exist"
with open(client1_wallet_file, 'r') as f:
client1_wallet = json.load(f)
assert "address" in client1_wallet, "Client1 wallet should have address"
assert "balance" in client1_wallet, "Client1 wallet should have balance"
assert "transactions" in client1_wallet, "Client1 wallet should have transactions list"
assert client1_wallet["address"] == "aitbc1client1", "Client1 wallet should have correct address"
# Check miner1 wallet
miner1_wallet_file = MINER1_HOME_PATH / ".aitbc" / "wallets" / "miner1_wallet.json"
assert miner1_wallet_file.exists(), "Miner1 wallet file should exist"
with open(miner1_wallet_file, 'r') as f:
miner1_wallet = json.load(f)
assert "address" in miner1_wallet, "Miner1 wallet should have address"
assert "balance" in miner1_wallet, "Miner1 wallet should have balance"
assert "transactions" in miner1_wallet, "Miner1 wallet should have transactions list"
assert miner1_wallet["address"] == "aitbc1miner1", "Miner1 wallet should have correct address"
def test_fixture_import():
"""Test that fixtures can be imported correctly"""
from tests.e2e.fixtures import (
HomeDirManager,
create_test_wallet,
setup_fixture_homes
)
# Test that classes are importable
assert HomeDirManager is not None, "HomeDirManager should be importable"
# Test that functions are importable
assert callable(create_test_wallet), "create_test_wallet should be callable"
assert callable(setup_fixture_homes), "setup_fixture_homes should be callable"
# Test create_test_wallet function
test_wallet = create_test_wallet("test_agent", "aitbc1test", 500)
expected_keys = {"address", "balance", "transactions", "created_at", "agent_name"}
assert set(test_wallet.keys()) == expected_keys, "Test wallet should have all expected keys"
assert test_wallet["address"] == "aitbc1test", "Test wallet should have correct address"
assert test_wallet["balance"] == 500, "Test wallet should have correct balance"
assert test_wallet["agent_name"] == "test_agent", "Test wallet should have correct agent name"
if __name__ == "__main__":
pytest.main([__file__, "-v"])