Tests restructuring

tests/fixtures/__init__.py

@@ -0,0 +1,3 @@
+# tests/fixtures/__init__.py
+"""Test fixtures for the FastAPI application test suite."""
+

tests/fixtures/auth_fixtures.py

@@ -0,0 +1,91 @@
+# tests/fixtures/auth_fixtures.py
+import uuid
+
+import pytest
+
+from middleware.auth import AuthManager
+from models.database_models import User
+
+
+@pytest.fixture(scope="session")
+def auth_manager():
+    """Create auth manager instance (session scope since it's stateless)"""
+    return AuthManager()
+
+
+@pytest.fixture
+def test_user(db, auth_manager):
+    """Create a test user with unique username"""
+    unique_id = str(uuid.uuid4())[:8]  # Short unique identifier
+    hashed_password = auth_manager.hash_password("testpass123")
+    user = User(
+        email=f"test_{unique_id}@example.com",
+        username=f"testuser_{unique_id}",
+        hashed_password=hashed_password,
+        role="user",
+        is_active=True,
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return user
+
+
+@pytest.fixture
+def test_admin(db, auth_manager):
+    """Create a test admin user with unique username"""
+    unique_id = str(uuid.uuid4())[:8]  # Short unique identifier
+    hashed_password = auth_manager.hash_password("adminpass123")
+    admin = User(
+        email=f"admin_{unique_id}@example.com",
+        username=f"admin_{unique_id}",
+        hashed_password=hashed_password,
+        role="admin",
+        is_active=True,
+    )
+    db.add(admin)
+    db.commit()
+    db.refresh(admin)
+    return admin
+
+
+@pytest.fixture
+def other_user(db, auth_manager):
+    """Create a different user for testing access controls"""
+    unique_id = str(uuid.uuid4())[:8]
+    hashed_password = auth_manager.hash_password("otherpass123")
+    user = User(
+        email=f"other_{unique_id}@example.com",
+        username=f"otheruser_{unique_id}",
+        hashed_password=hashed_password,
+        role="user",
+        is_active=True,
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return user
+
+
+@pytest.fixture
+def auth_headers(client, test_user):
+    """Get authentication headers for test user"""
+    response = client.post(
+        "/api/v1/auth/login",
+        json={"username": test_user.username, "password": "testpass123"},
+    )
+    assert response.status_code == 200, f"Login failed: {response.text}"
+    token = response.json()["access_token"]
+    return {"Authorization": f"Bearer {token}"}
+
+
+@pytest.fixture
+def admin_headers(client, test_admin):
+    """Get authentication headers for admin user"""
+    response = client.post(
+        "/api/v1/auth/login",
+        json={"username": test_admin.username, "password": "adminpass123"},
+    )
+    assert response.status_code == 200, f"Admin login failed: {response.text}"
+    token = response.json()["access_token"]
+    return {"Authorization": f"Bearer {token}"}

tests/fixtures/marketplace_fixtures.py

@@ -0,0 +1,50 @@
+# tests/fixtures/marketplace_fixtures.py
+import pytest
+
+from models.database_models import MarketplaceImportJob
+
+
+@pytest.fixture
+def test_marketplace_job(db, test_shop, test_user):
+    """Create a test marketplace import job"""
+    job = MarketplaceImportJob(
+        marketplace="amazon",
+        shop_name="Test Import Shop",
+        status="completed",
+        source_url="https://test-marketplace.example.com/import",
+        shop_id=test_shop.id,
+        user_id=test_user.id,
+        imported_count=5,
+        updated_count=3,
+        total_processed=8,
+        error_count=0,
+        error_message=None,
+    )
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+    return job
+
+
+def create_test_import_job(db, shop_id, user_id, **kwargs):
+    """Helper function to create MarketplaceImportJob with defaults"""
+    defaults = {
+        "marketplace": "test",
+        "shop_name": "Test Shop",
+        "status": "pending",
+        "source_url": "https://test.example.com/import",
+        "shop_id": shop_id,
+        "user_id": user_id,
+        "imported_count": 0,
+        "updated_count": 0,
+        "total_processed": 0,
+        "error_count": 0,
+        "error_message": None,
+    }
+    defaults.update(kwargs)
+
+    job = MarketplaceImportJob(**defaults)
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+    return job

tests/fixtures/product_fixtures.py

@@ -0,0 +1,108 @@
+# tests/fixtures/product_fixtures.py
+import uuid
+
+import pytest
+
+from models.database_models import Product
+
+
+@pytest.fixture
+def test_product(db):
+    """Create a test product"""
+    product = Product(
+        product_id="TEST001",
+        title="Test Product",
+        description="A test product",
+        price="10.99",
+        currency="EUR",
+        brand="TestBrand",
+        gtin="1234567890123",
+        availability="in stock",
+        marketplace="Letzshop",
+        shop_name="TestShop",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+@pytest.fixture
+def unique_product(db):
+    """Create a unique product for tests that need isolated product data"""
+    unique_id = str(uuid.uuid4())[:8]
+    product = Product(
+        product_id=f"UNIQUE_{unique_id}",
+        title=f"Unique Product {unique_id}",
+        description=f"A unique test product {unique_id}",
+        price="19.99",
+        currency="EUR",
+        brand=f"UniqueBrand_{unique_id}",
+        gtin=f"123456789{unique_id[:4]}",
+        availability="in stock",
+        marketplace="Letzshop",
+        shop_name=f"UniqueShop_{unique_id}",
+        google_product_category=f"UniqueCategory_{unique_id}",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+@pytest.fixture
+def multiple_products(db):
+    """Create multiple products for testing statistics and pagination"""
+    unique_id = str(uuid.uuid4())[:8]
+    products = []
+
+    for i in range(5):
+        product = Product(
+            product_id=f"MULTI_{unique_id}_{i}",
+            title=f"Multi Product {i} {unique_id}",
+            description=f"Multi test product {i}",
+            price=f"{10 + i}.99",
+            currency="EUR",
+            brand=f"MultiBrand_{i % 3}",  # Create 3 different brands
+            marketplace=f"MultiMarket_{i % 2}",  # Create 2 different marketplaces
+            shop_name=f"MultiShop_{i}",
+            google_product_category=f"MultiCategory_{i % 2}",  # Create 2 different categories
+            gtin=f"1234567890{i}{unique_id[:2]}",
+        )
+        products.append(product)
+
+    db.add_all(products)
+    db.commit()
+    for product in products:
+        db.refresh(product)
+    return products
+
+
+def create_unique_product_factory():
+    """Factory function to create unique products in tests"""
+
+    def _create_product(db, **kwargs):
+        unique_id = str(uuid.uuid4())[:8]
+        defaults = {
+            "product_id": f"FACTORY_{unique_id}",
+            "title": f"Factory Product {unique_id}",
+            "price": "15.99",
+            "currency": "EUR",
+            "marketplace": "TestMarket",
+            "shop_name": "TestShop",
+        }
+        defaults.update(kwargs)
+
+        product = Product(**defaults)
+        db.add(product)
+        db.commit()
+        db.refresh(product)
+        return product
+
+    return _create_product
+
+
+@pytest.fixture
+def product_factory():
+    """Fixture that provides a product factory function"""
+    return create_unique_product_factory()

tests/fixtures/shop_fixtures.py

@@ -0,0 +1,163 @@
+# tests/fixtures/shop_fixtures.py
+import uuid
+
+import pytest
+
+from models.database_models import Shop, ShopProduct, Stock
+
+
+@pytest.fixture
+def test_shop(db, test_user):
+    """Create a test shop with unique shop code"""
+    unique_id = str(uuid.uuid4())[:8]  # Short unique identifier
+    shop = Shop(
+        shop_code=f"TESTSHOP_{unique_id}",
+        shop_name=f"Test Shop {unique_id}",
+        owner_id=test_user.id,
+        is_active=True,
+        is_verified=True,
+    )
+    db.add(shop)
+    db.commit()
+    db.refresh(shop)
+    return shop
+
+
+@pytest.fixture
+def unique_shop(db, test_user):
+    """Create a unique shop for tests that need isolated shop data"""
+    unique_id = str(uuid.uuid4())[:8]
+    shop = Shop(
+        shop_code=f"UNIQUESHOP_{unique_id}",
+        shop_name=f"Unique Test Shop {unique_id}",
+        description=f"A unique test shop {unique_id}",
+        owner_id=test_user.id,
+        is_active=True,
+        is_verified=True,
+    )
+    db.add(shop)
+    db.commit()
+    db.refresh(shop)
+    return shop
+
+
+@pytest.fixture
+def inactive_shop(db, other_user):
+    """Create an inactive shop owned by other_user"""
+    unique_id = str(uuid.uuid4())[:8]
+    shop = Shop(
+        shop_code=f"INACTIVE_{unique_id}",
+        shop_name=f"Inactive Shop {unique_id}",
+        owner_id=other_user.id,
+        is_active=False,
+        is_verified=False,
+    )
+    db.add(shop)
+    db.commit()
+    db.refresh(shop)
+    return shop
+
+
+@pytest.fixture
+def verified_shop(db, other_user):
+    """Create a verified shop owned by other_user"""
+    unique_id = str(uuid.uuid4())[:8]
+    shop = Shop(
+        shop_code=f"VERIFIED_{unique_id}",
+        shop_name=f"Verified Shop {unique_id}",
+        owner_id=other_user.id,
+        is_active=True,
+        is_verified=True,
+    )
+    db.add(shop)
+    db.commit()
+    db.refresh(shop)
+    return shop
+
+
+@pytest.fixture
+def shop_product(db, test_shop, unique_product):
+    """Create a shop product relationship"""
+    shop_product = ShopProduct(
+        shop_id=test_shop.id, product_id=unique_product.id, is_active=True
+    )
+    # Add optional fields if they exist in your model
+    if hasattr(ShopProduct, "shop_price"):
+        shop_product.shop_price = 24.99
+    if hasattr(ShopProduct, "is_featured"):
+        shop_product.is_featured = False
+    if hasattr(ShopProduct, "min_quantity"):
+        shop_product.min_quantity = 1
+
+    db.add(shop_product)
+    db.commit()
+    db.refresh(shop_product)
+    return shop_product
+
+
+@pytest.fixture
+def test_stock(db, test_product, test_shop):
+    """Create test stock entry"""
+    unique_id = str(uuid.uuid4())[:8].upper()  # Short unique identifier
+    stock = Stock(
+        gtin=test_product.gtin,  # Use gtin instead of product_id
+        location=f"WAREHOUSE_A_{unique_id}",
+        quantity=10,
+        reserved_quantity=0,
+        shop_id=test_shop.id,  # Add shop_id reference
+    )
+    db.add(stock)
+    db.commit()
+    db.refresh(stock)
+    return stock
+
+
+@pytest.fixture
+def multiple_stocks(db, multiple_products, test_shop):
+    """Create multiple stock entries for testing"""
+    stocks = []
+
+    for i, product in enumerate(multiple_products):
+        stock = Stock(
+            gtin=product.gtin,
+            location=f"LOC_{i}",
+            quantity=10 + (i * 5),  # Different quantities
+            reserved_quantity=i,
+            shop_id=test_shop.id,
+        )
+        stocks.append(stock)
+
+    db.add_all(stocks)
+    db.commit()
+    for stock in stocks:
+        db.refresh(stock)
+    return stocks
+
+
+def create_unique_shop_factory():
+    """Factory function to create unique shops in tests"""
+
+    def _create_shop(db, owner_id, **kwargs):
+        unique_id = str(uuid.uuid4())[:8]
+        defaults = {
+            "shop_code": f"FACTORY_{unique_id}",
+            "shop_name": f"Factory Shop {unique_id}",
+            "owner_id": owner_id,
+            "is_active": True,
+            "is_verified": False,
+        }
+        defaults.update(kwargs)
+
+        shop = Shop(**defaults)
+        db.add(shop)
+        db.commit()
+        db.refresh(shop)
+        return shop
+
+    return _create_shop
+
+
+@pytest.fixture
+def shop_factory():
+    """Fixture that provides a shop factory function"""
+    return create_unique_shop_factory()