orion/tests/fixtures/vendor_fixtures.py

# tests/fixtures/vendor_fixtures.py
import uuid

import pytest

from models.database.inventory import Inventory
from models.database.product import Product
from models.database.vendor import Vendor


@pytest.fixture
def test_vendor(db, test_user):
    """Create a test vendor with unique vendor code"""
    unique_id = str(uuid.uuid4())[:8].upper()
    vendor = Vendor(
        vendor_code=f"TESTVENDOR_{unique_id}",
        subdomain=f"testvendor{unique_id.lower()}",  # ADDED
        name=f"Test Vendor {unique_id.lower()}",  # FIXED
        owner_user_id=test_user.id,
        is_active=True,
        is_verified=True,
    )
    db.add(vendor)
    db.commit()
    db.refresh(vendor)
    # Expunge vendor from session to prevent ResourceWarning about unclosed connections
    db.expunge(vendor)
    return vendor


@pytest.fixture
def test_vendor_with_vendor_user(db, test_vendor_user):
    """Create a vendor owned by a vendor user (for testing vendor API endpoints)"""
    from models.database.vendor import VendorUser

    unique_id = str(uuid.uuid4())[:8].upper()
    vendor = Vendor(
        vendor_code=f"VENDORAPI_{unique_id}",
        subdomain=f"vendorapi{unique_id.lower()}",
        name=f"Vendor API Test {unique_id}",
        owner_user_id=test_vendor_user.id,
        is_active=True,
        is_verified=True,
    )
    db.add(vendor)
    db.commit()
    db.refresh(vendor)

    # Create VendorUser association
    vendor_user = VendorUser(
        vendor_id=vendor.id,
        user_id=test_vendor_user.id,
        is_owner=True,
        is_active=True,
    )
    db.add(vendor_user)
    db.commit()
    db.refresh(vendor)

    db.expunge(vendor)
    return vendor


@pytest.fixture
def unique_vendor(db, test_user):
    """Create a unique vendor for tests that need isolated vendor data"""
    unique_id = str(uuid.uuid4())[:8]
    vendor = Vendor(
        vendor_code=f"UNIQUEVENDOR_{unique_id.upper()}",
        subdomain=f"uniquevendor{unique_id.lower()}",  # ADDED
        name=f"Unique Test Vendor {unique_id}",  # FIXED
        description=f"A unique test vendor {unique_id}",
        owner_user_id=test_user.id,
        is_active=True,
        is_verified=True,
    )
    db.add(vendor)
    db.commit()
    db.refresh(vendor)
    # Expunge vendor from session to prevent ResourceWarning about unclosed connections
    db.expunge(vendor)
    return vendor


@pytest.fixture
def inactive_vendor(db, other_user):
    """Create an inactive vendor owned by other_user"""
    unique_id = str(uuid.uuid4())[:8]
    vendor = Vendor(
        vendor_code=f"INACTIVE_{unique_id.upper()}",
        subdomain=f"inactive{unique_id.lower()}",  # ADDED
        name=f"Inactive Vendor {unique_id}",  # FIXED
        owner_user_id=other_user.id,
        is_active=False,
        is_verified=False,
    )
    db.add(vendor)
    db.commit()
    db.refresh(vendor)
    # Expunge vendor from session to prevent ResourceWarning about unclosed connections
    db.expunge(vendor)
    return vendor


@pytest.fixture
def verified_vendor(db, other_user):
    """Create a verified vendor owned by other_user"""
    unique_id = str(uuid.uuid4())[:8]
    vendor = Vendor(
        vendor_code=f"VERIFIED_{unique_id.upper()}",
        subdomain=f"verified{unique_id.lower()}",  # ADDED
        name=f"Verified Vendor {unique_id}",  # FIXED
        owner_user_id=other_user.id,
        is_active=True,
        is_verified=True,
    )
    db.add(vendor)
    db.commit()
    db.refresh(vendor)
    # Expunge vendor from session to prevent ResourceWarning about unclosed connections
    db.expunge(vendor)
    return vendor


@pytest.fixture
def test_product(db, test_vendor, unique_product):
    """Create a vendor product relationship"""
    product = Product(
        vendor_id=test_vendor.id,
        marketplace_product_id=unique_product.id,
        is_active=True,
        price=24.99,
        is_featured=False,
        min_quantity=1,
    )
    db.add(product)
    db.commit()
    db.refresh(product)
    # Expunge product from session to prevent ResourceWarning about unclosed connections
    db.expunge(product)
    return product


@pytest.fixture
def test_inventory(db, test_product):
    """Create test inventory entry linked to product."""
    unique_id = str(uuid.uuid4())[:8].upper()
    inventory = Inventory(
        product_id=test_product.id,
        vendor_id=test_product.vendor_id,
        location=f"WAREHOUSE_A_{unique_id}",
        quantity=100,
        reserved_quantity=10,
        gtin=test_product.marketplace_product.gtin,  # Optional reference
    )
    db.add(inventory)
    db.commit()
    db.refresh(inventory)
    # Expunge inventory from session to prevent ResourceWarning about unclosed connections
    db.expunge(inventory)
    return inventory


@pytest.fixture
def multiple_inventory_entries(db, multiple_products, test_vendor):
    """Create multiple inventory entries for testing"""
    inventory_entries = []
    for i, product in enumerate(multiple_products):
        inventory = Inventory(
            gtin=product.gtin,
            location=f"LOC_{i}",
            quantity=10 + (i * 5),
            reserved_quantity=i,
            vendor_id=test_vendor.id,
        )
        inventory_entries.append(inventory)

    db.add_all(inventory_entries)
    db.commit()
    for inventory in inventory_entries:
        db.refresh(inventory)
        # Expunge each inventory from session to prevent ResourceWarning about unclosed connections
        db.expunge(inventory)
    return inventory_entries


def create_unique_vendor_factory():
    """Factory function to create unique vendors in tests"""

    def _create_vendor(db, owner_user_id, **kwargs):
        unique_id = str(uuid.uuid4())[:8]
        defaults = {
            "vendor_code": f"FACTORY_{unique_id.upper()}",
            "subdomain": f"factory{unique_id.lower()}",  # ADDED
            "name": f"Factory Vendor {unique_id}",  # FIXED
            "owner_user_id": owner_user_id,
            "is_active": True,
            "is_verified": False,
        }
        defaults.update(kwargs)

        vendor = Vendor(**defaults)
        db.add(vendor)
        db.commit()
        db.refresh(vendor)
        return vendor

    return _create_vendor


@pytest.fixture
def vendor_factory():
    """Fixture that provides a vendor factory function"""
    return create_unique_vendor_factory()