sboulahtit/orion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

shop product refactoring

Browse Source
This commit is contained in:
Samir Boulahtit
2025-10-04 21:27:48 +02:00
parent c971674ec2
commit 4d2866af5e
21 changed files with 259 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
alembic/env.py
View File

@@ -35,10 +35,16 @@ except ImportError as e:
print(f" ✗ Stock model failed: {e}")
try:
from models.database.shop import Shop, ShopProduct
print(" ✓ Shop models imported")
from models.database.shop import Shop
print(" ✓ Shop model imported")
except ImportError as e:
print(f" ✗ Shop models failed: {e}")
print(f" ✗ Shop model failed: {e}")
try:
from models.database.product import Product
print(" ✓ Product model imported")
except ImportError as e:
print(f" ✗ Product model failed: {e}")
try:
from models.database.marketplace_import_job import MarketplaceImportJob

26
app/api/v1/shop.py
View File

@@ -16,8 +16,8 @@ from sqlalchemy.orm import Session
from app.api.deps import get_current_user, get_user_shop
from app.core.database import get_db
from app.services.shop_service import shop_service
from models.schemas.shop import (ShopCreate, ShopListResponse, ShopProductCreate,
ShopProductResponse, ShopResponse)
from models.schemas.shop import (ShopCreate, ShopListResponse,ShopResponse)
from models.schemas.product import (ProductCreate,ProductResponse)
from models.database.user import User
router = APIRouter()
@@ -72,10 +72,10 @@ def get_shop(
return ShopResponse.model_validate(shop)
@router.post("/shop/{shop_code}/products", response_model=ShopProductResponse)
@router.post("/shop/{shop_code}/products", response_model=ProductResponse)
def add_product_to_shop(
shop_code: str,
shop_product: ShopProductCreate,
product: ProductCreate,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_user),
):
@@ -84,18 +84,18 @@ def add_product_to_shop(
shop = get_user_shop(shop_code, current_user, db)
# Add product to shop
new_shop_product = shop_service.add_product_to_shop(
db=db, shop=shop, shop_product=shop_product
new_product = shop_service.add_product_to_shop(
db=db, shop=shop, product=product
)
# Return with product details
response = ShopProductResponse.model_validate(new_shop_product)
response.product = new_shop_product.product
response = ProductResponse.model_validate(new_product)
response.marketplace_product = new_product.marketplace_product
return response
@router.get("/shop/{shop_code}/products")
def get_shop_products(
def get_products(
shop_code: str,
skip: int = Query(0, ge=0),
limit: int = Query(100, ge=1, le=1000),
@@ -111,7 +111,7 @@ def get_shop_products(
)
# Get shop products
shop_products, total = shop_service.get_shop_products(
vendor_products, total = shop_service.get_products(
db=db,
shop=shop,
current_user=current_user,
@@ -123,9 +123,9 @@ def get_shop_products(
# Format response
products = []
for sp in shop_products:
product_response = ShopProductResponse.model_validate(sp)
product_response.product = sp.product
for vp in vendor_products:
product_response = ProductResponse.model_validate(vp)
product_response.marketplace_product = vp.marketplace_product
products.append(product_response)
return {

13
app/exceptions/__init__.py
View File

@@ -55,12 +55,15 @@ from .shop import (
ShopNotVerifiedException,
UnauthorizedShopAccessException,
InvalidShopDataException,
ShopProductAlreadyExistsException,
ShopProductNotFoundException,
MaxShopsReachedException,
ShopValidationException,
)
from .product import (
ProductNotFoundException,
ProductAlreadyExistsException,
)
from .marketplace_import_job import (
MarketplaceImportException,
ImportJobNotFoundException,
@@ -131,11 +134,13 @@ __all__ = [
"ShopNotVerifiedException",
"UnauthorizedShopAccessException",
"InvalidShopDataException",
"ShopProductAlreadyExistsException",
"ShopProductNotFoundException",
"MaxShopsReachedException",
"ShopValidationException",
# Product exceptions
"ProductAlreadyExistsException",
"ProductNotFoundException",
# Marketplace import exceptions
"MarketplaceImportException",
"ImportJobNotFoundException",

34
app/exceptions/product.py Normal file
View File

@@ -0,0 +1,34 @@
# app/exceptions/shop.py
"""
Shop management specific exceptions.
"""
from .base import (
ResourceNotFoundException,
ConflictException
)
class ProductAlreadyExistsException(ConflictException):
"""Raised when trying to add a product that already exists in shop."""
def __init__(self, shop_code: str, marketplace_product_id: str):
super().__init__(
message=f"MarketplaceProduct '{marketplace_product_id}' already exists in shop '{shop_code}'",
error_code="PRODUCT_ALREADY_EXISTS",
details={
"shop_code": shop_code,
"marketplace_product_id": marketplace_product_id,
},
)
class ProductNotFoundException(ResourceNotFoundException):
"""Raised when a shop product relationship is not found."""
def __init__(self, shop_code: str, marketplace_product_id: str):
super().__init__(
resource_type="ShopProduct",
identifier=f"{shop_code}/{marketplace_product_id}",
message=f"MarketplaceProduct '{marketplace_product_id}' not found in shop '{shop_code}'",
error_code="PRODUCT_NOT_FOUND",
)

26
app/exceptions/shop.py
View File

@@ -95,32 +95,6 @@ class InvalidShopDataException(ValidationException):
self.error_code = "INVALID_SHOP_DATA"
class ShopProductAlreadyExistsException(ConflictException):
"""Raised when trying to add a product that already exists in shop."""
def __init__(self, shop_code: str, marketplace_product_id: str):
super().__init__(
message=f"MarketplaceProduct '{marketplace_product_id}' already exists in shop '{shop_code}'",
error_code="SHOP_PRODUCT_ALREADY_EXISTS",
details={
"shop_code": shop_code,
"marketplace_product_id": marketplace_product_id,
},
)
class ShopProductNotFoundException(ResourceNotFoundException):
"""Raised when a shop product relationship is not found."""
def __init__(self, shop_code: str, marketplace_product_id: str):
super().__init__(
resource_type="ShopProduct",
identifier=f"{shop_code}/{marketplace_product_id}",
message=f"MarketplaceProduct '{marketplace_product_id}' not found in shop '{shop_code}'",
error_code="SHOP_PRODUCT_NOT_FOUND",
)
class MaxShopsReachedException(BusinessLogicException):
"""Raised when user tries to create more shops than allowed."""

58
app/services/shop_service.py
View File

@@ -21,13 +21,15 @@ from app.exceptions import (
UnauthorizedShopAccessException,
InvalidShopDataException,
MarketplaceProductNotFoundException,
ShopProductAlreadyExistsException,
ProductAlreadyExistsException,
MaxShopsReachedException,
ValidationException,
)
from models.schemas.shop import ShopCreate, ShopProductCreate
from models.schemas.shop import ShopCreate
from models.schemas.product import ProductCreate
from models.database.marketplace_product import MarketplaceProduct
from models.database.shop import Shop, ShopProduct
from models.database.shop import Shop
from models.database.product import Product
from models.database.user import User
logger = logging.getLogger(__name__)
@@ -184,49 +186,49 @@ class ShopService:
raise ValidationException("Failed to retrieve shop")
def add_product_to_shop(
self, db: Session, shop: Shop, shop_product: ShopProductCreate
) -> ShopProduct:
self, db: Session, shop: Shop, product: ProductCreate
) -> Product:
"""
Add existing product to shop catalog with shop-specific settings.
Args:
db: Database session
shop: Shop to add product to
shop_product: Shop product data
product: Shop product data
Returns:
Created ShopProduct object
Raises:
MarketplaceProductNotFoundException: If product not found
ShopProductAlreadyExistsException: If product already in shop
ProductAlreadyExistsException: If product already in shop
"""
try:
# Check if product exists
marketplace_product = self._get_product_by_id_or_raise(db, shop_product.marketplace_product_id)
marketplace_product = self._get_product_by_id_or_raise(db, product.marketplace_product_id)
# Check if product already in shop
if self._product_in_shop(db, shop.id, marketplace_product.id):
raise ShopProductAlreadyExistsException(shop.shop_code, shop_product.marketplace_product_id)
raise ProductAlreadyExistsException(shop.shop_code, product.marketplace_product_id)
# Create shop-product association
new_shop_product = ShopProduct(
new_product = Product(
shop_id=shop.id,
marketplace_product_id=marketplace_product.id,
**shop_product.model_dump(exclude={"marketplace_product_id"}),
**product.model_dump(exclude={"marketplace_product_id"}),
)
db.add(new_shop_product)
db.add(new_product)
db.commit()
db.refresh(new_shop_product)
db.refresh(new_product)
# Load the product relationship
db.refresh(new_shop_product)
db.refresh(new_product)
logger.info(f"MarketplaceProduct {shop_product.marketplace_product_id} added to shop {shop.shop_code}")
return new_shop_product
logger.info(f"MarketplaceProduct {product.marketplace_product_id} added to shop {shop.shop_code}")
return new_product
except (MarketplaceProductNotFoundException, ShopProductAlreadyExistsException):
except (MarketplaceProductNotFoundException, ProductAlreadyExistsException):
db.rollback()
raise # Re-raise custom exceptions
except Exception as e:
@@ -234,7 +236,7 @@ class ShopService:
logger.error(f"Error adding product to shop: {str(e)}")
raise ValidationException("Failed to add product to shop")
def get_shop_products(
def get_products(
self,
db: Session,
shop: Shop,
@@ -243,7 +245,7 @@ class ShopService:
limit: int = 100,
active_only: bool = True,
featured_only: bool = False,
) -> Tuple[List[ShopProduct], int]:
) -> Tuple[List[Product], int]:
"""
Get products in shop catalog with filtering.
@@ -257,7 +259,7 @@ class ShopService:
featured_only: Filter for featured products only
Returns:
Tuple of (shop_products_list, total_count)
Tuple of (products_list, total_count)
Raises:
UnauthorizedShopAccessException: If shop access denied
@@ -268,17 +270,17 @@ class ShopService:
raise UnauthorizedShopAccessException(shop.shop_code, current_user.id)
# Query shop products
query = db.query(ShopProduct).filter(ShopProduct.shop_id == shop.id)
query = db.query(Product).filter(Product.shop_id == shop.id)
if active_only:
query = query.filter(ShopProduct.is_active == True)
query = query.filter(Product.is_active == True)
if featured_only:
query = query.filter(ShopProduct.is_featured == True)
query = query.filter(Product.is_featured == True)
total = query.count()
shop_products = query.offset(skip).limit(limit).all()
products = query.offset(skip).limit(limit).all()
return shop_products, total
return products, total
except UnauthorizedShopAccessException:
raise # Re-raise custom exceptions
@@ -332,10 +334,10 @@ class ShopService:
def _product_in_shop(self, db: Session, shop_id: int, marketplace_product_id: int) -> bool:
"""Check if product is already in shop."""
return (
db.query(ShopProduct)
db.query(Product)
.filter(
ShopProduct.shop_id == shop_id,
ShopProduct.marketplace_product_id == marketplace_product_id
Product.shop_id == shop_id,
Product.marketplace_product_id == marketplace_product_id
)
.first() is not None
)

5
models/__init__.py
View File

@@ -6,7 +6,8 @@ from .database.base import Base
from .database.user import User
from .database.marketplace_product import MarketplaceProduct
from .database.stock import Stock
from .database.shop import Shop, ShopProduct
from .database.shop import Shop
from .database.product import Product
from .database.marketplace_import_job import MarketplaceImportJob
# API models (Pydantic) - import the modules, not all classes
@@ -19,7 +20,7 @@ __all__ = [
"MarketplaceProduct",
"Stock",
"Shop",
"ShopProduct",
"Product",
"MarketplaceImportJob",
"api", # API models namespace
]

5
models/database/__init__.py
View File

@@ -5,7 +5,8 @@ from .base import Base
from .user import User
from .marketplace_product import MarketplaceProduct
from .stock import Stock
from .shop import Shop, ShopProduct
from .shop import Shop
from .product import Product
from .marketplace_import_job import MarketplaceImportJob
__all__ = [
@@ -14,6 +15,6 @@ __all__ = [
"MarketplaceProduct",
"Stock",
"Shop",
"ShopProduct",
"Product",
"MarketplaceImportJob",
]

2
models/database/marketplace_product.py
View File

@@ -64,7 +64,7 @@ class MarketplaceProduct(Base, TimestampMixin):
primaryjoin="MarketplaceProduct.gtin == Stock.gtin",
viewonly=True,
)
shop_products = relationship("ShopProduct", back_populates="product")
product = relationship("Product", back_populates="marketplace_product")
# Additional indexes for marketplace queries
__table_args__ = (

48
models/database/product.py Normal file
View File

@@ -0,0 +1,48 @@
from datetime import datetime
from sqlalchemy import (Boolean, Column, DateTime, Float, ForeignKey, Index,
Integer, String, Text, UniqueConstraint)
from sqlalchemy.orm import relationship
# Import Base from the central database module instead of creating a new one
from app.core.database import Base
from models.database.base import TimestampMixin
class Product(Base):
__tablename__ = "products"
id = Column(Integer, primary_key=True, index=True)
shop_id = Column(Integer, ForeignKey("shops.id"), nullable=False)
marketplace_product_id = Column(Integer, ForeignKey("marketplace_products.id"), nullable=False)
# Shop-specific overrides (can override the main product data)
product_id = Column(String) # Shop's internal product ID
price = Column(Float) # Override main product price
sale_price = Column(Float)
currency = Column(String)
availability = Column(String) # Override availability
condition = Column(String)
# Shop-specific metadata
is_featured = Column(Boolean, default=False)
is_active = Column(Boolean, default=True)
display_order = Column(Integer, default=0)
# Inventory management
min_quantity = Column(Integer, default=1)
max_quantity = Column(Integer)
# Timestamps
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
shop = relationship("Shop", back_populates="product")
marketplace_product = relationship("MarketplaceProduct", back_populates="product")
# Constraints
__table_args__ = (
UniqueConstraint("shop_id", "marketplace_product_id", name="uq_product"),
Index("idx_product_active", "shop_id", "is_active"),
Index("idx_product_featured", "shop_id", "is_featured"),
)

42
models/database/shop.py
View File

@@ -35,47 +35,7 @@ class Shop(Base, TimestampMixin):
# Relationships
owner = relationship("User", back_populates="owned_shops")
shop_products = relationship("ShopProduct", back_populates="shop")
product = relationship("Product", back_populates="shop")
marketplace_import_jobs = relationship(
"MarketplaceImportJob", back_populates="shop"
)
class ShopProduct(Base):
__tablename__ = "shop_products"
id = Column(Integer, primary_key=True, index=True)
shop_id = Column(Integer, ForeignKey("shops.id"), nullable=False)
marketplace_product_id = Column(Integer, ForeignKey("marketplace_products.id"), nullable=False)
# Shop-specific overrides (can override the main product data)
shop_product_id = Column(String) # Shop's internal product ID
shop_price = Column(Float) # Override main product price
shop_sale_price = Column(Float)
shop_currency = Column(String)
shop_availability = Column(String) # Override availability
shop_condition = Column(String)
# Shop-specific metadata
is_featured = Column(Boolean, default=False)
is_active = Column(Boolean, default=True)
display_order = Column(Integer, default=0)
# Inventory management
min_quantity = Column(Integer, default=1)
max_quantity = Column(Integer)
# Timestamps
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
shop = relationship("Shop", back_populates="shop_products")
product = relationship("MarketplaceProduct", back_populates="shop_products")
# Constraints
__table_args__ = (
UniqueConstraint("shop_id", "marketplace_product_id", name="uq_shop_product"),
Index("idx_shop_product_active", "shop_id", "is_active"),
Index("idx_shop_product_featured", "shop_id", "is_featured"),
)

37
models/schemas/product.py Normal file
View File

@@ -0,0 +1,37 @@
# product.py - Keep basic format validation, remove business logic
import re
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field, field_validator
from models.schemas.marketplace_product import MarketplaceProductResponse
class ProductCreate(BaseModel):
marketplace_product_id: str = Field(..., description="MarketplaceProduct ID to add to shop")
product_id: Optional[str] = None
price: Optional[float] = None # Removed: ge=0 constraint
sale_price: Optional[float] = None # Removed: ge=0 constraint
currency: Optional[str] = None
availability: Optional[str] = None
condition: Optional[str] = None
is_featured: bool = Field(False, description="Featured product flag")
min_quantity: int = Field(1, description="Minimum order quantity")
max_quantity: Optional[int] = None # Removed: ge=1 constraint
# Service will validate price ranges and quantity logic
class ProductResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: int
shop_id: int
marketplace_product: MarketplaceProductResponse
product_id: Optional[str]
price: Optional[float]
sale_price: Optional[float]
currency: Optional[str]
availability: Optional[str]
condition: Optional[str]
is_featured: bool
is_active: bool
min_quantity: int
max_quantity: Optional[int]
created_at: datetime
updated_at: datetime

32
models/schemas/shop.py
View File

@@ -3,7 +3,6 @@ import re
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field, field_validator
from models.schemas.marketplace_product import MarketplaceProductResponse
class ShopCreate(BaseModel):
shop_code: str = Field(..., description="Unique shop identifier")
@@ -62,34 +61,3 @@ class ShopListResponse(BaseModel):
total: int
skip: int
limit: int
class ShopProductCreate(BaseModel):
marketplace_product_id: str = Field(..., description="MarketplaceProduct ID to add to shop")
shop_product_id: Optional[str] = None
shop_price: Optional[float] = None # Removed: ge=0 constraint
shop_sale_price: Optional[float] = None # Removed: ge=0 constraint
shop_currency: Optional[str] = None
shop_availability: Optional[str] = None
shop_condition: Optional[str] = None
is_featured: bool = Field(False, description="Featured product flag")
min_quantity: int = Field(1, description="Minimum order quantity")
max_quantity: Optional[int] = None # Removed: ge=1 constraint
# Service will validate price ranges and quantity logic
class ShopProductResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: int
shop_id: int
product: MarketplaceProductResponse
shop_product_id: Optional[str]
shop_price: Optional[float]
shop_sale_price: Optional[float]
shop_currency: Optional[str]
shop_availability: Optional[str]
shop_condition: Optional[str]
is_featured: bool
is_active: bool
min_quantity: int
max_quantity: Optional[int]
created_at: datetime
updated_at: datetime

5
scripts/verify_setup.py
View File

@@ -65,7 +65,7 @@ def verify_database_setup():
# Expected tables from your models
expected_tables = [
'users', 'products', 'stock', 'shops', 'shop_products',
'users', 'products', 'stock', 'shops', 'products',
'marketplace_import_jobs', 'alembic_version'
]
@@ -133,7 +133,8 @@ def verify_model_structure():
from models.database.user import User
from models.database.marketplace_product import MarketplaceProduct
from models.database.stock import Stock
from models.database.shop import Shop, ShopProduct
from models.database.shop import Shop
from models.database.product import Product
from models.database.marketplace_import_job import MarketplaceImportJob
print("[OK] All database models imported successfully")

3
tests/conftest.py
View File

@@ -10,7 +10,8 @@ from main import app
# Import all models to ensure they're registered with Base metadata
from models.database.marketplace_import_job import MarketplaceImportJob
from models.database.marketplace_product import MarketplaceProduct
from models.database.shop import Shop, ShopProduct
from models.database.shop import Shop
from models.database.product import Product
from models.database.stock import Stock
from models.database.user import User

25
tests/fixtures/shop_fixtures.py vendored
View File

@@ -3,7 +3,8 @@ import uuid
import pytest
from models.database.shop import Shop, ShopProduct
from models.database.shop import Shop
from models.database.product import Product
from models.database.stock import Stock
@@ -77,23 +78,23 @@ def verified_shop(db, other_user):
@pytest.fixture
def shop_product(db, test_shop, unique_product):
def test_product(db, test_shop, unique_product):
"""Create a shop product relationship"""
shop_product = ShopProduct(
product = Product(
shop_id=test_shop.id, marketplace_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
if hasattr(Product, "shop_price"):
product.price = 24.99
if hasattr(Product, "is_featured"):
product.is_featured = False
if hasattr(Product, "min_quantity"):
product.min_quantity = 1
db.add(shop_product)
db.add(product)
db.commit()
db.refresh(shop_product)
return shop_product
db.refresh(product)
return product
@pytest.fixture

4
tests/fixtures/testing_fixtures.py vendored
View File

@@ -22,9 +22,9 @@ def empty_db(db):
# In order to respect foreign key constraints
tables_to_clear = [
"marketplace_import_jobs", # Has foreign keys to shops and users
"shop_products", # Has foreign keys to shops and products
"products", # Has foreign keys to shops and products
"stock", # Fixed: singular not plural
"products", # Referenced by shop_products
"products", # Referenced by products
"shops", # Has foreign key to users
"users" # Base table
]

38
tests/integration/api/v1/test_shop_endpoints.py
View File

@@ -183,9 +183,9 @@ class TestShopsAPI:
def test_add_product_to_shop_success(self, client, auth_headers, test_shop, unique_product):
"""Test adding product to shop successfully"""
shop_product_data = {
product_data = {
"marketplace_product_id": unique_product.marketplace_product_id, # Use string marketplace_product_id, not database id
"shop_price": 29.99,
"price": 29.99,
"is_active": True,
"is_featured": False,
}
@@ -193,7 +193,7 @@ class TestShopsAPI:
response = client.post(
f"/api/v1/shop/{test_shop.shop_code}/products",
headers=auth_headers,
json=shop_product_data
json=product_data
)
assert response.status_code == 200
@@ -201,21 +201,21 @@ class TestShopsAPI:
# The response structure contains nested product data
assert data["shop_id"] == test_shop.id
assert data["shop_price"] == 29.99
assert data["price"] == 29.99
assert data["is_active"] is True
assert data["is_featured"] is False
# MarketplaceProduct details are nested in the 'product' field
assert "product" in data
assert data["product"]["marketplace_product_id"] == unique_product.marketplace_product_id
assert data["product"]["id"] == unique_product.id
# MarketplaceProduct details are nested in the 'marketplace_product' field
assert "marketplace_product" in data
assert data["marketplace_product"]["marketplace_product_id"] == unique_product.marketplace_product_id
assert data["marketplace_product"]["id"] == unique_product.id
def test_add_product_to_shop_already_exists_conflict(self, client, auth_headers, test_shop, shop_product):
"""Test adding product that already exists in shop returns ShopProductAlreadyExistsException"""
# shop_product fixture already creates a relationship, get the marketplace_product_id string
existing_product = shop_product.product
def test_add_product_to_shop_already_exists_conflict(self, client, auth_headers, test_shop, test_product):
"""Test adding product that already exists in shop returns ProductAlreadyExistsException"""
# test_product fixture already creates a relationship, get the marketplace_product_id string
existing_product = test_product.marketplace_product
shop_product_data = {
product_data = {
"marketplace_product_id": existing_product.marketplace_product_id, # Use string marketplace_product_id
"shop_price": 29.99,
}
@@ -223,19 +223,19 @@ class TestShopsAPI:
response = client.post(
f"/api/v1/shop/{test_shop.shop_code}/products",
headers=auth_headers,
json=shop_product_data
json=product_data
)
assert response.status_code == 409
data = response.json()
assert data["error_code"] == "SHOP_PRODUCT_ALREADY_EXISTS"
assert data["error_code"] == "PRODUCT_ALREADY_EXISTS"
assert data["status_code"] == 409
assert test_shop.shop_code in data["message"]
assert existing_product.marketplace_product_id in data["message"]
def test_add_nonexistent_product_to_shop_not_found(self, client, auth_headers, test_shop):
"""Test adding nonexistent product to shop returns MarketplaceProductNotFoundException"""
shop_product_data = {
product_data = {
"marketplace_product_id": "NONEXISTENT_PRODUCT", # Use string marketplace_product_id that doesn't exist
"shop_price": 29.99,
}
@@ -243,7 +243,7 @@ class TestShopsAPI:
response = client.post(
f"/api/v1/shop/{test_shop.shop_code}/products",
headers=auth_headers,
json=shop_product_data
json=product_data
)
assert response.status_code == 404
@@ -252,7 +252,7 @@ class TestShopsAPI:
assert data["status_code"] == 404
assert "NONEXISTENT_PRODUCT" in data["message"]
def test_get_shop_products_success(self, client, auth_headers, test_shop, shop_product):
def test_get_products_success(self, client, auth_headers, test_shop, test_product):
"""Test getting shop products successfully"""
response = client.get(
f"/api/v1/shop/{test_shop.shop_code}/products",
@@ -266,7 +266,7 @@ class TestShopsAPI:
assert "shop" in data
assert data["shop"]["shop_code"] == test_shop.shop_code
def test_get_shop_products_with_filters(self, client, auth_headers, test_shop):
def test_get_products_with_filters(self, client, auth_headers, test_shop):
"""Test getting shop products with filtering"""
# Test active_only filter
response = client.get(

2
tests/integration/workflows/test_integration.py
View File

@@ -60,7 +60,7 @@ class TestIntegrationFlows:
assert response.status_code == 200
assert response.json()["total"] == 1
def test_shop_product_workflow(self, client, auth_headers):
def test_product_workflow(self, client, auth_headers):
"""Test shop creation and product management workflow"""
# 1. Create a shop
shop_data = {

58
tests/unit/services/test_shop_service.py
View File

@@ -8,11 +8,12 @@ from app.exceptions import (
UnauthorizedShopAccessException,
InvalidShopDataException,
MarketplaceProductNotFoundException,
ShopProductAlreadyExistsException,
ProductAlreadyExistsException,
MaxShopsReachedException,
ValidationException,
)
from models.schemas.shop import ShopCreate, ShopProductCreate
from models.schemas.shop import ShopCreate
from models.schemas.product import ProductCreate
@pytest.mark.unit
@@ -178,27 +179,26 @@ class TestShopService:
def test_add_product_to_shop_success(self, db, test_shop, unique_product):
"""Test successfully adding product to shop"""
shop_product_data = ShopProductCreate(
product_data = ProductCreate(
marketplace_product_id=unique_product.marketplace_product_id,
price="15.99",
is_featured=True,
stock_quantity=5,
)
shop_product = self.service.add_product_to_shop(
db, test_shop, shop_product_data
product = self.service.add_product_to_shop(
db, test_shop, product_data
)
assert shop_product is not None
assert shop_product.shop_id == test_shop.id
assert shop_product.marketplace_product_id == unique_product.id
assert product is not None
assert product.shop_id == test_shop.id
assert product.marketplace_product_id == unique_product.id
def test_add_product_to_shop_product_not_found(self, db, test_shop):
"""Test adding non-existent product to shop fails"""
shop_product_data = ShopProductCreate(marketplace_product_id="NONEXISTENT", price="15.99")
product_data = ProductCreate(marketplace_product_id="NONEXISTENT", price="15.99")
with pytest.raises(MarketplaceProductNotFoundException) as exc_info:
self.service.add_product_to_shop(db, test_shop, shop_product_data)
self.service.add_product_to_shop(db, test_shop, product_data)
exception = exc_info.value
assert exception.status_code == 404
@@ -206,36 +206,36 @@ class TestShopService:
assert exception.details["resource_type"] == "MarketplaceProduct"
assert exception.details["identifier"] == "NONEXISTENT"
def test_add_product_to_shop_already_exists(self, db, test_shop, shop_product):
def test_add_product_to_shop_already_exists(self, db, test_shop, test_product):
"""Test adding product that's already in shop fails"""
shop_product_data = ShopProductCreate(
marketplace_product_id=shop_product.product.marketplace_product_id, price="15.99"
product_data = ProductCreate(
marketplace_product_id=test_product.marketplace_product.marketplace_product_id, price="15.99"
)
with pytest.raises(ShopProductAlreadyExistsException) as exc_info:
self.service.add_product_to_shop(db, test_shop, shop_product_data)
with pytest.raises(ProductAlreadyExistsException) as exc_info:
self.service.add_product_to_shop(db, test_shop, product_data)
exception = exc_info.value
assert exception.status_code == 409
assert exception.error_code == "SHOP_PRODUCT_ALREADY_EXISTS"
assert exception.error_code == "PRODUCT_ALREADY_EXISTS"
assert exception.details["shop_code"] == test_shop.shop_code
assert exception.details["marketplace_product_id"] == shop_product.product.marketplace_product_id
assert exception.details["marketplace_product_id"] == test_product.marketplace_product.marketplace_product_id
def test_get_shop_products_owner_access(
self, db, test_user, test_shop, shop_product
def test_get_products_owner_access(
self, db, test_user, test_shop, test_product
):
"""Test shop owner can get shop products"""
products, total = self.service.get_shop_products(db, test_shop, test_user)
products, total = self.service.get_products(db, test_shop, test_user)
assert total >= 1
assert len(products) >= 1
product_ids = [p.marketplace_product_id for p in products]
assert shop_product.marketplace_product_id in product_ids
assert test_product.marketplace_product_id in product_ids
def test_get_shop_products_access_denied(self, db, test_user, inactive_shop):
def test_get_products_access_denied(self, db, test_user, inactive_shop):
"""Test non-owner cannot access unverified shop products"""
with pytest.raises(UnauthorizedShopAccessException) as exc_info:
self.service.get_shop_products(db, inactive_shop, test_user)
self.service.get_products(db, inactive_shop, test_user)
exception = exc_info.value
assert exception.status_code == 403
@@ -243,16 +243,16 @@ class TestShopService:
assert exception.details["shop_code"] == inactive_shop.shop_code
assert exception.details["user_id"] == test_user.id
def test_get_shop_products_with_filters(self, db, test_user, test_shop, shop_product):
def test_get_products_with_filters(self, db, test_user, test_shop, test_product):
"""Test getting shop products with various filters"""
# Test active only filter
products, total = self.service.get_shop_products(
products, total = self.service.get_products(
db, test_shop, test_user, active_only=True
)
assert all(p.is_active for p in products)
# Test featured only filter
products, total = self.service.get_shop_products(
products, total = self.service.get_products(
db, test_shop, test_user, featured_only=True
)
assert all(p.is_featured for p in products)
@@ -299,12 +299,12 @@ class TestShopService:
monkeypatch.setattr(db, "commit", mock_commit)
shop_product_data = ShopProductCreate(
product_data = ProductCreate(
marketplace_product_id=unique_product.marketplace_product_id, price="15.99"
)
with pytest.raises(ValidationException) as exc_info:
self.service.add_product_to_shop(db, test_shop, shop_product_data)
self.service.add_product_to_shop(db, test_shop, product_data)
exception = exc_info.value
assert exception.error_code == "VALIDATION_ERROR"

4
tests/unit/services/test_stats_service.py
View File

@@ -315,7 +315,7 @@ class TestStatsService:
def test_get_unique_shops_count(self, db, test_marketplace_product):
"""Test getting unique shops count"""
# Add products with different shop names
shop_products = [
products = [
MarketplaceProduct(
marketplace_product_id="SHOP001",
title="Shop MarketplaceProduct 1",
@@ -333,7 +333,7 @@ class TestStatsService:
currency="EUR",
),
]
db.add_all(shop_products)
db.add_all(products)
db.commit()
count = self.service._get_unique_shops_count(db)