specify which tests to run

.cursor/rules/django-project.mdc

@@ -0,0 +1,17 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+- This is a Django project which uses SQLite as the database.
+- Follow Django conventions and best practices; use the Django ORM and define fields with appropriate types.
+- Use function-based views and follow Django conventions for naming and structuring views.
+- Templates use the Django template language and Bootstrap 5 CSS and JavaScript for styling.
+- The main Django app is in `hub/services`; ignore the app `hub/broker`.
+- Docker-specific code is in the folder `docker/`.
+- Kubernetes deployment-specific files are in `deployment/`.
+- GitLab CI is used as the main CI/CD system.
+- The project uses Astral uv to manage the Python project, dependencies, and the venv.
+- Execute Django with `uv run --extra dev manage.py`.
+- Always add comments to the code to describe what's happening.
+- Answers should be short and concise, and should not include any unnecessary comments or explanations, but be clear on which file a code block should be placed in.

.forgejo/setup-local-testing.sh

@@ -0,0 +1,273 @@
+#!/bin/bash
+
+# Forgejo Actions Local Testing Setup
+# This script helps test the pricing workflows locally before pushing
+
+set -e
+
+echo "🔧 Forgejo Actions - Local Pricing Test Setup"
+echo "============================================="
+
+# Check if we're in the right directory
+if [ ! -f "manage.py" ]; then
+    echo "❌ Error: This script must be run from the Django project root directory"
+    echo "   Expected to find manage.py in current directory"
+    exit 1
+fi
+
+# Check if uv is installed
+if ! command -v uv &> /dev/null; then
+    echo "❌ Error: uv is not installed"
+    echo "   Please install uv: https://docs.astral.sh/uv/getting-started/installation/"
+    exit 1
+fi
+
+echo ""
+echo "📋 Pre-flight Checks"
+echo "--------------------"
+
+# Check if test files exist
+REQUIRED_FILES=(
+    "hub/services/tests/test_pricing.py"
+    "hub/services/tests/test_pricing_edge_cases.py"
+    "hub/services/tests/test_pricing_integration.py"
+    ".forgejo/workflows/ci.yml"
+    ".forgejo/workflows/pricing-tests.yml"
+)
+
+all_files_exist=true
+for file in "${REQUIRED_FILES[@]}"; do
+    if [ -f "$file" ]; then
+        echo "✅ $file"
+    else
+        echo "❌ $file (missing)"
+        all_files_exist=false
+    fi
+done
+
+if [ "$all_files_exist" = false ]; then
+    echo ""
+    echo "❌ Some required files are missing. Please ensure all test files are present."
+    exit 1
+fi
+
+echo ""
+echo "🔍 Environment Setup"
+echo "--------------------"
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+uv sync --extra dev
+
+# Check Django configuration
+echo "🔧 Checking Django configuration..."
+export DJANGO_SETTINGS_MODULE=hub.settings
+uv run --extra dev manage.py check --verbosity=0
+
+echo ""
+echo "🧪 Running Pricing Tests Locally"
+echo "--------------------------------"
+
+# Function to run tests with timing
+run_test_group() {
+    local test_name="$1"
+    local test_path="$2"
+    local start_time=$(date +%s)
+    
+    echo "🔄 Running $test_name..."
+    if uv run --extra dev manage.py test "$test_path" --verbosity=1; then
+        local end_time=$(date +%s)
+        local duration=$((end_time - start_time))
+        echo "✅ $test_name completed in ${duration}s"
+    else
+        echo "❌ $test_name failed"
+        return 1
+    fi
+}
+
+# Run test groups (similar to what the workflows do)
+echo "Running the same tests that Forgejo Actions will run..."
+echo ""
+
+# Basic pricing tests
+run_test_group "Basic Pricing Tests" "hub.services.tests.test_pricing" || exit 1
+echo ""
+
+# Edge case tests  
+run_test_group "Edge Case Tests" "hub.services.tests.test_pricing_edge_cases" || exit 1
+echo ""
+
+# Integration tests
+run_test_group "Integration Tests" "hub.services.tests.test_pricing_integration" || exit 1
+echo ""
+
+# Django system checks (like in CI)
+echo "🔍 Running Django system checks..."
+uv run --extra dev manage.py check --verbosity=2
+echo "✅ System checks passed"
+echo ""
+
+# Code quality checks (if ruff is available)
+if command -v ruff &> /dev/null || uv run ruff --version &> /dev/null 2>&1; then
+    echo "🎨 Running code quality checks..."
+    
+    echo "  - Checking linting..."
+    if uv run ruff check hub/services/tests/test_pricing*.py --quiet; then
+        echo "✅ Linting passed"
+    else
+        echo "⚠️  Linting issues found (run 'uv run ruff check hub/services/tests/test_pricing*.py' for details)"
+    fi
+    
+    echo "  - Checking formatting..."
+    if uv run ruff format --check hub/services/tests/test_pricing*.py --quiet; then
+        echo "✅ Formatting is correct"
+    else
+        echo "⚠️  Formatting issues found (run 'uv run ruff format hub/services/tests/test_pricing*.py' to fix)"
+    fi
+else
+    echo "ℹ️  Skipping code quality checks (ruff not available)"
+fi
+
+echo ""
+echo "📊 Test Coverage Analysis"
+echo "-------------------------"
+
+# Generate coverage report (if coverage is available)
+if uv run --extra dev coverage --version &> /dev/null 2>&1; then
+    echo "📈 Generating test coverage report..."
+    
+    # Run tests with coverage
+    uv run --extra dev coverage run --source='hub/services/models/pricing' \
+        manage.py test \
+        hub.services.tests.test_pricing \
+        hub.services.tests.test_pricing_edge_cases \
+        hub.services.tests.test_pricing_integration \
+        --verbosity=0
+    
+    # Generate reports
+    echo ""
+    echo "Coverage Summary:"
+    uv run --extra dev coverage report --show-missing
+    
+    # Generate HTML report
+    uv run --extra dev coverage html
+    echo ""
+    echo "📄 HTML coverage report generated: htmlcov/index.html"
+    
+    # Check coverage threshold (like in CI)
+    coverage_percentage=$(uv run coverage report | grep TOTAL | awk '{print $4}' | sed 's/%//')
+    if [ -n "$coverage_percentage" ]; then
+        if (( $(echo "$coverage_percentage >= 85" | bc -l) )); then
+            echo "✅ Coverage threshold met: ${coverage_percentage}%"
+        else
+            echo "⚠️  Coverage below threshold: ${coverage_percentage}% (target: 85%)"
+        fi
+    fi
+else
+    echo "ℹ️  Skipping coverage analysis (coverage not available)"
+    echo "   Install with: uv add coverage"
+fi
+
+echo ""
+echo "🚀 Performance Test"
+echo "-------------------"
+
+# Quick performance test
+echo "🏃 Running quick performance test..."
+cat << 'EOF' > quick_performance_test.py
+import os
+import django
+import time
+from decimal import Decimal
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'hub.settings')
+django.setup()
+
+from hub.services.models.base import Currency, Term
+from hub.services.models.providers import CloudProvider
+from hub.services.models.services import Service
+from hub.services.models.pricing import (
+    VSHNAppCatPrice, VSHNAppCatBaseFee, VSHNAppCatUnitRate,
+    ProgressiveDiscountModel, DiscountTier
+)
+
+# Create test data
+provider = CloudProvider.objects.create(
+    name="Perf Test", slug="perf-test", description="Test", website="https://test.com"
+)
+service = Service.objects.create(
+    name="Perf Service", slug="perf-service", description="Test", features="Test"
+)
+
+discount = ProgressiveDiscountModel.objects.create(name="Perf Discount", active=True)
+DiscountTier.objects.create(
+    discount_model=discount, min_units=0, max_units=10, discount_percent=Decimal('0')
+)
+DiscountTier.objects.create(
+    discount_model=discount, min_units=10, max_units=None, discount_percent=Decimal('15')
+)
+
+price_config = VSHNAppCatPrice.objects.create(
+    service=service, variable_unit='RAM', term='MTH', discount_model=discount
+)
+VSHNAppCatBaseFee.objects.create(
+    vshn_appcat_price_config=price_config, currency='CHF', amount=Decimal('50.00')
+)
+VSHNAppCatUnitRate.objects.create(
+    vshn_appcat_price_config=price_config, currency='CHF', 
+    service_level='GA', amount=Decimal('4.0000')
+)
+
+# Performance test
+test_cases = [10, 50, 100, 500, 1000]
+print("Units | Time (ms) | Result (CHF)")
+print("-" * 35)
+
+for units in test_cases:
+    start_time = time.time()
+    result = price_config.calculate_final_price('CHF', 'GA', units)
+    end_time = time.time()
+    
+    duration_ms = (end_time - start_time) * 1000
+    price = result['total_price'] if result else 'Error'
+    print(f"{units:5d} | {duration_ms:8.2f} | {price}")
+
+print("\n✅ Performance test completed")
+EOF
+
+uv run python quick_performance_test.py
+rm quick_performance_test.py
+
+echo ""
+echo "🎉 Local Testing Complete!"
+echo "=========================="
+echo ""
+echo "📋 Summary:"
+echo "  ✅ All pricing tests passed"
+echo "  ✅ Django system checks passed"
+echo "  ✅ Performance test completed"
+if command -v ruff &> /dev/null || uv run ruff --version &> /dev/null 2>&1; then
+    echo "  ✅ Code quality checks completed"
+fi
+if uv run coverage --version &> /dev/null 2>&1; then
+    echo "  ✅ Coverage analysis completed"
+fi
+echo ""
+echo "🚀 Your code is ready for Forgejo Actions!"
+echo ""
+echo "Next steps:"
+echo "  1. Commit your changes: git add . && git commit -m 'Your commit message'"
+echo "  2. Push to trigger workflows: git push origin your-branch"
+echo "  3. Check Actions tab in your repository for results"
+echo ""
+echo "Workflow files created:"
+echo "  - .forgejo/workflows/ci.yml (main CI/CD pipeline)"
+echo "  - .forgejo/workflows/pricing-tests.yml (detailed pricing tests)"
+echo "  - .forgejo/workflows/pr-pricing-validation.yml (PR validation)"
+echo "  - .forgejo/workflows/scheduled-pricing-tests.yml (daily tests)"
+echo ""
+
+# Clean up temporary files
+if [ -f "htmlcov/index.html" ]; then
+    echo "📄 Open htmlcov/index.html in your browser to view detailed coverage report"
+fi

.forgejo/workflows/test.yaml

@@ -0,0 +1,34 @@
+name: Django Tests
+
+on:
+  push:
+    branches: ["*"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    container: catthehacker/ubuntu:act-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Docker image (local only)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: false
+          load: true
+          tags: website:test
+
+      - name: Run Django tests in container
+        run: |
+          docker run --rm \
+            -w /app \
+            -e SECRET_KEY=dummysecretkey \
+            website:test \
+            sh -c 'uv run --extra dev manage.py migrate --noinput && uv run --extra dev manage.py test hub.services.tests --verbosity=2'

FORGEJO_ACTIONS_SETUP.md

@@ -0,0 +1,232 @@
+# Forgejo Actions CI/CD Setup for Pricing Tests
+
+## Overview
+
+I've created a comprehensive Forgejo Actions CI/CD setup that automatically runs your pricing tests whenever code changes are made. This ensures that your pricing calculations remain accurate and prevents regressions from being introduced into production.
+
+## Files Created
+
+### Workflow Files
+1. **`.forgejo/workflows/ci.yml`** - Main CI/CD pipeline (208 lines)
+2. **`.forgejo/workflows/pricing-tests.yml`** - Dedicated pricing tests (297 lines)  
+3. **`.forgejo/workflows/pr-pricing-validation.yml`** - Pull request validation (234 lines)
+4. **`.forgejo/workflows/scheduled-pricing-tests.yml`** - Daily scheduled tests (359 lines)
+
+### Documentation and Utilities
+5. **`.forgejo/workflows/README.md`** - Comprehensive workflow documentation
+6. **`.forgejo/setup-local-testing.sh`** - Local testing setup script
+
+## Workflow Features
+
+### 🚀 Main CI/CD Pipeline (`ci.yml`)
+**Triggers**: Push to main/develop, Pull Requests
+
+**Jobs**:
+- **Test Job**: Runs all Django tests including pricing tests with PostgreSQL
+- **Lint Job**: Code quality checks with ruff
+- **Security Job**: Security scanning with safety and bandit  
+- **Build Job**: Docker image building (only on main/develop)
+- **Deploy Job**: Production deployment to OpenShift (only on main)
+
+**Key Features**:
+- Separates pricing tests into distinct groups for visibility
+- Uses PostgreSQL service for realistic database testing
+- Only builds and deploys if all tests pass
+- Includes comprehensive Django system checks
+
+### 🧮 Pricing-Specific Tests (`pricing-tests.yml`)
+**Triggers**: Changes to pricing-related files
+- `hub/services/models/pricing.py`
+- `hub/services/tests/test_pricing*.py`
+- `hub/services/forms.py`
+- `hub/services/views/**`
+- `hub/services/templates/**`
+
+**Features**:
+- **Matrix Testing**: Python 3.12/3.13 × Django 5.0/5.1
+- **Performance Testing**: Large dataset calculations and stress tests
+- **Coverage Reporting**: Test coverage analysis and HTML reports
+- **Sample Validation**: Real pricing scenarios validation
+- **Documentation Checks**: Ensures tests are properly documented
+
+### 🔍 Pull Request Validation (`pr-pricing-validation.yml`)
+**Triggers**: Pull requests affecting pricing code
+
+**Features**:
+- **Migration Detection**: Checks if pricing model changes need migrations
+- **Coverage Threshold**: Enforces 85% test coverage minimum
+- **Critical Method Analysis**: Detects changes to important pricing methods
+- **Backward Compatibility**: Validates that existing APIs still work
+- **Test Addition Validation**: Ensures new features have corresponding tests
+- **PR Summary Generation**: Creates detailed summaries for reviewers
+
+### 📅 Scheduled Testing (`scheduled-pricing-tests.yml`)
+**Triggers**: Daily at 6 AM UTC, Manual dispatch
+
+**Features**:
+- **Multi-Database Testing**: SQLite and PostgreSQL matrix
+- **Stress Testing**: Concurrent calculations and large datasets
+- **Data Integrity Checks**: Validates pricing data consistency
+- **Daily Reports**: System health and statistics
+- **Automatic Issue Creation**: Creates GitHub issues on failures
+- **Performance Monitoring**: Tracks calculation performance over time
+
+## Security and Environment
+
+### Required Secrets
+Set these in your Forgejo repository settings:
+```yaml
+REGISTRY_USERNAME      # Container registry username  
+REGISTRY_PASSWORD      # Container registry password
+OPENSHIFT_SERVER      # OpenShift server URL
+OPENSHIFT_TOKEN       # OpenShift authentication token
+```
+
+### Environment Variables
+```yaml
+REGISTRY: registry.vshn.net
+NAMESPACE: vshn-servalafe-prod
+DATABASE_URL: # Set automatically by workflows
+DJANGO_SETTINGS_MODULE: hub.settings
+```
+
+## Test Coverage
+
+The workflows provide comprehensive testing of:
+
+### ✅ Core Pricing Functionality
+- Progressive discount calculations with multiple tiers
+- Final price calculations including base fees, unit rates, and addons
+- Multi-currency support (CHF, EUR, USD)
+- Service level pricing differences (Best Effort vs Guaranteed)
+- Addon pricing (base fee and unit rate types)
+
+### ✅ Edge Cases and Error Handling
+- Zero and negative value handling
+- Very large number calculations
+- Missing price data scenarios
+- Decimal precision edge cases
+- Database constraint validation
+- Inactive discount model behavior
+
+### ✅ Integration Scenarios
+- Complete service setups with all components
+- Real-world pricing scenarios (e.g., PostgreSQL with 16GB RAM)
+- External price comparisons with competitors
+- Cross-model relationship validation
+
+### ✅ Performance and Stress Testing
+- Large dataset calculations (up to 5000 units)
+- Concurrent price calculations (50 simultaneous)
+- Complex discount models with multiple tiers
+- Performance regression detection
+
+## Usage Examples
+
+### Automatic Triggers
+```bash
+# Trigger full CI/CD pipeline
+git push origin main
+
+# Trigger pricing-specific tests
+git push origin feature/pricing-improvements
+
+# Trigger PR validation
+git checkout -b feature/new-pricing
+# Make changes to pricing files
+git push origin feature/new-pricing
+# Create pull request
+```
+
+### Manual Triggers
+- Use Forgejo Actions UI to manually run workflows
+- Scheduled tests can be run with different scopes:
+  - `all` - All pricing tests
+  - `pricing-only` - Basic pricing tests only  
+  - `integration-only` - Integration tests only
+
+### Local Testing
+```bash
+# Run local validation before pushing
+./.forgejo/setup-local-testing.sh
+```
+
+## Monitoring and Alerts
+
+### Test Results
+- **Real-time feedback**: See test results in PR checks
+- **Detailed logs**: Comprehensive logging with grouped output
+- **Coverage reports**: HTML coverage reports as downloadable artifacts
+- **Performance metrics**: Timing data for all calculations
+
+### Failure Handling
+- **PR blocking**: Failed tests prevent merging
+- **Issue creation**: Scheduled test failures automatically create GitHub issues
+- **Notification**: Team notifications on critical failures
+- **Artifact preservation**: Test results saved for 30 days
+
+## Integration with Existing CI/CD
+
+### Relationship with GitLab CI
+Your existing `.gitlab-ci.yml` focuses on:
+- Docker image building
+- Production deployment
+- Simple build-test-deploy workflow
+
+The new Forgejo Actions provide:
+- **Comprehensive testing** with multiple scenarios
+- **Detailed validation** of pricing-specific changes
+- **Matrix testing** across Python/Django versions
+- **Automated quality gates** with coverage thresholds
+- **Continuous monitoring** with scheduled tests
+
+Both systems can coexist and complement each other.
+
+## Best Practices
+
+### For Developers
+1. **Run tests locally** using the setup script before pushing
+2. **Add tests** for any new pricing functionality
+3. **Check coverage** to ensure adequate test coverage
+4. **Review PR summaries** for detailed change analysis
+
+### For Maintainers
+1. **Monitor scheduled tests** for early issue detection
+2. **Review coverage trends** to maintain quality
+3. **Update thresholds** as the codebase evolves
+4. **Investigate failures** promptly to prevent regressions
+
+## Benefits
+
+### 🛡️ Regression Prevention
+- Comprehensive test suite catches pricing calculation errors
+- Matrix testing ensures compatibility across versions
+- Backward compatibility checks prevent API breakage
+
+### 🔍 Quality Assurance
+- 85% minimum test coverage enforced
+- Code quality checks with ruff
+- Security scanning with safety and bandit
+- Documentation completeness validation
+
+### 📊 Continuous Monitoring
+- Daily health checks catch issues early
+- Performance regression detection
+- Data integrity validation
+- Automatic issue creation for failures
+
+### 🚀 Developer Experience
+- Fast feedback on pricing changes
+- Detailed PR summaries for reviewers
+- Local testing script for pre-push validation
+- Clear documentation and troubleshooting guides
+
+## Next Steps
+
+1. **Set up secrets** in your Forgejo repository settings
+2. **Test locally** using `./.forgejo/setup-local-testing.sh`
+3. **Push changes** to trigger the workflows
+4. **Monitor results** in the Actions tab
+5. **Customize** workflows based on your specific needs
+
+The system is designed to be robust, comprehensive, and maintainable, ensuring that your pricing calculations remain accurate as your codebase evolves.

PRICING_TESTS_SUMMARY.md

@@ -0,0 +1,182 @@
+# Pricing Model Test Suite Summary
+
+## Overview
+I've created a comprehensive test suite for the Django pricing models in the Servala project. The test suite ensures that all price calculations work correctly and provides protection against regressions when making future changes to the pricing logic.
+
+## Test Files Created
+
+### 1. `hub/services/tests/test_pricing.py` (639 lines)
+**Core pricing model tests with 29 test methods:**
+
+#### ComputePlanTestCase (6 tests)
+- String representation
+- Price creation and retrieval
+- Non-existent price handling
+- Unique constraint validation
+
+#### StoragePlanTestCase (4 tests)
+- String representation
+- Price creation and retrieval
+- Non-existent price handling
+
+#### ProgressiveDiscountModelTestCase (6 tests)
+- String representation
+- Discount calculations for single and multiple tiers
+- Discount breakdown analysis
+- Tier representation
+
+#### VSHNAppCatPriceTestCase (8 tests)
+- String representation
+- Base fee and unit rate management
+- Final price calculations with and without discounts
+- Error handling for negative values and missing data
+- Price calculations without discount models
+
+#### VSHNAppCatAddonTestCase (5 tests)
+- Base fee and unit rate addon types
+- Error handling for missing service levels
+- Final price calculations with mandatory and optional addons
+- Addon string representations
+
+### 2. `hub/services/tests/test_pricing_edge_cases.py` (8 tests)
+**Edge cases and error conditions:**
+- Overlapping discount tier handling
+- Zero unit calculations
+- Very large number handling
+- Inactive discount model behavior
+- Missing addon price data
+- Validity date ranges
+- Decimal precision edge cases
+- Unique constraint enforcement
+- Addon ordering and filtering
+
+### 3. `hub/services/tests/test_pricing_integration.py` (8 tests)
+**Integration tests for complex scenarios:**
+- Complete pricing setup across all models
+- Multi-currency pricing (CHF, EUR, USD)
+- Complex AppCat services with all features
+- External price comparisons
+- Service availability based on pricing
+- Model relationship verification
+- Comprehensive real-world scenarios
+
+### 4. `hub/services/tests/test_utils.py`
+**Test utilities and helpers:**
+- `PricingTestMixin` for common setup
+- Helper functions for expected price calculations
+- Test data factory methods
+
+### 5. `hub/services/tests/README.md`
+**Comprehensive documentation covering:**
+- Test structure and organization
+- How to run tests
+- Test coverage details
+- Key test scenarios
+- Best practices for adding new tests
+- Maintenance guidelines
+
+### 6. `run_pricing_tests.sh`
+**Test runner script for easy execution**
+
+## Key Features Tested
+
+### Price Calculation Logic
+✅ **Progressive Discount Models**: Multi-tier discount calculations with proper tier handling  
+✅ **Final Price Calculations**: Base fees + unit rates + addons with discounts  
+✅ **Multi-Currency Support**: CHF, EUR, USD pricing  
+✅ **Addon Pricing**: Both base fee and unit rate addon types  
+✅ **Service Level Pricing**: Different rates for Best Effort vs Guaranteed service levels  
+
+### Business Logic
+✅ **Mandatory vs Optional Addons**: Proper inclusion in price calculations  
+✅ **Discount Model Activation**: Active/inactive discount model handling  
+✅ **Public Display Settings**: Service availability based on pricing configuration  
+✅ **External Price Comparisons**: Integration with competitor pricing data  
+
+### Error Handling
+✅ **Negative Values**: Proper error handling for invalid inputs  
+✅ **Missing Data**: Graceful handling of missing price configurations  
+✅ **Decimal Precision**: Accurate monetary calculations  
+✅ **Constraint Validation**: Database constraint enforcement  
+
+### Edge Cases
+✅ **Zero Units**: Calculations with zero quantity  
+✅ **Large Numbers**: Performance with high unit counts  
+✅ **Boundary Conditions**: Discount tier boundaries  
+✅ **Data Integrity**: Relationship and constraint validation  
+
+## Test Coverage Statistics
+- **Total Test Methods**: 45 test methods across all test files
+- **Models Covered**: All pricing-related models (ComputePlan, StoragePlan, VSHNAppCatPrice, Progressive Discounts, Addons, etc.)
+- **Scenarios Covered**: Basic CRUD, complex calculations, error conditions, integration scenarios
+- **Edge Cases**: Comprehensive coverage of boundary conditions and error states
+
+## Real-World Test Scenarios
+
+### PostgreSQL Service Pricing
+The integration tests include a complete PostgreSQL service setup with:
+- 16 GiB RAM requirement with progressive discounts
+- Mandatory automated backup addon
+- Optional monitoring and SSL certificate addons
+- Expected total: CHF 186.20/month
+
+### Multi-Tier Discount Example
+For 60 units with progressive discount:
+- First 10 units: 100% of base rate (no discount)
+- Next 40 units: 90% of base rate (10% discount)
+- Next 10 units: 80% of base rate (20% discount)
+
+### External Price Comparison
+Tests include AWS RDS comparison scenarios to verify competitive pricing.
+
+## Usage Instructions
+
+### Run All Tests
+```bash
+cd /home/tobru/src/servala/website
+uv run --extra dev manage.py test hub.services.tests --verbosity=2
+```
+
+### Run Specific Test Categories
+```bash
+# Basic pricing tests
+uv run --extra dev manage.py test hub.services.tests.test_pricing
+
+# Edge case tests
+uv run --extra dev manage.py test hub.services.tests.test_pricing_edge_cases
+
+# Integration tests
+uv run --extra dev manage.py test hub.services.tests.test_pricing_integration
+```
+
+### Use Test Runner Script
+```bash
+./run_pricing_tests.sh
+```
+
+## Benefits
+
+### Regression Protection
+The comprehensive test suite protects against breaking changes when:
+- Modifying discount calculation algorithms
+- Adding new pricing features
+- Refactoring pricing models
+- Updating business logic
+
+### Documentation
+Tests serve as living documentation of how the pricing system should work, including:
+- Expected calculation logic
+- Error handling behavior
+- Integration patterns
+- Business rules
+
+### Confidence in Changes
+Developers can make changes to the pricing system with confidence, knowing that the test suite will catch any regressions or unexpected behavior changes.
+
+## Maintenance
+- Tests are organized into logical groups for easy maintenance
+- Helper utilities reduce code duplication
+- Comprehensive documentation guides future development
+- Test runner script simplifies execution
+
+The test suite follows Django best practices and provides comprehensive coverage of the pricing models and calculations, ensuring the reliability and correctness of the pricing system.

hub/services/admin/pricing.py

@@ -25,6 +25,9 @@ from ..models import (
     VSHNAppCatBaseFee,
     VSHNAppCatPrice,
     VSHNAppCatUnitRate,
+    VSHNAppCatAddon,
+    VSHNAppCatAddonBaseFee,
+    VSHNAppCatAddonUnitRate,
     ProgressiveDiscountModel,
     DiscountTier,
     ExternalPricePlans,
@@ -297,6 +300,15 @@ class VSHNAppCatUnitRateInline(admin.TabularInline):
     fields = ("currency", "service_level", "amount")
 
 
+class VSHNAppCatAddonInline(admin.TabularInline):
+    """Inline admin for VSHNAppCatAddon model within the VSHNAppCatPrice admin"""
+
+    model = VSHNAppCatAddon
+    extra = 1
+    fields = ("name", "addon_type", "mandatory", "active")
+    show_change_link = True
+
+
 class DiscountTierInline(admin.TabularInline):
     """Inline admin for DiscountTier model"""
 
@@ -330,7 +342,7 @@ class VSHNAppCatPriceAdmin(admin.ModelAdmin):
     )
     list_filter = ("variable_unit", "service", "discount_model")
     search_fields = ("service__name",)
-    inlines = [VSHNAppCatBaseFeeInline, VSHNAppCatUnitRateInline]
+    inlines = [VSHNAppCatBaseFeeInline, VSHNAppCatUnitRateInline, VSHNAppCatAddonInline]
 
     def admin_display_base_fees(self, obj):
         """Display base fees in admin list view"""
@@ -542,3 +554,84 @@ class ExternalPricePlansAdmin(ImportExportModelAdmin):
         return f"{count} plan{'s' if count != 1 else ''}"
 
     display_compare_to_count.short_description = "Compare To"
+
+
+class VSHNAppCatAddonBaseFeeInline(admin.TabularInline):
+    """Inline admin for VSHNAppCatAddonBaseFee model"""
+
+    model = VSHNAppCatAddonBaseFee
+    extra = 1
+    fields = ("currency", "amount")
+
+
+class VSHNAppCatAddonUnitRateInline(admin.TabularInline):
+    """Inline admin for VSHNAppCatAddonUnitRate model"""
+
+    model = VSHNAppCatAddonUnitRate
+    extra = 1
+    fields = ("currency", "service_level", "amount")
+
+
+class VSHNAppCatAddonInline(admin.TabularInline):
+    """Inline admin for VSHNAppCatAddon model within the VSHNAppCatPrice admin"""
+
+    model = VSHNAppCatAddon
+    extra = 1
+    fields = ("name", "addon_type", "mandatory", "active", "order")
+    show_change_link = True
+
+
+@admin.register(VSHNAppCatAddon)
+class VSHNAppCatAddonAdmin(admin.ModelAdmin):
+    """Admin configuration for VSHNAppCatAddon model"""
+
+    list_display = (
+        "name",
+        "vshn_appcat_price_config",
+        "addon_type",
+        "mandatory",
+        "active",
+        "display_pricing",
+        "order",
+    )
+    list_filter = (
+        "addon_type",
+        "mandatory",
+        "active",
+        "vshn_appcat_price_config__service",
+    )
+    search_fields = (
+        "name",
+        "description",
+        "commercial_description",
+        "vshn_appcat_price_config__service__name",
+    )
+    ordering = ("vshn_appcat_price_config__service__name", "order", "name")
+
+    # Different inlines based on addon type
+    inlines = [VSHNAppCatAddonBaseFeeInline, VSHNAppCatAddonUnitRateInline]
+
+    def display_pricing(self, obj):
+        """Display pricing information based on addon type"""
+        if obj.addon_type == "BF":  # Base Fee
+            fees = obj.base_fees.all()
+            if not fees:
+                return "No base fees set"
+            return format_html(
+                "<br>".join([f"{fee.amount} {fee.currency}" for fee in fees])
+            )
+        elif obj.addon_type == "UR":  # Unit Rate
+            rates = obj.unit_rates.all()
+            if not rates:
+                return "No unit rates set"
+            return format_html(
+                "<br>".join(
+                    [
+                        f"{rate.amount} {rate.currency} ({rate.get_service_level_display()})"
+                        for rate in rates
+                    ]
+                )
+            )
+        return "Unknown addon type"
+
+    display_pricing.short_description = "Pricing"

hub/services/migrations/0035_alter_article_image_vshnappcataddon_and_more.py

@@ -0,0 +1,195 @@
+# Generated by Django 5.2 on 2025-06-19 13:53
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("services", "0034_article"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="article",
+            name="image",
+            field=models.ImageField(
+                help_text="Title picture for the article", upload_to="article_images/"
+            ),
+        ),
+        migrations.CreateModel(
+            name="VSHNAppCatAddon",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(help_text="Name of the addon", max_length=100),
+                ),
+                (
+                    "description",
+                    models.TextField(
+                        blank=True, help_text="Technical description of the addon"
+                    ),
+                ),
+                (
+                    "commercial_description",
+                    models.TextField(
+                        blank=True,
+                        help_text="Commercial description displayed in the frontend",
+                    ),
+                ),
+                (
+                    "addon_type",
+                    models.CharField(
+                        choices=[("BF", "Base Fee"), ("UR", "Unit Rate")],
+                        help_text="Type of addon pricing (fixed fee or per-unit)",
+                        max_length=2,
+                    ),
+                ),
+                (
+                    "mandatory",
+                    models.BooleanField(
+                        default=False, help_text="Is this addon mandatory?"
+                    ),
+                ),
+                (
+                    "active",
+                    models.BooleanField(
+                        default=True,
+                        help_text="Is this addon active and available for selection?",
+                    ),
+                ),
+                (
+                    "order",
+                    models.IntegerField(
+                        default=0, help_text="Display order in the frontend"
+                    ),
+                ),
+                ("valid_from", models.DateTimeField(blank=True, null=True)),
+                ("valid_to", models.DateTimeField(blank=True, null=True)),
+                (
+                    "vshn_appcat_price_config",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="addons",
+                        to="services.vshnappcatprice",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Service Addon",
+                "ordering": ["order", "name"],
+            },
+        ),
+        migrations.CreateModel(
+            name="VSHNAppCatAddonBaseFee",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "currency",
+                    models.CharField(
+                        choices=[
+                            ("CHF", "Swiss Franc"),
+                            ("EUR", "Euro"),
+                            ("USD", "US Dollar"),
+                        ],
+                        max_length=3,
+                    ),
+                ),
+                (
+                    "amount",
+                    models.DecimalField(
+                        decimal_places=2,
+                        help_text="Base fee in the specified currency, excl. VAT",
+                        max_digits=10,
+                    ),
+                ),
+                (
+                    "addon",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="base_fees",
+                        to="services.vshnappcataddon",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Addon Base Fee",
+                "ordering": ["currency"],
+                "unique_together": {("addon", "currency")},
+            },
+        ),
+        migrations.CreateModel(
+            name="VSHNAppCatAddonUnitRate",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "currency",
+                    models.CharField(
+                        choices=[
+                            ("CHF", "Swiss Franc"),
+                            ("EUR", "Euro"),
+                            ("USD", "US Dollar"),
+                        ],
+                        max_length=3,
+                    ),
+                ),
+                (
+                    "service_level",
+                    models.CharField(
+                        choices=[
+                            ("BE", "Best Effort"),
+                            ("GA", "Guaranteed Availability"),
+                        ],
+                        max_length=2,
+                    ),
+                ),
+                (
+                    "amount",
+                    models.DecimalField(
+                        decimal_places=4,
+                        help_text="Price per unit in the specified currency and service level, excl. VAT",
+                        max_digits=10,
+                    ),
+                ),
+                (
+                    "addon",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="unit_rates",
+                        to="services.vshnappcataddon",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Addon Unit Rate",
+                "ordering": ["currency", "service_level"],
+                "unique_together": {("addon", "currency", "service_level")},
+            },
+        ),
+    ]

hub/services/models/pricing.py

@@ -1,4 +1,5 @@
 from django.db import models
+from django.db.models import Q
 
 from .base import Currency, Term, Unit
 from .providers import CloudProvider
@@ -339,7 +340,11 @@ class VSHNAppCatPrice(models.Model):
             return None
 
     def calculate_final_price(
-        self, currency_code: str, service_level: str, number_of_units: int
+        self,
+        currency_code: str,
+        service_level: str,
+        number_of_units: int,
+        addon_ids=None,
     ):
         base_fee = self.get_base_fee(currency_code)
         unit_rate = self.get_unit_rate(currency_code, service_level)
@@ -359,7 +364,49 @@ class VSHNAppCatPrice(models.Model):
         else:
             total_price = base_fee + (unit_rate * number_of_units)
 
-        return total_price
+        # Add prices for mandatory addons and selected addons
+        addon_total = 0
+        addon_breakdown = []
+
+        # Query all active addons related to this price config
+        addons_query = self.addons.filter(active=True)
+
+        # Include mandatory addons and explicitly selected addons
+        if addon_ids:
+            addons = addons_query.filter(Q(mandatory=True) | Q(id__in=addon_ids))
+        else:
+            addons = addons_query.filter(mandatory=True)
+
+        for addon in addons:
+            addon_price = 0
+            if addon.addon_type == VSHNAppCatAddon.AddonType.BASE_FEE:
+                addon_price_value = addon.get_price(currency_code)
+                if addon_price_value:
+                    addon_price = addon_price_value
+            elif addon.addon_type == VSHNAppCatAddon.AddonType.UNIT_RATE:
+                addon_price_value = addon.get_price(currency_code, service_level)
+                if addon_price_value:
+                    addon_price = addon_price_value * number_of_units
+
+            addon_total += addon_price
+            addon_breakdown.append(
+                {
+                    "id": addon.id,
+                    "name": addon.name,
+                    "description": addon.description,
+                    "commercial_description": addon.commercial_description,
+                    "mandatory": addon.mandatory,
+                    "price": addon_price,
+                }
+            )
+
+        total_price += addon_total
+
+        return {
+            "total_price": total_price,
+            "addon_total": addon_total,
+            "addon_breakdown": addon_breakdown,
+        }
 
 
 class VSHNAppCatUnitRate(models.Model):
@@ -389,6 +436,118 @@ class VSHNAppCatUnitRate(models.Model):
         return f"{self.vshn_appcat_price_config.service.name} - {self.get_service_level_display()} Unit Rate - {self.amount} {self.currency}"
 
 
+class VSHNAppCatAddon(models.Model):
+    """
+    Addon pricing model for VSHNAppCatPrice. Can be added to a service price configuration
+    to provide additional features or resources with their own pricing.
+    """
+
+    class AddonType(models.TextChoices):
+        BASE_FEE = "BF", "Base Fee"  # Fixed amount regardless of units
+        UNIT_RATE = "UR", "Unit Rate"  # Price per unit
+
+    vshn_appcat_price_config = models.ForeignKey(
+        VSHNAppCatPrice, on_delete=models.CASCADE, related_name="addons"
+    )
+    name = models.CharField(max_length=100, help_text="Name of the addon")
+    description = models.TextField(
+        blank=True, help_text="Technical description of the addon"
+    )
+    commercial_description = models.TextField(
+        blank=True, help_text="Commercial description displayed in the frontend"
+    )
+    addon_type = models.CharField(
+        max_length=2,
+        choices=AddonType.choices,
+        help_text="Type of addon pricing (fixed fee or per-unit)",
+    )
+    mandatory = models.BooleanField(default=False, help_text="Is this addon mandatory?")
+    active = models.BooleanField(
+        default=True, help_text="Is this addon active and available for selection?"
+    )
+    order = models.IntegerField(default=0, help_text="Display order in the frontend")
+    valid_from = models.DateTimeField(blank=True, null=True)
+    valid_to = models.DateTimeField(blank=True, null=True)
+
+    class Meta:
+        verbose_name = "Service Addon"
+        ordering = ["order", "name"]
+
+    def __str__(self):
+        return f"{self.vshn_appcat_price_config.service.name} - {self.name}"
+
+    def get_price(self, currency_code: str, service_level: str = None):
+        """Get the price for this addon in the specified currency and service level"""
+        try:
+            if self.addon_type == self.AddonType.BASE_FEE:
+                return self.base_fees.get(currency=currency_code).amount
+            elif self.addon_type == self.AddonType.UNIT_RATE:
+                if not service_level:
+                    raise ValueError("Service level is required for unit rate addons")
+                return self.unit_rates.get(
+                    currency=currency_code, service_level=service_level
+                ).amount
+        except (
+            VSHNAppCatAddonBaseFee.DoesNotExist,
+            VSHNAppCatAddonUnitRate.DoesNotExist,
+        ):
+            return None
+
+
+class VSHNAppCatAddonBaseFee(models.Model):
+    """Base fee for an addon (fixed amount regardless of units)"""
+
+    addon = models.ForeignKey(
+        VSHNAppCatAddon, on_delete=models.CASCADE, related_name="base_fees"
+    )
+    currency = models.CharField(
+        max_length=3,
+        choices=Currency.choices,
+    )
+    amount = models.DecimalField(
+        max_digits=10,
+        decimal_places=2,
+        help_text="Base fee in the specified currency, excl. VAT",
+    )
+
+    class Meta:
+        verbose_name = "Addon Base Fee"
+        unique_together = ("addon", "currency")
+        ordering = ["currency"]
+
+    def __str__(self):
+        return f"{self.addon.name} Base Fee - {self.amount} {self.currency}"
+
+
+class VSHNAppCatAddonUnitRate(models.Model):
+    """Unit rate for an addon (price per unit)"""
+
+    addon = models.ForeignKey(
+        VSHNAppCatAddon, on_delete=models.CASCADE, related_name="unit_rates"
+    )
+    currency = models.CharField(
+        max_length=3,
+        choices=Currency.choices,
+    )
+    service_level = models.CharField(
+        max_length=2,
+        choices=VSHNAppCatPrice.ServiceLevel.choices,
+    )
+    amount = models.DecimalField(
+        max_digits=10,
+        decimal_places=4,
+        help_text="Price per unit in the specified currency and service level, excl. VAT",
+    )
+
+    class Meta:
+        verbose_name = "Addon Unit Rate"
+        unique_together = ("addon", "currency", "service_level")
+        ordering = ["currency", "service_level"]
+
+    def __str__(self):
+        return f"{self.addon.name} - {self.get_service_level_display()} Unit Rate - {self.amount} {self.currency}"
+
+
 class ExternalPricePlans(models.Model):
     plan_name = models.CharField()
     description = models.CharField(max_length=200, blank=True, null=True)

hub/services/templates/services/offering_detail.html

@@ -271,11 +271,19 @@
                                                         <input type="radio" class="btn-check" name="serviceLevel" id="serviceLevelBestEffort" value="Best Effort" checked>
                                                         <label class="btn btn-outline-primary" for="serviceLevelBestEffort">Best Effort</label>
                                                         
-                                                        <input type="radio" class="btn-check" name="serviceLevel" id="serviceLevelGuaranteed" value="Guaranteed">
+                                                        <input type="radio" class="btn-check" name="serviceLevel" id="serviceLevelGuaranteed" value="Guaranteed Availability">
                                                         <label class="btn btn-outline-primary" for="serviceLevelGuaranteed">Guaranteed Availability</label>
                                                     </div>
                                                 </div>
                                                 
+                                                <!-- Addons Section - Hidden by default, shown by JS if addons exist -->
+                                                <div class="mb-4" id="addonsSection" style="display: none;">
+                                                    <label class="form-label">Add-ons (Optional)</label>
+                                                    <div id="addonsContainer">
+                                                        <!-- Add-ons will be dynamically populated here -->
+                                                    </div>
+                                                </div>
+
                                                 <!-- Direct Plan Selection -->
                                                 <div class="mb-4">
                                                     <label for="planSelect" class="form-label">Or choose a specific plan</label>
@@ -345,6 +353,12 @@
                                                             <span>Storage - <span id="storageAmount">20</span> GB</span>
                                                             <span class="fw-bold">CHF <span id="storagePrice">0.00</span></span>
                                                         </div>
+                                                        
+                                                        <!-- Addons Pricing -->
+                                                        <div id="addonPricingContainer">
+                                                            <!-- Addon pricing will be dynamically added here -->
+                                                        </div>
+                                                        
                                                         <hr>
                                                         <div class="d-flex justify-content-between">
                                                             <span class="fs-5 fw-bold">Total Monthly Price</span>
@@ -446,6 +460,4 @@
         </div>
     </div>
 </section>
-
-
 {% endblock %}

hub/services/templates/services/pricelist.html

@@ -1,5 +1,6 @@
 {% extends 'base.html' %}
 {% load static %}
+{% load math_tags %}
 
 {% block title %}Complete Price List{% endblock %}
 
@@ -7,12 +8,177 @@
 <script src="{% static "js/chart.js" %}"></script>
 {% endblock %}
 
+{% block extra_css %}
+<style>
+    .addon-details {
+        max-width: 300px;
+        font-size: 0.85em;
+    }
+    
+    .addon-item {
+        background-color: #f8f9fa;
+        border-radius: 4px;
+        padding: 4px 8px;
+        margin-bottom: 4px;
+    }
+    
+    .addon-name {
+        font-weight: 500;
+    }
+    
+    .addon-price {
+        color: #28a745;
+        font-size: 0.9em;
+    }
+    
+    .pricing-table th {
+        white-space: nowrap;
+    }
+    
+    .final-price-header {
+        background-color: #28a745 !important;
+        color: white !important;
+    }
+    
+    .final-price-cell {
+        background-color: #d4edda;
+        color: #155724;
+    }
+    
+    .comparison-row {
+        font-size: 0.9em;
+    }
+    
+    .servala-row {
+        border-bottom: 2px solid #007bff;
+    }
+    
+    /* Price calculation breakdown styling */
+    .price-breakdown-header {
+        background: linear-gradient(135deg, #28a745, #20b2aa);
+    }
+    
+    .compute-plan-col {
+        background-color: rgba(13, 110, 253, 0.1);
+        border-right: 2px solid #0d6efd;
+    }
+    
+    .sla-base-col {
+        background-color: rgba(111, 66, 193, 0.1);
+        border-right: 2px solid #6f42c1;
+    }
+    
+    .sla-units-col {
+        background-color: rgba(253, 126, 20, 0.1);
+        border-right: 2px solid #fd7e14;
+    }
+    
+    .mandatory-addons-col {
+        background-color: rgba(220, 53, 69, 0.1);
+        border-right: 2px solid #dc3545;
+    }
+    
+    .total-sla-col {
+        background-color: rgba(25, 135, 84, 0.2);
+        border-right: 3px solid #198754;
+    }
+    
+    /* Mathematical operator styling */
+    .math-operator {
+        font-size: 1.2em;
+        font-weight: bold;
+        color: #666;
+        padding: 0 5px;
+    }
+    
+    /* Price calculation formula helper */
+    .price-formula {
+        background-color: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 0.25rem;
+        padding: 10px;
+        margin-bottom: 20px;
+        font-family: monospace;
+        text-align: center;
+    }
+    
+    .price-formula .formula-part {
+        display: inline-block;
+        padding: 2px 8px;
+        margin: 0 5px;
+        border-radius: 3px;
+        font-weight: bold;
+    }
+    
+    .price-formula .compute-part { background-color: rgba(13, 110, 253, 0.2); color: #0d6efd; }
+    .price-formula .sla-base-part { background-color: rgba(111, 66, 193, 0.2); color: #6f42c1; }
+    .price-formula .sla-units-part { background-color: rgba(253, 126, 20, 0.2); color: #fd7e14; }
+    .price-formula .addons-part { background-color: rgba(220, 53, 69, 0.2); color: #dc3545; }
+    .price-formula .equals-part { background-color: rgba(25, 135, 84, 0.2); color: #198754; }
+</style>
+{% endblock %}
+
 {% block content %}
 <div class="container-fluid mt-4">
     <div class="row">
         <div class="col-12">
             <h1 class="mb-4">Complete Price List - All Service Variants</h1>
             
+            <!-- Pricing Model Explanation -->
+            <div class="card mb-4">
+                <div class="card-header" data-bs-toggle="collapse" data-bs-target="#pricingExplanation" aria-expanded="false" aria-controls="pricingExplanation" style="cursor: pointer;">
+                    <h5 class="mb-0">
+                        <i class="bi bi-info-circle me-2"></i>How Our Pricing Works
+                        <small class="text-muted ms-2">(Click to expand)</small>
+                    </h5>
+                </div>
+                <div class="collapse" id="pricingExplanation">
+                    <div class="card-body">
+                        <div class="row">
+                            <div class="col-md-6">
+                                <h6>Price Components</h6>
+                                <ul class="list-unstyled">
+                                    <li class="mb-2">
+                                        <span class="badge" style="background-color: #0d6efd;">Compute Plan Price</span>
+                                        <span class="ms-2">Base infrastructure cost for CPU, memory, and storage</span>
+                                    </li>
+                                    <li class="mb-2">
+                                        <span class="badge" style="background-color: #6f42c1;">SLA Base</span>
+                                        <span class="ms-2">Fixed cost for the service level agreement</span>
+                                    </li>
+                                    <li class="mb-2">
+                                        <span class="badge" style="background-color: #fd7e14;">Units × SLA Per Unit</span>
+                                        <span class="ms-2">Variable cost based on scale/usage</span>
+                                    </li>
+                                    <li class="mb-2">
+                                        <span class="badge" style="background-color: #dc3545;">Mandatory Add-ons</span>
+                                        <span class="ms-2">Required additional services (backup, monitoring, etc.)</span>
+                                    </li>
+                                </ul>
+                            </div>
+                            <div class="col-md-6">
+                                <h6>Final Price Formula</h6>
+                                <div class="bg-light p-3 rounded">
+                                    <code>
+                                        <span style="color: #0d6efd;">Compute Plan Price</span> + 
+                                        <span style="color: #6f42c1;">SLA Base</span> + 
+                                        <span style="color: #fd7e14;">(Units × SLA Per Unit)</span> + 
+                                        <span style="color: #dc3545;">Mandatory Add-ons</span> = 
+                                        <strong style="color: #198754;">Final Price</strong>
+                                    </code>
+                                </div>
+                                <p class="mt-3 mb-0">
+                                    <small class="text-muted">
+                                        This transparent pricing model ensures you understand exactly what you're paying for. 
+                                        The table below breaks down each component for every service variant we offer.
+                                    </small>
+                                </p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
             <!-- Filter Form -->
             <div class="card mb-4">
                 <div class="card-header">
@@ -71,6 +237,12 @@
                                     Show discount details
                                 </label>
                             </div>
+                            <div class="form-check">
+                                <input class="form-check-input" type="checkbox" name="addon_details" value="true" id="addon_details" {% if show_addon_details %}checked{% endif %}>
+                                <label class="form-check-label" for="addon_details">
+                                    Show addon details
+                                </label>
+                            </div>
                             <div class="form-check">
                                 <input class="form-check-input" type="checkbox" name="price_comparison" value="true" id="price_comparison" {% if show_price_comparison %}checked{% endif %}>
                                 <label class="form-check-label" for="price_comparison">
@@ -87,13 +259,16 @@
             </div>
 
             <!-- Active Filters Display -->
-            {% if filter_cloud_provider or filter_service or filter_compute_plan_group or filter_service_level %}
+            {% if filter_cloud_provider or filter_service or filter_compute_plan_group or filter_service_level or show_discount_details or show_addon_details or show_price_comparison %}
                 <div class="alert alert-info">
                     <strong>Active Filters:</strong>
                     {% if filter_cloud_provider %}<span class="badge me-1">Cloud Provider: {{ filter_cloud_provider }}</span>{% endif %}
                     {% if filter_service %}<span class="badge me-1">Service: {{ filter_service }}</span>{% endif %}
                     {% if filter_compute_plan_group %}<span class="badge me-1">Group: {{ filter_compute_plan_group }}</span>{% endif %}
                     {% if filter_service_level %}<span class="badge me-1">Service Level: {{ filter_service_level }}</span>{% endif %}
+                    {% if show_discount_details %}<span class="badge bg-secondary me-1">Discount Details</span>{% endif %}
+                    {% if show_addon_details %}<span class="badge bg-info me-1">Addon Details</span>{% endif %}
+                    {% if show_price_comparison %}<span class="badge bg-warning me-1">Price Comparison</span>{% endif %}
                 </div>
             {% endif %}
             
@@ -174,31 +349,97 @@
                                                 <strong>Replica Enforce:</strong> {{ first_row.replica_enforce }}
                                             </div>
                                         </div>
+                                        
+                                        {# Display add-on summary #}
+                                        {% if show_addon_details and first_row.mandatory_addons or first_row.optional_addons %}
+                                            <div class="card mb-3">
+                                                <div class="card-header">
+                                                    <h6 class="mb-0">Available Add-ons for {{ first_row.service }}</h6>
+                                                </div>
+                                                <div class="card-body">
+                                                    {% if first_row.mandatory_addons %}
+                                                        <div class="mb-3">
+                                                            <h6 class="text-success">Mandatory Add-ons (included in all plans):</h6>
+                                                            <div class="row">
+                                                                {% for addon in first_row.mandatory_addons %}
+                                                                    <div class="col-md-4 mb-2">
+                                                                        <div class="border border-success rounded p-2">
+                                                                            <strong>{{ addon.name }}</strong>
+                                                                            <div class="text-muted small">{{ addon.commercial_description|default:addon.description }}</div>
+                                                                            <div class="text-success fw-bold">{{ addon.price|floatformat:2 }} {{ first_row.currency }}</div>
+                                                                            <small class="text-muted">{{ addon.addon_type }}</small>
+                                                                        </div>
+                                                                    </div>
+                                                                {% endfor %}
+                                                            </div>
+                                                        </div>
+                                                    {% endif %}
+                                                    
+                                                    {% if first_row.optional_addons %}
+                                                        <div>
+                                                            <h6 class="text-info">Optional Add-ons (can be added):</h6>
+                                                            <div class="row">
+                                                                {% for addon in first_row.optional_addons %}
+                                                                    <div class="col-md-4 mb-2">
+                                                                        <div class="border border-info rounded p-2">
+                                                                            <strong>{{ addon.name }}</strong>
+                                                                            <div class="text-muted small">{{ addon.commercial_description|default:addon.description }}</div>
+                                                                            <div class="text-info fw-bold">{{ addon.price|floatformat:2 }} {{ first_row.currency }}</div>
+                                                                            <small class="text-muted">{{ addon.addon_type }}</small>
+                                                                        </div>
+                                                                    </div>
+                                                                {% endfor %}
+                                                            </div>
+                                                        </div>
+                                                    {% endif %}
+                                                </div>
+                                            </div>
+                                        {% endif %}
                                     {% endwith %}
                                     
+                                    <!-- Price Calculation Formula Helper -->
+                                    <div class="price-formula">
+                                        <strong>Final Price Calculation:</strong><br>
+                                        <span class="formula-part compute-part">Compute Plan Price</span>
+                                        <span class="math-operator">+</span>
+                                        <span class="formula-part sla-base-part">SLA Base</span>
+                                        <span class="math-operator">+</span>
+                                        <span class="formula-part sla-units-part">Units × SLA Per Unit</span>
+                                        <span class="math-operator">+</span>
+                                        <span class="formula-part addons-part">Mandatory Add-ons</span>
+                                        <span class="math-operator">=</span>
+                                        <span class="formula-part equals-part">Final Price</span>
+                                    </div>
+                                    
                                     <div class="table-responsive">
                                         <table class="table table-striped table-bordered table-sm pricing-table">
                                             <thead class="table-dark">
                                                 <tr>
-                                                    <th>Compute Plan</th>
-                                                    <th>Cloud Provider</th>
-                                                    <th>vCPUs</th>
-                                                    <th>RAM (GB)</th>
-                                                    <th>Term</th>
-                                                    <th>Currency</th>
-                                                    <th>Compute Plan Price</th>
-                                                    <th>Units</th>
-                                                    <th>SLA Base</th>
-                                                    <th>SLA Per Unit</th>
-                                                    <th>SLA Price</th>
+                                                    <th rowspan="2">Compute Plan</th>
+                                                    <th rowspan="2">Cloud Provider</th>
+                                                    <th rowspan="2">vCPUs</th>
+                                                    <th rowspan="2">RAM (GB)</th>
+                                                    <th rowspan="2">Term</th>
+                                                    <th rowspan="2">Currency</th>
+                                                    <th colspan="5" class="text-center" style="background-color: #198754 !important;">Price Calculation Breakdown</th>
+                                                    {% if show_addon_details %}
+                                                    <th rowspan="2">Add-ons</th>
+                                                    {% endif %}
                                                     {% if show_discount_details %}
-                                                    <th>Discount Model</th>
-                                                    <th>Discount Details</th>
+                                                    <th rowspan="2">Discount Model</th>
+                                                    <th rowspan="2">Discount Details</th>
                                                     {% endif %}
                                                     {% if show_price_comparison %}
-                                                    <th>External Comparisons</th>
+                                                    <th rowspan="2">External Comparisons</th>
                                                     {% endif %}
-                                                    <th class="final-price-header">Final Price</th>
+                                                    <th rowspan="2" class="final-price-header">Final Price</th>
+                                                </tr>
+                                                <tr>
+                                                    <th style="background-color: #0d6efd; color: white;">Compute Plan Price</th>
+                                                    <th style="background-color: #6f42c1; color: white;">SLA Base</th>
+                                                    <th style="background-color: #fd7e14; color: white;">Units × SLA Per Unit</th>
+                                                    <th style="background-color: #dc3545; color: white;">Mandatory Add-ons</th>
+                                                    <th style="background-color: #198754; color: white;">= Total SLA Price</th>
                                                 </tr>
                                             </thead>
                                             <tbody>
@@ -210,11 +451,92 @@
                                                     <td>{{ row.ram }}</td>
                                                     <td>{{ row.term }}</td>
                                                     <td>{{ row.currency }}</td>
-                                                    <td>{{ row.compute_plan_price|floatformat:2 }}</td>
-                                                    <td>{{ row.units }}</td>
-                                                    <td>{{ row.sla_base|floatformat:2 }}</td>
-                                                    <td>{{ row.sla_per_unit|floatformat:4 }}</td>
-                                                    <td>{{ row.sla_price|floatformat:2 }}</td>
+                                                    <!-- Price Calculation Breakdown -->
+                                                    <td class="text-center" style="background-color: rgba(13, 110, 253, 0.1);">
+                                                        <span class="fw-bold">{{ row.compute_plan_price|floatformat:2 }}</span>
+                                                    </td>
+                                                    <td class="text-center" style="background-color: rgba(111, 66, 193, 0.1);">
+                                                        <span class="fw-bold">{{ row.sla_base|floatformat:2 }}</span>
+                                                    </td>
+                                                    <td class="text-center" style="background-color: rgba(253, 126, 20, 0.1);">
+                                                        <span class="fw-bold">{{ row.units|floatformat:0 }} × {{ row.sla_per_unit|floatformat:4 }}</span><br>
+                                                        <small class="text-muted">= {{ row.units|multiply:row.sla_per_unit|floatformat:2 }}</small>
+                                                    </td>
+                                                    <td class="text-center" style="background-color: rgba(220, 53, 69, 0.1);">
+                                                        {% if row.mandatory_addons %}
+                                                            {% for addon in row.mandatory_addons %}
+                                                                <div class="mb-1">
+                                                                    {% if addon.addon_type == "Unit Rate" %}
+                                                                        <strong>{{ addon.name }}</strong><br>
+                                                                        <span class="fw-bold">{{ row.units|floatformat:0 }} × {{ addon.price|floatformat:4 }}</span><br>
+                                                                        <small class="text-muted">= {{ row.units|multiply:addon.price|floatformat:2 }}</small>
+                                                                    {% elif addon.addon_type == "Base Fee" %}
+                                                                        <strong>{{ addon.name }}</strong><br>
+                                                                        <span class="fw-bold">{{ addon.price|floatformat:2 }}</span>
+                                                                    {% else %}
+                                                                        <strong>{{ addon.name }}</strong><br>
+                                                                        <span class="fw-bold">{{ addon.price|floatformat:2 }}</span>
+                                                                    {% endif %}
+                                                                </div>
+                                                                {% if not forloop.last %}<hr class="my-1">{% endif %}
+                                                            {% endfor %}
+                                                        {% else %}
+                                                            <span class="text-muted">n/a</span>
+                                                        {% endif %}
+                                                    </td>
+                                                    <td class="text-center fw-bold" style="background-color: rgba(25, 135, 84, 0.2);">
+                                                        {% with addon_total=row.mandatory_addons|calculate_addon_total:row.units %}
+                                                            {{ row.sla_price|add_float:addon_total|floatformat:2 }}
+                                                        {% endwith %}
+                                                    </td>
+                                                    {% if show_addon_details %}
+                                                    <td>
+                                                        {% if row.mandatory_addons or row.optional_addons %}
+                                                            <div class="addon-details">
+                                                                {% if row.mandatory_addons %}
+                                                                    <div class="mb-2">
+                                                                        <small class="text-success fw-bold">Mandatory Add-ons:</small>
+                                                                        {% for addon in row.mandatory_addons %}
+                                                                            <div class="addon-item border-start border-success ps-2 mb-1">
+                                                                                <div class="d-flex justify-content-between">
+                                                                                    <span class="addon-name">{{ addon.name }}</span>
+                                                                                    <span class="addon-price fw-bold">{{ addon.price|floatformat:2 }} {{ row.currency }}</span>
+                                                                                </div>
+                                                                                {% if addon.commercial_description %}
+                                                                                    <div class="text-muted small">{{ addon.commercial_description }}</div>
+                                                                                {% elif addon.description %}
+                                                                                    <div class="text-muted small">{{ addon.description }}</div>
+                                                                                {% endif %}
+                                                                                <div class="text-muted small">Type: {{ addon.addon_type }}</div>
+                                                                            </div>
+                                                                        {% endfor %}
+                                                                    </div>
+                                                                {% endif %}
+                                                                {% if row.optional_addons %}
+                                                                    <div>
+                                                                        <small class="text-info fw-bold">Optional Add-ons:</small>
+                                                                        {% for addon in row.optional_addons %}
+                                                                            <div class="addon-item border-start border-info ps-2 mb-1">
+                                                                                <div class="d-flex justify-content-between">
+                                                                                    <span class="addon-name">{{ addon.name }}</span>
+                                                                                    <span class="addon-price">{{ addon.price|floatformat:2 }} {{ row.currency }}</span>
+                                                                                </div>
+                                                                                {% if addon.commercial_description %}
+                                                                                    <div class="text-muted small">{{ addon.commercial_description }}</div>
+                                                                                {% elif addon.description %}
+                                                                                    <div class="text-muted small">{{ addon.description }}</div>
+                                                                                {% endif %}
+                                                                                <div class="text-muted small">Type: {{ addon.addon_type }}</div>
+                                                                            </div>
+                                                                        {% endfor %}
+                                                                    </div>
+                                                                {% endif %}
+                                                            </div>
+                                                        {% else %}
+                                                            <span class="text-muted">No add-ons</span>
+                                                        {% endif %}
+                                                    </td>
+                                                    {% endif %}
                                                     {% if show_discount_details %}
                                                     <td>
                                                         {% if row.has_discount %}
@@ -262,11 +584,15 @@
                                                         </td>
                                                         <td class="text-muted">{{ row.term }}</td>
                                                         <td class="text-muted">{{ comparison.currency }}</td>
+                                                        <!-- Price breakdown columns for external comparisons -->
                                                         <td class="text-muted">-</td>
                                                         <td class="text-muted">-</td>
                                                         <td class="text-muted">-</td>
                                                         <td class="text-muted">-</td>
                                                         <td class="text-muted">-</td>
+                                                        {% if show_addon_details %}
+                                                        <td class="text-muted">-</td>
+                                                        {% endif %}
                                                         {% if show_discount_details %}
                                                         <td class="text-muted">-</td>
                                                         <td class="text-muted">-</td>
@@ -306,7 +632,7 @@
                                     
                                     {# Price Chart #}
                                     <div class="price-chart mt-3">
-                                        <h5 class="text-muted">Price Chart - Units vs Final Price</h5>
+                                        <h5 class="text-muted">Price Breakdown Chart - Units vs Price Components</h5>
                                         <div style="height: 400px;">
                                             <canvas id="chart-{{ group_name|slugify }}-{{ service_level|slugify }}" width="400" height="200"></canvas>
                                         </div>
@@ -338,6 +664,7 @@ document.addEventListener('DOMContentLoaded', function() {
     const filterForm = document.getElementById('filter-form');
     const filterSelects = document.querySelectorAll('.filter-select');
     const discountCheckbox = document.getElementById('discount_details');
+    const addonCheckbox = document.getElementById('addon_details');
     
     // Add change event listeners to all filter dropdowns
     filterSelects.forEach(function(select) {
@@ -351,13 +678,16 @@ document.addEventListener('DOMContentLoaded', function() {
         filterForm.submit();
     });
     
+    // Add change event listener to addon details checkbox
+    addonCheckbox.addEventListener('change', function() {
+        filterForm.submit();
+    });
+    
     // Add change event listener to price comparison checkbox
     const priceComparisonCheckbox = document.getElementById('price_comparison');
     priceComparisonCheckbox.addEventListener('change', function() {
         filterForm.submit();
-    });
-    
-    // Chart data for each service level
+    });                    // Chart data for each service level
     {% for group_name, service_levels in pricing_data_by_group_and_service_level.items %}
         {% for service_level, pricing_data in service_levels.items %}
             {% if pricing_data %}
@@ -374,18 +704,42 @@ document.addEventListener('DOMContentLoaded', function() {
                             fill: false
                         },
                         {
-                            label: 'SLA Price',
-                            data: [{% for row in pricing_data %}{{ row.sla_price|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
-                            borderColor: 'rgb(255, 99, 132)',
-                            backgroundColor: 'rgba(255, 99, 132, 0.2)',
+                            label: 'Compute Plan Price',
+                            data: [{% for row in pricing_data %}{{ row.compute_plan_price|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
+                            borderColor: 'rgb(13, 110, 253)',
+                            backgroundColor: 'rgba(13, 110, 253, 0.2)',
                             tension: 0.1,
                             fill: false
                         },
                         {
-                            label: 'Compute Plan Price',
-                            data: [{% for row in pricing_data %}{{ row.compute_plan_price|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
-                            borderColor: 'rgb(54, 162, 235)',
-                            backgroundColor: 'rgba(54, 162, 235, 0.2)',
+                            label: 'SLA Base',
+                            data: [{% for row in pricing_data %}{{ row.sla_base|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
+                            borderColor: 'rgb(111, 66, 193)',
+                            backgroundColor: 'rgba(111, 66, 193, 0.2)',
+                            tension: 0.1,
+                            fill: false
+                        },
+                        {
+                            label: 'Units × SLA Per Unit',
+                            data: [{% for row in pricing_data %}{{ row.units|multiply:row.sla_per_unit|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
+                            borderColor: 'rgb(253, 126, 20)',
+                            backgroundColor: 'rgba(253, 126, 20, 0.2)',
+                            tension: 0.1,
+                            fill: false
+                        },
+                        {
+                            label: 'Mandatory Add-ons',
+                            data: [{% for row in pricing_data %}{{ row.mandatory_addons|calculate_addon_total:row.units|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
+                            borderColor: 'rgb(220, 53, 69)',
+                            backgroundColor: 'rgba(220, 53, 69, 0.2)',
+                            tension: 0.1,
+                            fill: false
+                        },
+                        {
+                            label: 'Total SLA Price',
+                            data: [{% for row in pricing_data %}{{ row.sla_price|floatformat:2 }}{% if not forloop.last %}, {% endif %}{% endfor %}],
+                            borderColor: 'rgb(25, 135, 84)',
+                            backgroundColor: 'rgba(25, 135, 84, 0.2)',
                             tension: 0.1,
                             fill: false
                         }
@@ -418,7 +772,7 @@ document.addEventListener('DOMContentLoaded', function() {
                         plugins: {
                             title: {
                                 display: true,
-                                text: '{{ group_name }} - {{ service_level }} Pricing'
+                                text: '{{ group_name }} - {{ service_level }} Price Breakdown'
                             },
                             legend: {
                                 display: true

hub/services/templatetags/math_tags.py

@@ -0,0 +1,45 @@
+from django import template
+
+register = template.Library()
+
+
+@register.filter(name="multiply")
+def multiply(value, arg):
+    """Multiply two numbers in Django templates"""
+    try:
+        return float(value) * float(arg)
+    except (ValueError, TypeError):
+        return 0
+
+
+@register.filter(name="add_float")
+def add_float(value, arg):
+    """Add two numbers in Django templates"""
+    try:
+        return float(value) + float(arg)
+    except (ValueError, TypeError):
+        return 0
+
+
+@register.filter(name="sum_addon_prices")
+def sum_addon_prices(addons):
+    """Sum the prices of addons"""
+    try:
+        return sum(addon.price for addon in addons)
+    except (AttributeError, TypeError):
+        return 0
+
+
+@register.filter(name="calculate_addon_total")
+def calculate_addon_total(addons, units):
+    """Calculate total cost of addons based on their type and units"""
+    try:
+        total = 0
+        for addon in addons:
+            if addon.addon_type == "Unit Rate":
+                total += float(addon.price) * float(units)
+            else:  # Base Fee or other types
+                total += float(addon.price)
+        return total
+    except (AttributeError, TypeError, ValueError):
+        return 0

hub/services/tests.py

@@ -1,3 +1,4 @@
-from django.test import TestCase
-
-# Create your tests here.
+# Import all test modules to ensure they are discovered by Django's test runner
+from .tests.test_pricing import *
+from .tests.test_pricing_edge_cases import *
+from .tests.test_pricing_integration import *

hub/services/tests/README.md

@@ -0,0 +1,169 @@
+# Pricing Model Tests Documentation
+
+This directory contains comprehensive tests for the Django pricing models in the Servala project. The tests ensure that price calculations work correctly and prevent regressions when making changes to the pricing logic.
+
+## Test Structure
+
+### `test_pricing.py`
+Core tests for all pricing models including:
+- **ComputePlanTestCase**: Tests for compute plan pricing and retrieval
+- **StoragePlanTestCase**: Tests for storage plan pricing
+- **ProgressiveDiscountModelTestCase**: Tests for discount calculations with multiple tiers
+- **VSHNAppCatPriceTestCase**: Tests for AppCat service pricing with discounts
+- **VSHNAppCatAddonTestCase**: Tests for addon pricing (base fees and unit rates)
+
+### `test_pricing_edge_cases.py`
+Edge case and error condition tests including:
+- Discount calculations with zero units or very large numbers
+- Price calculations with inactive discount models
+- Missing price data handling
+- Decimal precision edge cases
+- Unique constraint enforcement
+- Addon ordering and filtering
+
+### `test_pricing_integration.py`
+Integration tests that verify models work together:
+- Complete pricing setup across all models
+- Multi-currency pricing scenarios
+- Complex AppCat services with all features
+- External price comparisons
+- Real-world comprehensive pricing scenarios
+
+### `test_utils.py`
+Helper utilities and mixins for test setup:
+- `PricingTestMixin`: Common setup methods for pricing tests
+- Helper functions for expected price calculations
+
+## Running the Tests
+
+### Individual Test Classes
+```bash
+# Run specific test class
+uv run --extra dev manage.py test hub.services.tests.test_pricing.ComputePlanTestCase --verbosity=2
+
+# Run specific test method
+uv run --extra dev manage.py test hub.services.tests.test_pricing.VSHNAppCatPriceTestCase.test_calculate_final_price_simple --verbosity=2
+```
+
+### All Pricing Tests
+```bash
+# Run all pricing tests
+uv run --extra dev manage.py test hub.services.tests --verbosity=2
+
+# Run with database reuse for faster execution
+uv run --extra dev manage.py test hub.services.tests --verbosity=2 --keepdb
+```
+
+### Test Script
+Use the provided test runner script:
+```bash
+./run_pricing_tests.sh
+```
+
+## Test Coverage
+
+The test suite covers:
+
+### Basic Model Functionality
+- Model creation and string representations
+- Field validation and constraints
+- Relationship handling
+
+### Price Calculations
+- Simple price retrieval (`get_price` methods)
+- Progressive discount calculations
+- Final price calculations with base fees, unit rates, and addons
+- Multi-currency support
+
+### Edge Cases
+- Zero or negative values
+- Very large numbers
+- Missing price data
+- Inactive discount models
+- Decimal precision issues
+
+### Business Logic
+- Mandatory vs. optional addons
+- Discount tier spanning
+- Service level pricing differences
+- External price comparisons
+
+### Integration Scenarios
+- Complete service setups
+- Real-world pricing scenarios
+- Cross-model relationships
+
+## Key Test Scenarios
+
+### Progressive Discount Testing
+The tests verify that progressive discounts work correctly:
+```python
+# Example: 0-9 units (0%), 10-49 units (10%), 50+ units (20%)
+# For 60 units:
+# - First 10 units: full price
+# - Next 40 units: 90% of price (10% discount)
+# - Next 10 units: 80% of price (20% discount)
+```
+
+### Addon Pricing Testing
+Tests cover both addon types:
+- **Base Fee Addons**: Fixed cost regardless of units
+- **Unit Rate Addons**: Cost multiplied by number of units
+
+### Multi-Currency Testing
+Ensures pricing works across CHF, EUR, and USD currencies.
+
+## Best Practices for Adding New Tests
+
+1. **Use Descriptive Test Names**: Test method names should clearly describe what is being tested
+2. **Test Both Success and Failure Cases**: Include tests for valid inputs and error conditions
+3. **Use Decimal for Monetary Values**: Always use `Decimal` for precise monetary calculations
+4. **Test Edge Cases**: Include tests for boundary conditions and unusual inputs
+5. **Verify Relationships**: Test that model relationships work correctly
+6. **Test Business Logic**: Focus on the actual business rules, not just CRUD operations
+
+## Common Test Patterns
+
+### Setting Up Test Data
+```python
+def setUp(self):
+    self.cloud_provider = CloudProvider.objects.create(
+        name="Test Provider",
+        slug="test-provider",
+        description="Test description",
+        website="https://test.com"
+    )
+```
+
+### Testing Price Calculations
+```python
+def test_price_calculation(self):
+    # Set up pricing data
+    # Call calculation method
+    result = price_config.calculate_final_price(currency, service_level, units)
+    # Verify expected result
+    self.assertEqual(result['total_price'], expected_amount)
+```
+
+### Testing Error Conditions
+```python
+def test_negative_units_error(self):
+    with self.assertRaises(ValueError):
+        price_config.calculate_final_price(currency, service_level, -1)
+```
+
+## Maintenance
+
+- Run tests after any changes to pricing models or calculations
+- Update tests when adding new pricing features
+- Add regression tests when fixing bugs
+- Keep test data realistic but minimal
+- Document complex test scenarios in comments
+
+## Dependencies
+
+The tests require:
+- Django test framework
+- Test database (SQLite in-memory for speed)
+- All pricing models and their dependencies
+- Decimal library for precise calculations

hub/services/tests/__init__.py

@@ -0,0 +1 @@
+# Tests for services app

hub/services/tests/test_pricing.py

@@ -0,0 +1,624 @@
+from decimal import Decimal
+from django.test import TestCase
+from django.core.exceptions import ValidationError
+
+from ..models.base import Currency, Term, Unit
+from ..models.providers import CloudProvider
+from ..models.services import Service
+from ..models.pricing import (
+    ComputePlan,
+    ComputePlanPrice,
+    StoragePlan,
+    StoragePlanPrice,
+    ProgressiveDiscountModel,
+    DiscountTier,
+    VSHNAppCatPrice,
+    VSHNAppCatBaseFee,
+    VSHNAppCatUnitRate,
+    VSHNAppCatAddon,
+    VSHNAppCatAddonBaseFee,
+    VSHNAppCatAddonUnitRate,
+)
+
+
+class ComputePlanTestCase(TestCase):
+    """Test cases for ComputePlan model and pricing"""
+
+    def setUp(self):
+        # Create test cloud provider
+        self.cloud_provider = CloudProvider.objects.create(
+            name="Test Provider",
+            slug="test-provider",
+            description="Test cloud provider",
+            website="https://test.com",
+        )
+
+        # Create test compute plan
+        self.compute_plan = ComputePlan.objects.create(
+            name="Small Plan",
+            vcpus=2.0,
+            ram=4.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            term=Term.MTH,
+        )
+
+    def test_compute_plan_str_representation(self):
+        """Test string representation of ComputePlan"""
+        self.assertEqual(str(self.compute_plan), "Small Plan")
+
+    def test_compute_plan_price_creation(self):
+        """Test creation of ComputePlanPrice"""
+        price = ComputePlanPrice.objects.create(
+            compute_plan=self.compute_plan,
+            currency=Currency.CHF,
+            amount=Decimal("100.00"),
+        )
+        self.assertEqual(price.amount, Decimal("100.00"))
+        self.assertEqual(price.currency, Currency.CHF)
+
+    def test_compute_plan_get_price_exists(self):
+        """Test get_price method when price exists"""
+        ComputePlanPrice.objects.create(
+            compute_plan=self.compute_plan,
+            currency=Currency.CHF,
+            amount=Decimal("100.00"),
+        )
+        price = self.compute_plan.get_price(Currency.CHF)
+        self.assertEqual(price, Decimal("100.00"))
+
+    def test_compute_plan_get_price_not_exists(self):
+        """Test get_price method when price doesn't exist"""
+        price = self.compute_plan.get_price(Currency.EUR)
+        self.assertIsNone(price)
+
+    def test_compute_plan_price_unique_constraint(self):
+        """Test unique constraint on compute_plan and currency"""
+        ComputePlanPrice.objects.create(
+            compute_plan=self.compute_plan,
+            currency=Currency.CHF,
+            amount=Decimal("100.00"),
+        )
+
+        # Creating another price with same plan and currency should be allowed
+        # (this will update the existing one)
+        with self.assertRaises(Exception):
+            ComputePlanPrice.objects.create(
+                compute_plan=self.compute_plan,
+                currency=Currency.CHF,
+                amount=Decimal("200.00"),
+            )
+
+
+class StoragePlanTestCase(TestCase):
+    """Test cases for StoragePlan model and pricing"""
+
+    def setUp(self):
+        # Create test cloud provider
+        self.cloud_provider = CloudProvider.objects.create(
+            name="Test Provider",
+            slug="test-provider",
+            description="Test cloud provider",
+            website="https://test.com",
+        )
+
+        # Create test storage plan
+        self.storage_plan = StoragePlan.objects.create(
+            name="SSD Storage",
+            cloud_provider=self.cloud_provider,
+            term=Term.MTH,
+            unit=Unit.GIB,
+        )
+
+    def test_storage_plan_str_representation(self):
+        """Test string representation of StoragePlan"""
+        self.assertEqual(str(self.storage_plan), "SSD Storage")
+
+    def test_storage_plan_price_creation(self):
+        """Test creation of StoragePlanPrice"""
+        price = StoragePlanPrice.objects.create(
+            storage_plan=self.storage_plan,
+            currency=Currency.CHF,
+            amount=Decimal("0.15"),
+        )
+        self.assertEqual(price.amount, Decimal("0.15"))
+        self.assertEqual(price.currency, Currency.CHF)
+
+    def test_storage_plan_get_price_exists(self):
+        """Test get_price method when price exists"""
+        StoragePlanPrice.objects.create(
+            storage_plan=self.storage_plan,
+            currency=Currency.USD,
+            amount=Decimal("0.12"),
+        )
+        price = self.storage_plan.get_price(Currency.USD)
+        self.assertEqual(price, Decimal("0.12"))
+
+    def test_storage_plan_get_price_not_exists(self):
+        """Test get_price method when price doesn't exist"""
+        price = self.storage_plan.get_price(Currency.EUR)
+        self.assertIsNone(price)
+
+
+class ProgressiveDiscountModelTestCase(TestCase):
+    """Test cases for ProgressiveDiscountModel and discount calculations"""
+
+    def setUp(self):
+        # Create discount model
+        self.discount_model = ProgressiveDiscountModel.objects.create(
+            name="Volume Discount",
+            description="Progressive discount based on usage",
+            active=True,
+        )
+
+        # Create discount tiers
+        # 0-9 units: 0% discount
+        DiscountTier.objects.create(
+            discount_model=self.discount_model,
+            min_units=0,
+            max_units=10,
+            discount_percent=Decimal("0.00"),
+        )
+
+        # 10-49 units: 10% discount
+        DiscountTier.objects.create(
+            discount_model=self.discount_model,
+            min_units=10,
+            max_units=50,
+            discount_percent=Decimal("10.00"),
+        )
+
+        # 50+ units: 20% discount
+        DiscountTier.objects.create(
+            discount_model=self.discount_model,
+            min_units=50,
+            max_units=None,  # Unlimited
+            discount_percent=Decimal("20.00"),
+        )
+
+    def test_discount_model_str_representation(self):
+        """Test string representation of DiscountModel"""
+        self.assertEqual(str(self.discount_model), "Volume Discount")
+
+    def test_calculate_discount_no_discount_tier(self):
+        """Test discount calculation for units in first tier (no discount)"""
+        base_rate = Decimal("10.00")
+        units = 5
+
+        final_price = self.discount_model.calculate_discount(base_rate, units)
+        expected_price = base_rate * units  # No discount
+
+        self.assertEqual(final_price, expected_price)
+
+    def test_calculate_discount_single_tier(self):
+        """Test discount calculation for units in second tier"""
+        base_rate = Decimal("10.00")
+        units = 15
+
+        final_price = self.discount_model.calculate_discount(base_rate, units)
+
+        # First 10 units at full price, next 5 at 90% (10% discount)
+        expected_price = (base_rate * 10) + (base_rate * Decimal("0.9") * 5)
+
+        self.assertEqual(final_price, expected_price)
+
+    def test_calculate_discount_multiple_tiers(self):
+        """Test discount calculation spanning multiple tiers"""
+        base_rate = Decimal("10.00")
+        units = 60
+
+        final_price = self.discount_model.calculate_discount(base_rate, units)
+
+        # First 10 units at 100% (0% discount)
+        # Next 40 units at 90% (10% discount)
+        # Next 10 units at 80% (20% discount)
+        expected_price = (
+            (base_rate * 10)
+            + (base_rate * Decimal("0.9") * 40)
+            + (base_rate * Decimal("0.8") * 10)
+        )
+
+        self.assertEqual(final_price, expected_price)
+
+    def test_get_discount_breakdown(self):
+        """Test discount breakdown calculation"""
+        base_rate = Decimal("10.00")
+        units = 25
+
+        breakdown = self.discount_model.get_discount_breakdown(base_rate, units)
+
+        self.assertEqual(len(breakdown), 2)  # Should have 2 tiers
+
+        # First tier: 0-9 units at 0% discount
+        self.assertEqual(breakdown[0]["units"], 10)
+        self.assertEqual(breakdown[0]["discount_percent"], Decimal("0.00"))
+        self.assertEqual(breakdown[0]["rate"], base_rate)
+
+        # Second tier: 10-24 units at 10% discount
+        self.assertEqual(breakdown[1]["units"], 15)
+        self.assertEqual(breakdown[1]["discount_percent"], Decimal("10.00"))
+        self.assertEqual(breakdown[1]["rate"], base_rate * Decimal("0.9"))
+
+    def test_discount_tier_str_representation(self):
+        """Test string representation of DiscountTier"""
+        tier = self.discount_model.tiers.get(min_units=10, max_units=50)
+        expected_str = "Volume Discount: 10-49 units → 10.00% discount"
+        self.assertEqual(str(tier), expected_str)
+
+        # Test unlimited tier
+        tier_unlimited = self.discount_model.tiers.get(min_units=50, max_units=None)
+        expected_str = "Volume Discount: 50+ units → 20.00% discount"
+        self.assertEqual(str(tier_unlimited), expected_str)
+
+
+class VSHNAppCatPriceTestCase(TestCase):
+    """Test cases for VSHNAppCatPrice model and final price calculations"""
+
+    def setUp(self):
+        # Create test service
+        self.service = Service.objects.create(
+            name="PostgreSQL",
+            slug="postgresql",
+            description="PostgreSQL database service",
+            features="High availability, automated backups",
+        )
+
+        # Create discount model
+        self.discount_model = ProgressiveDiscountModel.objects.create(
+            name="RAM Discount",
+            description="Progressive discount for RAM usage",
+            active=True,
+        )
+
+        # Create discount tiers
+        DiscountTier.objects.create(
+            discount_model=self.discount_model,
+            min_units=0,
+            max_units=5,
+            discount_percent=Decimal("0.00"),
+        )
+
+        DiscountTier.objects.create(
+            discount_model=self.discount_model,
+            min_units=5,
+            max_units=None,
+            discount_percent=Decimal("10.00"),
+        )
+
+        # Create price configuration
+        self.price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=self.discount_model,
+        )
+
+    def test_vshn_appcat_price_str_representation(self):
+        """Test string representation of VSHNAppCatPrice"""
+        expected_str = "PostgreSQL - Memory (RAM) based pricing"
+        self.assertEqual(str(self.price_config), expected_str)
+
+    def test_base_fee_creation_and_retrieval(self):
+        """Test creation and retrieval of base fees"""
+        base_fee = VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        retrieved_fee = self.price_config.get_base_fee(Currency.CHF)
+        self.assertEqual(retrieved_fee, Decimal("50.00"))
+
+        # Test non-existent currency
+        non_existent_fee = self.price_config.get_base_fee(Currency.EUR)
+        self.assertIsNone(non_existent_fee)
+
+    def test_unit_rate_creation_and_retrieval(self):
+        """Test creation and retrieval of unit rates"""
+        unit_rate = VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+        retrieved_rate = self.price_config.get_unit_rate(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED
+        )
+        self.assertEqual(retrieved_rate, Decimal("5.0000"))
+
+        # Test non-existent combination
+        non_existent_rate = self.price_config.get_unit_rate(
+            Currency.EUR, VSHNAppCatPrice.ServiceLevel.GUARANTEED
+        )
+        self.assertIsNone(non_existent_rate)
+
+    def test_calculate_final_price_simple(self):
+        """Test final price calculation without addons"""
+        # Create base fee and unit rate
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+        # Calculate price for 3 GiB RAM (should be in first tier, no discount)
+        result = self.price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 3
+        )
+
+        expected_total = Decimal("50.00") + (Decimal("5.0000") * 3)
+        self.assertEqual(result["total_price"], expected_total)
+        self.assertEqual(result["addon_total"], 0)
+
+    def test_calculate_final_price_with_discount(self):
+        """Test final price calculation with progressive discount"""
+        # Create base fee and unit rate
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+        # Calculate price for 8 GiB RAM (spans two discount tiers)
+        result = self.price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 8
+        )
+
+        # First 5 units at full price, next 3 at 90% (10% discount)
+        discounted_price = (Decimal("5.0000") * 5) + (
+            Decimal("5.0000") * Decimal("0.9") * 3
+        )
+        expected_total = Decimal("50.00") + discounted_price
+
+        self.assertEqual(result["total_price"], expected_total)
+
+    def test_calculate_final_price_negative_units(self):
+        """Test final price calculation with negative units (should raise error)"""
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+        with self.assertRaises(ValueError):
+            self.price_config.calculate_final_price(
+                Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, -1
+            )
+
+    def test_calculate_final_price_missing_data(self):
+        """Test final price calculation when base fee or unit rate is missing"""
+        # Only create base fee, no unit rate
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        result = self.price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 3
+        )
+
+        self.assertIsNone(result)
+
+    def test_calculate_final_price_without_discount_model(self):
+        """Test final price calculation when no discount model is active"""
+        # Remove discount model
+        self.price_config.discount_model = None
+        self.price_config.save()
+
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+        result = self.price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 8
+        )
+
+        # Should be simple multiplication without discount
+        expected_total = Decimal("50.00") + (Decimal("5.0000") * 8)
+        self.assertEqual(result["total_price"], expected_total)
+
+
+class VSHNAppCatAddonTestCase(TestCase):
+    """Test cases for VSHNAppCat addons and pricing"""
+
+    def setUp(self):
+        # Create test service
+        self.service = Service.objects.create(
+            name="PostgreSQL",
+            slug="postgresql",
+            description="PostgreSQL database service",
+            features="High availability, automated backups",
+        )
+
+        # Create price configuration
+        self.price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+        )
+
+        # Create base fee and unit rate for main service
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("5.0000"),
+        )
+
+    def test_addon_base_fee_type(self):
+        """Test addon with base fee type"""
+        addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Backup Extension",
+            description="Extended backup retention",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=True,
+        )
+
+        # Create base fee for addon
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=addon, currency=Currency.CHF, amount=Decimal("25.00")
+        )
+
+        # Test get_price method
+        price = addon.get_price(Currency.CHF)
+        self.assertEqual(price, Decimal("25.00"))
+
+    def test_addon_unit_rate_type(self):
+        """Test addon with unit rate type"""
+        addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Additional Storage",
+            description="Extra storage per GiB",
+            addon_type=VSHNAppCatAddon.AddonType.UNIT_RATE,
+            mandatory=False,
+        )
+
+        # Create unit rate for addon
+        VSHNAppCatAddonUnitRate.objects.create(
+            addon=addon,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("0.5000"),
+        )
+
+        # Test get_price method
+        price = addon.get_price(Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED)
+        self.assertEqual(price, Decimal("0.5000"))
+
+    def test_addon_unit_rate_without_service_level(self):
+        """Test addon unit rate without service level (should raise error)"""
+        addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Additional Storage",
+            addon_type=VSHNAppCatAddon.AddonType.UNIT_RATE,
+        )
+
+        VSHNAppCatAddonUnitRate.objects.create(
+            addon=addon,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("0.5000"),
+        )
+
+        with self.assertRaises(ValueError):
+            addon.get_price(Currency.CHF)
+
+    def test_calculate_final_price_with_mandatory_addons(self):
+        """Test final price calculation including mandatory addons"""
+        # Create mandatory base fee addon
+        mandatory_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Backup Extension",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=True,
+        )
+
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=mandatory_addon, currency=Currency.CHF, amount=Decimal("25.00")
+        )
+
+        # Create mandatory unit rate addon
+        mandatory_unit_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Monitoring",
+            addon_type=VSHNAppCatAddon.AddonType.UNIT_RATE,
+            mandatory=True,
+        )
+
+        VSHNAppCatAddonUnitRate.objects.create(
+            addon=mandatory_unit_addon,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("1.0000"),
+        )
+
+        result = self.price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 4
+        )
+
+        # Base: 50 + (5 * 4) = 70
+        # Mandatory addons: 25 + (1 * 4) = 29
+        # Total: 99
+        expected_total = Decimal("99.00")
+        self.assertEqual(result["total_price"], expected_total)
+        self.assertEqual(result["addon_total"], Decimal("29.00"))
+        self.assertEqual(len(result["addon_breakdown"]), 2)
+
+    def test_calculate_final_price_with_selected_addons(self):
+        """Test final price calculation including selected optional addons"""
+        # Create optional addon
+        optional_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="SSL Certificate",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=False,
+        )
+
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=optional_addon, currency=Currency.CHF, amount=Decimal("15.00")
+        )
+
+        # Calculate price with selected addon
+        result = self.price_config.calculate_final_price(
+            Currency.CHF,
+            VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            4,
+            addon_ids=[optional_addon.id],
+        )
+
+        # Base: 50 + (5 * 4) = 70
+        # Selected addon: 15
+        # Total: 85
+        expected_total = Decimal("85.00")
+        self.assertEqual(result["total_price"], expected_total)
+        self.assertEqual(result["addon_total"], Decimal("15.00"))
+
+    def test_addon_str_representation(self):
+        """Test string representation of addon"""
+        addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=self.price_config,
+            name="Backup Extension",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+        )
+
+        expected_str = "PostgreSQL - Backup Extension"
+        self.assertEqual(str(addon), expected_str)

hub/services/tests/test_pricing_edge_cases.py

@@ -0,0 +1,325 @@
+from decimal import Decimal
+from django.test import TestCase
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+from datetime import timedelta
+
+from ..models.base import Currency, Term, Unit
+from ..models.providers import CloudProvider
+from ..models.services import Service
+from ..models.pricing import (
+    ComputePlan,
+    ComputePlanPrice,
+    StoragePlan,
+    StoragePlanPrice,
+    ProgressiveDiscountModel,
+    DiscountTier,
+    VSHNAppCatPrice,
+    VSHNAppCatBaseFee,
+    VSHNAppCatUnitRate,
+    VSHNAppCatAddon,
+    VSHNAppCatAddonBaseFee,
+    VSHNAppCatAddonUnitRate,
+    ExternalPricePlans,
+)
+
+
+class PricingEdgeCasesTestCase(TestCase):
+    """Test edge cases and error conditions in pricing models"""
+
+    def setUp(self):
+        self.cloud_provider = CloudProvider.objects.create(
+            name="Test Provider",
+            slug="test-provider",
+            description="Test cloud provider",
+            website="https://test.com",
+        )
+
+        self.service = Service.objects.create(
+            name="Test Service",
+            slug="test-service",
+            description="Test service",
+            features="Test features",
+        )
+
+    def test_discount_tier_validation_overlapping_ranges(self):
+        """Test that overlapping discount tiers can be created (business logic may handle conflicts)"""
+        discount_model = ProgressiveDiscountModel.objects.create(
+            name="Test Discount", active=True
+        )
+
+        # Create first tier
+        DiscountTier.objects.create(
+            discount_model=discount_model,
+            min_units=0,
+            max_units=20,
+            discount_percent=Decimal("5.00"),
+        )
+
+        # Create overlapping tier - should be allowed at model level
+        # Business logic in calculate_discount should handle this appropriately
+        DiscountTier.objects.create(
+            discount_model=discount_model,
+            min_units=15,
+            max_units=30,
+            discount_percent=Decimal("10.00"),
+        )
+
+        # Should be able to create both tiers
+        self.assertEqual(discount_model.tiers.count(), 2)
+
+    def test_discount_calculation_with_zero_units(self):
+        """Test discount calculation with zero units"""
+        discount_model = ProgressiveDiscountModel.objects.create(
+            name="Test Discount", active=True
+        )
+
+        DiscountTier.objects.create(
+            discount_model=discount_model,
+            min_units=0,
+            max_units=10,
+            discount_percent=Decimal("0.00"),
+        )
+
+        result = discount_model.calculate_discount(Decimal("10.00"), 0)
+        self.assertEqual(result, 0)
+
+    def test_discount_calculation_with_very_large_numbers(self):
+        """Test discount calculation with very large numbers"""
+        discount_model = ProgressiveDiscountModel.objects.create(
+            name="Test Discount", active=True
+        )
+
+        DiscountTier.objects.create(
+            discount_model=discount_model,
+            min_units=0,
+            max_units=None,
+            discount_percent=Decimal("10.00"),
+        )
+
+        large_units = 1000000
+        base_rate = Decimal("0.001")
+
+        result = discount_model.calculate_discount(base_rate, large_units)
+        expected = base_rate * Decimal("0.9") * large_units
+        self.assertEqual(result, expected)
+
+    def test_price_calculation_with_inactive_discount_model(self):
+        """Test price calculation when discount model is inactive"""
+        discount_model = ProgressiveDiscountModel.objects.create(
+            name="Inactive Discount", active=False  # Inactive
+        )
+
+        DiscountTier.objects.create(
+            discount_model=discount_model,
+            min_units=0,
+            max_units=None,
+            discount_percent=Decimal("50.00"),  # Large discount
+        )
+
+        price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=discount_model,
+        )
+
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=price_config,
+            currency=Currency.CHF,
+            amount=Decimal("50.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("10.0000"),
+        )
+
+        result = price_config.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 5
+        )
+
+        # Should ignore discount since model is inactive
+        expected_total = Decimal("50.00") + (Decimal("10.0000") * 5)
+        self.assertEqual(result["total_price"], expected_total)
+
+    def test_addon_with_missing_prices(self):
+        """Test addon behavior when price data is missing"""
+        price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+        )
+
+        # Create addon but no corresponding price objects
+        addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=price_config,
+            name="Incomplete Addon",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=True,
+        )
+
+        # Should return None when price doesn't exist
+        price = addon.get_price(Currency.CHF)
+        self.assertIsNone(price)
+
+    def test_compute_plan_with_validity_dates(self):
+        """Test compute plan with validity date ranges"""
+        now = timezone.now()
+        past_date = now - timedelta(days=30)
+        future_date = now + timedelta(days=30)
+
+        # Create plan that is not yet valid
+        future_plan = ComputePlan.objects.create(
+            name="Future Plan",
+            vcpus=4.0,
+            ram=8.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            valid_from=future_date,
+            valid_to=None,
+        )
+
+        # Create plan that has expired
+        expired_plan = ComputePlan.objects.create(
+            name="Expired Plan",
+            vcpus=2.0,
+            ram=4.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            valid_from=past_date,
+            valid_to=past_date + timedelta(days=10),
+        )
+
+        # Plans should still be created and queryable
+        self.assertTrue(ComputePlan.objects.filter(name="Future Plan").exists())
+        self.assertTrue(ComputePlan.objects.filter(name="Expired Plan").exists())
+
+    def test_decimal_precision_edge_cases(self):
+        """Test decimal precision in price calculations"""
+        price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+        )
+
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=price_config,
+            currency=Currency.CHF,
+            amount=Decimal("0.01"),  # Very small base fee
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=price_config,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("0.0001"),  # Very small unit rate
+        )
+
+        result = price_config.calculate_final_price(
+            Currency.CHF,
+            VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            1000,  # Large quantity
+        )
+
+        expected_total = Decimal("0.01") + (Decimal("0.0001") * 1000)
+        self.assertEqual(result["total_price"], expected_total)
+
+    def test_external_price_comparison_model(self):
+        """Test ExternalPricePlans model functionality"""
+        compute_plan = ComputePlan.objects.create(
+            name="Comparison Plan",
+            vcpus=2.0,
+            ram=4.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+        )
+
+        external_price = ExternalPricePlans.objects.create(
+            plan_name="Competitor Plan",
+            description="Competitor offering",
+            cloud_provider=self.cloud_provider,
+            service=self.service,
+            currency=Currency.USD,
+            term=Term.MTH,
+            amount=Decimal("99.99"),
+            vcpus=2.0,
+            ram=4.0,
+            storage=50.0,
+        )
+
+        external_price.compare_to.add(compute_plan)
+
+        self.assertEqual(
+            str(external_price), "Test Provider - Test Service - Competitor Plan"
+        )
+        self.assertTrue(external_price.compare_to.filter(id=compute_plan.id).exists())
+
+    def test_unique_constraints_enforcement(self):
+        """Test that unique constraints are properly enforced"""
+        compute_plan = ComputePlan.objects.create(
+            name="Test Plan",
+            vcpus=2.0,
+            ram=4.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+        )
+
+        # Create first price
+        ComputePlanPrice.objects.create(
+            compute_plan=compute_plan, currency=Currency.CHF, amount=Decimal("100.00")
+        )
+
+        # Try to create duplicate - should raise IntegrityError
+        with self.assertRaises(Exception):  # IntegrityError or ValidationError
+            ComputePlanPrice.objects.create(
+                compute_plan=compute_plan,
+                currency=Currency.CHF,
+                amount=Decimal("200.00"),
+            )
+
+    def test_addon_ordering_and_active_filtering(self):
+        """Test addon ordering and active status filtering"""
+        price_config = VSHNAppCatPrice.objects.create(
+            service=self.service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+        )
+
+        # Create addons with different orders and active status
+        addon1 = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=price_config,
+            name="Third Addon",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            order=3,
+            active=True,
+        )
+
+        addon2 = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=price_config,
+            name="First Addon",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            order=1,
+            active=True,
+        )
+
+        addon3 = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=price_config,
+            name="Inactive Addon",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            order=2,
+            active=False,
+        )
+
+        # Test ordering
+        ordered_addons = price_config.addons.all().order_by("order", "name")
+        self.assertEqual(ordered_addons[0], addon2)  # order=1
+        self.assertEqual(ordered_addons[1], addon3)  # order=2
+        self.assertEqual(ordered_addons[2], addon1)  # order=3
+
+        # Test active filtering
+        active_addons = price_config.addons.filter(active=True)
+        self.assertEqual(active_addons.count(), 2)
+        self.assertNotIn(addon3, active_addons)

hub/services/tests/test_pricing_integration.py

@@ -0,0 +1,532 @@
+from decimal import Decimal
+from django.test import TestCase
+from django.utils import timezone
+
+from ..models.base import Currency, Term, Unit
+from ..models.providers import CloudProvider
+from ..models.services import Service, Category
+from ..models.pricing import (
+    ComputePlan,
+    ComputePlanPrice,
+    ComputePlanGroup,
+    StoragePlan,
+    StoragePlanPrice,
+    ProgressiveDiscountModel,
+    DiscountTier,
+    VSHNAppCatPrice,
+    VSHNAppCatBaseFee,
+    VSHNAppCatUnitRate,
+    VSHNAppCatAddon,
+    VSHNAppCatAddonBaseFee,
+    VSHNAppCatAddonUnitRate,
+    ExternalPricePlans,
+)
+
+
+class PricingIntegrationTestCase(TestCase):
+    """Integration tests for pricing models working together"""
+
+    def setUp(self):
+        """Set up test data for integration tests"""
+        # Create cloud provider
+        self.cloud_provider = CloudProvider.objects.create(
+            name="VSHN Cloud",
+            slug="vshn-cloud",
+            description="Swiss cloud provider",
+            website="https://vshn.ch",
+            is_featured=True,
+        )
+
+        # Create service category
+        self.database_category = Category.objects.create(
+            name="Databases", slug="databases", description="Database services"
+        )
+
+        # Create database service
+        self.postgresql_service = Service.objects.create(
+            name="PostgreSQL",
+            slug="postgresql",
+            description="Managed PostgreSQL database service",
+            tagline="Reliable, scalable PostgreSQL",
+            features="High availability, automated backups, monitoring",
+            is_featured=True,
+        )
+        self.postgresql_service.categories.add(self.database_category)
+
+        # Create compute plan group
+        self.standard_group = ComputePlanGroup.objects.create(
+            name="Standard",
+            description="Standard compute plans",
+            node_label="standard",
+            order=1,
+        )
+
+        # Create multiple compute plans
+        self.small_plan = ComputePlan.objects.create(
+            name="Small",
+            vcpus=1.0,
+            ram=2.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            group=self.standard_group,
+            term=Term.MTH,
+            active=True,
+        )
+
+        self.medium_plan = ComputePlan.objects.create(
+            name="Medium",
+            vcpus=2.0,
+            ram=4.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            group=self.standard_group,
+            term=Term.MTH,
+            active=True,
+        )
+
+        self.large_plan = ComputePlan.objects.create(
+            name="Large",
+            vcpus=4.0,
+            ram=8.0,
+            cpu_mem_ratio=0.5,
+            cloud_provider=self.cloud_provider,
+            group=self.standard_group,
+            term=Term.MTH,
+            active=True,
+        )
+
+        # Create storage plan
+        self.ssd_storage = StoragePlan.objects.create(
+            name="SSD Storage",
+            cloud_provider=self.cloud_provider,
+            term=Term.MTH,
+            unit=Unit.GIB,
+        )
+
+        # Create progressive discount model for AppCat
+        self.ram_discount_model = ProgressiveDiscountModel.objects.create(
+            name="RAM Volume Discount",
+            description="Progressive discount for RAM usage",
+            active=True,
+        )
+
+        # Create discount tiers
+        DiscountTier.objects.create(
+            discount_model=self.ram_discount_model,
+            min_units=0,
+            max_units=8,
+            discount_percent=Decimal("0.00"),  # 0-7 GiB: no discount
+        )
+
+        DiscountTier.objects.create(
+            discount_model=self.ram_discount_model,
+            min_units=8,
+            max_units=32,
+            discount_percent=Decimal("10.00"),  # 8-31 GiB: 10% discount
+        )
+
+        DiscountTier.objects.create(
+            discount_model=self.ram_discount_model,
+            min_units=32,
+            max_units=None,
+            discount_percent=Decimal("20.00"),  # 32+ GiB: 20% discount
+        )
+
+    def test_complete_pricing_setup(self):
+        """Test complete pricing setup for all models"""
+        # Set up compute plan prices
+        ComputePlanPrice.objects.create(
+            compute_plan=self.small_plan, currency=Currency.CHF, amount=Decimal("50.00")
+        )
+
+        ComputePlanPrice.objects.create(
+            compute_plan=self.medium_plan,
+            currency=Currency.CHF,
+            amount=Decimal("100.00"),
+        )
+
+        ComputePlanPrice.objects.create(
+            compute_plan=self.large_plan,
+            currency=Currency.CHF,
+            amount=Decimal("200.00"),
+        )
+
+        # Set up storage pricing
+        StoragePlanPrice.objects.create(
+            storage_plan=self.ssd_storage,
+            currency=Currency.CHF,
+            amount=Decimal("0.20"),  # 0.20 CHF per GiB
+        )
+
+        # Verify all prices are retrievable
+        self.assertEqual(self.small_plan.get_price(Currency.CHF), Decimal("50.00"))
+        self.assertEqual(self.medium_plan.get_price(Currency.CHF), Decimal("100.00"))
+        self.assertEqual(self.large_plan.get_price(Currency.CHF), Decimal("200.00"))
+        self.assertEqual(self.ssd_storage.get_price(Currency.CHF), Decimal("0.20"))
+
+    def test_multi_currency_pricing(self):
+        """Test pricing in multiple currencies"""
+        # Set up prices in CHF, EUR, and USD
+        currencies_and_rates = [
+            (Currency.CHF, Decimal("100.00")),
+            (Currency.EUR, Decimal("95.00")),
+            (Currency.USD, Decimal("110.00")),
+        ]
+
+        for currency, amount in currencies_and_rates:
+            ComputePlanPrice.objects.create(
+                compute_plan=self.medium_plan, currency=currency, amount=amount
+            )
+
+        # Verify all currencies are available
+        for currency, expected_amount in currencies_and_rates:
+            self.assertEqual(self.medium_plan.get_price(currency), expected_amount)
+
+    def test_appcat_service_with_complete_pricing(self):
+        """Test complete AppCat service pricing with all features"""
+        # Create AppCat price configuration
+        appcat_price = VSHNAppCatPrice.objects.create(
+            service=self.postgresql_service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=self.ram_discount_model,
+            ha_replica_min=1,
+            ha_replica_max=3,
+            public_display_enabled=True,
+        )
+
+        # Set up base fees for different currencies
+        base_fees = [
+            (Currency.CHF, Decimal("25.00")),
+            (Currency.EUR, Decimal("22.50")),
+            (Currency.USD, Decimal("27.50")),
+        ]
+
+        for currency, amount in base_fees:
+            VSHNAppCatBaseFee.objects.create(
+                vshn_appcat_price_config=appcat_price, currency=currency, amount=amount
+            )
+
+        # Set up unit rates for different service levels and currencies
+        unit_rates = [
+            (Currency.CHF, VSHNAppCatPrice.ServiceLevel.BEST_EFFORT, Decimal("3.5000")),
+            (Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, Decimal("5.0000")),
+            (Currency.EUR, VSHNAppCatPrice.ServiceLevel.BEST_EFFORT, Decimal("3.2000")),
+            (Currency.EUR, VSHNAppCatPrice.ServiceLevel.GUARANTEED, Decimal("4.5000")),
+            (Currency.USD, VSHNAppCatPrice.ServiceLevel.BEST_EFFORT, Decimal("3.8000")),
+            (Currency.USD, VSHNAppCatPrice.ServiceLevel.GUARANTEED, Decimal("5.5000")),
+        ]
+
+        for currency, service_level, amount in unit_rates:
+            VSHNAppCatUnitRate.objects.create(
+                vshn_appcat_price_config=appcat_price,
+                currency=currency,
+                service_level=service_level,
+                amount=amount,
+            )
+
+        # Create mandatory addon (backup)
+        backup_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            name="Automated Backup",
+            description="Daily automated backups with 30-day retention",
+            commercial_description="Never lose your data with automated daily backups",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=True,
+            order=1,
+        )
+
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=backup_addon, currency=Currency.CHF, amount=Decimal("15.00")
+        )
+
+        # Create optional addon (monitoring)
+        monitoring_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            name="Advanced Monitoring",
+            description="Detailed monitoring with custom alerts",
+            commercial_description="Get insights into your database performance",
+            addon_type=VSHNAppCatAddon.AddonType.UNIT_RATE,
+            mandatory=False,
+            order=2,
+        )
+
+        VSHNAppCatAddonUnitRate.objects.create(
+            addon=monitoring_addon,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("0.5000"),
+        )
+
+        # Test price calculation scenarios
+
+        # Scenario 1: Small setup (4 GiB RAM, no discount)
+        result_small = appcat_price.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 4
+        )
+
+        # Base: 25 + (5 * 4) = 45
+        # Mandatory backup: 15
+        # Total: 60
+        self.assertEqual(result_small["total_price"], Decimal("60.00"))
+        self.assertEqual(result_small["addon_total"], Decimal("15.00"))
+        self.assertEqual(len(result_small["addon_breakdown"]), 1)
+
+        # Scenario 2: Medium setup (16 GiB RAM, partial discount)
+        result_medium = appcat_price.calculate_final_price(
+            Currency.CHF, VSHNAppCatPrice.ServiceLevel.GUARANTEED, 16
+        )
+
+        # First 8 GiB at full rate: 5 * 8 = 40
+        # Next 8 GiB at 90% (10% discount): 5 * 0.9 * 8 = 36
+        # Unit cost: 76
+        # Base: 25 + 76 = 101
+        # Mandatory backup: 15
+        # Total: 116
+        self.assertEqual(result_medium["total_price"], Decimal("116.00"))
+
+        # Scenario 3: Large setup with optional addon (40 GiB RAM, full discount tiers)
+        result_large = appcat_price.calculate_final_price(
+            Currency.CHF,
+            VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            40,
+            addon_ids=[monitoring_addon.id],
+        )
+
+        # First 8 GiB at full rate: 5 * 8 = 40
+        # Next 24 GiB at 90% (10% discount): 5 * 0.9 * 24 = 108
+        # Next 8 GiB at 80% (20% discount): 5 * 0.8 * 8 = 32
+        # Unit cost: 180
+        # Base: 25 + 180 = 205
+        # Mandatory backup: 15
+        # Optional monitoring: 0.5 * 40 = 20
+        # Total: 240
+        self.assertEqual(result_large["total_price"], Decimal("240.00"))
+        self.assertEqual(result_large["addon_total"], Decimal("35.00"))
+        self.assertEqual(len(result_large["addon_breakdown"]), 2)
+
+    def test_external_price_comparison_integration(self):
+        """Test external price comparison with internal pricing"""
+        # Set up internal pricing
+        appcat_price = VSHNAppCatPrice.objects.create(
+            service=self.postgresql_service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+        )
+
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.USD,
+            amount=Decimal("30.00"),
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.USD,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("4.0000"),
+        )
+
+        # Create external competitor pricing
+        aws_provider = CloudProvider.objects.create(
+            name="AWS",
+            slug="aws",
+            description="Amazon Web Services",
+            website="https://aws.amazon.com",
+        )
+
+        external_price = ExternalPricePlans.objects.create(
+            plan_name="RDS PostgreSQL db.t3.medium",
+            description="AWS RDS PostgreSQL instance",
+            source="https://aws.amazon.com/rds/postgresql/pricing/",
+            cloud_provider=aws_provider,
+            service=self.postgresql_service,
+            vshn_appcat_price=appcat_price,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            currency=Currency.USD,
+            term=Term.MTH,
+            amount=Decimal("62.56"),  # Monthly cost for db.t3.medium
+            vcpus=2.0,
+            ram=4.0,  # 4 GiB RAM
+            storage=20.0,  # 20 GiB storage included
+            competitor_sla="99.95%",
+            replicas=1,
+        )
+
+        # Compare internal vs external pricing for equivalent setup
+        internal_result = appcat_price.calculate_final_price(
+            Currency.USD,
+            VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            4,  # 4 GiB RAM to match external offering
+        )
+
+        # Internal: 30 + (4 * 4) = 46 USD
+        internal_price = internal_result["total_price"]
+        external_price_amount = external_price.amount
+
+        self.assertEqual(internal_price, Decimal("46.00"))
+        self.assertEqual(external_price_amount, Decimal("62.56"))
+
+        # Verify our pricing is competitive
+        self.assertLess(internal_price, external_price_amount)
+
+    def test_service_availability_with_pricing(self):
+        """Test service availability based on pricing configuration"""
+        # Create service with pricing but not enabled for public display
+        redis_service = Service.objects.create(
+            name="Redis",
+            slug="redis",
+            description="In-memory data store",
+            features="High performance caching",
+        )
+
+        redis_price = VSHNAppCatPrice.objects.create(
+            service=redis_service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            public_display_enabled=False,  # Private pricing
+        )
+
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=redis_price,
+            currency=Currency.CHF,
+            amount=Decimal("20.00"),
+        )
+
+        # Service should exist but not be publicly available for pricing
+        self.assertFalse(redis_price.public_display_enabled)
+
+        # Enable public display
+        redis_price.public_display_enabled = True
+        redis_price.save()
+
+        self.assertTrue(redis_price.public_display_enabled)
+
+    def test_pricing_model_relationships(self):
+        """Test all pricing model relationships work correctly"""
+        # Verify cloud provider relationships
+        self.assertEqual(self.cloud_provider.compute_plans.count(), 3)
+        self.assertEqual(self.cloud_provider.storage_plans.count(), 1)
+
+        # Verify service relationships
+        self.assertTrue(hasattr(self.postgresql_service, "vshn_appcat_price"))
+
+        # Verify compute plan group relationships
+        self.assertEqual(self.standard_group.compute_plans.count(), 3)
+
+        # Create and verify discount model relationships
+        appcat_price = VSHNAppCatPrice.objects.create(
+            service=self.postgresql_service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=self.ram_discount_model,
+        )
+
+        self.assertEqual(self.ram_discount_model.price_configs.count(), 1)
+        self.assertEqual(self.ram_discount_model.tiers.count(), 3)
+
+        # Test cascade deletions work properly
+        service_id = self.postgresql_service.id
+        appcat_price_id = appcat_price.id
+
+        # Delete service should cascade to appcat price
+        self.postgresql_service.delete()
+
+        with self.assertRaises(VSHNAppCatPrice.DoesNotExist):
+            VSHNAppCatPrice.objects.get(id=appcat_price_id)
+
+    def test_comprehensive_pricing_scenario(self):
+        """Test a comprehensive real-world pricing scenario"""
+        # Company needs PostgreSQL with high availability
+        # Requirements: 16 GiB RAM, automated backups, monitoring, SSL
+
+        appcat_price = VSHNAppCatPrice.objects.create(
+            service=self.postgresql_service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=self.ram_discount_model,
+            ha_replica_min=2,
+            ha_replica_max=3,
+            public_display_enabled=True,
+        )
+
+        # Set up pricing
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.CHF,
+            amount=Decimal("40.00"),  # Base fee for managed service
+        )
+
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("6.0000"),  # CHF per GiB RAM
+        )
+
+        # Create all required addons
+        backup_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            name="Enterprise Backup",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=True,
+            order=1,
+        )
+
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=backup_addon, currency=Currency.CHF, amount=Decimal("25.00")
+        )
+
+        monitoring_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            name="Advanced Monitoring",
+            addon_type=VSHNAppCatAddon.AddonType.UNIT_RATE,
+            mandatory=False,
+            order=2,
+        )
+
+        VSHNAppCatAddonUnitRate.objects.create(
+            addon=monitoring_addon,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=Decimal("0.7500"),
+        )
+
+        ssl_addon = VSHNAppCatAddon.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            name="SSL Certificate",
+            addon_type=VSHNAppCatAddon.AddonType.BASE_FEE,
+            mandatory=False,
+            order=3,
+        )
+
+        VSHNAppCatAddonBaseFee.objects.create(
+            addon=ssl_addon, currency=Currency.CHF, amount=Decimal("18.00")
+        )
+
+        # Calculate final price with all selected addons
+        result = appcat_price.calculate_final_price(
+            Currency.CHF,
+            VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            16,  # 16 GiB RAM
+            addon_ids=[monitoring_addon.id, ssl_addon.id],
+        )
+
+        # Expected calculation:
+        # Base fee: 40.00
+        # RAM cost: First 8 at 6.00 = 48.00, Next 8 at 5.40 (10% discount) = 43.20
+        # RAM total: 91.20
+        # Mandatory backup: 25.00
+        # Optional monitoring: 0.75 * 16 = 12.00
+        # Optional SSL: 18.00
+        # Total: 40.00 + 91.20 + 25.00 + 12.00 + 18.00 = 186.20
+
+        self.assertEqual(result["total_price"], Decimal("186.20"))
+        self.assertEqual(result["addon_total"], Decimal("55.00"))
+        self.assertEqual(len(result["addon_breakdown"]), 3)
+
+        # Verify addon breakdown details
+        addon_names = [addon["name"] for addon in result["addon_breakdown"]]
+        self.assertIn("Enterprise Backup", addon_names)
+        self.assertIn("Advanced Monitoring", addon_names)
+        self.assertIn("SSL Certificate", addon_names)

hub/services/tests/test_utils.py

@@ -0,0 +1,125 @@
+"""
+Test utilities and fixtures for pricing tests
+"""
+
+from decimal import Decimal
+from django.test import TestCase
+
+from ..models.base import Currency, Term, Unit
+from ..models.providers import CloudProvider
+from ..models.services import Service, Category
+from ..models.pricing import (
+    ProgressiveDiscountModel,
+    DiscountTier,
+    VSHNAppCatPrice,
+    VSHNAppCatBaseFee,
+    VSHNAppCatUnitRate,
+)
+
+
+class PricingTestMixin:
+    """Mixin providing common setup for pricing tests"""
+
+    def create_test_cloud_provider(self, name="Test Provider"):
+        """Create a test cloud provider"""
+        return CloudProvider.objects.create(
+            name=name,
+            slug=name.lower().replace(" ", "-"),
+            description=f"{name} description",
+            website=f"https://{name.lower().replace(' ', '')}.com",
+        )
+
+    def create_test_service(self, name="Test Service"):
+        """Create a test service"""
+        return Service.objects.create(
+            name=name,
+            slug=name.lower().replace(" ", "-"),
+            description=f"{name} description",
+            features=f"{name} features",
+        )
+
+    def create_test_discount_model(self, name="Test Discount", tiers=None):
+        """Create a test discount model with optional tiers"""
+        discount_model = ProgressiveDiscountModel.objects.create(
+            name=name, description=f"{name} description", active=True
+        )
+
+        if tiers is None:
+            # Default tiers: 0-9 (0%), 10-49 (10%), 50+ (20%)
+            tiers = [
+                (0, 10, Decimal("0.00")),
+                (10, 50, Decimal("10.00")),
+                (50, None, Decimal("20.00")),
+            ]
+
+        for min_units, max_units, discount_percent in tiers:
+            DiscountTier.objects.create(
+                discount_model=discount_model,
+                min_units=min_units,
+                max_units=max_units,
+                discount_percent=discount_percent,
+            )
+
+        return discount_model
+
+    def create_test_appcat_price(
+        self,
+        service,
+        discount_model=None,
+        base_fee=Decimal("50.00"),
+        unit_rate=Decimal("5.0000"),
+    ):
+        """Create a test AppCat price configuration"""
+        appcat_price = VSHNAppCatPrice.objects.create(
+            service=service,
+            variable_unit=VSHNAppCatPrice.VariableUnit.RAM,
+            term=Term.MTH,
+            discount_model=discount_model,
+        )
+
+        # Create base fee
+        VSHNAppCatBaseFee.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.CHF,
+            amount=base_fee,
+        )
+
+        # Create unit rate
+        VSHNAppCatUnitRate.objects.create(
+            vshn_appcat_price_config=appcat_price,
+            currency=Currency.CHF,
+            service_level=VSHNAppCatPrice.ServiceLevel.GUARANTEED,
+            amount=unit_rate,
+        )
+
+        return appcat_price
+
+
+def calculate_expected_discounted_price(base_rate, units, discount_tiers):
+    """Helper function to calculate expected discounted price manually"""
+    final_price = Decimal("0")
+    remaining_units = units
+
+    # Sort tiers by min_units
+    sorted_tiers = sorted(discount_tiers, key=lambda x: x[0])
+
+    for min_units, max_units, discount_percent in sorted_tiers:
+        if remaining_units <= 0:
+            break
+
+        # Skip if we haven't reached this tier yet
+        if units < min_units:
+            continue
+
+        # Calculate units in this tier
+        tier_max = max_units if max_units else float("inf")
+        units_start = max(0, units - remaining_units)
+        units_end = min(units, tier_max if max_units else units)
+        tier_units = max(0, units_end - max(units_start, min_units - 1))
+
+        if tier_units > 0:
+            discounted_rate = base_rate * (1 - discount_percent / 100)
+            final_price += discounted_rate * tier_units
+            remaining_units -= tier_units
+
+    return final_price

hub/services/views/offerings.py

@@ -367,6 +367,43 @@ def generate_pricing_data(offering):
                 else:
                     sla_price = standard_sla_price
 
+                # Get addons information
+                addons = appcat_price.addons.filter(active=True)
+                mandatory_addons = []
+                optional_addons = []
+
+                # Calculate additional price from mandatory addons
+                addon_total = 0
+
+                for addon in addons:
+                    addon_price = None
+                    addon_price_per_unit = None
+
+                    if addon.addon_type == "BF":  # Base Fee
+                        addon_price = addon.get_price(currency)
+                    elif addon.addon_type == "UR":  # Unit Rate
+                        addon_price_per_unit = addon.get_price(currency, service_level)
+                        if addon_price_per_unit:
+                            addon_price = addon_price_per_unit * total_units
+
+                    addon_info = {
+                        "id": addon.id,
+                        "name": addon.name,
+                        "description": addon.description,
+                        "commercial_description": addon.commercial_description,
+                        "addon_type": addon.get_addon_type_display(),
+                        "price": addon_price,
+                        "price_per_unit": addon_price_per_unit,  # Add per-unit price for frontend calculations
+                    }
+
+                    if addon.mandatory:
+                        mandatory_addons.append(addon_info)
+                        if addon_price:
+                            addon_total += addon_price
+                            sla_price += addon_price
+                    else:
+                        optional_addons.append(addon_info)
+
                 final_price = compute_plan_price + sla_price
                 service_level_display = dict(VSHNAppCatPrice.ServiceLevel.choices)[
                     service_level
@@ -393,6 +430,11 @@ def generate_pricing_data(offering):
                         "storage_price": storage_price_data.get(currency, 0),
                         "ha_replica_min": appcat_price.ha_replica_min,
                         "ha_replica_max": appcat_price.ha_replica_max,
+                        "variable_unit": appcat_price.variable_unit,
+                        "units": units,
+                        "total_units": total_units,
+                        "mandatory_addons": mandatory_addons,
+                        "optional_addons": optional_addons,
                     }
                 )
 

hub/services/views/pricelist.py

@@ -43,6 +43,7 @@ def pricelist(request):
     """Generate comprehensive price list grouped by compute plan groups and service levels"""
     # Get filter parameters from request
     show_discount_details = request.GET.get("discount_details", "").lower() == "true"
+    show_addon_details = request.GET.get("addon_details", "").lower() == "true"
     show_price_comparison = request.GET.get("price_comparison", "").lower() == "true"
     filter_cloud_provider = request.GET.get("cloud_provider", "")
     filter_service = request.GET.get("service", "")
@@ -202,7 +203,84 @@ def pricelist(request):
                         discount_savings = 0
                         discount_percentage = 0
 
-                    final_price = compute_plan_price + sla_price
+                    # Calculate final price using the model method to ensure consistency
+                    price_calculation = appcat_price.calculate_final_price(
+                        currency_code=currency,
+                        service_level=service_level,
+                        number_of_units=total_units,
+                        addon_ids=None,  # This will include only mandatory addons
+                    )
+
+                    if price_calculation is None:
+                        continue
+
+                    # Calculate base service price (without addons) for display purposes
+                    base_sla_price = base_fee + (total_units * unit_rate)
+
+                    # Apply discount if available
+                    discount_breakdown = None
+                    if (
+                        appcat_price.discount_model
+                        and appcat_price.discount_model.active
+                    ):
+                        discounted_price = (
+                            appcat_price.discount_model.calculate_discount(
+                                unit_rate, total_units
+                            )
+                        )
+                        sla_price = base_fee + discounted_price
+                        discount_savings = base_sla_price - sla_price
+                        discount_percentage = (
+                            (discount_savings / base_sla_price) * 100
+                            if base_sla_price > 0
+                            else 0
+                        )
+                        discount_breakdown = (
+                            appcat_price.discount_model.get_discount_breakdown(
+                                unit_rate, total_units
+                            )
+                        )
+                    else:
+                        sla_price = base_sla_price
+                        discounted_price = total_units * unit_rate
+                        discount_savings = 0
+                        discount_percentage = 0
+
+                    # Extract addon information from the calculation
+                    mandatory_addons = []
+                    optional_addons = []
+
+                    # Get all addons to separate mandatory from optional
+                    all_addons = appcat_price.addons.filter(active=True)
+                    for addon in all_addons:
+                        addon_price = None
+
+                        if addon.addon_type == "BF":  # Base Fee
+                            addon_price = addon.get_price(currency)
+                        elif addon.addon_type == "UR":  # Unit Rate
+                            addon_price_per_unit = addon.get_price(
+                                currency, service_level
+                            )
+                            if addon_price_per_unit:
+                                addon_price = addon_price_per_unit * total_units
+
+                        addon_info = {
+                            "id": addon.id,
+                            "name": addon.name,
+                            "description": addon.description,
+                            "commercial_description": addon.commercial_description,
+                            "addon_type": addon.get_addon_type_display(),
+                            "price": addon_price,
+                        }
+
+                        if addon.mandatory:
+                            mandatory_addons.append(addon_info)
+                        else:
+                            optional_addons.append(addon_info)
+
+                    # Use the calculated total price which includes mandatory addons
+                    service_price_with_addons = price_calculation["total_price"]
+                    final_price = compute_plan_price + service_price_with_addons
                     service_level_display = dict(VSHNAppCatPrice.ServiceLevel.choices)[
                         service_level
                     ]
@@ -274,8 +352,8 @@ def pricelist(request):
                             "service_level": service_level_display,
                             "sla_base": base_fee,
                             "sla_per_unit": unit_rate,
-                            "sla_price": sla_price,
-                            "standard_sla_price": standard_sla_price,
+                            "sla_price": service_price_with_addons,
+                            "standard_sla_price": base_sla_price,
                             "discounted_sla_price": (
                                 base_fee + discounted_price
                                 if appcat_price.discount_model
@@ -296,6 +374,8 @@ def pricelist(request):
                                 and appcat_price.discount_model.active
                             ),
                             "external_comparisons": external_comparisons,
+                            "mandatory_addons": mandatory_addons,
+                            "optional_addons": optional_addons,
                         }
                     )
 
@@ -344,6 +424,7 @@ def pricelist(request):
     context = {
         "pricing_data_by_group_and_service_level": final_context_data,
         "show_discount_details": show_discount_details,
+        "show_addon_details": show_addon_details,
         "show_price_comparison": show_price_comparison,
         "filter_cloud_provider": filter_cloud_provider,
         "filter_service": filter_service,

hub/settings.py

@@ -254,6 +254,7 @@ JAZZMIN_SETTINGS = {
     "changeform_format_overrides": {
         "services.ProgressiveDiscountModel": "single",
         "services.VSHNAppCatPrice": "single",
+        "services.VSHNAppCatAddon": "single",
     },
     "related_modal_active": True,
 }

run_pricing_tests.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Test runner script for pricing tests
+
+echo "Running Django pricing model tests..."
+echo "====================================="
+
+# Run specific pricing tests
+echo "1. Running basic pricing model tests..."
+uv run --extra dev manage.py test hub.services.tests.test_pricing --verbosity=2
+
+echo ""
+echo "2. Running pricing edge case tests..."
+uv run --extra dev manage.py test hub.services.tests.test_pricing_edge_cases --verbosity=2
+
+echo ""
+echo "3. Running pricing integration tests..."
+uv run --extra dev manage.py test hub.services.tests.test_pricing_integration --verbosity=2
+
+echo ""
+echo "4. Running all pricing tests together..."
+uv run --extra dev manage.py test hub.services.tests --verbosity=2 --keepdb
+
+echo ""
+echo "Test run completed!"