0e6c9eda72
- Add DynamicPricingEngine and MarketDataCollector dependencies to GPU marketplace endpoints
- Implement dynamic pricing calculation for GPU registration with market_balance strategy
- Calculate real-time dynamic prices at booking time with confidence scores and pricing factors
- Enhance /marketplace/pricing/{model} endpoint with comprehensive dynamic pricing analysis
- Add static vs dynamic price
612 lines
24 KiB
Python
612 lines
24 KiB
Python
"""
|
|
Unit Tests for Dynamic Pricing Engine
|
|
Tests pricing calculations, strategies, and market data processing
|
|
"""
|
|
|
|
import pytest
|
|
import asyncio
|
|
from datetime import datetime, timedelta
|
|
from unittest.mock import Mock, patch, AsyncMock
|
|
import numpy as np
|
|
|
|
from app.services.dynamic_pricing_engine import (
|
|
DynamicPricingEngine,
|
|
PricingStrategy,
|
|
ResourceType,
|
|
PriceConstraints,
|
|
PricingFactors,
|
|
MarketConditions,
|
|
PriceTrend
|
|
)
|
|
from app.domain.pricing_strategies import StrategyLibrary
|
|
|
|
|
|
class TestDynamicPricingEngine:
|
|
"""Test cases for DynamicPricingEngine"""
|
|
|
|
@pytest.fixture
|
|
def pricing_engine(self):
|
|
"""Create a pricing engine instance for testing"""
|
|
config = {
|
|
"min_price": 0.001,
|
|
"max_price": 1000.0,
|
|
"update_interval": 300,
|
|
"forecast_horizon": 72,
|
|
"max_volatility_threshold": 0.3,
|
|
"circuit_breaker_threshold": 0.5
|
|
}
|
|
engine = DynamicPricingEngine(config)
|
|
return engine
|
|
|
|
@pytest.fixture
|
|
def sample_market_conditions(self):
|
|
"""Create sample market conditions for testing"""
|
|
return MarketConditions(
|
|
region="us_west",
|
|
resource_type=ResourceType.GPU,
|
|
demand_level=0.8,
|
|
supply_level=0.6,
|
|
average_price=0.05,
|
|
price_volatility=0.15,
|
|
utilization_rate=0.75,
|
|
competitor_prices=[0.045, 0.055, 0.048, 0.052],
|
|
market_sentiment=0.2
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_engine_initialization(self, pricing_engine):
|
|
"""Test engine initialization"""
|
|
await pricing_engine.initialize()
|
|
|
|
assert pricing_engine.min_price == 0.001
|
|
assert pricing_engine.max_price == 1000.0
|
|
assert pricing_engine.update_interval == 300
|
|
assert pricing_engine.forecast_horizon == 72
|
|
assert isinstance(pricing_engine.pricing_history, dict)
|
|
assert isinstance(pricing_engine.provider_strategies, dict)
|
|
assert isinstance(pricing_engine.price_constraints, dict)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_calculate_dynamic_price_basic(self, pricing_engine, sample_market_conditions):
|
|
"""Test basic dynamic price calculation"""
|
|
|
|
# Mock market conditions
|
|
with patch.object(pricing_engine, '_get_market_conditions', return_value=sample_market_conditions):
|
|
result = await pricing_engine.calculate_dynamic_price(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.MARKET_BALANCE,
|
|
region="us_west"
|
|
)
|
|
|
|
assert result.resource_id == "test_gpu_1"
|
|
assert result.resource_type == ResourceType.GPU
|
|
assert result.current_price == 0.05
|
|
assert result.recommended_price > 0
|
|
assert result.recommended_price <= pricing_engine.max_price
|
|
assert result.recommended_price >= pricing_engine.min_price
|
|
assert isinstance(result.price_trend, PriceTrend)
|
|
assert 0 <= result.confidence_score <= 1
|
|
assert isinstance(result.factors_exposed, dict)
|
|
assert isinstance(result.reasoning, list)
|
|
assert result.strategy_used == PricingStrategy.MARKET_BALANCE
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_pricing_strategies_different_results(self, pricing_engine, sample_market_conditions):
|
|
"""Test that different strategies produce different results"""
|
|
|
|
with patch.object(pricing_engine, '_get_market_conditions', return_value=sample_market_conditions):
|
|
# Test aggressive growth strategy
|
|
result_growth = await pricing_engine.calculate_dynamic_price(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.AGGRESSIVE_GROWTH,
|
|
region="us_west"
|
|
)
|
|
|
|
# Test profit maximization strategy
|
|
result_profit = await pricing_engine.calculate_dynamic_price(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.PROFIT_MAXIMIZATION,
|
|
region="us_west"
|
|
)
|
|
|
|
# Results should be different
|
|
assert result_growth.recommended_price != result_profit.recommended_price
|
|
assert result_growth.strategy_used == PricingStrategy.AGGRESSIVE_GROWTH
|
|
assert result_profit.strategy_used == PricingStrategy.PROFIT_MAXIMIZATION
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_price_constraints_application(self, pricing_engine, sample_market_conditions):
|
|
"""Test that price constraints are properly applied"""
|
|
|
|
constraints = PriceConstraints(
|
|
min_price=0.03,
|
|
max_price=0.08,
|
|
max_change_percent=0.2
|
|
)
|
|
|
|
with patch.object(pricing_engine, '_get_market_conditions', return_value=sample_market_conditions):
|
|
result = await pricing_engine.calculate_dynamic_price(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.PROFIT_MAXIMIZATION,
|
|
constraints=constraints,
|
|
region="us_west"
|
|
)
|
|
|
|
# Should respect constraints
|
|
assert result.recommended_price >= constraints.min_price
|
|
assert result.recommended_price <= constraints.max_price
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_circuit_breaker_activation(self, pricing_engine, sample_market_conditions):
|
|
"""Test circuit breaker activation during high volatility"""
|
|
|
|
# Create high volatility conditions
|
|
high_volatility_conditions = MarketConditions(
|
|
region="us_west",
|
|
resource_type=ResourceType.GPU,
|
|
demand_level=0.9,
|
|
supply_level=0.3,
|
|
average_price=0.05,
|
|
price_volatility=0.6, # High volatility
|
|
utilization_rate=0.95,
|
|
competitor_prices=[0.045, 0.055, 0.048, 0.052],
|
|
market_sentiment=-0.3
|
|
)
|
|
|
|
# Add some pricing history
|
|
pricing_engine.pricing_history["test_gpu_1"] = [
|
|
Mock(price=0.05, timestamp=datetime.utcnow() - timedelta(minutes=10))
|
|
]
|
|
|
|
with patch.object(pricing_engine, '_get_market_conditions', return_value=high_volatility_conditions):
|
|
result = await pricing_engine.calculate_dynamic_price(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.MARKET_BALANCE,
|
|
region="us_west"
|
|
)
|
|
|
|
# Circuit breaker should be activated
|
|
assert "test_gpu_1" in pricing_engine.circuit_breakers
|
|
assert pricing_engine.circuit_breakers["test_gpu_1"] is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_price_forecast_generation(self, pricing_engine):
|
|
"""Test price forecast generation"""
|
|
|
|
# Add historical data
|
|
base_time = datetime.utcnow()
|
|
for i in range(48): # 48 data points
|
|
pricing_engine.pricing_history["test_gpu_1"] = pricing_engine.pricing_history.get("test_gpu_1", [])
|
|
pricing_engine.pricing_history["test_gpu_1"].append(
|
|
Mock(
|
|
price=0.05 + (i * 0.001),
|
|
demand_level=0.6 + (i % 10) * 0.02,
|
|
supply_level=0.7 - (i % 8) * 0.01,
|
|
confidence=0.8,
|
|
strategy_used="market_balance",
|
|
timestamp=base_time - timedelta(hours=48-i)
|
|
)
|
|
)
|
|
|
|
forecast = await pricing_engine.get_price_forecast("test_gpu_1", 24)
|
|
|
|
assert len(forecast) == 24
|
|
for point in forecast:
|
|
assert hasattr(point, 'timestamp')
|
|
assert hasattr(point, 'price')
|
|
assert hasattr(point, 'demand_level')
|
|
assert hasattr(point, 'supply_level')
|
|
assert hasattr(point, 'confidence')
|
|
assert 0 <= point.confidence <= 1
|
|
assert point.price >= pricing_engine.min_price
|
|
assert point.price <= pricing_engine.max_price
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_provider_strategy_management(self, pricing_engine):
|
|
"""Test setting and retrieving provider strategies"""
|
|
|
|
constraints = PriceConstraints(
|
|
min_price=0.02,
|
|
max_price=0.10
|
|
)
|
|
|
|
# Set strategy
|
|
success = await pricing_engine.set_provider_strategy(
|
|
provider_id="test_provider",
|
|
strategy=PricingStrategy.AGGRESSIVE_GROWTH,
|
|
constraints=constraints
|
|
)
|
|
|
|
assert success is True
|
|
assert pricing_engine.provider_strategies["test_provider"] == PricingStrategy.AGGRESSIVE_GROWTH
|
|
assert pricing_engine.price_constraints["test_provider"] == constraints
|
|
|
|
def test_demand_multiplier_calculation(self, pricing_engine):
|
|
"""Test demand multiplier calculation"""
|
|
|
|
# High demand
|
|
multiplier_high = pricing_engine._calculate_demand_multiplier(0.9, PricingStrategy.MARKET_BALANCE)
|
|
assert multiplier_high > 1.0
|
|
|
|
# Low demand
|
|
multiplier_low = pricing_engine._calculate_demand_multiplier(0.2, PricingStrategy.MARKET_BALANCE)
|
|
assert multiplier_low < 1.0
|
|
|
|
# Aggressive growth strategy should have lower multipliers
|
|
multiplier_growth = pricing_engine._calculate_demand_multiplier(0.8, PricingStrategy.AGGRESSIVE_GROWTH)
|
|
multiplier_balance = pricing_engine._calculate_demand_multiplier(0.8, PricingStrategy.MARKET_BALANCE)
|
|
assert multiplier_growth < multiplier_balance
|
|
|
|
def test_supply_multiplier_calculation(self, pricing_engine):
|
|
"""Test supply multiplier calculation"""
|
|
|
|
# Low supply (should increase prices)
|
|
multiplier_low_supply = pricing_engine._calculate_supply_multiplier(0.2, PricingStrategy.MARKET_BALANCE)
|
|
assert multiplier_low_supply > 1.0
|
|
|
|
# High supply (should decrease prices)
|
|
multiplier_high_supply = pricing_engine._calculate_supply_multiplier(0.9, PricingStrategy.MARKET_BALANCE)
|
|
assert multiplier_high_supply < 1.0
|
|
|
|
def test_time_multiplier_calculation(self, pricing_engine):
|
|
"""Test time-based multiplier calculation"""
|
|
|
|
# Test different hours
|
|
business_hour_multiplier = pricing_engine._calculate_time_multiplier()
|
|
|
|
# Mock different hours by temporarily changing the method
|
|
with patch('datetime.datetime') as mock_datetime:
|
|
mock_datetime.utcnow.return_value.hour = 14 # 2 PM business hour
|
|
business_hour_multiplier = pricing_engine._calculate_time_multiplier()
|
|
assert business_hour_multiplier > 1.0
|
|
|
|
mock_datetime.utcnow.return_value.hour = 3 # 3 AM late night
|
|
late_night_multiplier = pricing_engine._calculate_time_multiplier()
|
|
assert late_night_multiplier < 1.0
|
|
|
|
def test_competition_multiplier_calculation(self, pricing_engine):
|
|
"""Test competition-based multiplier calculation"""
|
|
|
|
competitor_prices = [0.045, 0.055, 0.048, 0.052]
|
|
base_price = 0.05
|
|
|
|
# Competitive response strategy
|
|
multiplier_competitive = pricing_engine._calculate_competition_multiplier(
|
|
base_price, competitor_prices, PricingStrategy.COMPETITIVE_RESPONSE
|
|
)
|
|
|
|
# Profit maximization strategy
|
|
multiplier_profit = pricing_engine._calculate_competition_multiplier(
|
|
base_price, competitor_prices, PricingStrategy.PROFIT_MAXIMIZATION
|
|
)
|
|
|
|
# Competitive strategy should be more responsive to competition
|
|
assert isinstance(multiplier_competitive, float)
|
|
assert isinstance(multiplier_profit, float)
|
|
|
|
def test_price_trend_determination(self, pricing_engine):
|
|
"""Test price trend determination"""
|
|
|
|
# Create increasing trend
|
|
pricing_engine.pricing_history["test_resource"] = [
|
|
Mock(price=0.05, timestamp=datetime.utcnow() - timedelta(minutes=50)),
|
|
Mock(price=0.051, timestamp=datetime.utcnow() - timedelta(minutes=40)),
|
|
Mock(price=0.052, timestamp=datetime.utcnow() - timedelta(minutes=30)),
|
|
Mock(price=0.053, timestamp=datetime.utcnow() - timedelta(minutes=20)),
|
|
Mock(price=0.054, timestamp=datetime.utcnow() - timedelta(minutes=10))
|
|
]
|
|
|
|
trend = pricing_engine._determine_price_trend("test_resource", 0.055)
|
|
assert trend == PriceTrend.INCREASING
|
|
|
|
# Create decreasing trend
|
|
pricing_engine.pricing_history["test_resource"] = [
|
|
Mock(price=0.055, timestamp=datetime.utcnow() - timedelta(minutes=50)),
|
|
Mock(price=0.054, timestamp=datetime.utcnow() - timedelta(minutes=40)),
|
|
Mock(price=0.053, timestamp=datetime.utcnow() - timedelta(minutes=30)),
|
|
Mock(price=0.052, timestamp=datetime.utcnow() - timedelta(minutes=20)),
|
|
Mock(price=0.051, timestamp=datetime.utcnow() - timedelta(minutes=10))
|
|
]
|
|
|
|
trend = pricing_engine._determine_price_trend("test_resource", 0.05)
|
|
assert trend == PriceTrend.DECREASING
|
|
|
|
def test_confidence_score_calculation(self, pricing_engine, sample_market_conditions):
|
|
"""Test confidence score calculation"""
|
|
|
|
factors = PricingFactors(
|
|
base_price=0.05,
|
|
demand_level=0.8,
|
|
supply_level=0.6,
|
|
market_volatility=0.1,
|
|
confidence_score=0.8
|
|
)
|
|
|
|
confidence = pricing_engine._calculate_confidence_score(factors, sample_market_conditions)
|
|
|
|
assert 0 <= confidence <= 1
|
|
assert isinstance(confidence, float)
|
|
|
|
def test_pricing_factors_calculation(self, pricing_engine, sample_market_conditions):
|
|
"""Test pricing factors calculation"""
|
|
|
|
factors = asyncio.run(pricing_engine._calculate_pricing_factors(
|
|
resource_id="test_gpu_1",
|
|
resource_type=ResourceType.GPU,
|
|
base_price=0.05,
|
|
strategy=PricingStrategy.MARKET_BALANCE,
|
|
market_conditions=sample_market_conditions
|
|
))
|
|
|
|
assert isinstance(factors, PricingFactors)
|
|
assert factors.base_price == 0.05
|
|
assert 0 <= factors.demand_multiplier <= 3.0
|
|
assert 0.8 <= factors.supply_multiplier <= 2.5
|
|
assert 0.7 <= factors.time_multiplier <= 1.5
|
|
assert 0.9 <= factors.performance_multiplier <= 1.3
|
|
assert 0.8 <= factors.competition_multiplier <= 1.4
|
|
assert 0.9 <= factors.sentiment_multiplier <= 1.2
|
|
assert 0.8 <= factors.regional_multiplier <= 1.3
|
|
|
|
def test_strategy_pricing_application(self, pricing_engine, sample_market_conditions):
|
|
"""Test strategy-specific pricing application"""
|
|
|
|
factors = PricingFactors(
|
|
base_price=0.05,
|
|
demand_multiplier=1.2,
|
|
supply_multiplier=1.1,
|
|
time_multiplier=1.0,
|
|
performance_multiplier=1.05,
|
|
competition_multiplier=0.95,
|
|
sentiment_multiplier=1.02,
|
|
regional_multiplier=1.0
|
|
)
|
|
|
|
# Test different strategies
|
|
price_aggressive = asyncio.run(pricing_engine._apply_strategy_pricing(
|
|
0.05, factors, PricingStrategy.AGGRESSIVE_GROWTH, sample_market_conditions
|
|
))
|
|
|
|
price_profit = asyncio.run(pricing_engine._apply_strategy_pricing(
|
|
0.05, factors, PricingStrategy.PROFIT_MAXIMIZATION, sample_market_conditions
|
|
))
|
|
|
|
# Should produce different results
|
|
assert price_aggressive != price_profit
|
|
assert price_aggressive > 0
|
|
assert price_profit > 0
|
|
|
|
def test_constraints_and_risk_application(self, pricing_engine):
|
|
"""Test constraints and risk management application"""
|
|
|
|
constraints = PriceConstraints(
|
|
min_price=0.03,
|
|
max_price=0.08,
|
|
max_change_percent=0.2
|
|
)
|
|
|
|
factors = PricingFactors(
|
|
base_price=0.05,
|
|
market_volatility=0.1
|
|
)
|
|
|
|
# Test normal price within constraints
|
|
normal_price = asyncio.run(pricing_engine._apply_constraints_and_risk(
|
|
"test_resource", 0.06, constraints, factors
|
|
))
|
|
assert 0.03 <= normal_price <= 0.08
|
|
|
|
# Test price above max constraint
|
|
high_price = asyncio.run(pricing_engine._apply_constraints_and_risk(
|
|
"test_resource", 0.10, constraints, factors
|
|
))
|
|
assert high_price <= constraints.max_price
|
|
|
|
# Test price below min constraint
|
|
low_price = asyncio.run(pricing_engine._apply_constraints_and_risk(
|
|
"test_resource", 0.01, constraints, factors
|
|
))
|
|
assert low_price >= constraints.min_price
|
|
|
|
def test_price_point_storage(self, pricing_engine):
|
|
"""Test price point storage in history"""
|
|
|
|
factors = PricingFactors(
|
|
base_price=0.05,
|
|
demand_level=0.8,
|
|
supply_level=0.6,
|
|
confidence_score=0.85
|
|
)
|
|
|
|
asyncio.run(pricing_engine._store_price_point(
|
|
"test_resource", 0.055, factors, PricingStrategy.MARKET_BALANCE
|
|
))
|
|
|
|
assert "test_resource" in pricing_engine.pricing_history
|
|
assert len(pricing_engine.pricing_history["test_resource"]) == 1
|
|
|
|
point = pricing_engine.pricing_history["test_resource"][0]
|
|
assert point.price == 0.055
|
|
assert point.demand_level == 0.8
|
|
assert point.supply_level == 0.6
|
|
assert point.confidence == 0.85
|
|
assert point.strategy_used == "market_balance"
|
|
|
|
def test_seasonal_factor_calculation(self, pricing_engine):
|
|
"""Test seasonal factor calculation"""
|
|
|
|
# Test morning hours
|
|
morning_factor = pricing_engine._calculate_seasonal_factor(9)
|
|
assert morning_factor > 1.0
|
|
|
|
# Test business peak
|
|
peak_factor = pricing_engine._calculate_seasonal_factor(14)
|
|
assert peak_factor > morning_factor
|
|
|
|
# Test late night
|
|
night_factor = pricing_engine._calculate_seasonal_factor(3)
|
|
assert night_factor < 1.0
|
|
|
|
def test_demand_supply_forecasting(self, pricing_engine):
|
|
"""Test demand and supply level forecasting"""
|
|
|
|
demand_history = [0.6, 0.7, 0.8, 0.75, 0.9, 0.85]
|
|
supply_history = [0.7, 0.6, 0.5, 0.55, 0.4, 0.45]
|
|
|
|
demand_forecast = pricing_engine._forecast_demand_level(demand_history, 1)
|
|
supply_forecast = pricing_engine._forecast_supply_level(supply_history, 1)
|
|
|
|
assert 0 <= demand_forecast <= 1
|
|
assert 0 <= supply_forecast <= 1
|
|
assert isinstance(demand_forecast, float)
|
|
assert isinstance(supply_forecast, float)
|
|
|
|
|
|
class TestPricingFactors:
|
|
"""Test cases for PricingFactors dataclass"""
|
|
|
|
def test_pricing_factors_creation(self):
|
|
"""Test PricingFactors creation with default values"""
|
|
factors = PricingFactors(base_price=0.05)
|
|
|
|
assert factors.base_price == 0.05
|
|
assert factors.demand_multiplier == 1.0
|
|
assert factors.supply_multiplier == 1.0
|
|
assert factors.time_multiplier == 1.0
|
|
assert factors.performance_multiplier == 1.0
|
|
assert factors.competition_multiplier == 1.0
|
|
assert factors.sentiment_multiplier == 1.0
|
|
assert factors.regional_multiplier == 1.0
|
|
assert factors.confidence_score == 0.8
|
|
assert factors.risk_adjustment == 0.0
|
|
|
|
def test_pricing_factors_with_custom_values(self):
|
|
"""Test PricingFactors creation with custom values"""
|
|
factors = PricingFactors(
|
|
base_price=0.05,
|
|
demand_multiplier=1.5,
|
|
supply_multiplier=0.8,
|
|
confidence_score=0.9
|
|
)
|
|
|
|
assert factors.base_price == 0.05
|
|
assert factors.demand_multiplier == 1.5
|
|
assert factors.supply_multiplier == 0.8
|
|
assert factors.confidence_score == 0.9
|
|
|
|
|
|
class TestPriceConstraints:
|
|
"""Test cases for PriceConstraints dataclass"""
|
|
|
|
def test_price_constraints_creation(self):
|
|
"""Test PriceConstraints creation with default values"""
|
|
constraints = PriceConstraints()
|
|
|
|
assert constraints.min_price is None
|
|
assert constraints.max_price is None
|
|
assert constraints.max_change_percent == 0.5
|
|
assert constraints.min_change_interval == 300
|
|
assert constraints.strategy_lock_period == 3600
|
|
|
|
def test_price_constraints_with_custom_values(self):
|
|
"""Test PriceConstraints creation with custom values"""
|
|
constraints = PriceConstraints(
|
|
min_price=0.02,
|
|
max_price=0.10,
|
|
max_change_percent=0.3
|
|
)
|
|
|
|
assert constraints.min_price == 0.02
|
|
assert constraints.max_price == 0.10
|
|
assert constraints.max_change_percent == 0.3
|
|
|
|
|
|
class TestMarketConditions:
|
|
"""Test cases for MarketConditions dataclass"""
|
|
|
|
def test_market_conditions_creation(self):
|
|
"""Test MarketConditions creation"""
|
|
conditions = MarketConditions(
|
|
region="us_west",
|
|
resource_type=ResourceType.GPU,
|
|
demand_level=0.8,
|
|
supply_level=0.6,
|
|
average_price=0.05,
|
|
price_volatility=0.15,
|
|
utilization_rate=0.75
|
|
)
|
|
|
|
assert conditions.region == "us_west"
|
|
assert conditions.resource_type == ResourceType.GPU
|
|
assert conditions.demand_level == 0.8
|
|
assert conditions.supply_level == 0.6
|
|
assert conditions.average_price == 0.05
|
|
assert conditions.price_volatility == 0.15
|
|
assert conditions.utilization_rate == 0.75
|
|
assert conditions.competitor_prices == []
|
|
assert conditions.market_sentiment == 0.0
|
|
assert isinstance(conditions.timestamp, datetime)
|
|
|
|
|
|
class TestStrategyLibrary:
|
|
"""Test cases for StrategyLibrary"""
|
|
|
|
def test_get_all_strategies(self):
|
|
"""Test getting all available strategies"""
|
|
strategies = StrategyLibrary.get_all_strategies()
|
|
|
|
assert isinstance(strategies, dict)
|
|
assert len(strategies) > 0
|
|
assert PricingStrategy.AGGRESSIVE_GROWTH in strategies
|
|
assert PricingStrategy.PROFIT_MAXIMIZATION in strategies
|
|
assert PricingStrategy.MARKET_BALANCE in strategies
|
|
|
|
# Check strategy configurations
|
|
for strategy_type, config in strategies.items():
|
|
assert config.strategy_type == strategy_type
|
|
assert config.name is not None
|
|
assert config.description is not None
|
|
assert config.parameters is not None
|
|
assert isinstance(config.parameters.base_multiplier, float)
|
|
|
|
def test_aggressive_growth_strategy(self):
|
|
"""Test aggressive growth strategy configuration"""
|
|
strategy = StrategyLibrary.get_aggressive_growth_strategy()
|
|
|
|
assert strategy.strategy_type == PricingStrategy.AGGRESSIVE_GROWTH
|
|
assert strategy.parameters.base_multiplier < 1.0 # Lower prices for growth
|
|
assert strategy.parameters.growth_target_rate > 0.2 # High growth target
|
|
assert strategy.risk_tolerance.value == "aggressive"
|
|
|
|
def test_profit_maximization_strategy(self):
|
|
"""Test profit maximization strategy configuration"""
|
|
strategy = StrategyLibrary.get_profit_maximization_strategy()
|
|
|
|
assert strategy.strategy_type == PricingStrategy.PROFIT_MAXIMIZATION
|
|
assert strategy.parameters.base_multiplier > 1.0 # Higher prices for profit
|
|
assert strategy.parameters.profit_target_margin > 0.3 # High profit target
|
|
assert strategy.parameters.demand_sensitivity > 0.5 # Demand sensitive
|
|
|
|
def test_market_balance_strategy(self):
|
|
"""Test market balance strategy configuration"""
|
|
strategy = StrategyLibrary.get_market_balance_strategy()
|
|
|
|
assert strategy.strategy_type == PricingStrategy.MARKET_BALANCE
|
|
assert strategy.parameters.base_multiplier == 1.0 # Balanced pricing
|
|
assert strategy.parameters.volatility_threshold < 0.2 # Lower volatility tolerance
|
|
assert strategy.risk_tolerance.value == "moderate"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pytest.main([__file__])
|