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

Add sys import to test files and remove obsolete integration tests
Some checks failed
API Endpoint Tests / test-api-endpoints (push) Successful in 9s
Details
Blockchain Synchronization Verification / sync-verification (push) Failing after 1s
Details
CLI Tests / test-cli (push) Failing after 3s
Details
Documentation Validation / validate-docs (push) Successful in 6s
Details
Documentation Validation / validate-policies-strict (push) Successful in 2s
Details
Integration Tests / test-service-integration (push) Successful in 40s
Details
Multi-Node Blockchain Health Monitoring / health-check (push) Successful in 1s
Details
P2P Network Verification / p2p-verification (push) Successful in 2s
Details
Production Tests / Production Integration Tests (push) Successful in 21s
Details
Python Tests / test-python (push) Successful in 13s
Details
Security Scanning / security-scan (push) Failing after 46s
Details
Smart Contract Tests / test-solidity (map[name:aitbc-token path:packages/solidity/aitbc-token]) (push) Successful in 17s
Details
Smart Contract Tests / lint-solidity (push) Successful in 10s
Details

Browse Source 
- Add sys import to 29 test files across agent-coordinator, blockchain-event-bridge, blockchain-node, and coordinator-api
- Remove apps/blockchain-event-bridge/tests/test_integration.py (obsolete bridge integration tests)
- Remove apps/coordinator-api/tests/test_integration.py (obsolete API integration tests)
- Implement GPU registration in marketplace_gpu.py with GPURegistry model persistence
This commit is contained in:
aitbc
2026-04-23 16:43:17 +02:00
parent b8b1454573
commit e60cc3226c
134 changed files with 14321 additions and 1873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
apps/marketplace/tests/__init__.py Normal file
View File

@@ -0,0 +1 @@
"""Agent marketplace service tests"""

250
apps/marketplace/tests/test_edge_cases_marketplace.py Normal file
View File

@@ -0,0 +1,250 @@
"""Edge case and error handling tests for agent marketplace service"""
import pytest
import sys
import sys
from pathlib import Path
from fastapi.testclient import TestClient
from agent_marketplace import app, GPUOffering, DealRequest, DealConfirmation, MinerRegistration, gpu_offerings, marketplace_deals, miner_registrations, chain_offerings
@pytest.fixture(autouse=True)
def reset_state():
"""Reset global state before each test"""
gpu_offerings.clear()
marketplace_deals.clear()
miner_registrations.clear()
chain_offerings.clear()
yield
gpu_offerings.clear()
marketplace_deals.clear()
miner_registrations.clear()
chain_offerings.clear()
@pytest.mark.unit
def test_gpu_offering_empty_chains():
"""Test GPUOffering with empty chains"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=[],
capabilities=["inference"]
)
assert offering.chains == []
@pytest.mark.unit
def test_gpu_offering_empty_capabilities():
"""Test GPUOffering with empty capabilities"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=[]
)
assert offering.capabilities == []
@pytest.mark.unit
def test_miner_registration_empty_chains():
"""Test MinerRegistration with empty preferred chains"""
registration = MinerRegistration(
miner_id="miner_123",
wallet_address="0x1234567890abcdef",
preferred_chains=[],
gpu_specs={"model": "RTX 4090"}
)
assert registration.preferred_chains == []
@pytest.mark.unit
def test_deal_request_empty_offering_id():
"""Test DealRequest with empty offering_id"""
request = DealRequest(
offering_id="",
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
assert request.offering_id == ""
@pytest.mark.unit
def test_deal_confirmation_empty_deal_id():
"""Test DealConfirmation with empty deal_id"""
confirmation = DealConfirmation(
deal_id="",
miner_confirmation=True,
chain="ait-devnet"
)
assert confirmation.deal_id == ""
@pytest.mark.integration
def test_get_gpu_offerings_empty():
"""Test getting GPU offerings when none exist"""
client = TestClient(app)
response = client.get("/api/v1/offerings")
assert response.status_code == 200
data = response.json()
assert data["total_count"] == 0
@pytest.mark.integration
def test_get_deals_empty():
"""Test getting deals when none exist"""
client = TestClient(app)
response = client.get("/api/v1/deals")
assert response.status_code == 200
data = response.json()
assert data["total_count"] == 0
@pytest.mark.integration
def test_get_miner_offerings_no_offerings():
"""Test getting offerings for miner with no offerings"""
client = TestClient(app)
response = client.get("/api/v1/miners/miner_123/offerings")
assert response.status_code == 200
data = response.json()
assert data["total_count"] == 0
@pytest.mark.integration
def test_get_chain_offerings_no_offerings():
"""Test getting chain offerings when none exist"""
client = TestClient(app)
response = client.get("/api/v1/chains/ait-devnet/offerings")
assert response.status_code == 200
data = response.json()
assert data["total_count"] == 0
@pytest.mark.integration
def test_request_deal_offering_not_available():
"""Test requesting deal for unavailable offering"""
client = TestClient(app)
# Create an offering
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
# Mark as occupied
gpu_offerings[offering_id]["status"] = "occupied"
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
assert response.status_code == 400
@pytest.mark.integration
def test_confirm_deal_already_confirmed():
"""Test confirming a deal that's already confirmed"""
client = TestClient(app)
# Create offering and request deal
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
deal_response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
deal_id = deal_response.json()["deal_id"]
# Confirm the deal
confirmation = DealConfirmation(
deal_id=deal_id,
miner_confirmation=True,
chain="ait-devnet"
)
client.post(f"/api/v1/deals/{deal_id}/confirm", json=confirmation.model_dump())
# Try to confirm again
response = client.post(f"/api/v1/deals/{deal_id}/confirm", json=confirmation.model_dump())
assert response.status_code == 400
@pytest.mark.integration
def test_confirm_deal_chain_mismatch():
"""Test confirming deal with wrong chain"""
client = TestClient(app)
# Create offering and request deal
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
deal_response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
deal_id = deal_response.json()["deal_id"]
# Confirm with wrong chain
confirmation = DealConfirmation(
deal_id=deal_id,
miner_confirmation=True,
chain="ait-testnet"
)
response = client.post(f"/api/v1/deals/{deal_id}/confirm", json=confirmation.model_dump())
assert response.status_code == 400
@pytest.mark.integration
def test_get_marketplace_stats_empty():
"""Test getting marketplace stats with no data"""
client = TestClient(app)
response = client.get("/api/v1/stats")
assert response.status_code == 200
data = response.json()
assert data["total_offerings"] == 0
assert data["active_deals"] == 0

506
apps/marketplace/tests/test_integration_marketplace.py Normal file
View File

@@ -0,0 +1,506 @@
"""Integration tests for agent marketplace service"""
import pytest
import sys
import sys
from pathlib import Path
from fastapi.testclient import TestClient
from agent_marketplace import app, GPUOffering, DealRequest, DealConfirmation, MinerRegistration, gpu_offerings, marketplace_deals, miner_registrations, chain_offerings
@pytest.fixture(autouse=True)
def reset_state():
"""Reset global state before each test"""
gpu_offerings.clear()
marketplace_deals.clear()
miner_registrations.clear()
chain_offerings.clear()
yield
gpu_offerings.clear()
marketplace_deals.clear()
miner_registrations.clear()
chain_offerings.clear()
@pytest.mark.integration
def test_health_check():
"""Test health check endpoint"""
client = TestClient(app)
response = client.get("/health")
assert response.status_code == 200
data = response.json()
assert data["status"] == "ok"
assert "supported_chains" in data
@pytest.mark.integration
def test_get_supported_chains():
"""Test getting supported chains"""
client = TestClient(app)
response = client.get("/api/v1/chains")
assert response.status_code == 200
data = response.json()
assert "chains" in data
@pytest.mark.integration
def test_register_miner():
"""Test registering a miner"""
client = TestClient(app)
registration = MinerRegistration(
miner_id="miner_123",
wallet_address="0x1234567890abcdef",
preferred_chains=["ait-devnet"],
gpu_specs={"model": "RTX 4090"}
)
response = client.post("/api/v1/miners/register", json=registration.model_dump())
assert response.status_code == 200
data = response.json()
assert data["success"] is True
assert data["miner_id"] == "miner_123"
@pytest.mark.integration
def test_register_miner_update_existing():
"""Test updating existing miner registration"""
client = TestClient(app)
registration = MinerRegistration(
miner_id="miner_123",
wallet_address="0x1234567890abcdef",
preferred_chains=["ait-devnet"],
gpu_specs={"model": "RTX 4090"}
)
client.post("/api/v1/miners/register", json=registration.model_dump())
# Update with new data
registration.wallet_address = "0xabcdef1234567890"
response = client.post("/api/v1/miners/register", json=registration.model_dump())
assert response.status_code == 200
@pytest.mark.integration
def test_create_gpu_offering():
"""Test creating a GPU offering"""
client = TestClient(app)
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
response = client.post("/api/v1/offerings/create", json=offering.model_dump())
assert response.status_code == 200
data = response.json()
assert data["success"] is True
assert "offering_id" in data
@pytest.mark.integration
def test_create_gpu_offering_invalid_chain():
"""Test creating GPU offering with invalid chain"""
client = TestClient(app)
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["invalid-chain"],
capabilities=["inference"]
)
response = client.post("/api/v1/offerings/create", json=offering.model_dump())
assert response.status_code == 400
@pytest.mark.integration
def test_get_gpu_offerings():
"""Test getting GPU offerings"""
client = TestClient(app)
# Create an offering first
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
client.post("/api/v1/offerings/create", json=offering.model_dump())
response = client.get("/api/v1/offerings")
assert response.status_code == 200
data = response.json()
assert "offerings" in data
@pytest.mark.integration
def test_get_gpu_offerings_with_filters():
"""Test getting GPU offerings with filters"""
client = TestClient(app)
# Create offerings
offering1 = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
offering2 = GPUOffering(
miner_id="miner_456",
gpu_model="RTX 3080",
gpu_memory=10240,
cuda_cores=8704,
price_per_hour=0.30,
available_hours=24,
chains=["ait-testnet"],
capabilities=["inference"]
)
client.post("/api/v1/offerings/create", json=offering1.model_dump())
client.post("/api/v1/offerings/create", json=offering2.model_dump())
response = client.get("/api/v1/offerings?chain=ait-devnet&gpu_model=RTX")
assert response.status_code == 200
@pytest.mark.integration
def test_get_gpu_offering():
"""Test getting specific GPU offering"""
client = TestClient(app)
# Create an offering first
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
response = client.get(f"/api/v1/offerings/{offering_id}")
assert response.status_code == 200
data = response.json()
assert data["offering_id"] == offering_id
@pytest.mark.integration
def test_get_gpu_offering_not_found():
"""Test getting nonexistent GPU offering"""
client = TestClient(app)
response = client.get("/api/v1/offerings/nonexistent")
assert response.status_code == 404
@pytest.mark.integration
def test_request_deal():
"""Test requesting a deal"""
client = TestClient(app)
# Create an offering first
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
assert response.status_code == 200
data = response.json()
assert data["success"] is True
assert "deal_id" in data
@pytest.mark.integration
def test_request_deal_offering_not_found():
"""Test requesting deal for nonexistent offering"""
client = TestClient(app)
deal_request = DealRequest(
offering_id="nonexistent",
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
assert response.status_code == 404
@pytest.mark.integration
def test_request_deal_chain_not_supported():
"""Test requesting deal with unsupported chain"""
client = TestClient(app)
# Create an offering
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-testnet"
)
response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
assert response.status_code == 400
@pytest.mark.integration
def test_confirm_deal():
"""Test confirming a deal"""
client = TestClient(app)
# Create offering and request deal
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
deal_response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
deal_id = deal_response.json()["deal_id"]
confirmation = DealConfirmation(
deal_id=deal_id,
miner_confirmation=True,
chain="ait-devnet"
)
response = client.post(f"/api/v1/deals/{deal_id}/confirm", json=confirmation.model_dump())
assert response.status_code == 200
data = response.json()
assert data["success"] is True
assert data["status"] == "confirmed"
@pytest.mark.integration
def test_confirm_deal_reject():
"""Test rejecting a deal"""
client = TestClient(app)
# Create offering and request deal
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
deal_response = client.post("/api/v1/deals/request", json=deal_request.model_dump())
deal_id = deal_response.json()["deal_id"]
confirmation = DealConfirmation(
deal_id=deal_id,
miner_confirmation=False,
chain="ait-devnet"
)
response = client.post(f"/api/v1/deals/{deal_id}/confirm", json=confirmation.model_dump())
assert response.status_code == 200
data = response.json()
assert data["status"] == "rejected"
@pytest.mark.integration
def test_confirm_deal_not_found():
"""Test confirming nonexistent deal"""
client = TestClient(app)
confirmation = DealConfirmation(
deal_id="nonexistent",
miner_confirmation=True,
chain="ait-devnet"
)
response = client.post("/api/v1/deals/nonexistent/confirm", json=confirmation.model_dump())
assert response.status_code == 404
@pytest.mark.integration
def test_get_deals():
"""Test getting deals"""
client = TestClient(app)
response = client.get("/api/v1/deals")
assert response.status_code == 200
data = response.json()
assert "deals" in data
@pytest.mark.integration
def test_get_deals_with_filters():
"""Test getting deals with filters"""
client = TestClient(app)
# Create offering and request deal
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
deal_request = DealRequest(
offering_id=offering_id,
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
client.post("/api/v1/deals/request", json=deal_request.model_dump())
response = client.get("/api/v1/deals?miner_id=miner_123")
assert response.status_code == 200
@pytest.mark.integration
def test_get_miner_offerings():
"""Test getting offerings for a specific miner"""
client = TestClient(app)
# Create an offering
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
client.post("/api/v1/offerings/create", json=offering.model_dump())
response = client.get("/api/v1/miners/miner_123/offerings")
assert response.status_code == 200
data = response.json()
assert data["miner_id"] == "miner_123"
@pytest.mark.integration
def test_get_chain_offerings():
"""Test getting offerings for a specific chain"""
client = TestClient(app)
# Create an offering
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
client.post("/api/v1/offerings/create", json=offering.model_dump())
response = client.get("/api/v1/chains/ait-devnet/offerings")
assert response.status_code == 200
data = response.json()
assert data["chain"] == "ait-devnet"
@pytest.mark.integration
def test_get_chain_offerings_unsupported_chain():
"""Test getting offerings for unsupported chain"""
client = TestClient(app)
response = client.get("/api/v1/chains/unsupported-chain/offerings")
assert response.status_code == 400
@pytest.mark.integration
def test_remove_offering():
"""Test removing a GPU offering"""
client = TestClient(app)
# Create an offering
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
create_response = client.post("/api/v1/offerings/create", json=offering.model_dump())
offering_id = create_response.json()["offering_id"]
response = client.delete(f"/api/v1/offerings/{offering_id}")
assert response.status_code == 200
data = response.json()
assert data["success"] is True
@pytest.mark.integration
def test_remove_offering_not_found():
"""Test removing nonexistent offering"""
client = TestClient(app)
response = client.delete("/api/v1/offerings/nonexistent")
assert response.status_code == 404
@pytest.mark.integration
def test_get_marketplace_stats():
"""Test getting marketplace statistics"""
client = TestClient(app)
response = client.get("/api/v1/stats")
assert response.status_code == 200
data = response.json()
assert "total_offerings" in data
assert "chain_stats" in data

178
apps/marketplace/tests/test_unit_marketplace.py Normal file
View File

@@ -0,0 +1,178 @@
"""Unit tests for agent marketplace service"""
import pytest
import sys
from pathlib import Path
# Add app src to path
project_root = Path(__file__).parent.parent.parent.parent
sys.path.insert(0, str(project_root / "apps" / "marketplace"))
from agent_marketplace import app, GPUOffering, DealRequest, DealConfirmation, MinerRegistration
@pytest.mark.unit
def test_app_initialization():
"""Test that the FastAPI app initializes correctly"""
assert app is not None
assert app.title == "AITBC Agent-First GPU Marketplace"
assert app.version == "1.0.0"
@pytest.mark.unit
def test_gpu_offering_model():
"""Test GPUOffering model"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet", "ait-testnet"],
capabilities=["inference", "training"]
)
assert offering.miner_id == "miner_123"
assert offering.gpu_model == "RTX 4090"
assert offering.gpu_memory == 24576
assert offering.price_per_hour == 0.50
assert offering.chains == ["ait-devnet", "ait-testnet"]
@pytest.mark.unit
def test_gpu_offering_defaults():
"""Test GPUOffering with default values"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
assert offering.min_rental_hours == 1
assert offering.max_concurrent_jobs == 1
@pytest.mark.unit
def test_deal_request_model():
"""Test DealRequest model"""
request = DealRequest(
offering_id="offering_123",
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet",
special_requirements="Need for high performance"
)
assert request.offering_id == "offering_123"
assert request.buyer_id == "buyer_123"
assert request.rental_hours == 10
assert request.chain == "ait-devnet"
@pytest.mark.unit
def test_deal_request_without_special_requirements():
"""Test DealRequest without special requirements"""
request = DealRequest(
offering_id="offering_123",
buyer_id="buyer_123",
rental_hours=10,
chain="ait-devnet"
)
assert request.special_requirements is None
@pytest.mark.unit
def test_deal_confirmation_model():
"""Test DealConfirmation model"""
confirmation = DealConfirmation(
deal_id="deal_123",
miner_confirmation=True,
chain="ait-devnet"
)
assert confirmation.deal_id == "deal_123"
assert confirmation.miner_confirmation is True
assert confirmation.chain == "ait-devnet"
@pytest.mark.unit
def test_deal_confirmation_rejection():
"""Test DealConfirmation with rejection"""
confirmation = DealConfirmation(
deal_id="deal_123",
miner_confirmation=False,
chain="ait-devnet"
)
assert confirmation.miner_confirmation is False
@pytest.mark.unit
def test_miner_registration_model():
"""Test MinerRegistration model"""
registration = MinerRegistration(
miner_id="miner_123",
wallet_address="0x1234567890abcdef",
preferred_chains=["ait-devnet", "ait-testnet"],
gpu_specs={"model": "RTX 4090", "memory": 24576}
)
assert registration.miner_id == "miner_123"
assert registration.wallet_address == "0x1234567890abcdef"
assert registration.preferred_chains == ["ait-devnet", "ait-testnet"]
@pytest.mark.unit
def test_miner_registration_defaults():
"""Test MinerRegistration with default pricing model"""
registration = MinerRegistration(
miner_id="miner_123",
wallet_address="0x1234567890abcdef",
preferred_chains=["ait-devnet"],
gpu_specs={"model": "RTX 4090"}
)
assert registration.pricing_model == "hourly"
@pytest.mark.unit
def test_gpu_offering_negative_price():
"""Test GPUOffering with negative price"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=-0.50,
available_hours=24,
chains=["ait-devnet"],
capabilities=["inference"]
)
assert offering.price_per_hour == -0.50
@pytest.mark.unit
def test_gpu_offering_zero_hours():
"""Test GPUOffering with zero available hours"""
offering = GPUOffering(
miner_id="miner_123",
gpu_model="RTX 4090",
gpu_memory=24576,
cuda_cores=16384,
price_per_hour=0.50,
available_hours=0,
chains=["ait-devnet"],
capabilities=["inference"]
)
assert offering.available_hours == 0
@pytest.mark.unit
def test_deal_request_negative_hours():
"""Test DealRequest with negative rental hours"""
request = DealRequest(
offering_id="offering_123",
buyer_id="buyer_123",
rental_hours=-10,
chain="ait-devnet"
)
assert request.rental_hours == -10