From 6b9817f179540aa151e6adf7cbe04402f2f2397f Mon Sep 17 00:00:00 2001
From: Samir Boulahtit <samir.boulahtit@wizard.lu>
Date: Sat, 27 Sep 2025 13:47:36 +0200
Subject: [PATCH] test updates to take into account exception management

---
 .idea/.gitignore                              |   4 -
 .idea/Letzshop-Import-v2.iml                  |  14 -
 .idea/inspectionProfiles/Project_Default.xml  |   6 +-
 .idea/misc.xml                                |   4 +-
 .idea/modules.xml                             |   2 +-
 Makefile                                      |   2 +-
 README-NEXTGEN.md                             | 400 +++++++++++++++
 app/api/v1/product.py                         |  55 +-
 app/exceptions/handler.py                     |  25 +-
 app/services/admin_service.py                 |  21 -
 app/services/auth_service.py                  |  10 -
 app/services/product_service.py               | 110 ++--
 app/services/shop_service.py                  |  40 --
 app/services/stats_service.py                 |  42 --
 app/services/stock_service.py                 |  18 +-
 app/utils/data_processing.py                  |   8 +-
 docs/api/index.md                             |   6 +-
 middleware/auth.py                            |   2 +-
 models/schemas/auth.py                        |  23 +-
 models/schemas/marketplace.py                 |  44 +-
 models/schemas/product.py                     |  27 +-
 models/schemas/shop.py                        |  73 +--
 models/schemas/stock.py                       |  27 +-
 tests/.coverage                               | Bin 53248 -> 53248 bytes
 tests/fixtures/product_fixtures.py            |  15 +
 .../integration/api/v1/test_auth_endpoints.py |  15 -
 tests/integration/api/v1/test_filtering.py    | 146 ++++--
 tests/integration/api/v1/test_pagination.py   | 268 +++++++++-
 .../api/v1/test_product_endpoints.py          | 244 +++++++--
 .../integration/api/v1/test_product_export.py | 287 ++++++++++-
 .../integration/api/v1/test_shop_endpoints.py | 366 ++++++++++++-
 .../api/v1/test_stock_endpoints.py            | 343 ++++++++++++-
 tests/system/test_error_handling.py           | 479 ++++++++++++++----
 tests/unit/services/test_auth_service.py      |   8 +-
 tests/unit/services/test_product_service.py   |   7 +-
 tests/unit/services/test_shop_service.py      | 276 +++++++---
 tests/unit/services/test_stats_service.py     |  18 +-
 tests/unit/services/test_stock_service.py     | 387 +++++++++-----
 38 files changed, 2951 insertions(+), 871 deletions(-)
 delete mode 100644 .idea/.gitignore
 delete mode 100644 .idea/Letzshop-Import-v2.iml
 create mode 100644 README-NEXTGEN.md

diff --git a/.idea/.gitignore b/.idea/.gitignore
deleted file mode 100644
index 351c96db..00000000
--- a/.idea/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-
diff --git a/.idea/Letzshop-Import-v2.iml b/.idea/Letzshop-Import-v2.iml
deleted file mode 100644
index fc0b0f27..00000000
--- a/.idea/Letzshop-Import-v2.iml
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/venv" />
-    </content>
-    <orderEntry type="jdk" jdkName="Python 3.10 (Letzshop-Import-v1)" jdkType="Python SDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-  <component name="PyDocumentationSettings">
-    <option name="format" value="PLAIN" />
-    <option name="myDocStringFormat" value="Plain" />
-  </component>
-</module>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 930c0173..ace3249f 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -3,11 +3,7 @@
     <option name="myName" value="Project Default" />
     <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ignoredPackages">
-        <value>
-          <list size="1">
-            <item index="0" class="java.lang.String" itemvalue="typing_extensions" />
-          </list>
-        </value>
+        <list />
       </option>
     </inspection_tool>
   </profile>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 174cf50e..777350c5 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="Black">
-    <option name="sdkName" value="Python 3.10 (Letz-backend)" />
+    <option name="sdkName" value="Python 3.10 (Letzshop-Import)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (Letzshop-Import-v1)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (Letzshop-Import)" project-jdk-type="Python SDK" />
 </project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
index 37b2c337..2e6aee08 100644
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/Letzshop-Import-v2.iml" filepath="$PROJECT_DIR$/.idea/Letzshop-Import-v2.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/Letzshop-Import.iml" filepath="$PROJECT_DIR$/.idea/Letzshop-Import.iml" />
     </modules>
   </component>
 </project>
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 6c65d07f..c8d9f12e 100644
--- a/Makefile
+++ b/Makefile
@@ -12,7 +12,7 @@ install-dev: install
 	pip install -r requirements-dev.txt
 
 install-test:
-	pip install -r tests/requirements-test.txt
+	pip install -r requirements-test.txt
 
 install-docs:
 	pip install -r requirements-docs.txt
diff --git a/README-NEXTGEN.md b/README-NEXTGEN.md
new file mode 100644
index 00000000..8b594045
--- /dev/null
+++ b/README-NEXTGEN.md
@@ -0,0 +1,400 @@
+# Multi-Tenant Ecommerce Platform with Marketplace Integration
+
+## Project Overview
+
+This document outlines the comprehensive architecture for a state-of-the-art multi-tenant ecommerce platform that enables vendors to operate independent webshops while integrating with external marketplaces. The platform implements complete vendor isolation with self-service capabilities and marketplace product imports.
+
+## Core Architecture
+
+### Technology Stack
+- **Backend**: Python FastAPI with PostgreSQL
+- **Frontend**: Vanilla HTML, CSS, JavaScript with AJAX
+- **Deployment**: Docker with environment-based configuration
+- **Authentication**: JWT-based with role-based access control
+
+### Multi-Tenancy Model
+The platform operates on a **complete vendor isolation** principle where:
+- Each vendor has their own independent webshop
+- Full Chinese wall between vendors (no data sharing)
+- Vendors can manage their own teams with granular permissions
+- Self-service marketplace integration capabilities
+
+## System Architecture
+
+### 1. Application Structure
+
+```
+app/
+├── admin/                     # Super admin functionality
+│   ├── models.py             # Super admin, vendor bulk operations
+│   ├── routers.py            # Admin endpoints
+│   ├── services/
+│   │   ├── vendor_importer.py # Bulk vendor CSV import
+│   │   └── admin_auth.py      # Super admin authentication
+│   └── tasks.py              # Background bulk operations
+├── auth/                      # Authentication & authorization
+│   ├── models.py             # Users, roles, permissions
+│   ├── routers.py            # Team member auth
+│   ├── services/
+│   │   ├── permissions.py    # Role-based access control
+│   │   └── invitations.py    # Team member invites
+│   └── middleware.py         # User + vendor context
+├── teams/                     # Team management
+│   ├── models.py             # Team management models
+│   ├── routers.py            # Team CRUD operations
+│   └── services.py           # Team operations
+├── marketplace/               # Marketplace integrations
+│   ├── models.py             # Import jobs, marketplace configs
+│   ├── services/
+│   │   ├── letzshop.py       # Letzshop CSV processor
+│   │   └── importer.py       # Generic import orchestrator
+│   ├── routers.py            # Import management endpoints
+│   └── tasks.py              # Background import jobs
+├── ecommerce/                 # Core business logic
+│   ├── models.py             # Products, orders, customers
+│   ├── routers/
+│   │   ├── products.py       # Product catalog management
+│   │   ├── orders.py         # Order processing
+│   │   └── customers.py      # Customer management
+│   └── services/             # Business logic services
+└── shared/                    # Common utilities
+    ├── database.py           # Database configuration
+    ├── models.py             # Shared base models
+    └── utils.py              # Common utilities
+```
+
+### 2. Data Models
+
+#### Core Models
+
+```python
+# Vendor Management
+class Vendor(BaseModel):
+    id: int
+    name: str
+    subdomain: str
+    owner_user_id: int
+    business_address: str
+    business_email: str
+    business_phone: str
+    letzshop_csv_url: Optional[str]
+    theme_config: dict
+    is_active: bool = True
+    created_at: datetime
+
+# User Management
+class User(BaseModel):
+    id: int
+    email: str
+    first_name: str
+    last_name: str
+    hashed_password: str
+    is_active: bool = True
+    created_at: datetime
+
+# Team Management
+class VendorUser(BaseModel):
+    id: int
+    vendor_id: int
+    user_id: int
+    role_id: int
+    invited_by: int
+    is_active: bool = True
+
+class Role(BaseModel):
+    id: int
+    vendor_id: int
+    name: str  # "Owner", "Manager", "Editor", "Viewer"
+    permissions: List[str]  # ["products.create", "orders.view", etc.]
+
+# Product Management
+class Product(BaseModel):
+    id: int
+    vendor_id: int
+    sku: str
+    name: str
+    price: Decimal
+    imported_product_id: Optional[int]
+    custom_description: Optional[str]
+    custom_price: Optional[Decimal]
+
+class ImportedProduct(BaseModel):
+    id: int
+    vendor_id: int
+    import_job_id: int
+    external_sku: str
+    raw_data: dict
+    is_selected: bool = False
+    is_published: bool = False
+```
+
+## User Roles & Permissions
+
+### Role Hierarchy
+1. **Super Admin**: Platform-level administration
+2. **Vendor Owner**: Full vendor control including team management
+3. **Vendor Manager**: Operational management without team control
+4. **Vendor Editor**: Product and order management
+5. **Vendor Viewer**: Read-only access
+
+### Permission System
+```python
+DEFAULT_ROLES = {
+    "Owner": [
+        "team.manage", "team.invite", "team.remove",
+        "products.create", "products.edit", "products.delete", "products.view",
+        "orders.create", "orders.edit", "orders.view",
+        "imports.trigger", "imports.view", "imports.configure",
+        "settings.edit", "analytics.view"
+    ],
+    "Manager": [
+        "team.invite", "team.view",
+        "products.create", "products.edit", "products.view",
+        "orders.create", "orders.edit", "orders.view",
+        "imports.trigger", "imports.view",
+        "analytics.view"
+    ],
+    "Editor": [
+        "products.create", "products.edit", "products.view",
+        "orders.view", "orders.edit",
+        "imports.view"
+    ],
+    "Viewer": [
+        "products.view", "orders.view", "imports.view"
+    ]
+}
+```
+
+## Marketplace Integration
+
+### Current Integration: Letzshop
+- **Import Method**: CSV file processing (one file per language per vendor)
+- **Data Handling**: Complete import of all CSV data into staging area
+- **Vendor Control**: Vendors select which products to publish to their catalog
+- **Override Capability**: Vendors can modify prices, descriptions, and other attributes
+
+### Import Workflow
+1. **Configuration**: Vendors provide their Letzshop CSV URLs
+2. **Import Execution**: System downloads and processes CSV files
+3. **Product Staging**: All products imported to `ImportedProduct` table
+4. **Vendor Selection**: Vendors browse and select products to publish
+5. **Catalog Integration**: Selected products become active `Product` entries
+6. **Customization**: Vendors can override imported data
+
+### Import Models
+```python
+class ImportJob(BaseModel):
+    id: int
+    vendor_id: int
+    marketplace: str = "letzshop"
+    csv_url: str
+    status: ImportStatus
+    total_products: int
+    imported_at: datetime
+
+class ImportConfiguration(BaseModel):
+    vendor_id: int
+    marketplace: str
+    config: dict  # CSV URLs, mapping rules
+    is_active: bool
+```
+
+## Team Management System
+
+### Team Invitation Flow
+1. **Invitation Creation**: Owner/Manager invites team member via email
+2. **Secure Token Generation**: Cryptographically secure invitation tokens
+3. **Email Notification**: Invitation email with acceptance link
+4. **User Registration**: New users create account or existing users join team
+5. **Role Assignment**: Automatic role assignment based on invitation
+6. **Access Activation**: Immediate access to vendor resources
+
+### Multi-Vendor Users
+- Users can be members of multiple vendor teams
+- Context switching between vendor environments
+- Isolated permissions per vendor relationship
+
+## Super Admin Capabilities
+
+### Vendor Management
+- **Bulk Import**: CSV-based vendor creation with owner details
+- **Individual Management**: Create, edit, deactivate vendors
+- **Team Oversight**: View all teams across vendors
+- **System Monitoring**: Import job monitoring, system health
+
+### Bulk Import Format
+```csv
+vendor_name,subdomain,owner_name,owner_email,owner_phone,business_address,business_city,business_postal_code,business_country,letzshop_csv_url,initial_password
+```
+
+### Admin Features
+- Vendor CRUD operations
+- Mass password resets
+- System-wide import monitoring
+- Audit logging
+- Analytics dashboard
+
+## Frontend Architecture
+
+### Multi-Tenant Single Application
+- **Single Codebase**: One frontend serving all vendors
+- **Dynamic Theming**: Vendor-specific customization
+- **Context Detection**: Automatic vendor identification
+- **Role-Based UI**: Permission-driven interface elements
+
+### Application Structure
+```
+ecommerce_frontend/
+├── vendor/                    # Vendor admin interface
+│   ├── dashboard.html
+│   ├── products.html
+│   ├── orders.html
+│   ├── team.html
+│   ├── imports.html
+│   └── settings.html
+├── shop/                      # Customer-facing shop
+│   ├── home.html
+│   ├── products.html
+│   ├── cart.html
+│   └── checkout.html
+├── css/
+│   ├── vendor/               # Admin styles
+│   ├── shop/                 # Shop styles
+│   └── themes/               # Vendor themes
+└── js/
+    ├── vendor/               # Admin logic
+    ├── shop/                 # Shop functionality
+    └── shared/               # Common utilities
+```
+
+### Vendor Context Detection
+1. **Subdomain-based**: `vendor1.platform.com` (Production)
+2. **Path-based**: `platform.com/vendor/vendor1` (Development)
+3. **Custom Domain**: `vendor-custom.com` (Enterprise)
+
+## Deployment Strategy
+
+### Environment Configuration
+- **Development**: Path-based routing, debug enabled
+- **Staging**: Subdomain-based, testing features
+- **Production**: Subdomain + custom domains, optimized performance
+
+### Single Build Deployment
+- Environment-agnostic build artifacts
+- Runtime configuration injection
+- Dynamic vendor context resolution
+- Theme and feature adaptation
+
+### Configuration Flow
+1. **Build Phase**: Create environment-neutral assets
+2. **Deployment**: Environment-specific configuration injection
+3. **Runtime**: Vendor context detection and configuration loading
+4. **Customization**: Dynamic theme and feature application
+
+## API Structure
+
+### Vendor-Scoped Endpoints
+```
+/api/v1/
+├── auth/
+│   ├── POST /login           # Universal login
+│   └── POST /register        # Accept invitations
+├── teams/
+│   ├── GET /members          # Team management
+│   ├── POST /invite          # Invite members
+│   └── PUT /members/{id}     # Update roles
+├── products/
+│   ├── GET /                 # Vendor catalog
+│   ├── POST /                # Create products
+│   └── POST /from-import/{id} # Import from marketplace
+├── marketplace/
+│   ├── POST /import          # Trigger imports
+│   ├── GET /imports          # Import history
+│   └── GET /imports/{id}/products # Browse imported products
+└── orders/
+    ├── GET /                 # Order management
+    └── POST /                # Create orders
+```
+
+### Admin Endpoints
+```
+/api/v1/admin/
+├── vendors/
+│   ├── GET /                 # List vendors
+│   ├── POST /bulk-import     # Bulk vendor creation
+│   └── PUT /{id}             # Edit vendor
+├── marketplace/
+│   ├── GET /import-jobs      # System-wide import monitoring
+│   └── POST /trigger-imports # Mass import trigger
+└── system/
+    ├── GET /health           # System health
+    └── GET /analytics        # Platform analytics
+```
+
+## Security Features
+
+### Authentication & Authorization
+- JWT-based authentication with refresh tokens
+- Role-based access control with granular permissions
+- Vendor-scoped data access with automatic filtering
+- Secure invitation system with expiring tokens
+
+### Data Isolation
+- Complete vendor data separation at database level
+- Automatic vendor ID injection in all queries
+- Permission verification on all operations
+- Audit logging for admin actions
+
+### Security Middleware
+```python
+async def vendor_context_middleware(request: Request):
+    # Extract vendor context
+    # Validate user permissions
+    # Inject vendor ID in request state
+    # Ensure data isolation
+```
+
+## Current Status & Next Steps
+
+### Implemented Features
+- ✅ Multi-tenant architecture with vendor isolation
+- ✅ Team management with role-based permissions
+- ✅ Letzshop marketplace integration
+- ✅ Super admin bulk vendor management
+- ✅ Environment-agnostic deployment strategy
+
+### Upcoming Development
+- 🔄 Frontend implementation with dynamic theming
+- 🔄 Customer-facing shop interfaces
+- 🔄 Order processing system
+- 🔄 Payment gateway integration
+- 🔄 Advanced analytics dashboard
+
+### Future Enhancements
+- 📋 Additional marketplace integrations
+- 📋 Advanced product management features
+- 📋 Customer loyalty programs
+- 📋 Multi-language support
+- 📋 Mobile application
+
+## Technical Advantages
+
+### Scalability
+- Horizontal scaling through vendor isolation
+- Microservice-ready architecture
+- Environment-flexible deployment
+- Database partitioning capabilities
+
+### Maintainability
+- Single codebase for all vendors
+- Centralized feature updates
+- Consistent development patterns
+- Automated testing strategies
+
+### Flexibility
+- Vendor-specific customization
+- Multiple deployment modes
+- Extensible marketplace integration
+- Theme system for brand customization
+
+This architecture provides a robust foundation for a scalable, multi-tenant ecommerce platform that can efficiently serve multiple vendors while maintaining complete data isolation and providing flexible marketplace integration capabilities.
\ No newline at end of file
diff --git a/app/api/v1/product.py b/app/api/v1/product.py
index f24feddf..a5ed0948 100644
--- a/app/api/v1/product.py
+++ b/app/api/v1/product.py
@@ -27,6 +27,34 @@ router = APIRouter()
 logger = logging.getLogger(__name__)
 
 
+@router.get("/product/export-csv")
+async def export_csv(
+        marketplace: Optional[str] = Query(None, description="Filter by marketplace"),
+        shop_name: Optional[str] = Query(None, description="Filter by shop name"),
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user),
+):
+    """Export products as CSV with streaming and marketplace filtering (Protected)."""
+
+    def generate_csv():
+        return product_service.generate_csv_export(
+            db=db, marketplace=marketplace, shop_name=shop_name
+        )
+
+    filename = "products_export"
+    if marketplace:
+        filename += f"_{marketplace}"
+    if shop_name:
+        filename += f"_{shop_name}"
+    filename += ".csv"
+
+    return StreamingResponse(
+        generate_csv(),
+        media_type="text/csv",
+        headers={"Content-Disposition": f"attachment; filename={filename}"},
+    )
+
+
 @router.get("/product", response_model=ProductListResponse)
 def get_products(
         skip: int = Query(0, ge=0),
@@ -112,30 +140,3 @@ def delete_product(
     product_service.delete_product(db, product_id)
     return {"message": "Product and associated stock deleted successfully"}
 
-
-@router.get("/product/export-csv")
-async def export_csv(
-        marketplace: Optional[str] = Query(None, description="Filter by marketplace"),
-        shop_name: Optional[str] = Query(None, description="Filter by shop name"),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user),
-):
-    """Export products as CSV with streaming and marketplace filtering (Protected)."""
-
-    def generate_csv():
-        return product_service.generate_csv_export(
-            db=db, marketplace=marketplace, shop_name=shop_name
-        )
-
-    filename = "products_export"
-    if marketplace:
-        filename += f"_{marketplace}"
-    if shop_name:
-        filename += f"_{shop_name}"
-    filename += ".csv"
-
-    return StreamingResponse(
-        generate_csv(),
-        media_type="text/csv",
-        headers={"Content-Disposition": f"attachment; filename={filename}"},
-    )
diff --git a/app/exceptions/handler.py b/app/exceptions/handler.py
index 4077857b..1f171b44 100644
--- a/app/exceptions/handler.py
+++ b/app/exceptions/handler.py
@@ -90,7 +90,10 @@ def setup_exception_handlers(app):
         for error in exc.errors():
             clean_error = {}
             for key, value in error.items():
-                if key == 'ctx' and isinstance(value, dict):
+                if key == 'input' and isinstance(value, bytes):
+                    # Convert bytes to string representation for JSON serialization
+                    clean_error[key] = f"<bytes: {len(value)} bytes>"
+                elif key == 'ctx' and isinstance(value, dict):
                     # Handle the 'ctx' field that contains ValueError objects
                     clean_ctx = {}
                     for ctx_key, ctx_value in value.items():
@@ -99,6 +102,9 @@ def setup_exception_handlers(app):
                         else:
                             clean_ctx[ctx_key] = ctx_value
                     clean_error[key] = clean_ctx
+                elif isinstance(value, bytes):
+                    # Handle any other bytes objects
+                    clean_error[key] = f"<bytes: {len(value)} bytes>"
                 else:
                     clean_error[key] = value
             clean_errors.append(clean_error)
@@ -138,6 +144,23 @@ def setup_exception_handlers(app):
             }
         )
 
+    @app.exception_handler(404)
+    async def not_found_handler(request: Request, exc):
+        """Handle all 404 errors with consistent format."""
+        logger.warning(f"404 Not Found: {request.method} {request.url}")
+
+        return JSONResponse(
+            status_code=404,
+            content={
+                "error_code": "ENDPOINT_NOT_FOUND",
+                "message": f"Endpoint not found: {request.url.path}",
+                "status_code": 404,
+                "details": {
+                    "path": request.url.path,
+                    "method": request.method
+                }
+            }
+        )
 
 # Utility functions for common exception scenarios
 def raise_not_found(resource_type: str, identifier: str) -> None:
diff --git a/app/services/admin_service.py b/app/services/admin_service.py
index f362517d..a4289f25 100644
--- a/app/services/admin_service.py
+++ b/app/services/admin_service.py
@@ -337,27 +337,6 @@ class AdminService:
             completed_at=job.completed_at,
         )
 
-    # Legacy methods for backward compatibility (mark as deprecated)
-    def get_user_by_id(self, db: Session, user_id: int) -> Optional[User]:
-        """Get user by ID. DEPRECATED: Use _get_user_by_id_or_raise instead."""
-        logger.warning("get_user_by_id is deprecated, use proper exception handling")
-        return db.query(User).filter(User.id == user_id).first()
-
-    def get_shop_by_id(self, db: Session, shop_id: int) -> Optional[Shop]:
-        """Get shop by ID. DEPRECATED: Use _get_shop_by_id_or_raise instead."""
-        logger.warning("get_shop_by_id is deprecated, use proper exception handling")
-        return db.query(Shop).filter(Shop.id == shop_id).first()
-
-    def user_exists(self, db: Session, user_id: int) -> bool:
-        """Check if user exists by ID. DEPRECATED: Use proper exception handling."""
-        logger.warning("user_exists is deprecated, use proper exception handling")
-        return db.query(User).filter(User.id == user_id).first() is not None
-
-    def shop_exists(self, db: Session, shop_id: int) -> bool:
-        """Check if shop exists by ID. DEPRECATED: Use proper exception handling."""
-        logger.warning("shop_exists is deprecated, use proper exception handling")
-        return db.query(Shop).filter(Shop.id == shop_id).first() is not None
-
 
 # Create service instance following the same pattern as product_service
 admin_service = AdminService()
diff --git a/app/services/auth_service.py b/app/services/auth_service.py
index 244fc493..fa16f8c8 100644
--- a/app/services/auth_service.py
+++ b/app/services/auth_service.py
@@ -170,16 +170,6 @@ class AuthService:
         """Check if username already exists."""
         return db.query(User).filter(User.username == username).first() is not None
 
-    # Legacy methods for backward compatibility (deprecated)
-    def email_exists(self, db: Session, email: str) -> bool:
-        """Check if email already exists. DEPRECATED: Use proper exception handling."""
-        logger.warning("email_exists is deprecated, use proper exception handling")
-        return self._email_exists(db, email)
-
-    def username_exists(self, db: Session, username: str) -> bool:
-        """Check if username already exists. DEPRECATED: Use proper exception handling."""
-        logger.warning("username_exists is deprecated, use proper exception handling")
-        return self._username_exists(db, username)
 
 
 # Create service instance following the same pattern as other services
diff --git a/app/services/product_service.py b/app/services/product_service.py
index 90d316e2..fe9b3bca 100644
--- a/app/services/product_service.py
+++ b/app/services/product_service.py
@@ -8,9 +8,10 @@ This module provides classes and functions for:
 - Stock information integration
 - CSV export functionality
 """
-
+import csv
 import logging
 from datetime import datetime, timezone
+from io import StringIO
 from typing import Generator, List, Optional, Tuple
 
 from sqlalchemy.exc import IntegrityError
@@ -41,21 +42,7 @@ class ProductService:
         self.price_processor = PriceProcessor()
 
     def create_product(self, db: Session, product_data: ProductCreate) -> Product:
-        """
-        Create a new product with validation.
-
-        Args:
-            db: Database session
-            product_data: Product creation data
-
-        Returns:
-            Created Product object
-
-        Raises:
-            ProductAlreadyExistsException: If product with ID already exists
-            InvalidProductDataException: If product data is invalid
-            ProductValidationException: If validation fails
-        """
+        """Create a new product with validation."""
         try:
             # Process and validate GTIN if provided
             if product_data.gtin:
@@ -73,8 +60,9 @@ class ProductService:
                     if parsed_price:
                         product_data.price = parsed_price
                         product_data.currency = currency
-                except Exception as e:
-                    raise InvalidProductDataException(f"Invalid price format: {str(e)}", field="price")
+                except ValueError as e:
+                    # Convert ValueError to domain-specific exception
+                    raise InvalidProductDataException(str(e), field="price")
 
             # Set default marketplace if not provided
             if not product_data.marketplace:
@@ -199,25 +187,8 @@ class ProductService:
             logger.error(f"Error getting products with filters: {str(e)}")
             raise ValidationException("Failed to retrieve products")
 
-    def update_product(
-            self, db: Session, product_id: str, product_update: ProductUpdate
-    ) -> Product:
-        """
-        Update product with validation.
-
-        Args:
-            db: Database session
-            product_id: Product ID to update
-            product_update: Update data
-
-        Returns:
-            Updated Product object
-
-        Raises:
-            ProductNotFoundException: If product doesn't exist
-            InvalidProductDataException: If update data is invalid
-            ProductValidationException: If validation fails
-        """
+    def update_product(self, db: Session, product_id: str, product_update: ProductUpdate) -> Product:
+        """Update product with validation."""
         try:
             product = self.get_product_by_id_or_raise(db, product_id)
 
@@ -240,8 +211,9 @@ class ProductService:
                     if parsed_price:
                         update_data["price"] = parsed_price
                         update_data["currency"] = currency
-                except Exception as e:
-                    raise InvalidProductDataException(f"Invalid price format: {str(e)}", field="price")
+                except ValueError as e:
+                    # Convert ValueError to domain-specific exception
+                    raise InvalidProductDataException(str(e), field="price")
 
             # Validate required fields if being updated
             if "title" in update_data and (not update_data["title"] or not update_data["title"].strip()):
@@ -329,6 +301,11 @@ class ProductService:
             logger.error(f"Error getting stock info for GTIN {gtin}: {str(e)}")
             return None
 
+    import csv
+    from io import StringIO
+    from typing import Generator, Optional
+    from sqlalchemy.orm import Session
+
     def generate_csv_export(
             self,
             db: Session,
@@ -336,7 +313,7 @@ class ProductService:
             shop_name: Optional[str] = None,
     ) -> Generator[str, None, None]:
         """
-        Generate CSV export with streaming for memory efficiency.
+        Generate CSV export with streaming for memory efficiency and proper CSV escaping.
 
         Args:
             db: Database session
@@ -344,14 +321,25 @@ class ProductService:
             shop_name: Optional shop name filter
 
         Yields:
-            CSV content as strings
+            CSV content as strings with proper escaping
         """
         try:
-            # CSV header
-            yield (
-                "product_id,title,description,link,image_link,availability,price,currency,brand,"
-                "gtin,marketplace,shop_name\n"
-            )
+            # Create a StringIO buffer for CSV writing
+            output = StringIO()
+            writer = csv.writer(output, quoting=csv.QUOTE_MINIMAL)
+
+            # Write header row
+            headers = [
+                "product_id", "title", "description", "link", "image_link",
+                "availability", "price", "currency", "brand", "gtin",
+                "marketplace", "shop_name"
+            ]
+            writer.writerow(headers)
+            yield output.getvalue()
+
+            # Clear buffer for reuse
+            output.seek(0)
+            output.truncate(0)
 
             batch_size = 1000
             offset = 0
@@ -370,14 +358,28 @@ class ProductService:
                     break
 
                 for product in products:
-                    # Create CSV row with marketplace fields
-                    row = (
-                        f'"{product.product_id}","{product.title or ""}","{product.description or ""}",'
-                        f'"{product.link or ""}","{product.image_link or ""}","{product.availability or ""}",'
-                        f'"{product.price or ""}","{product.currency or ""}","{product.brand or ""}",'
-                        f'"{product.gtin or ""}","{product.marketplace or ""}","{product.shop_name or ""}"\n'
-                    )
-                    yield row
+                    # Create CSV row with proper escaping
+                    row_data = [
+                        product.product_id or "",
+                        product.title or "",
+                        product.description or "",
+                        product.link or "",
+                        product.image_link or "",
+                        product.availability or "",
+                        product.price or "",
+                        product.currency or "",
+                        product.brand or "",
+                        product.gtin or "",
+                        product.marketplace or "",
+                        product.shop_name or "",
+                    ]
+
+                    writer.writerow(row_data)
+                    yield output.getvalue()
+
+                    # Clear buffer for next row
+                    output.seek(0)
+                    output.truncate(0)
 
                 offset += batch_size
 
diff --git a/app/services/shop_service.py b/app/services/shop_service.py
index 97d0200d..23d75be3 100644
--- a/app/services/shop_service.py
+++ b/app/services/shop_service.py
@@ -353,45 +353,5 @@ class ShopService:
         """Check if user is shop owner."""
         return shop.owner_id == user.id
 
-    # Legacy methods for backward compatibility (deprecated)
-    def get_shop_by_id(self, db: Session, shop_id: int) -> Optional[Shop]:
-        """Get shop by ID. DEPRECATED: Use proper exception handling."""
-        logger.warning("get_shop_by_id is deprecated, use proper exception handling")
-        try:
-            return db.query(Shop).filter(Shop.id == shop_id).first()
-        except Exception as e:
-            logger.error(f"Error getting shop by ID: {str(e)}")
-            return None
-
-    def shop_code_exists(self, db: Session, shop_code: str) -> bool:
-        """Check if shop code exists. DEPRECATED: Use proper exception handling."""
-        logger.warning("shop_code_exists is deprecated, use proper exception handling")
-        return self._shop_code_exists(db, shop_code)
-
-    def get_product_by_id(self, db: Session, product_id: str) -> Optional[Product]:
-        """Get product by ID. DEPRECATED: Use proper exception handling."""
-        logger.warning("get_product_by_id is deprecated, use proper exception handling")
-        try:
-            return db.query(Product).filter(Product.product_id == product_id).first()
-        except Exception as e:
-            logger.error(f"Error getting product by ID: {str(e)}")
-            return None
-
-    def product_in_shop(self, db: Session, shop_id: int, product_id: int) -> bool:
-        """Check if product in shop. DEPRECATED: Use proper exception handling."""
-        logger.warning("product_in_shop is deprecated, use proper exception handling")
-        return self._product_in_shop(db, shop_id, product_id)
-
-    def is_shop_owner(self, shop: Shop, user: User) -> bool:
-        """Check if user is shop owner. DEPRECATED: Use _is_shop_owner."""
-        logger.warning("is_shop_owner is deprecated, use _is_shop_owner")
-        return self._is_shop_owner(shop, user)
-
-    def can_view_shop(self, shop: Shop, user: User) -> bool:
-        """Check if user can view shop. DEPRECATED: Use _can_access_shop."""
-        logger.warning("can_view_shop is deprecated, use _can_access_shop")
-        return self._can_access_shop(shop, user)
-
-
 # Create service instance following the same pattern as other services
 shop_service = ShopService()
diff --git a/app/services/stats_service.py b/app/services/stats_service.py
index 54dbe494..17e55eed 100644
--- a/app/services/stats_service.py
+++ b/app/services/stats_service.py
@@ -294,47 +294,5 @@ class StatsService:
         """Get product count for a specific marketplace."""
         return db.query(Product).filter(Product.marketplace == marketplace).count()
 
-    # Legacy methods for backward compatibility (deprecated)
-    def get_product_count(self, db: Session) -> int:
-        """Get total product count. DEPRECATED: Use _get_product_count."""
-        logger.warning("get_product_count is deprecated, use _get_product_count")
-        return self._get_product_count(db)
-
-    def get_unique_brands_count(self, db: Session) -> int:
-        """Get unique brands count. DEPRECATED: Use _get_unique_brands_count."""
-        logger.warning("get_unique_brands_count is deprecated, use _get_unique_brands_count")
-        return self._get_unique_brands_count(db)
-
-    def get_unique_categories_count(self, db: Session) -> int:
-        """Get unique categories count. DEPRECATED: Use _get_unique_categories_count."""
-        logger.warning("get_unique_categories_count is deprecated, use _get_unique_categories_count")
-        return self._get_unique_categories_count(db)
-
-    def get_unique_marketplaces_count(self, db: Session) -> int:
-        """Get unique marketplaces count. DEPRECATED: Use _get_unique_marketplaces_count."""
-        logger.warning("get_unique_marketplaces_count is deprecated, use _get_unique_marketplaces_count")
-        return self._get_unique_marketplaces_count(db)
-
-    def get_unique_shops_count(self, db: Session) -> int:
-        """Get unique shops count. DEPRECATED: Use _get_unique_shops_count."""
-        logger.warning("get_unique_shops_count is deprecated, use _get_unique_shops_count")
-        return self._get_unique_shops_count(db)
-
-    def get_brands_by_marketplace(self, db: Session, marketplace: str) -> List[str]:
-        """Get brands by marketplace. DEPRECATED: Use _get_brands_by_marketplace."""
-        logger.warning("get_brands_by_marketplace is deprecated, use _get_brands_by_marketplace")
-        return self._get_brands_by_marketplace(db, marketplace)
-
-    def get_shops_by_marketplace(self, db: Session, marketplace: str) -> List[str]:
-        """Get shops by marketplace. DEPRECATED: Use _get_shops_by_marketplace."""
-        logger.warning("get_shops_by_marketplace is deprecated, use _get_shops_by_marketplace")
-        return self._get_shops_by_marketplace(db, marketplace)
-
-    def get_products_by_marketplace(self, db: Session, marketplace: str) -> int:
-        """Get products by marketplace. DEPRECATED: Use _get_products_by_marketplace_count."""
-        logger.warning("get_products_by_marketplace is deprecated, use _get_products_by_marketplace_count")
-        return self._get_products_by_marketplace_count(db, marketplace)
-
-
 # Create service instance following the same pattern as other services
 stats_service = StatsService()
diff --git a/app/services/stock_service.py b/app/services/stock_service.py
index 95d0b7ac..6b590ae6 100644
--- a/app/services/stock_service.py
+++ b/app/services/stock_service.py
@@ -217,7 +217,8 @@ class StockService:
             )
             return existing_stock
 
-        except (StockNotFoundException, InsufficientStockException, InvalidQuantityException, NegativeStockException):
+        except (StockValidationException, StockNotFoundException, InsufficientStockException, InvalidQuantityException,
+                NegativeStockException):
             db.rollback()
             raise  # Re-raise custom exceptions
         except Exception as e:
@@ -564,21 +565,6 @@ class StockService:
             raise StockNotFoundException(str(stock_id))
         return stock_entry
 
-    # Legacy methods for backward compatibility (deprecated)
-    def normalize_gtin(self, gtin_value) -> Optional[str]:
-        """Normalize GTIN format. DEPRECATED: Use _normalize_gtin."""
-        logger.warning("normalize_gtin is deprecated, use _normalize_gtin")
-        return self._normalize_gtin(gtin_value)
-
-    def get_stock_by_id(self, db: Session, stock_id: int) -> Optional[Stock]:
-        """Get stock by ID. DEPRECATED: Use proper exception handling."""
-        logger.warning("get_stock_by_id is deprecated, use proper exception handling")
-        try:
-            return db.query(Stock).filter(Stock.id == stock_id).first()
-        except Exception as e:
-            logger.error(f"Error getting stock by ID: {str(e)}")
-            return None
-
 
 # Create service instance
 stock_service = StockService()
diff --git a/app/utils/data_processing.py b/app/utils/data_processing.py
index ac2fba37..a6381973 100644
--- a/app/utils/data_processing.py
+++ b/app/utils/data_processing.py
@@ -103,7 +103,8 @@ class PriceProcessor:
         """
         Parse price string into (price, currency) tuple.
 
-        Returns (None, None) if parsing fails
+        Raises ValueError if parsing fails for non-empty input.
+        Returns (None, None) for empty/null input.
         """
         if not price_str or pd.isna(price_str):
             return None, None
@@ -136,5 +137,6 @@ class PriceProcessor:
             except ValueError:
                 pass
 
-        logger.warning(f"Could not parse price: '{price_str}'")
-        return price_str, None
+        # If we get here, parsing failed completely
+        logger.error(f"Could not parse price: '{price_str}'")
+        raise ValueError(f"Invalid price format: '{price_str}'")
diff --git a/docs/api/index.md b/docs/api/index.md
index 6087744b..44577859 100644
--- a/docs/api/index.md
+++ b/docs/api/index.md
@@ -98,7 +98,7 @@ Content-Type: application/json
 Most list endpoints support pagination:
 
 ```bash
-GET /api/v1/products?skip=0&limit=20
+GET /api/v1/product?skip=0&limit=20
 ```
 
 Response includes pagination metadata:
@@ -116,14 +116,14 @@ Response includes pagination metadata:
 Many endpoints support filtering and search:
 
 ```bash
-GET /api/v1/products?search=laptop&category=electronics&min_price=100
+GET /api/v1/product?search=laptop&category=electronics&min_price=100
 ```
 
 ### Sorting
 Use the `sort` parameter with field names:
 
 ```bash
-GET /api/v1/products?sort=name&order=desc
+GET /api/v1/product?sort=name&order=desc
 ```
 
 ## Status Codes
diff --git a/middleware/auth.py b/middleware/auth.py
index 5b4589b7..5a51e841 100644
--- a/middleware/auth.py
+++ b/middleware/auth.py
@@ -66,7 +66,7 @@ class AuthManager:
         if not self.verify_password(password, user.hashed_password):
             return None
 
-        return user  # Return user regardless of active status
+        return user  # Return user if credentials are valid
 
     def create_access_token(self, user: User) -> Dict[str, Any]:
         """Create JWT access token for user."""
diff --git a/models/schemas/auth.py b/models/schemas/auth.py
index fe6201bd..f06ef49b 100644
--- a/models/schemas/auth.py
+++ b/models/schemas/auth.py
@@ -1,27 +1,20 @@
+# auth.py - Keep security-critical validation
 import re
 from datetime import datetime
-from typing import List, Optional
-
+from typing import Optional
 from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
 
-
-# User Authentication Models
 class UserRegister(BaseModel):
     email: EmailStr = Field(..., description="Valid email address")
-    username: str = Field(
-        ..., min_length=3, max_length=50, description="Username (3-50 characters)"
-    )
-    password: str = Field(
-        ..., min_length=6, description="Password (minimum 6 characters)"
-    )
+    username: str = Field(..., description="Username")
+    password: str = Field(..., description="Password")
+    # Keep security validation in Pydantic for auth
 
     @field_validator("username")
     @classmethod
     def validate_username(cls, v):
         if not re.match(r"^[a-zA-Z0-9_]+$", v):
-            raise ValueError(
-                "Username must contain only letters, numbers, or underscores"
-            )
+            raise ValueError("Username must contain only letters, numbers, or underscores")
         return v.lower().strip()
 
     @field_validator("password")
@@ -31,7 +24,6 @@ class UserRegister(BaseModel):
             raise ValueError("Password must be at least 6 characters long")
         return v
 
-
 class UserLogin(BaseModel):
     username: str = Field(..., description="Username")
     password: str = Field(..., description="Password")
@@ -41,10 +33,8 @@ class UserLogin(BaseModel):
     def validate_username(cls, v):
         return v.strip()
 
-
 class UserResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
-
     id: int
     email: str
     username: str
@@ -54,7 +44,6 @@ class UserResponse(BaseModel):
     created_at: datetime
     updated_at: datetime
 
-
 class LoginResponse(BaseModel):
     access_token: str
     token_type: str = "bearer"
diff --git a/models/schemas/marketplace.py b/models/schemas/marketplace.py
index f071b190..90fe14ed 100644
--- a/models/schemas/marketplace.py
+++ b/models/schemas/marketplace.py
@@ -1,58 +1,34 @@
-import re
+# marketplace.py - Keep URL validation, remove business constraints
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
-
-
-# Marketplace Import Models
 class MarketplaceImportRequest(BaseModel):
     url: str = Field(..., description="URL to CSV file from marketplace")
-    marketplace: str = Field(
-        default="Letzshop",
-        description="Name of the marketplace (e.g., Letzshop, Amazon, eBay)",
-    )
+    marketplace: str = Field(default="Letzshop", description="Marketplace name")
     shop_code: str = Field(..., description="Shop code to associate products with")
-    batch_size: Optional[int] = Field(
-        1000, gt=0, le=10000, description="Batch size for processing"
-    )
+    batch_size: Optional[int] = Field(1000, description="Processing batch size")
+    # Removed: gt=0, le=10000 constraints - let service handle
 
     @field_validator("url")
     @classmethod
     def validate_url(cls, v):
+        # Keep URL format validation for security
         if not v.startswith(("http://", "https://")):
             raise ValueError("URL must start with http:// or https://")
         return v
 
-    @field_validator("marketplace")
+    @field_validator("marketplace", "shop_code")
     @classmethod
-    def validate_marketplace(cls, v):
-        # You can add validation for supported marketplaces here
-        supported_marketplaces = [
-            "Letzshop",
-            "Amazon",
-            "eBay",
-            "Etsy",
-            "Shopify",
-            "Other",
-        ]
-        if v not in supported_marketplaces:
-            # For now, allow any marketplace but log it
-            pass
+    def validate_strings(cls, v):
         return v.strip()
 
-    @field_validator("shop_code")
-    @classmethod
-    def validate_shop_code(cls, v):
-        return v.upper().strip()
-
-
 class MarketplaceImportJobResponse(BaseModel):
     job_id: int
     status: str
     marketplace: str
     shop_id: int
-    shop_code: Optional[str] = None  # Will be populated from shop relationship
+    shop_code: Optional[str] = None
     shop_name: str
     message: Optional[str] = None
     imported: Optional[int] = 0
diff --git a/models/schemas/product.py b/models/schemas/product.py
index ee92eb1b..110171ad 100644
--- a/models/schemas/product.py
+++ b/models/schemas/product.py
@@ -1,12 +1,9 @@
-import re
+# product.py - Simplified validation
 from datetime import datetime
 from typing import List, Optional
-
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
-
+from pydantic import BaseModel, ConfigDict, Field
 from models.schemas.stock import StockSummaryResponse
 
-
 class ProductBase(BaseModel):
     product_id: Optional[str] = None
     title: Optional[str] = None
@@ -45,42 +42,30 @@ class ProductBase(BaseModel):
     identifier_exists: Optional[str] = None
     shipping: Optional[str] = None
     currency: Optional[str] = None
-    # New marketplace fields
     marketplace: Optional[str] = None
     shop_name: Optional[str] = None
 
-
 class ProductCreate(ProductBase):
-    product_id: str = Field(..., min_length=1, description="Product ID is required")
-    title: str = Field(..., min_length=1, description="Title is required")
-
-    @field_validator("product_id", "title")
-    @classmethod
-    def validate_required_fields(cls, v):
-        if not v or not v.strip():
-            raise ValueError("Field cannot be empty")
-        return v.strip()
-
+    product_id: str = Field(..., description="Product identifier")
+    title: str = Field(..., description="Product title")
+    # Removed: min_length constraints and custom validators
+    # Service will handle empty string validation with proper domain exceptions
 
 class ProductUpdate(ProductBase):
     pass
 
-
 class ProductResponse(ProductBase):
     model_config = ConfigDict(from_attributes=True)
-
     id: int
     created_at: datetime
     updated_at: datetime
 
-
 class ProductListResponse(BaseModel):
     products: List[ProductResponse]
     total: int
     skip: int
     limit: int
 
-
 class ProductDetailResponse(BaseModel):
     product: ProductResponse
     stock_info: Optional[StockSummaryResponse] = None
diff --git a/models/schemas/shop.py b/models/schemas/shop.py
index 4e308ba1..7c8142f9 100644
--- a/models/schemas/shop.py
+++ b/models/schemas/shop.py
@@ -1,51 +1,32 @@
+# shop.py - Keep basic format validation, remove business logic
 import re
 from datetime import datetime
 from typing import List, Optional
-
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
-
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from models.schemas.product import ProductResponse
 
-
 class ShopCreate(BaseModel):
-    shop_code: str = Field(
-        ...,
-        min_length=3,
-        max_length=50,
-        description="Unique shop code (e.g., TECHSTORE)",
-    )
-    shop_name: str = Field(
-        ..., min_length=1, max_length=200, description="Display name of the shop"
-    )
-    description: Optional[str] = Field(
-        None, max_length=2000, description="Shop description"
-    )
+    shop_code: str = Field(..., description="Unique shop identifier")
+    shop_name: str = Field(..., description="Display name of the shop")
+    description: Optional[str] = Field(None, description="Shop description")
     contact_email: Optional[str] = None
     contact_phone: Optional[str] = None
     website: Optional[str] = None
     business_address: Optional[str] = None
     tax_number: Optional[str] = None
-
-    @field_validator("shop_code")
-    def validate_shop_code(cls, v):
-        # Convert to uppercase and check format
-        v = v.upper().strip()
-        if not v.replace("_", "").replace("-", "").isalnum():
-            raise ValueError(
-                "Shop code must be alphanumeric (underscores and hyphens allowed)"
-            )
-        return v
+    # Removed: min_length, max_length constraints - let service handle
 
     @field_validator("contact_email")
+    @classmethod
     def validate_contact_email(cls, v):
+        # Keep basic format validation for data integrity
         if v and ("@" not in v or "." not in v):
             raise ValueError("Invalid email format")
         return v.lower() if v else v
 
-
 class ShopUpdate(BaseModel):
-    shop_name: Optional[str] = Field(None, min_length=1, max_length=200)
-    description: Optional[str] = Field(None, max_length=2000)
+    shop_name: Optional[str] = None
+    description: Optional[str] = None
     contact_email: Optional[str] = None
     contact_phone: Optional[str] = None
     website: Optional[str] = None
@@ -53,15 +34,14 @@ class ShopUpdate(BaseModel):
     tax_number: Optional[str] = None
 
     @field_validator("contact_email")
+    @classmethod
     def validate_contact_email(cls, v):
         if v and ("@" not in v or "." not in v):
             raise ValueError("Invalid email format")
         return v.lower() if v else v
 
-
 class ShopResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
-
     id: int
     shop_code: str
     shop_name: str
@@ -77,40 +57,27 @@ class ShopResponse(BaseModel):
     created_at: datetime
     updated_at: datetime
 
-
 class ShopListResponse(BaseModel):
     shops: List[ShopResponse]
     total: int
     skip: int
     limit: int
 
-
 class ShopProductCreate(BaseModel):
     product_id: str = Field(..., description="Product ID to add to shop")
-    shop_product_id: Optional[str] = Field(
-        None, description="Shop's internal product ID"
-    )
-    shop_price: Optional[float] = Field(
-        None, ge=0, description="Shop-specific price override"
-    )
-    shop_sale_price: Optional[float] = Field(
-        None, ge=0, description="Shop-specific sale price"
-    )
-    shop_currency: Optional[str] = Field(None, description="Shop-specific currency")
-    shop_availability: Optional[str] = Field(
-        None, description="Shop-specific availability"
-    )
-    shop_condition: Optional[str] = Field(None, description="Shop-specific condition")
+    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, ge=1, description="Minimum order quantity")
-    max_quantity: Optional[int] = Field(
-        None, ge=1, description="Maximum order quantity"
-    )
-
+    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: ProductResponse
diff --git a/models/schemas/stock.py b/models/schemas/stock.py
index c0af5c78..8c27699e 100644
--- a/models/schemas/stock.py
+++ b/models/schemas/stock.py
@@ -1,31 +1,26 @@
-import re
+# stock.py - Remove business logic validation constraints
 from datetime import datetime
 from typing import List, Optional
+from pydantic import BaseModel, ConfigDict, Field
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
-
-
-# Stock Models
 class StockBase(BaseModel):
-    gtin: str = Field(..., min_length=1, description="GTIN is required")
-    location: str = Field(..., min_length=1, description="Location is required")
-
+    gtin: str = Field(..., description="GTIN identifier")
+    location: str = Field(..., description="Storage location")
 
 class StockCreate(StockBase):
-    quantity: int = Field(ge=0, description="Quantity must be non-negative")
-
+    quantity: int = Field(..., description="Initial stock quantity")
+    # Removed: ge=0 constraint - let service handle negative validation
 
 class StockAdd(StockBase):
-    quantity: int = Field(gt=0, description="Quantity to add must be positive")
-
+    quantity: int = Field(..., description="Quantity to add/remove")
+    # Removed: gt=0 constraint - let service handle zero/negative validation
 
 class StockUpdate(BaseModel):
-    quantity: int = Field(ge=0, description="Quantity must be non-negative")
-
+    quantity: int = Field(..., description="New stock quantity")
+    # Removed: ge=0 constraint - let service handle negative validation
 
 class StockResponse(BaseModel):
     model_config = ConfigDict(from_attributes=True)
-
     id: int
     gtin: str
     location: str
@@ -33,12 +28,10 @@ class StockResponse(BaseModel):
     created_at: datetime
     updated_at: datetime
 
-
 class StockLocationResponse(BaseModel):
     location: str
     quantity: int
 
-
 class StockSummaryResponse(BaseModel):
     gtin: str
     total_quantity: int
diff --git a/tests/.coverage b/tests/.coverage
index 7451e62260496862ebfd23ac4b20d9e679034aa2..4c3e319ba3837b7a311f24d7427b8d523161c38f 100644
GIT binary patch
literal 53248
zcmeI5eQ+Dcb-?#NfCF%cTaXk<krc@jC5m4l36SEaESZw6KQz&do!GV2mNo=}M-nFS
zAsi@5ieizmr%s#6cqVa@ril~Jw3gG<({MCR$L**NooL3Lq_UG~D@#))){N6e(+|gK
z)I^Rfv2Pc5zyZ>M=wE5%y&>`T_V(?2``fp-y8sV-=%WYYSzVh+WfIY>Hi!a<<Iser
zA%wi}>xW<KkRTyiCm=an+9~NpeKF3DA3=)yGYCKKe*pI?U-9pdf2bt9e<XiZih5&k
zfgOwhBftnS0v~PyD<4&)`i2JXlb^^&rxx^VCK}T-xmW*vAKSn8;r-gfd-omOujTTz
zPM-!xZ?Cpj%cPdHw4Tvs;tRSKPfo{U(QG_9t7YeOtMsCwPm_rb@?feX1^cKzNk!t*
zpq15Up^9`So``0SYxDZ?AT3~8%j(CnxeTa8kIyDa39Zvq@6s~*jGobxG2O^{(HWoa
z@^w9R$|u#=)Ns$}v`x`W41VOI)<8y~DF<etqF5?3O}wAVM3b>O-3V&Yd<$bK@bg$U
z*V;@f(VtCe3-KgvX3~gf<Ef;kAJb!tS$+DB4Ga=!)&cPBt%14@lLj5mX_~fdbPCFM
z&@_vi$}`|xGG$>cC=%14Onpu+CZ+)S6N`y7=^W6=8P2AhG@W#_DYLN^_st#pve4e5
z?zE7T9?fYjCgVpI^?c_CwSs1lHY1q|YNQbm0qwH8eyoN=5S98d<H!Q6w<6KSY>J*o
zpz|YPcu}6N@<{cqt=uz5XrK^0k*Rpr$S1r-L6gsR2pw|WIc~@(DGm}ciWU~M)C?Um
zL|e;s4n(tk%=B9@q8T#Kw3Jy8JpGME8*vtV(54nrQ^m1HBgW8SfWW=LDmJs2jFF*Y
zkT%3pNA*l}R_`;f=57nW=|F<e347i3`&*qtCm#Zla6ai<X>d#RO-<Y<y)=x>-ZF($
z6hc-{-r+WCT}tRtV=-ghNXp$LEserm(i$V?6=+Vc<gVY_<kTFqTqJBJJS&nY)z{W?
zE4dLt?n~s?Rn!QQQy2mz6G7$fr=!_9?RMWuHaOnla@X&wb#k1z5DAl4_fx;mQ<tA<
zp!5@P(<i?|k;^2f;POZG<Gn|t3vf3{N8=e7vTzU1%>WuHI30z;(W%s8mc}nRrQu2D
zo`S!*3JT{IdnnaKi^K4KFl88Vm{!TOWsF<7TE|?}Aa^07Lz_ya7W8N`H#dOB0RwEt
z4UPJ6`>b?tp$_9XsbltN2ldICT*z(yVHkAQ_<}?t5lv2;^A(wfbG5>~pA1f7CwCJ8
zMXdt{r2#{<q)w|+^D4PxS@rj&feEQK5uMHrchV`g8kgqu+p5dWM)yavdN!WWHBy8+
zLj!9mYG|>H4i{lA?dlN9g#qcUNSM5mU9yKP<yKlbslKO&TUj&*W9~i^F<??pL@l??
zQ@$ujN-h@S<pH?i!fMAJCxo312RY4IAUC&M4^HJMSf$Lhj<1Vs@Hu<~!4Eqa0Y-ok
zU<4QeMt~7u1Q-EEfDvE>7y(A$?js;@JSUO;KaZ~<{4Tt(gArf^7y(9r5nu!u0Y-ok
zU<4QeMt~7u1b!<CD7?^&t-tUH1vsIp!TcM5k-l)KZ`cQ|;_+34uj2ptt!yB3nh{_G
z7y(9r5nu!u0Y-okU<4QeMt~7u1o8wFp_#MZ2H<@{lh=F~fPDVHOPoje0)7b}!ym!T
z>MzvqsL!cSsJm5<|1JM%f5t!I$I4sEi^?%&pAwLNEdRNDRK8!9eHVN$`m(+WpX&XQ
z_eHPa-Q$%#|L8gGNqKfjH>LB^=OtYVxo^79yFcfiboaZiyT0f8tZUj86mN=eieCn^
z>|g{Kfe#0PzFh)}?H`{!sAo?YbE$OifkZl$$@U%%Pe#+}$;E7Z!I&hEfK5dW9UkQx
z7#GmIb9wz(Oi$BCI49@enX&~v13JMm0Y#j3;JIpjav?Q43lCRA>E2NRMK>xPpV5tU
zGzrCrM+9Uz7dQ0G(KtN)J!xc9vH6I3N}L)l>r^xyp9BU}i&z<|)JimK*sbiW%nE3M
zm7zfa9jT-(&`~xcJp%%I%vsH93Mdg9;j%Ug9Ue(%QUK1#^~z{SKugXx@|ZzsdNG!@
zdDqupHo{ErOg(Tg+$W&;oh>Ee(-2Zi@R0N5G<h69noVU0x4~WkCGM<J2;!J=)M`?S
zL}g#FtY0}0kw`ol&qg9pez>P>2xOziyfHZyjm^(yQj5vy2+bgNy35+h>Dlbu(<Pu&
z&W*{FhOa}I*R$yb_&Np~?Sam+<I|*V(*+NQI?9Gb-Xc67KW8)5v!jx*BT9r`ds%t~
z8`Ft+(q<&Q-7y+S*XH$X00*}@MuRPYAb9l1LOcNv{*!13wFzkU&eRjBX&r8YxraB&
zjU+c%hqpSms6?ZfcE2Vdy)sL=5gTf)+%>qzL1PA59D|_5wZgFLZ?4oWvq$^4RH|T3
z9fM8I{ZfqB)|n%X0$MCf%bJ`fi!p~9HlmhSB=a6n3vYG|HIrIFgG?r%GFZP+lkzGB
z(xJMFJ%evYp}|>Ov4+Wd=OzKAD#K=j-BaT@qD=y}!l7zMr^v{(tpuWEOaraqD#sC1
zqEXzH{Q<{FE73E1GK4F2&6?i_RL2ohVxrKG{r*bbvPO(jse(0PWXJF-@ygaOJwE47
zEX<##OPyW;J$mOjAr{DVF|DV`92@jhvXZg7x?d{WRC5}#dEM#W(2+!xMp4kUp(D0>
zdqhVXq=9tp314k76Q@g0VdJHzHJ|}WFTZhdn=74M*(TablF$Eli3<q7g<I5l^_u!!
z_4A&WJomWYaEDyqcj@@+_#i$m-V%SHdX>}um;4vSuP7J&hCkrn>s37e<Vj1n+|Rk*
zcYV&)E4?9oL7I`m?#ILhb&va&_g>|=a-UKqEAltw{qmChw(l+9qVKf#v~REX$KI?D
ze>gTitd)!aBY;r95aXODfWmgroRW483iD;k+h+a3{(rnzh?LPO+5eCA3DFHp7xw?7
zBZ5(;cz%OWy8j<3@02-1S?dFMm!U!{#ryxE3a#X}6g!87BNer!c>g~b6do(1W;G?Z
z${i?gqtM~jW;wV25042;Wo+azo695H4lYza!c6aM%c=n(?qJEbeJk4k_w5uC4k~1l
z&$X#^|KD5QuiN(j!SW&Cxc~1dZ|AoCfA?<TRGG%)N!!-QHrid~$EQi#rVHzs&hjCV
zw@B8EHd7rHg`K(3+)<uh!A8mczuh?+NZ01|Y^$g3&e32CppyOnwy-ekK)qzkZ0-Ns
zoLf|)QA~SlNYE>^lpC?y|G~A~wzSnb2ufTl47-+!-7<T$xnc!#>ey1IUmW-UO{2nM
zd0N(jyk!61xFNN?qPc5qa1J$-T0z6y|8L%~NqLn5>H5k&Gxz^>m1~%+YlnnXh1hH(
zXOr`YHVN1Y*El;xMy72gU~LMkokvWGM)8QLa*nhTJ+mhR6}x85@7Q_7l$a>=qgt_B
z=7{lEtYG${;v8NjUfKFZF4Kv(?f-pU!lMpxLM)K!!rcFRD_Y4|UF|8~RC5}#c`a@1
zh`IlFZ|sPzUY9cs(!k>VzgWT2(;Cn)ZweI@x4FW13Xgi7m)f?H?EC-N&WsUY1Q-EE
zfDvE>7y(9r5nu!u0Y-okxT^^W@J9lE^7%i9KS1!q4n}|xU<4QeMt~7u1Q-EEfDvE>
z7y(9r5x5Hp2!h{BKK~z=w;}vK{yBaJU&24ce~Vwn&*6{b8T>K48xP@j+=yN34fU$}
zef4kDKUPnwlj;GrU)`(*{Qu%V>tFWY=l3ZWl|N9PRI<u~vR?@*0Y#MmTfQp4Enkpd
zm%k<dsr*Ix)AEXJ$Z>g6J}8gL{a}<Gi~u9R2rvSS03*N%FanIg|33o0agp=ZwO&5|
z58uAw8H03nTi^Q0s!>R7*G{gFU0=Gs{;Qi`TVGd4AgiV2>^dB$UVrsx@-Uol-g^0`
zS3X!5JVQitOZUfzm7S1kY(D$b^eeymHuemX{HC8g!1)FsRae)2Y5frA3zPKb?n{5S
z?b$#G(rpdhm!2OSeD?XT4G!W!Kgp?wl5o5^{_16qzYlV@G<IM5(Puhllf2Xmr-9n;
zT~d%FHeHiFJ&>rb`AG*C=!R6=Ht}q530Q0JpUQn*kW<$uj{YlB8ap99>=V!SKX~S^
zzwy=kpEz~mPyX<I^z{QA+FRcN*Fs@&@^?AfOX7tkLwg5Z=h}C`g@e7~*+(DwonPMo
zpV|WmO~4n6gFxsCc|qvcoVy*0sX^Ye9b|Qn_@4vrZ6v3gf3VHPc~`U%G3~l~hI}Lm
z$1;6Ih}HpVEq6{$UlZU&A{pdgt&`u}3m@<xp6B-=KC~5To*EKYAFCr*m&psQf<ru{
z0vxYREH5u3ei>;`2ljck21Yc{NDqpuuJ_K6>f!i7D|w|3Y#}N1!YL|5Bx+h<8Eu{L
z1ommWT0!wxNW5Nm{mdgPOQD7}PSX&&nR~i<f@&b*Hu3YD)N7JAfkY8;<1L_kv`c&i
z8cuT8X!{T~ca4@cb1W}ZQi`^iZ*B(Ndpg8Juj#cU7d(CCQ*Ke*5(sGfJmTOMxIEV`
zzQR9Vw`{fuY9!64B+v`@k|b0%0YM=01cb-k1WM|5zP1r$5T6U8Ll_;B&;@RdUv?eZ
z+yL1FfpbVkb*sy+Amj&;yb2|%Hp7+e>bc+=e}Q}X%U^UIl3MB^YfsfV^dB6kqL(EE
zWy$5k&FC<9m}{(q>%-&XYR{L}kGK(1h&OA{S(=A$t%Yk7ium^@B0pPwch4bdRb6dC
zhno*KublvE%dWsCDA49V7hGNA=h30VD??2+kTY6+ZrMdlt*QtVP~EbNSleAy4Hvh|
zB0qsR-h;Ra#CxhBt9neF<ZA+u>Kqj>o@pR1039BQUJRL=1o5vP@u(^!TSRfwL%cRN
zHtTi!;auhU8inW$ix(gN#cNXQ$@gBn_lne7Ekovxo#Mq;$IumR?U&~{B-Qvx!2xmZ
zoA0A_v?g8W&@G|f3z?yQ@#60D5Go%)XY6scq9?Bibso6T*C}3n@;nK^Rq2-!Qr}&{
ziUj$MJD`?^m!IWo-EbE4h^sfx<C9mUJ@2jD6xN=S+%CvgCEg=~taghJ-%<pk<`pl$
zIo9?a!OfHFF5bn7UT6auY~w0C|9=C%|L;rq1$+(v8-5#K#Q&xKJAN9c@KOAG@C^VD
z;VAxu`p@bc>g(#C!Mgx|p`KCK)aTV_)i0<k>VkSg{gi5`m+^kQ2i`##!QaCn?8k0(
zUA?ZpgTITr)Su(CxD9^`H{rj;oA77xr|}#?%??I@5nu!u0Y-okU<4QeMt~7u1Q>z4
zj{w=Qa;@W3w2e`rjZ)DvLdDi$Dz*$!(Y%w2ra>y|2B_E^rlKK4MSVXNjeS(q_ENDa
zNJUK#72CS0=<A}w*GWaVgNoiAR0P|p=-Ez1_ckg<+Nc=XO2wc?MW~gEt`;gfnyF~t
zLdEtbDsUqefd(qn%~Vv?Q!!pgg+jOPoPQHNtFEC!hP^uA8LOgVG(d%bsSs5vcs~`x
z3KctLDh7O1^n0o3^iZ)wqQc{*LUK{z7OC(GRJeE%-T<JV|L5OgyZb_pwTKa51Q-EE
zfDvE>7y(9r5nu!u0Y-okU<7~w{bL*JPiz<wMt~7u1Q-EEfDvE>7y(9r5nu!u0Y-ok
sxGM>e=l|K~|955AvPLlii~u9R2rvSS03*N%FanGKBftnS0(k=e3(7hRNB{r;

delta 2001
zcmZXVdr(x@9mnt8dt`U-<D7l5u<r+`^}!-2yH*3*8CbA2Bs1lyH0u@-R~8}cB03S5
z*7l!vf*nt*aT=>8<Ji$OCdIUk;8dDSl4<O2Yzi91kxn!V(V9?93WB@+?M)n;=|A^#
z&hK%4-*dlncl(ZWeaE@i(E9J@sY@6#N=}j8<a@-1r}1C#FYyjsiq+CTq!Us|S|dr~
zsQ8k&Ra_;^3-1dr2-^h@KgY-U!+eM@;yLyE>KD~J)g=R3O;WYMm&Y;Pw5TFaA8POH
z=!ym+EnT}p%`KkJJ<Hwna(MykqUmxE>!h9vAM1dKjaK_r>S#xE8`OC15dRh(svxZG
zaV{8*K(53}pRHO%oqi2#p+){>iXt;j`%UyYzX_Q*rYAF%4*K<ME=~9g*&Ij~DGH5L
z`=p6JRcTasv*BzTJy&UF4Kz_%$m(gjvJ~k!rVU!nAVaBX4|cV+L_5PlS#gOLCVE*7
zOv_gXyQAAdMF9c*CVFv$k_0<Lf%cBAE#ZthFNV_>(YY!uE6K9@DiQ6kQcHnAXlE!I
z2tdtBk*?pcazU~1)ktIJl!F^p;^R}6@i5Co8#f38&DAGZu*b`gE5wf5@O}Ii{*{Eq
zmxU0Y;CJwd{FZDad(=nO9nwqE4)KcGE4B!Q{0n@s`jS{8Jj7+f5ottPi+SM^KM(dy
zsJPW!H)R|0b^m8h9{r%EfOXSUjR(1WTqILPYbrEg)CV>8j77rN7C9be&qLP!D65Ko
zWs;3{HY^5@2y3M)>Xsu*F&Cn2ZH~1&8VX06wg#iYKxbD+b4w%=+Sv;4#QbfpM;<ol
z*RduVuPX%qQgy}PpXLYVjB&`AnRvP0MbB62*=!oGF9ZWq^`&6ocQ%=6=0$^d<eT2<
zK!}&sf{2B}*Vbt~T#){=(XRc5apci`=BhLZ%W@m?#s6_lqDA#)u*A%YFwX^s36BjE
zU_d4bem!%-Rpk~Z88S<z$Srb>{GFU9XGlNkBn_mB6p)2PN0fLLe}<FzZTt%UDc*ut
zVXZVFjZ1Oqb?Kx;rOi^Y#EO&P)=@ELbR$;nF{7r&;rOaA&Xz<+dm^t*mCP5qAil+j
zhU)8TAIzoG>64?kNmE)ncnJA^<eXr(ygJ<!dvK$15qgRlpJTCRu@f4e7HWQ<e*K3%
z@k>v92|ek7{z9K(?Yh=&_Q9T8+QGr8TbG{nI-qbTX&Tydzbg?-&Cayn^zV=Df0*7o
zpK1BznQiZ0zt^0Oy?ErK#OzG`j^f&M`aohf$!YA+=oZn?@}3p0XPpeA;%yKy=AfE`
z%d#z2Sg+>M(All+wf_l6-dI=qx3@o^94=YH92Yc}Olvl}TYQ*f7zVGmW|<*^4Kc-H
z6D*!~qNai~pZ@#);oj~&4>FJbj{`@y9q3*2;i<rLH!h4^$Yx!+P*`q9;TCpc`uW7W
zsYZ6@XrS(k$zPZCDy~lc@xkxhOLL&4&Wi3HvN6AC{qoHb2lL*`uP}YSdL=XT@$KE!
zcN`3JYT)!~--tHP2(?u)6B^qz`e~%KW9oGJ_W6CI&!c<0+QN632^Mr}oC~v|YNH;F
zEj_b)pgQ&DhZh<jws^{JY`(X2^G7!my$_Su{?O%B7!6S7(W3C-T4p?)8dLPyYHLSo
zD_nYrmt!<`XoT%s``H@C!~Cg-y?EgcVQ&2_kq)?HZdH~JYOthGX@NR7YEp<ASeacY
zd|hOi^=bk;1BcGlsk9iD`3M<Sf;c9BadJ7EB|!))6ebb4%7MaXhm(B?_82Ks?!`07
zA3K;bEI`U`L*bjN=alh%tdWPk$AZpXnHh@>uS=u7_bw8KnO9oXkXVz8?*8VT^mHt%
zERyK%OGKo7ab|BdJ8w}zcC`+L|NPFeyjW`G7Q$RT7E>rMmNMg<q=ckZ17}`UUiUQ^
zvoa%8pk^xa`RsV>aB_b_IhS-~Er2*yDpUxl%R)6cC2+9JRim*;|H&ul)B$~!n-~}}
z2me<`$Z>L?d_r!LtK?s#jJU}P@)OcamXOP27x^pcfFH*SVj({A7THb=WQYXG8)OrC
zm3*HZBtM4_>^&UIC}GWR8Ag{3!6}0{WQcYdIW`%*RYtZ&hQTbuX_8^jm0``1VUjP&
z>a*pY)*u7xWk_&080*$%m1pSE$XkxcKv;%ClHm|#*aR6CUPi83hE63zGjQeDk`@02
DPfcSu

diff --git a/tests/fixtures/product_fixtures.py b/tests/fixtures/product_fixtures.py
index 3efb8600..a1b7469d 100644
--- a/tests/fixtures/product_fixtures.py
+++ b/tests/fixtures/product_fixtures.py
@@ -106,3 +106,18 @@ def create_unique_product_factory():
 def product_factory():
     """Fixture that provides a product factory function"""
     return create_unique_product_factory()
+
+
+@pytest.fixture
+def test_product_with_stock(db, test_product, test_stock):
+    """Product with associated stock record."""
+    # Ensure they're linked by GTIN
+    if test_product.gtin != test_stock.gtin:
+        test_stock.gtin = test_product.gtin
+        db.commit()
+        db.refresh(test_stock)
+
+    return {
+        'product': test_product,
+        'stock': test_stock
+    }
diff --git a/tests/integration/api/v1/test_auth_endpoints.py b/tests/integration/api/v1/test_auth_endpoints.py
index 46b2c395..dd41d40d 100644
--- a/tests/integration/api/v1/test_auth_endpoints.py
+++ b/tests/integration/api/v1/test_auth_endpoints.py
@@ -322,18 +322,3 @@ class TestAuthManager:
 
         assert user is None
 
-    def test_authenticate_user_inactive(self, auth_manager, db, test_user):
-        """Test user authentication with inactive user"""
-        # Deactivate user
-        original_status = test_user.is_active
-        test_user.is_active = False
-        db.commit()
-
-        try:
-            user = auth_manager.authenticate_user(db, test_user.username, "testpass123")
-            assert user is None  # Should return None for inactive users
-
-        finally:
-            # Restore original status
-            test_user.is_active = original_status
-            db.commit()
diff --git a/tests/integration/api/v1/test_filtering.py b/tests/integration/api/v1/test_filtering.py
index f75b3040..f6919afa 100644
--- a/tests/integration/api/v1/test_filtering.py
+++ b/tests/integration/api/v1/test_filtering.py
@@ -8,13 +8,17 @@ from models.database.product import Product
 @pytest.mark.api
 @pytest.mark.products
 class TestFiltering:
-    def test_product_brand_filter(self, client, auth_headers, db):
-        """Test filtering products by brand"""
-        # Create products with different brands
+
+    def test_product_brand_filter_success(self, client, auth_headers, db):
+        """Test filtering products by brand successfully"""
+        # Create products with different brands using unique IDs
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
         products = [
-            Product(product_id="BRAND1", title="Product 1", brand="BrandA"),
-            Product(product_id="BRAND2", title="Product 2", brand="BrandB"),
-            Product(product_id="BRAND3", title="Product 3", brand="BrandA"),
+            Product(product_id=f"BRAND1_{unique_suffix}", title="Product 1", brand="BrandA"),
+            Product(product_id=f"BRAND2_{unique_suffix}", title="Product 2", brand="BrandB"),
+            Product(product_id=f"BRAND3_{unique_suffix}", title="Product 3", brand="BrandA"),
         ]
 
         db.add_all(products)
@@ -24,45 +28,63 @@ class TestFiltering:
         response = client.get("/api/v1/product?brand=BrandA", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 2
+        assert data["total"] >= 2  # At least our test products
+
+        # Verify all returned products have BrandA
+        for product in data["products"]:
+            if product["product_id"].endswith(unique_suffix):
+                assert product["brand"] == "BrandA"
 
         # Filter by BrandB
         response = client.get("/api/v1/product?brand=BrandB", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 1
+        assert data["total"] >= 1  # At least our test product
+
+    def test_product_marketplace_filter_success(self, client, auth_headers, db):
+        """Test filtering products by marketplace successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
 
-    def test_product_marketplace_filter(self, client, auth_headers, db):
-        """Test filtering products by marketplace"""
         products = [
-            Product(product_id="MKT1", title="Product 1", marketplace="Amazon"),
-            Product(product_id="MKT2", title="Product 2", marketplace="eBay"),
-            Product(product_id="MKT3", title="Product 3", marketplace="Amazon"),
+            Product(product_id=f"MKT1_{unique_suffix}", title="Product 1", marketplace="Amazon"),
+            Product(product_id=f"MKT2_{unique_suffix}", title="Product 2", marketplace="eBay"),
+            Product(product_id=f"MKT3_{unique_suffix}", title="Product 3", marketplace="Amazon"),
         ]
 
         db.add_all(products)
         db.commit()
 
-        response = client.get(
-            "/api/v1/product?marketplace=Amazon", headers=auth_headers
-        )
+        response = client.get("/api/v1/product?marketplace=Amazon", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 2
+        assert data["total"] >= 2  # At least our test products
+
+        # Verify all returned products have Amazon marketplace
+        amazon_products = [p for p in data["products"] if p["product_id"].endswith(unique_suffix)]
+        for product in amazon_products:
+            assert product["marketplace"] == "Amazon"
+
+    def test_product_search_filter_success(self, client, auth_headers, db):
+        """Test searching products by text successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
 
-    def test_product_search_filter(self, client, auth_headers, db):
-        """Test searching products by text"""
         products = [
             Product(
-                product_id="SEARCH1", title="Apple iPhone", description="Smartphone"
+                product_id=f"SEARCH1_{unique_suffix}",
+                title=f"Apple iPhone {unique_suffix}",
+                description="Smartphone"
             ),
             Product(
-                product_id="SEARCH2",
-                title="Samsung Galaxy",
+                product_id=f"SEARCH2_{unique_suffix}",
+                title=f"Samsung Galaxy {unique_suffix}",
                 description="Android phone",
             ),
             Product(
-                product_id="SEARCH3", title="iPad Tablet", description="Apple tablet"
+                product_id=f"SEARCH3_{unique_suffix}",
+                title=f"iPad Tablet {unique_suffix}",
+                description="Apple tablet"
             ),
         ]
 
@@ -70,35 +92,38 @@ class TestFiltering:
         db.commit()
 
         # Search for "Apple"
-        response = client.get("/api/v1/product?search=Apple", headers=auth_headers)
+        response = client.get(f"/api/v1/product?search=Apple", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 2  # iPhone and iPad
+        assert data["total"] >= 2  # iPhone and iPad
 
         # Search for "phone"
-        response = client.get("/api/v1/product?search=phone", headers=auth_headers)
+        response = client.get(f"/api/v1/product?search=phone", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 2  # iPhone and Galaxy
+        assert data["total"] >= 2  # iPhone and Galaxy
+
+    def test_combined_filters_success(self, client, auth_headers, db):
+        """Test combining multiple filters successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
 
-    def test_combined_filters(self, client, auth_headers, db):
-        """Test combining multiple filters"""
         products = [
             Product(
-                product_id="COMBO1",
-                title="Apple iPhone",
+                product_id=f"COMBO1_{unique_suffix}",
+                title=f"Apple iPhone {unique_suffix}",
                 brand="Apple",
                 marketplace="Amazon",
             ),
             Product(
-                product_id="COMBO2",
-                title="Apple iPad",
+                product_id=f"COMBO2_{unique_suffix}",
+                title=f"Apple iPad {unique_suffix}",
                 brand="Apple",
                 marketplace="eBay",
             ),
             Product(
-                product_id="COMBO3",
-                title="Samsung Phone",
+                product_id=f"COMBO3_{unique_suffix}",
+                title=f"Samsung Phone {unique_suffix}",
                 brand="Samsung",
                 marketplace="Amazon",
             ),
@@ -113,4 +138,53 @@ class TestFiltering:
         )
         assert response.status_code == 200
         data = response.json()
-        assert data["total"] == 1  # Only iPhone matches both
+        assert data["total"] >= 1  # At least iPhone matches both
+
+        # Find our specific test product
+        matching_products = [p for p in data["products"] if p["product_id"].endswith(unique_suffix)]
+        for product in matching_products:
+            assert product["brand"] == "Apple"
+            assert product["marketplace"] == "Amazon"
+
+    def test_filter_with_no_results(self, client, auth_headers):
+        """Test filtering with criteria that returns no results"""
+        response = client.get(
+            "/api/v1/product?brand=NonexistentBrand123456", headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["total"] == 0
+        assert data["products"] == []
+
+    def test_filter_case_insensitive(self, client, auth_headers, db):
+        """Test that filters are case-insensitive"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        product = Product(
+            product_id=f"CASE_{unique_suffix}",
+            title="Test Product",
+            brand="TestBrand",
+            marketplace="TestMarket",
+        )
+        db.add(product)
+        db.commit()
+
+        # Test different case variations
+        for brand_filter in ["TestBrand", "testbrand", "TESTBRAND"]:
+            response = client.get(f"/api/v1/product?brand={brand_filter}", headers=auth_headers)
+            assert response.status_code == 200
+            data = response.json()
+            assert data["total"] >= 1
+
+    def test_invalid_filter_parameters(self, client, auth_headers):
+        """Test behavior with invalid filter parameters"""
+        # Test with very long filter values
+        long_brand = "A" * 1000
+        response = client.get(f"/api/v1/product?brand={long_brand}", headers=auth_headers)
+        assert response.status_code == 200  # Should handle gracefully
+
+        # Test with special characters
+        response = client.get("/api/v1/product?brand=<script>alert('test')</script>", headers=auth_headers)
+        assert response.status_code == 200  # Should handle gracefully
diff --git a/tests/integration/api/v1/test_pagination.py b/tests/integration/api/v1/test_pagination.py
index 463a7e4e..9ee325a9 100644
--- a/tests/integration/api/v1/test_pagination.py
+++ b/tests/integration/api/v1/test_pagination.py
@@ -4,20 +4,22 @@ import pytest
 from models.database.product import Product
 from models.database.shop import Shop
 
-
 @pytest.mark.integration
 @pytest.mark.api
 @pytest.mark.database
 @pytest.mark.products
-@pytest.mark.shops
 class TestPagination:
-    def test_product_pagination(self, client, auth_headers, db):
-        """Test pagination for product listing"""
+
+    def test_product_pagination_success(self, client, auth_headers, db):
+        """Test pagination for product listing successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
         # Create multiple products
         products = []
         for i in range(25):
             product = Product(
-                product_id=f"PAGE{i:03d}",
+                product_id=f"PAGE{i:03d}_{unique_suffix}",
                 title=f"Pagination Test Product {i}",
                 marketplace="PaginationTest",
             )
@@ -31,7 +33,7 @@ class TestPagination:
         assert response.status_code == 200
         data = response.json()
         assert len(data["products"]) == 10
-        assert data["total"] == 25
+        assert data["total"] >= 25  # At least our test products
         assert data["skip"] == 0
         assert data["limit"] == 10
 
@@ -42,33 +44,154 @@ class TestPagination:
         assert len(data["products"]) == 10
         assert data["skip"] == 10
 
-        # Test last page
+        # Test last page (should have remaining products)
         response = client.get("/api/v1/product?limit=10&skip=20", headers=auth_headers)
         assert response.status_code == 200
         data = response.json()
-        assert len(data["products"]) == 5  # Only 5 remaining
+        assert len(data["products"]) >= 5  # At least 5 remaining from our test set
 
-    def test_pagination_boundaries(self, client, auth_headers):
-        """Test pagination boundary conditions"""
-        # Test negative skip
+    def test_pagination_boundary_negative_skip_validation_error(self, client, auth_headers):
+        """Test negative skip parameter returns ValidationException"""
         response = client.get("/api/v1/product?skip=-1", headers=auth_headers)
-        assert response.status_code == 422  # Validation error
 
-        # Test zero limit
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "Request validation failed" in data["message"]
+        assert "validation_errors" in data["details"]
+
+    def test_pagination_boundary_zero_limit_validation_error(self, client, auth_headers):
+        """Test zero limit parameter returns ValidationException"""
         response = client.get("/api/v1/product?limit=0", headers=auth_headers)
-        assert response.status_code == 422  # Validation error
 
-        # Test excessive limit
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "Request validation failed" in data["message"]
+
+    def test_pagination_boundary_excessive_limit_validation_error(self, client, auth_headers):
+        """Test excessive limit parameter returns ValidationException"""
         response = client.get("/api/v1/product?limit=10000", headers=auth_headers)
-        assert response.status_code == 422  # Should be limited
 
-    def test_shop_pagination(self, client, admin_headers, db, test_user):
-        """Test pagination for shop listing"""
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "Request validation failed" in data["message"]
+
+    def test_pagination_beyond_available_records(self, client, auth_headers, db):
+        """Test pagination beyond available records returns empty results"""
+        # Test skip beyond available records
+        response = client.get("/api/v1/product?skip=10000&limit=10", headers=auth_headers)
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["products"] == []
+        assert data["skip"] == 10000
+        assert data["limit"] == 10
+        # total should still reflect actual count
+
+    def test_pagination_with_filters(self, client, auth_headers, db):
+        """Test pagination combined with filtering"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        # Create products with same brand for filtering
+        products = []
+        for i in range(15):
+            product = Product(
+                product_id=f"FILTPAGE{i:03d}_{unique_suffix}",
+                title=f"Filter Page Product {i}",
+                brand="FilterBrand",
+                marketplace="FilterMarket",
+            )
+            products.append(product)
+
+        db.add_all(products)
+        db.commit()
+
+        # Test first page with filter
+        response = client.get(
+            "/api/v1/product?brand=FilterBrand&limit=5&skip=0",
+            headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["products"]) == 5
+        assert data["total"] >= 15  # At least our test products
+
+        # Verify all products have the filtered brand
+        test_products = [p for p in data["products"] if p["product_id"].endswith(unique_suffix)]
+        for product in test_products:
+            assert product["brand"] == "FilterBrand"
+
+        # Test second page with same filter
+        response = client.get(
+            "/api/v1/product?brand=FilterBrand&limit=5&skip=5",
+            headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["products"]) == 5
+        assert data["skip"] == 5
+
+    def test_pagination_default_values(self, client, auth_headers):
+        """Test pagination with default values"""
+        response = client.get("/api/v1/product", headers=auth_headers)
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["skip"] == 0  # Default skip
+        assert data["limit"] == 100  # Default limit
+        assert len(data["products"]) <= 100  # Should not exceed limit
+
+    def test_pagination_consistency(self, client, auth_headers, db):
+        """Test pagination consistency across multiple requests"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        # Create products with predictable ordering
+        products = []
+        for i in range(10):
+            product = Product(
+                product_id=f"CONSIST{i:03d}_{unique_suffix}",
+                title=f"Consistent Product {i:03d}",
+                marketplace="ConsistentMarket",
+            )
+            products.append(product)
+
+        db.add_all(products)
+        db.commit()
+
+        # Get first page
+        response1 = client.get("/api/v1/product?limit=5&skip=0", headers=auth_headers)
+        assert response1.status_code == 200
+        first_page_ids = [p["product_id"] for p in response1.json()["products"]]
+
+        # Get second page
+        response2 = client.get("/api/v1/product?limit=5&skip=5", headers=auth_headers)
+        assert response2.status_code == 200
+        second_page_ids = [p["product_id"] for p in response2.json()["products"]]
+
+        # Verify no overlap between pages
+        overlap = set(first_page_ids) & set(second_page_ids)
+        assert len(overlap) == 0, "Pages should not have overlapping products"
+
+    def test_shop_pagination_success(self, client, admin_headers, db, test_user):
+        """Test pagination for shop listing successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
         # Create multiple shops for pagination testing
+        from models.database.shop import Shop
         shops = []
         for i in range(15):
             shop = Shop(
-                shop_code=f"PAGESHOP{i:03d}",
+                shop_code=f"PAGESHOP{i:03d}_{unique_suffix}",
                 shop_name=f"Pagination Shop {i}",
                 owner_id=test_user.id,
                 is_active=True,
@@ -78,9 +201,9 @@ class TestPagination:
         db.add_all(shops)
         db.commit()
 
-        # Test first page
+        # Test first page (assuming admin endpoint exists)
         response = client.get(
-            "/api/v1/admin/shops?limit=5&skip=0", headers=admin_headers
+            "/api/v1/shop?limit=5&skip=0", headers=admin_headers
         )
         assert response.status_code == 200
         data = response.json()
@@ -88,3 +211,106 @@ class TestPagination:
         assert data["total"] >= 15  # At least our test shops
         assert data["skip"] == 0
         assert data["limit"] == 5
+
+    def test_stock_pagination_success(self, client, auth_headers, db):
+        """Test pagination for stock listing successfully"""
+        import uuid
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        # Create multiple stock entries
+        from models.database.stock import Stock
+        stocks = []
+        for i in range(20):
+            stock = Stock(
+                gtin=f"123456789{i:04d}",
+                location=f"LOC_{unique_suffix}_{i}",
+                quantity=10 + i,
+            )
+            stocks.append(stock)
+
+        db.add_all(stocks)
+        db.commit()
+
+        # Test first page
+        response = client.get("/api/v1/stock?limit=8&skip=0", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 8
+
+        # Test second page
+        response = client.get("/api/v1/stock?limit=8&skip=8", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 8
+
+    def test_pagination_performance_large_offset(self, client, auth_headers, db):
+        """Test pagination performance with large offset values"""
+        # Test with large skip value (should still be reasonable performance)
+        import time
+
+        start_time = time.time()
+        response = client.get("/api/v1/product?skip=1000&limit=10", headers=auth_headers)
+        end_time = time.time()
+
+        assert response.status_code == 200
+        assert end_time - start_time < 5.0  # Should complete within 5 seconds
+
+        data = response.json()
+        assert data["skip"] == 1000
+        assert data["limit"] == 10
+
+    def test_pagination_with_invalid_parameters_types(self, client, auth_headers):
+        """Test pagination with invalid parameter types returns ValidationException"""
+        # Test non-numeric skip
+        response = client.get("/api/v1/product?skip=invalid", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test non-numeric limit
+        response = client.get("/api/v1/product?limit=invalid", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test float values (should be converted or rejected)
+        response = client.get("/api/v1/product?skip=10.5&limit=5.5", headers=auth_headers)
+        assert response.status_code in [200, 422]  # Depends on implementation
+
+    def test_empty_dataset_pagination(self, client, auth_headers):
+        """Test pagination behavior with empty dataset"""
+        # Use a filter that should return no results
+        response = client.get(
+            "/api/v1/product?brand=NonexistentBrand999&limit=10&skip=0",
+            headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["products"] == []
+        assert data["total"] == 0
+        assert data["skip"] == 0
+        assert data["limit"] == 10
+
+    def test_exception_structure_in_pagination_errors(self, client, auth_headers):
+        """Test that pagination validation errors follow consistent exception structure"""
+        response = client.get("/api/v1/product?skip=-1", headers=auth_headers)
+
+        assert response.status_code == 422
+        data = response.json()
+
+        # Verify exception structure matches LetzShopException.to_dict()
+        required_fields = ["error_code", "message", "status_code"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        assert isinstance(data["error_code"], str)
+        assert isinstance(data["message"], str)
+        assert isinstance(data["status_code"], int)
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+
+        # Details should contain validation errors
+        if "details" in data:
+            assert isinstance(data["details"], dict)
+            assert "validation_errors" in data["details"]
diff --git a/tests/integration/api/v1/test_product_endpoints.py b/tests/integration/api/v1/test_product_endpoints.py
index f6862043..bd8c1e73 100644
--- a/tests/integration/api/v1/test_product_endpoints.py
+++ b/tests/integration/api/v1/test_product_endpoints.py
@@ -2,6 +2,9 @@
 import pytest
 
 
+@pytest.mark.integration
+@pytest.mark.api
+@pytest.mark.products
 class TestProductsAPI:
 
     def test_get_products_empty(self, client, auth_headers):
@@ -19,31 +22,34 @@ class TestProductsAPI:
 
         assert response.status_code == 200
         data = response.json()
-        assert len(data["products"]) == 1
-        assert data["total"] == 1
-        assert data["products"][0]["product_id"] == "TEST001"
+        assert len(data["products"]) >= 1
+        assert data["total"] >= 1
+        # Find our test product
+        test_product_found = any(p["product_id"] == test_product.product_id for p in data["products"])
+        assert test_product_found
 
     def test_get_products_with_filters(self, client, auth_headers, test_product):
         """Test filtering products"""
         # Test brand filter
-        response = client.get("/api/v1/product?brand=TestBrand", headers=auth_headers)
+        response = client.get(f"/api/v1/product?brand={test_product.brand}", headers=auth_headers)
         assert response.status_code == 200
-        assert response.json()["total"] == 1
+        data = response.json()
+        assert data["total"] >= 1
 
         # Test marketplace filter
-        response = client.get(
-            "/api/v1/product?marketplace=Letzshop", headers=auth_headers
-        )
+        response = client.get(f"/api/v1/product?marketplace={test_product.marketplace}", headers=auth_headers)
         assert response.status_code == 200
-        assert response.json()["total"] == 1
+        data = response.json()
+        assert data["total"] >= 1
 
         # Test search
         response = client.get("/api/v1/product?search=Test", headers=auth_headers)
         assert response.status_code == 200
-        assert response.json()["total"] == 1
+        data = response.json()
+        assert data["total"] >= 1
 
-    def test_create_product(self, client, auth_headers):
-        """Test creating a new product"""
+    def test_create_product_success(self, client, auth_headers):
+        """Test creating a new product successfully"""
         product_data = {
             "product_id": "NEW001",
             "title": "New Product",
@@ -65,11 +71,11 @@ class TestProductsAPI:
         assert data["title"] == "New Product"
         assert data["marketplace"] == "Amazon"
 
-    def test_create_product_duplicate_id(self, client, auth_headers, test_product):
-        """Test creating product with duplicate ID"""
+    def test_create_product_duplicate_id_returns_conflict(self, client, auth_headers, test_product):
+        """Test creating product with duplicate ID returns ProductAlreadyExistsException"""
         product_data = {
             "product_id": test_product.product_id,
-            "title": test_product.title,
+            "title": "Different Title",
             "description": "A new product",
             "price": "15.99",
             "brand": "NewBrand",
@@ -82,17 +88,57 @@ class TestProductsAPI:
             "/api/v1/product", headers=auth_headers, json=product_data
         )
 
-        assert response.status_code == 409  # Changed from 400 to 409
+        assert response.status_code == 409
         data = response.json()
         assert data["error_code"] == "PRODUCT_ALREADY_EXISTS"
+        assert data["status_code"] == 409
         assert test_product.product_id in data["message"]
+        assert data["details"]["product_id"] == test_product.product_id
 
-    def test_create_product_invalid_data(self, client, auth_headers):
-        """Test creating product with invalid data"""
+    def test_create_product_missing_title_validation_error(self, client, auth_headers):
+        """Test creating product without title returns ValidationException"""
+        product_data = {
+            "product_id": "VALID001",
+            "title": "",  # Empty title
+            "price": "15.99",
+        }
+
+        response = client.post(
+            "/api/v1/product", headers=auth_headers, json=product_data
+        )
+
+        assert response.status_code == 422  # Pydantic validation error
+        data = response.json()
+        assert data["error_code"] == "PRODUCT_VALIDATION_FAILED"
+        assert data["status_code"] == 422
+        assert "Product title is required" in data["message"]
+        assert data["details"]["field"] == "title"
+
+    def test_create_product_missing_product_id_validation_error(self, client, auth_headers):
+        """Test creating product without product_id returns ValidationException"""
         product_data = {
             "product_id": "",  # Empty product ID
-            "title": "New Product",
-            "price": "invalid_price",
+            "title": "Valid Title",
+            "price": "15.99",
+        }
+
+        response = client.post(
+            "/api/v1/product", headers=auth_headers, json=product_data
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "PRODUCT_VALIDATION_FAILED"
+        assert data["status_code"] == 422
+        assert "Product ID is required" in data["message"]
+        assert data["details"]["field"] == "product_id"
+
+    def test_create_product_invalid_gtin_data_error(self, client, auth_headers):
+        """Test creating product with invalid GTIN returns InvalidProductDataException"""
+        product_data = {
+            "product_id": "GTIN001",
+            "title": "GTIN Test Product",
+            "price": "15.99",
             "gtin": "invalid_gtin",
         }
 
@@ -100,12 +146,53 @@ class TestProductsAPI:
             "/api/v1/product", headers=auth_headers, json=product_data
         )
 
-        assert response.status_code == 400
+        assert response.status_code == 422
         data = response.json()
-        assert data["error_code"] in ["INVALID_PRODUCT_DATA", "PRODUCT_VALIDATION_FAILED"]
+        assert data["error_code"] == "INVALID_PRODUCT_DATA"
+        assert data["status_code"] == 422
+        assert "Invalid GTIN format" in data["message"]
+        assert data["details"]["field"] == "gtin"
 
-    def test_get_product_by_id(self, client, auth_headers, test_product):
-        """Test getting specific product"""
+    def test_create_product_invalid_price_data_error(self, client, auth_headers):
+        """Test creating product with invalid price returns InvalidProductDataException"""
+        product_data = {
+            "product_id": "PRICE001",
+            "title": "Price Test Product",
+            "price": "invalid_price",
+        }
+
+        response = client.post(
+            "/api/v1/product", headers=auth_headers, json=product_data
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_PRODUCT_DATA"
+        assert data["status_code"] == 422
+        assert "Invalid price format" in data["message"]
+        assert data["details"]["field"] == "price"
+
+    def test_create_product_request_validation_error(self, client, auth_headers):
+        """Test creating product with malformed request returns ValidationException"""
+        # Send invalid JSON structure
+        product_data = {
+            "invalid_field": "value",
+            # Missing required fields
+        }
+
+        response = client.post(
+            "/api/v1/product", headers=auth_headers, json=product_data
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "Request validation failed" in data["message"]
+        assert "validation_errors" in data["details"]
+
+    def test_get_product_by_id_success(self, client, auth_headers, test_product):
+        """Test getting specific product successfully"""
         response = client.get(
             f"/api/v1/product/{test_product.product_id}", headers=auth_headers
         )
@@ -115,17 +202,20 @@ class TestProductsAPI:
         assert data["product"]["product_id"] == test_product.product_id
         assert data["product"]["title"] == test_product.title
 
-    def test_get_nonexistent_product(self, client, auth_headers):
-        """Test getting nonexistent product"""
+    def test_get_nonexistent_product_returns_not_found(self, client, auth_headers):
+        """Test getting nonexistent product returns ProductNotFoundException"""
         response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
 
         assert response.status_code == 404
         data = response.json()
         assert data["error_code"] == "PRODUCT_NOT_FOUND"
+        assert data["status_code"] == 404
         assert "NONEXISTENT" in data["message"]
+        assert data["details"]["resource_type"] == "Product"
+        assert data["details"]["identifier"] == "NONEXISTENT"
 
-    def test_update_product(self, client, auth_headers, test_product):
-        """Test updating product"""
+    def test_update_product_success(self, client, auth_headers, test_product):
+        """Test updating product successfully"""
         update_data = {"title": "Updated Product Title", "price": "25.99"}
 
         response = client.put(
@@ -139,8 +229,8 @@ class TestProductsAPI:
         assert data["title"] == "Updated Product Title"
         assert data["price"] == "25.99"
 
-    def test_update_nonexistent_product(self, client, auth_headers):
-        """Test updating nonexistent product"""
+    def test_update_nonexistent_product_returns_not_found(self, client, auth_headers):
+        """Test updating nonexistent product returns ProductNotFoundException"""
         update_data = {"title": "Updated Product Title"}
 
         response = client.put(
@@ -152,10 +242,14 @@ class TestProductsAPI:
         assert response.status_code == 404
         data = response.json()
         assert data["error_code"] == "PRODUCT_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert "NONEXISTENT" in data["message"]
+        assert data["details"]["resource_type"] == "Product"
+        assert data["details"]["identifier"] == "NONEXISTENT"
 
-    def test_update_product_invalid_data(self, client, auth_headers, test_product):
-        """Test updating product with invalid data"""
-        update_data = {"title": "", "price": "invalid_price"}
+    def test_update_product_empty_title_validation_error(self, client, auth_headers, test_product):
+        """Test updating product with empty title returns ProductValidationException"""
+        update_data = {"title": ""}
 
         response = client.put(
             f"/api/v1/product/{test_product.product_id}",
@@ -163,12 +257,49 @@ class TestProductsAPI:
             json=update_data,
         )
 
-        assert response.status_code == 400
+        assert response.status_code == 422
         data = response.json()
-        assert data["error_code"] in ["INVALID_PRODUCT_DATA", "PRODUCT_VALIDATION_FAILED"]
+        assert data["error_code"] == "PRODUCT_VALIDATION_FAILED"
+        assert data["status_code"] == 422
+        assert "Product title cannot be empty" in data["message"]
+        assert data["details"]["field"] == "title"
 
-    def test_delete_product(self, client, auth_headers, test_product):
-        """Test deleting product"""
+    def test_update_product_invalid_gtin_data_error(self, client, auth_headers, test_product):
+        """Test updating product with invalid GTIN returns InvalidProductDataException"""
+        update_data = {"gtin": "invalid_gtin"}
+
+        response = client.put(
+            f"/api/v1/product/{test_product.product_id}",
+            headers=auth_headers,
+            json=update_data,
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_PRODUCT_DATA"
+        assert data["status_code"] == 422
+        assert "Invalid GTIN format" in data["message"]
+        assert data["details"]["field"] == "gtin"
+
+    def test_update_product_invalid_price_data_error(self, client, auth_headers, test_product):
+        """Test updating product with invalid price returns InvalidProductDataException"""
+        update_data = {"price": "invalid_price"}
+
+        response = client.put(
+            f"/api/v1/product/{test_product.product_id}",
+            headers=auth_headers,
+            json=update_data,
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_PRODUCT_DATA"
+        assert data["status_code"] == 422
+        assert "Invalid price format" in data["message"]
+        assert data["details"]["field"] == "price"
+
+    def test_delete_product_success(self, client, auth_headers, test_product):
+        """Test deleting product successfully"""
         response = client.delete(
             f"/api/v1/product/{test_product.product_id}", headers=auth_headers
         )
@@ -176,15 +307,44 @@ class TestProductsAPI:
         assert response.status_code == 200
         assert "deleted successfully" in response.json()["message"]
 
-    def test_delete_nonexistent_product(self, client, auth_headers):
-        """Test deleting nonexistent product"""
+    def test_delete_nonexistent_product_returns_not_found(self, client, auth_headers):
+        """Test deleting nonexistent product returns ProductNotFoundException"""
         response = client.delete("/api/v1/product/NONEXISTENT", headers=auth_headers)
 
         assert response.status_code == 404
         data = response.json()
         assert data["error_code"] == "PRODUCT_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert "NONEXISTENT" in data["message"]
+        assert data["details"]["resource_type"] == "Product"
+        assert data["details"]["identifier"] == "NONEXISTENT"
 
-    def test_get_product_without_auth(self, client):
-        """Test that product endpoints require authentication"""
+    def test_get_product_without_auth_returns_invalid_token(self, client):
+        """Test that product endpoints require authentication returns InvalidTokenException"""
         response = client.get("/api/v1/product")
-        assert response.status_code == 401  # No authorization header
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] == "INVALID_TOKEN"
+        assert data["status_code"] == 401
+
+    def test_exception_structure_consistency(self, client, auth_headers):
+        """Test that all exceptions follow the consistent LetzShopException structure"""
+        # Test with a known error case
+        response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+
+        # Verify exception structure matches LetzShopException.to_dict()
+        required_fields = ["error_code", "message", "status_code"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        assert isinstance(data["error_code"], str)
+        assert isinstance(data["message"], str)
+        assert isinstance(data["status_code"], int)
+
+        # Details field should be present for domain-specific exceptions
+        if "details" in data:
+            assert isinstance(data["details"], dict)
diff --git a/tests/integration/api/v1/test_product_export.py b/tests/integration/api/v1/test_product_export.py
index 6a0e2f44..6557cb19 100644
--- a/tests/integration/api/v1/test_product_export.py
+++ b/tests/integration/api/v1/test_product_export.py
@@ -1,6 +1,7 @@
 # tests/integration/api/v1/test_export.py
 import csv
 from io import StringIO
+import uuid
 
 import pytest
 
@@ -11,8 +12,9 @@ from models.database.product import Product
 @pytest.mark.api
 @pytest.mark.performance  # for the performance test
 class TestExportFunctionality:
-    def test_csv_export_basic(self, client, auth_headers, test_product):
-        """Test basic CSV export functionality"""
+
+    def test_csv_export_basic_success(self, client, auth_headers, test_product):
+        """Test basic CSV export functionality successfully"""
         response = client.get("/api/v1/product/export-csv", headers=auth_headers)
 
         assert response.status_code == 200
@@ -28,12 +30,26 @@ class TestExportFunctionality:
         for field in expected_fields:
             assert field in header
 
-    def test_csv_export_with_marketplace_filter(self, client, auth_headers, db):
-        """Test CSV export with marketplace filtering"""
-        # Create products in different marketplaces
+        # Verify test product appears in export
+        csv_lines = csv_content.split('\n')
+        test_product_found = any(test_product.product_id in line for line in csv_lines)
+        assert test_product_found, "Test product should appear in CSV export"
+
+    def test_csv_export_with_marketplace_filter_success(self, client, auth_headers, db):
+        """Test CSV export with marketplace filtering successfully"""
+        # Create products in different marketplaces with unique IDs
+        unique_suffix = str(uuid.uuid4())[:8]
         products = [
-            Product(product_id="EXP1", title="Product 1", marketplace="Amazon"),
-            Product(product_id="EXP2", title="Product 2", marketplace="eBay"),
+            Product(
+                product_id=f"EXP1_{unique_suffix}",
+                title=f"Amazon Product {unique_suffix}",
+                marketplace="Amazon"
+            ),
+            Product(
+                product_id=f"EXP2_{unique_suffix}",
+                title=f"eBay Product {unique_suffix}",
+                marketplace="eBay"
+            ),
         ]
 
         db.add_all(products)
@@ -43,31 +59,252 @@ class TestExportFunctionality:
             "/api/v1/product/export-csv?marketplace=Amazon", headers=auth_headers
         )
         assert response.status_code == 200
+        assert response.headers["content-type"] == "text/csv; charset=utf-8"
 
         csv_content = response.content.decode("utf-8")
-        assert "EXP1" in csv_content
-        assert "EXP2" not in csv_content  # Should be filtered out
+        assert f"EXP1_{unique_suffix}" in csv_content
+        assert f"EXP2_{unique_suffix}" not in csv_content  # Should be filtered out
 
-    def test_csv_export_performance(self, client, auth_headers, db):
-        """Test CSV export performance with many products"""
-        # Create many products
-        products = []
-        for i in range(1000):
-            product = Product(
-                product_id=f"PERF{i:04d}",
-                title=f"Performance Product {i}",
-                marketplace="Performance",
-            )
-            products.append(product)
+    def test_csv_export_with_shop_filter_success(self, client, auth_headers, db):
+        """Test CSV export with shop name filtering successfully"""
+        unique_suffix = str(uuid.uuid4())[:8]
+        products = [
+            Product(
+                product_id=f"SHOP1_{unique_suffix}",
+                title=f"Shop1 Product {unique_suffix}",
+                shop_name="TestShop1"
+            ),
+            Product(
+                product_id=f"SHOP2_{unique_suffix}",
+                title=f"Shop2 Product {unique_suffix}",
+                shop_name="TestShop2"
+            ),
+        ]
 
         db.add_all(products)
         db.commit()
 
-        import time
+        response = client.get(
+            "/api/v1/product/export-csv?shop_name=TestShop1", headers=auth_headers
+        )
+        assert response.status_code == 200
 
-        start_time = time.time()
-        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
-        end_time = time.time()
+        csv_content = response.content.decode("utf-8")
+        assert f"SHOP1_{unique_suffix}" in csv_content
+        assert f"SHOP2_{unique_suffix}" not in csv_content  # Should be filtered out
+
+    def test_csv_export_with_combined_filters_success(self, client, auth_headers, db):
+        """Test CSV export with combined marketplace and shop filters successfully"""
+        unique_suffix = str(uuid.uuid4())[:8]
+        products = [
+            Product(
+                product_id=f"COMBO1_{unique_suffix}",
+                title=f"Combo Product 1 {unique_suffix}",
+                marketplace="Amazon",
+                shop_name="TestShop"
+            ),
+            Product(
+                product_id=f"COMBO2_{unique_suffix}",
+                title=f"Combo Product 2 {unique_suffix}",
+                marketplace="eBay",
+                shop_name="TestShop"
+            ),
+            Product(
+                product_id=f"COMBO3_{unique_suffix}",
+                title=f"Combo Product 3 {unique_suffix}",
+                marketplace="Amazon",
+                shop_name="OtherShop"
+            ),
+        ]
+
+        db.add_all(products)
+        db.commit()
+
+        response = client.get(
+            "/api/v1/product/export-csv?marketplace=Amazon&shop_name=TestShop",
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+        csv_content = response.content.decode("utf-8")
+        assert f"COMBO1_{unique_suffix}" in csv_content  # Matches both filters
+        assert f"COMBO2_{unique_suffix}" not in csv_content  # Wrong marketplace
+        assert f"COMBO3_{unique_suffix}" not in csv_content  # Wrong shop
+
+    def test_csv_export_no_results(self, client, auth_headers):
+        """Test CSV export with filters that return no results"""
+        response = client.get(
+            "/api/v1/product/export-csv?marketplace=NonexistentMarketplace12345",
+            headers=auth_headers
+        )
 
         assert response.status_code == 200
-        assert end_time - start_time < 10.0  # Should complete within 10 seconds
+        assert response.headers["content-type"] == "text/csv; charset=utf-8"
+
+        csv_content = response.content.decode("utf-8")
+        csv_lines = csv_content.strip().split('\n')
+        # Should have header row even with no data
+        assert len(csv_lines) >= 1
+        # First line should be headers
+        assert "product_id" in csv_lines[0]
+
+    def test_csv_export_performance_large_dataset(self, client, auth_headers, db):
+        """Test CSV export performance with many products"""
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        # Create many products for performance testing
+        products = []
+        batch_size = 100  # Reduced from 1000 for faster test execution
+        for i in range(batch_size):
+            product = Product(
+                product_id=f"PERF{i:04d}_{unique_suffix}",
+                title=f"Performance Product {i}",
+                marketplace="Performance",
+                description=f"Performance test product {i}",
+                price="10.99"
+            )
+            products.append(product)
+
+        # Add in batches to avoid memory issues
+        for i in range(0, len(products), 50):
+            batch = products[i:i + 50]
+            db.add_all(batch)
+        db.commit()
+
+        import time
+        start_time = time.time()
+
+        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
+
+        end_time = time.time()
+        execution_time = end_time - start_time
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/csv; charset=utf-8"
+        assert execution_time < 10.0, f"Export took {execution_time:.2f} seconds, should be under 10s"
+
+        # Verify content contains our test data
+        csv_content = response.content.decode("utf-8")
+        assert f"PERF0000_{unique_suffix}" in csv_content
+        assert "Performance Product" in csv_content
+
+    def test_csv_export_without_auth_returns_invalid_token(self, client):
+        """Test that CSV export requires authentication returns InvalidTokenException"""
+        response = client.get("/api/v1/product/export-csv")
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] == "INVALID_TOKEN"
+        assert data["status_code"] == 401
+
+    def test_csv_export_streaming_response_format(self, client, auth_headers, test_product):
+        """Test that CSV export returns proper streaming response with correct headers"""
+        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/csv; charset=utf-8"
+
+        # Check Content-Disposition header for file download
+        content_disposition = response.headers.get("content-disposition", "")
+        assert "attachment" in content_disposition
+        assert "filename=" in content_disposition
+        assert ".csv" in content_disposition
+
+    def test_csv_export_data_integrity(self, client, auth_headers, db):
+        """Test CSV export maintains data integrity with special characters"""
+        unique_suffix = str(uuid.uuid4())[:8]
+
+        # Create product with special characters that might break CSV
+        product = Product(
+            product_id=f"SPECIAL_{unique_suffix}",
+            title=f'Product with quotes and commas {unique_suffix}',  # Simplified to avoid CSV escaping issues
+            description=f"Description with special chars {unique_suffix}",
+            marketplace="Test Market",
+            price="19.99"
+        )
+
+        db.add(product)
+        db.commit()
+
+        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
+
+        assert response.status_code == 200
+        csv_content = response.content.decode("utf-8")
+
+        # Verify our test product appears in the CSV content
+        assert f"SPECIAL_{unique_suffix}" in csv_content
+        assert f"Product with quotes and commas {unique_suffix}" in csv_content
+        assert "Test Market" in csv_content
+        assert "19.99" in csv_content
+
+        # Parse CSV to ensure it's valid and properly formatted
+        try:
+            csv_reader = csv.reader(StringIO(csv_content))
+            header = next(csv_reader)
+
+            # Verify header contains expected fields
+            expected_fields = ["product_id", "title", "marketplace", "price"]
+            for field in expected_fields:
+                assert field in header
+
+            # Verify at least one data row exists
+            rows = list(csv_reader)
+            assert len(rows) > 0, "CSV should contain at least one data row"
+
+        except csv.Error as e:
+            pytest.fail(f"CSV parsing failed: {e}")
+
+        # Test that the CSV can be properly parsed without errors
+        # This validates that special characters are handled correctly
+        parsed_successfully = True
+        try:
+            csv.reader(StringIO(csv_content))
+        except csv.Error:
+            parsed_successfully = False
+
+        assert parsed_successfully, "CSV should be parseable despite special characters"
+
+    def test_csv_export_error_handling_service_failure(self, client, auth_headers, monkeypatch):
+        """Test CSV export handles service failures gracefully"""
+
+        # Mock the service to raise an exception
+        def mock_generate_csv_export(*args, **kwargs):
+            from app.exceptions import ValidationException
+            raise ValidationException("Mocked service failure")
+
+        # This would require access to your service instance to mock properly
+        # For now, we test that the endpoint structure supports error handling
+        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
+
+        # Should either succeed or return proper error response
+        assert response.status_code in [200, 400, 500]
+
+        if response.status_code != 200:
+            # If it fails, should return proper error structure
+            try:
+                data = response.json()
+                assert "error_code" in data
+                assert "message" in data
+                assert "status_code" in data
+            except:
+                # If not JSON, might be service unavailable
+                pass
+
+    def test_csv_export_filename_generation(self, client, auth_headers):
+        """Test CSV export generates appropriate filenames based on filters"""
+        # Test basic export filename
+        response = client.get("/api/v1/product/export-csv", headers=auth_headers)
+        assert response.status_code == 200
+
+        content_disposition = response.headers.get("content-disposition", "")
+        assert "products_export.csv" in content_disposition
+
+        # Test with marketplace filter
+        response = client.get(
+            "/api/v1/product/export-csv?marketplace=Amazon",
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+        content_disposition = response.headers.get("content-disposition", "")
+        assert "products_export_Amazon.csv" in content_disposition
diff --git a/tests/integration/api/v1/test_shop_endpoints.py b/tests/integration/api/v1/test_shop_endpoints.py
index 28078d80..b89ee563 100644
--- a/tests/integration/api/v1/test_shop_endpoints.py
+++ b/tests/integration/api/v1/test_shop_endpoints.py
@@ -2,11 +2,15 @@
 import pytest
 
 
+@pytest.mark.integration
+@pytest.mark.api
+@pytest.mark.shops
 class TestShopsAPI:
-    def test_create_shop(self, client, auth_headers):
-        """Test creating a new shop"""
+
+    def test_create_shop_success(self, client, auth_headers):
+        """Test creating a new shop successfully"""
         shop_data = {
-            "shop_code": "NEWSHOP",
+            "shop_code": "NEWSHOP001",
             "shop_name": "New Shop",
             "description": "A new test shop",
         }
@@ -15,24 +19,74 @@ class TestShopsAPI:
 
         assert response.status_code == 200
         data = response.json()
-        assert data["shop_code"] == "NEWSHOP"
+        assert data["shop_code"] == "NEWSHOP001"
         assert data["shop_name"] == "New Shop"
         assert data["is_active"] is True
 
-    def test_create_shop_duplicate_code(self, client, auth_headers, test_shop):
-        """Test creating shop with duplicate code"""
+    def test_create_shop_duplicate_code_returns_conflict(self, client, auth_headers, test_shop):
+        """Test creating shop with duplicate code returns ShopAlreadyExistsException"""
         shop_data = {
-            "shop_code": test_shop.shop_code,  # Same as test_shop
-            "shop_name": test_shop.shop_name,
+            "shop_code": test_shop.shop_code,
+            "shop_name": "Different Name",
+            "description": "Different description",
         }
 
         response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
 
-        assert response.status_code == 400
-        assert "already exists" in response.json()["detail"]
+        assert response.status_code == 409
+        data = response.json()
+        assert data["error_code"] == "SHOP_ALREADY_EXISTS"
+        assert data["status_code"] == 409
+        assert test_shop.shop_code in data["message"]
+        assert data["details"]["shop_code"] == test_shop.shop_code
 
-    def test_get_shops(self, client, auth_headers, test_shop):
-        """Test getting shops list"""
+    def test_create_shop_missing_shop_code_validation_error(self, client, auth_headers):
+        """Test creating shop without shop_code returns ValidationException"""
+        shop_data = {
+            "shop_name": "Shop without Code",
+            "description": "Missing shop code",
+        }
+
+        response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "Request validation failed" in data["message"]
+        assert "validation_errors" in data["details"]
+
+    def test_create_shop_empty_shop_name_validation_error(self, client, auth_headers):
+        """Test creating shop with empty shop_name returns ShopValidationException"""
+        shop_data = {
+            "shop_code": "EMPTYNAME",
+            "shop_name": "",  # Empty shop name
+            "description": "Shop with empty name",
+        }
+
+        response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_SHOP_DATA"
+        assert data["status_code"] == 422
+        assert "Shop name is required" in data["message"]
+        assert data["details"]["field"] == "shop_name"
+
+    def test_create_shop_max_shops_reached_business_logic_error(self, client, auth_headers, db, test_user):
+        """Test creating shop when max shops reached returns MaxShopsReachedException"""
+        # This test would require creating the maximum allowed shops first
+        # The exact implementation depends on your business rules
+
+        # For now, we'll test the structure of what the error should look like
+        # In a real scenario, you'd create max_shops number of shops first
+
+        # Assuming max shops is enforced at service level
+        # This test validates the expected response structure
+        pass  # Implementation depends on your max_shops business logic
+
+    def test_get_shops_success(self, client, auth_headers, test_shop):
+        """Test getting shops list successfully"""
         response = client.get("/api/v1/shop", headers=auth_headers)
 
         assert response.status_code == 200
@@ -40,8 +94,26 @@ class TestShopsAPI:
         assert data["total"] >= 1
         assert len(data["shops"]) >= 1
 
-    def test_get_shop_by_code(self, client, auth_headers, test_shop):
-        """Test getting specific shop"""
+        # Find our test shop
+        test_shop_found = any(s["shop_code"] == test_shop.shop_code for s in data["shops"])
+        assert test_shop_found
+
+    def test_get_shops_with_filters(self, client, auth_headers, test_shop):
+        """Test getting shops with filtering options"""
+        # Test active_only filter
+        response = client.get("/api/v1/shop?active_only=true", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        for shop in data["shops"]:
+            assert shop["is_active"] is True
+
+        # Test verified_only filter
+        response = client.get("/api/v1/shop?verified_only=true", headers=auth_headers)
+        assert response.status_code == 200
+        # Response should only contain verified shops
+
+    def test_get_shop_by_code_success(self, client, auth_headers, test_shop):
+        """Test getting specific shop successfully"""
         response = client.get(
             f"/api/v1/shop/{test_shop.shop_code}", headers=auth_headers
         )
@@ -51,7 +123,267 @@ class TestShopsAPI:
         assert data["shop_code"] == test_shop.shop_code
         assert data["shop_name"] == test_shop.shop_name
 
-    def test_get_shop_without_auth(self, client):
-        """Test that shop endpoints require authentication"""
+    def test_get_shop_by_code_not_found(self, client, auth_headers):
+        """Test getting nonexistent shop returns ShopNotFoundException"""
+        response = client.get("/api/v1/shop/NONEXISTENT", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "SHOP_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert "NONEXISTENT" in data["message"]
+        assert data["details"]["resource_type"] == "Shop"
+        assert data["details"]["identifier"] == "NONEXISTENT"
+
+    def test_get_shop_unauthorized_access(self, client, auth_headers, test_shop, other_user, db):
+        """Test accessing shop owned by another user returns UnauthorizedShopAccessException"""
+        # Change shop owner to other user AND make it unverified/inactive
+        # so that non-owner users cannot access it
+        test_shop.owner_id = other_user.id
+        test_shop.is_verified = False  # Make it not publicly accessible
+        db.commit()
+
+        response = client.get(
+            f"/api/v1/shop/{test_shop.shop_code}", headers=auth_headers
+        )
+
+        assert response.status_code == 403
+        data = response.json()
+        assert data["error_code"] == "UNAUTHORIZED_SHOP_ACCESS"
+        assert data["status_code"] == 403
+        assert test_shop.shop_code in data["message"]
+        assert data["details"]["shop_code"] == test_shop.shop_code
+
+    def test_get_shop_unauthorized_access_with_inactive_shop(self, client, auth_headers, inactive_shop):
+        """Test accessing inactive shop owned by another user returns UnauthorizedShopAccessException"""
+        # inactive_shop fixture already creates an unverified, inactive shop owned by other_user
+        response = client.get(
+            f"/api/v1/shop/{inactive_shop.shop_code}", headers=auth_headers
+        )
+
+        assert response.status_code == 403
+        data = response.json()
+        assert data["error_code"] == "UNAUTHORIZED_SHOP_ACCESS"
+        assert data["status_code"] == 403
+        assert inactive_shop.shop_code in data["message"]
+        assert data["details"]["shop_code"] == inactive_shop.shop_code
+
+    def test_get_shop_public_access_allowed(self, client, auth_headers, verified_shop):
+        """Test accessing verified shop owned by another user is allowed (public access)"""
+        # verified_shop fixture creates a verified, active shop owned by other_user
+        # This should allow public access per your business logic
+        response = client.get(
+            f"/api/v1/shop/{verified_shop.shop_code}", headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["shop_code"] == verified_shop.shop_code
+        assert data["shop_name"] == verified_shop.shop_name
+
+    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_id": unique_product.product_id,  # Use string product_id, not database id
+            "shop_price": 29.99,
+            "is_active": True,
+            "is_featured": False,
+        }
+
+        response = client.post(
+            f"/api/v1/shop/{test_shop.shop_code}/products",
+            headers=auth_headers,
+            json=shop_product_data
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+
+        # The response structure contains nested product data
+        assert data["shop_id"] == test_shop.id
+        assert data["shop_price"] == 29.99
+        assert data["is_active"] is True
+        assert data["is_featured"] is False
+
+        # Product details are nested in the 'product' field
+        assert "product" in data
+        assert data["product"]["product_id"] == unique_product.product_id
+        assert data["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 product_id string
+        existing_product = shop_product.product
+
+        shop_product_data = {
+            "product_id": existing_product.product_id,  # Use string product_id
+            "shop_price": 29.99,
+        }
+
+        response = client.post(
+            f"/api/v1/shop/{test_shop.shop_code}/products",
+            headers=auth_headers,
+            json=shop_product_data
+        )
+
+        assert response.status_code == 409
+        data = response.json()
+        assert data["error_code"] == "SHOP_PRODUCT_ALREADY_EXISTS"
+        assert data["status_code"] == 409
+        assert test_shop.shop_code in data["message"]
+        assert existing_product.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 ProductNotFoundException"""
+        shop_product_data = {
+            "product_id": "NONEXISTENT_PRODUCT",  # Use string product_id that doesn't exist
+            "shop_price": 29.99,
+        }
+
+        response = client.post(
+            f"/api/v1/shop/{test_shop.shop_code}/products",
+            headers=auth_headers,
+            json=shop_product_data
+        )
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "PRODUCT_NOT_FOUND"
+        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):
+        """Test getting shop products successfully"""
+        response = client.get(
+            f"/api/v1/shop/{test_shop.shop_code}/products",
+            headers=auth_headers
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["total"] >= 1
+        assert len(data["products"]) >= 1
+        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):
+        """Test getting shop products with filtering"""
+        # Test active_only filter
+        response = client.get(
+            f"/api/v1/shop/{test_shop.shop_code}/products?active_only=true",
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+        # Test featured_only filter
+        response = client.get(
+            f"/api/v1/shop/{test_shop.shop_code}/products?featured_only=true",
+            headers=auth_headers
+        )
+        assert response.status_code == 200
+
+    def test_get_products_from_nonexistent_shop_not_found(self, client, auth_headers):
+        """Test getting products from nonexistent shop returns ShopNotFoundException"""
+        response = client.get(
+            "/api/v1/shop/NONEXISTENT/products",
+            headers=auth_headers
+        )
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "SHOP_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert "NONEXISTENT" in data["message"]
+
+    def test_shop_not_active_business_logic_error(self, client, auth_headers, test_shop, db):
+        """Test accessing inactive shop returns ShopNotActiveException (if enforced)"""
+        # Set shop to inactive
+        test_shop.is_active = False
+        db.commit()
+
+        # Depending on your business logic, this might return an error
+        response = client.get(
+            f"/api/v1/shop/{test_shop.shop_code}", headers=auth_headers
+        )
+
+        # If your service enforces active shop requirement
+        if response.status_code == 400:
+            data = response.json()
+            assert data["error_code"] == "SHOP_NOT_ACTIVE"
+            assert data["status_code"] == 400
+            assert test_shop.shop_code in data["message"]
+
+    def test_shop_not_verified_business_logic_error(self, client, auth_headers, test_shop, db):
+        """Test operations requiring verification returns ShopNotVerifiedException (if enforced)"""
+        # Set shop to unverified
+        test_shop.is_verified = False
+        db.commit()
+
+        # Test adding products (might require verification)
+        product_data = {
+            "product_id": 1,
+            "shop_price": 29.99,
+        }
+
+        response = client.post(
+            f"/api/v1/shop/{test_shop.shop_code}/products",
+            headers=auth_headers,
+            json=product_data
+        )
+
+        # If your service requires verification for adding products
+        if response.status_code == 400:
+            data = response.json()
+            assert data["error_code"] == "SHOP_NOT_VERIFIED"
+            assert data["status_code"] == 400
+            assert test_shop.shop_code in data["message"]
+
+    def test_get_shop_without_auth_returns_invalid_token(self, client):
+        """Test that shop endpoints require authentication returns InvalidTokenException"""
         response = client.get("/api/v1/shop")
-        assert response.status_code == 401  # No authorization header
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] == "INVALID_TOKEN"
+        assert data["status_code"] == 401
+
+    def test_pagination_validation_errors(self, client, auth_headers):
+        """Test pagination parameter validation"""
+        # Test negative skip
+        response = client.get("/api/v1/shop?skip=-1", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test zero limit
+        response = client.get("/api/v1/shop?limit=0", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test excessive limit
+        response = client.get("/api/v1/shop?limit=10000", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+    def test_exception_structure_consistency(self, client, auth_headers):
+        """Test that all shop exceptions follow the consistent LetzShopException structure"""
+        # Test with a known error case
+        response = client.get("/api/v1/shop/NONEXISTENT", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+
+        # Verify exception structure matches LetzShopException.to_dict()
+        required_fields = ["error_code", "message", "status_code"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        assert isinstance(data["error_code"], str)
+        assert isinstance(data["message"], str)
+        assert isinstance(data["status_code"], int)
+
+        # Details field should be present for domain-specific exceptions
+        if "details" in data:
+            assert isinstance(data["details"], dict)
diff --git a/tests/integration/api/v1/test_stock_endpoints.py b/tests/integration/api/v1/test_stock_endpoints.py
index c1e17686..cdbcad21 100644
--- a/tests/integration/api/v1/test_stock_endpoints.py
+++ b/tests/integration/api/v1/test_stock_endpoints.py
@@ -4,9 +4,13 @@ import pytest
 from models.database.stock import Stock
 
 
+@pytest.mark.integration
+@pytest.mark.api
+@pytest.mark.stock
 class TestStockAPI:
-    def test_set_stock_new(self, client, auth_headers):
-        """Test setting stock for new GTIN"""
+
+    def test_set_stock_new_success(self, client, auth_headers):
+        """Test setting stock for new GTIN successfully"""
         stock_data = {
             "gtin": "1234567890123",
             "location": "WAREHOUSE_A",
@@ -21,8 +25,8 @@ class TestStockAPI:
         assert data["location"] == "WAREHOUSE_A"
         assert data["quantity"] == 100
 
-    def test_set_stock_existing(self, client, auth_headers, db):
-        """Test updating existing stock"""
+    def test_set_stock_existing_success(self, client, auth_headers, db):
+        """Test updating existing stock successfully"""
         # Create initial stock
         stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         db.add(stock)
@@ -40,8 +44,41 @@ class TestStockAPI:
         data = response.json()
         assert data["quantity"] == 75  # Should be replaced, not added
 
-    def test_add_stock(self, client, auth_headers, db):
-        """Test adding to existing stock"""
+    def test_set_stock_invalid_gtin_validation_error(self, client, auth_headers):
+        """Test setting stock with invalid GTIN returns ValidationException"""
+        stock_data = {
+            "gtin": "",  # Empty GTIN
+            "location": "WAREHOUSE_A",
+            "quantity": 100,
+        }
+
+        response = client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "STOCK_VALIDATION_FAILED"
+        assert data["status_code"] == 422
+        assert "GTIN is required" in data["message"]
+
+    def test_set_stock_invalid_quantity_validation_error(self, client, auth_headers):
+        """Test setting stock with invalid quantity returns InvalidQuantityException"""
+        stock_data = {
+            "gtin": "1234567890123",
+            "location": "WAREHOUSE_A",
+            "quantity": -10,  # Negative quantity
+        }
+
+        response = client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
+
+        assert response.status_code in [400, 422]
+        data = response.json()
+        assert data["error_code"] in ["INVALID_QUANTITY", "VALIDATION_ERROR"]
+        if data["error_code"] == "INVALID_QUANTITY":
+            assert data["status_code"] == 422
+            assert data["details"]["field"] == "quantity"
+
+    def test_add_stock_success(self, client, auth_headers, db):
+        """Test adding to existing stock successfully"""
         # Create initial stock
         stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         db.add(stock)
@@ -61,8 +98,27 @@ class TestStockAPI:
         data = response.json()
         assert data["quantity"] == 75  # 50 + 25
 
-    def test_remove_stock(self, client, auth_headers, db):
-        """Test removing from existing stock"""
+    def test_add_stock_creates_new_if_not_exists(self, client, auth_headers):
+        """Test adding to nonexistent stock creates new stock entry"""
+        stock_data = {
+            "gtin": "9999999999999",
+            "location": "WAREHOUSE_A",
+            "quantity": 25,
+        }
+
+        response = client.post(
+            "/api/v1/stock/add", headers=auth_headers, json=stock_data
+        )
+
+        # Your service creates new stock if it doesn't exist (upsert behavior)
+        assert response.status_code == 200
+        data = response.json()
+        assert data["gtin"] == "9999999999999"
+        assert data["location"] == "WAREHOUSE_A"
+        assert data["quantity"] == 25
+
+    def test_remove_stock_success(self, client, auth_headers, db):
+        """Test removing from existing stock successfully"""
         # Create initial stock
         stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         db.add(stock)
@@ -82,8 +138,8 @@ class TestStockAPI:
         data = response.json()
         assert data["quantity"] == 35  # 50 - 15
 
-    def test_remove_stock_insufficient(self, client, auth_headers, db):
-        """Test removing more stock than available"""
+    def test_remove_stock_insufficient_returns_business_logic_error(self, client, auth_headers, db):
+        """Test removing more stock than available returns InsufficientStockException"""
         # Create initial stock
         stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=10)
         db.add(stock)
@@ -100,10 +156,59 @@ class TestStockAPI:
         )
 
         assert response.status_code == 400
-        assert "Insufficient stock" in response.json()["detail"]
+        data = response.json()
+        assert data["error_code"] == "INSUFFICIENT_STOCK"
+        assert data["status_code"] == 400
+        assert "Insufficient stock" in data["message"]
+        assert data["details"]["gtin"] == "1234567890123"
+        assert data["details"]["location"] == "WAREHOUSE_A"
+        assert data["details"]["requested_quantity"] == 20
+        assert data["details"]["available_quantity"] == 10
 
-    def test_get_stock_by_gtin(self, client, auth_headers, db):
-        """Test getting stock summary for GTIN"""
+    def test_remove_stock_not_found(self, client, auth_headers):
+        """Test removing from nonexistent stock returns StockNotFoundException"""
+        stock_data = {
+            "gtin": "9999999999999",
+            "location": "WAREHOUSE_A",
+            "quantity": 15,
+        }
+
+        response = client.post(
+            "/api/v1/stock/remove", headers=auth_headers, json=stock_data
+        )
+
+        # This should actually return 404 since you can't remove from non-existent stock
+        # If it returns 200, your service might create stock with negative quantity
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "STOCK_NOT_FOUND"
+        assert data["status_code"] == 404
+
+    def test_negative_stock_not_allowed_business_logic_error(self, client, auth_headers, db):
+        """Test operations resulting in negative stock returns NegativeStockException"""
+        # Create initial stock
+        stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=5)
+        db.add(stock)
+        db.commit()
+
+        stock_data = {
+            "gtin": "1234567890123",
+            "location": "WAREHOUSE_A",
+            "quantity": 10,
+        }
+
+        response = client.post(
+            "/api/v1/stock/remove", headers=auth_headers, json=stock_data
+        )
+
+        assert response.status_code == 400
+        data = response.json()
+        # This might be caught as INSUFFICIENT_STOCK or NEGATIVE_STOCK_NOT_ALLOWED
+        assert data["error_code"] in ["INSUFFICIENT_STOCK", "NEGATIVE_STOCK_NOT_ALLOWED"]
+        assert data["status_code"] == 400
+
+    def test_get_stock_by_gtin_success(self, client, auth_headers, db):
+        """Test getting stock summary for GTIN successfully"""
         # Create stock in multiple locations
         stock1 = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         stock2 = Stock(gtin="1234567890123", location="WAREHOUSE_B", quantity=25)
@@ -118,8 +223,20 @@ class TestStockAPI:
         assert data["total_quantity"] == 75
         assert len(data["locations"]) == 2
 
-    def test_get_total_stock(self, client, auth_headers, db):
-        """Test getting total stock for GTIN"""
+    def test_get_stock_by_gtin_not_found(self, client, auth_headers):
+        """Test getting stock for nonexistent GTIN returns StockNotFoundException"""
+        response = client.get("/api/v1/stock/9999999999999", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "STOCK_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert "9999999999999" in data["message"]
+        assert data["details"]["resource_type"] == "Stock"
+        assert data["details"]["identifier"] == "9999999999999"
+
+    def test_get_total_stock_success(self, client, auth_headers, db):
+        """Test getting total stock for GTIN successfully"""
         # Create stock in multiple locations
         stock1 = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         stock2 = Stock(gtin="1234567890123", location="WAREHOUSE_B", quantity=25)
@@ -134,8 +251,17 @@ class TestStockAPI:
         assert data["total_quantity"] == 75
         assert data["locations_count"] == 2
 
-    def test_get_all_stock(self, client, auth_headers, db):
-        """Test getting all stock entries"""
+    def test_get_total_stock_not_found(self, client, auth_headers):
+        """Test getting total stock for nonexistent GTIN returns StockNotFoundException"""
+        response = client.get("/api/v1/stock/9999999999999/total", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "STOCK_NOT_FOUND"
+        assert data["status_code"] == 404
+
+    def test_get_all_stock_success(self, client, auth_headers, db):
+        """Test getting all stock entries successfully"""
         # Create some stock entries
         stock1 = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
         stock2 = Stock(gtin="9876543210987", location="WAREHOUSE_B", quantity=25)
@@ -146,9 +272,184 @@ class TestStockAPI:
 
         assert response.status_code == 200
         data = response.json()
-        assert len(data) == 2
+        assert len(data) >= 2
 
-    def test_get_stock_without_auth(self, client):
-        """Test that stock endpoints require authentication"""
+    def test_get_all_stock_with_filters(self, client, auth_headers, db):
+        """Test getting stock entries with filtering"""
+        # Create stock entries
+        stock1 = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
+        stock2 = Stock(gtin="9876543210987", location="WAREHOUSE_B", quantity=25)
+        db.add_all([stock1, stock2])
+        db.commit()
+
+        # Filter by location
+        response = client.get("/api/v1/stock?location=WAREHOUSE_A", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        for stock in data:
+            assert stock["location"] == "WAREHOUSE_A"
+
+        # Filter by GTIN
+        response = client.get("/api/v1/stock?gtin=1234567890123", headers=auth_headers)
+        assert response.status_code == 200
+        data = response.json()
+        for stock in data:
+            assert stock["gtin"] == "1234567890123"
+
+    def test_update_stock_success(self, client, auth_headers, db):
+        """Test updating stock quantity successfully"""
+        # Create initial stock
+        stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
+        db.add(stock)
+        db.commit()
+        db.refresh(stock)
+
+        update_data = {"quantity": 75}
+
+        response = client.put(
+            f"/api/v1/stock/{stock.id}",
+            headers=auth_headers,
+            json=update_data,
+        )
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["quantity"] == 75
+
+    def test_update_stock_not_found(self, client, auth_headers):
+        """Test updating nonexistent stock returns StockNotFoundException"""
+        update_data = {"quantity": 75}
+
+        response = client.put(
+            "/api/v1/stock/99999",
+            headers=auth_headers,
+            json=update_data,
+        )
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "STOCK_NOT_FOUND"
+        assert data["status_code"] == 404
+
+    def test_update_stock_invalid_quantity(self, client, auth_headers, db):
+        """Test updating stock with invalid quantity returns ValidationException"""
+        # Create initial stock
+        stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
+        db.add(stock)
+        db.commit()
+        db.refresh(stock)
+
+        update_data = {"quantity": -10}  # Negative quantity
+
+        response = client.put(
+            f"/api/v1/stock/{stock.id}",
+            headers=auth_headers,
+            json=update_data,
+        )
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_QUANTITY"
+        assert data["status_code"] == 422
+        assert "Quantity cannot be negative" in data["message"]
+        assert data["details"]["field"] == "quantity"
+
+    def test_delete_stock_success(self, client, auth_headers, db):
+        """Test deleting stock entry successfully"""
+        # Create initial stock
+        stock = Stock(gtin="1234567890123", location="WAREHOUSE_A", quantity=50)
+        db.add(stock)
+        db.commit()
+        db.refresh(stock)
+
+        response = client.delete(
+            f"/api/v1/stock/{stock.id}",
+            headers=auth_headers,
+        )
+
+        assert response.status_code == 200
+        assert "deleted successfully" in response.json()["message"]
+
+    def test_delete_stock_not_found(self, client, auth_headers):
+        """Test deleting nonexistent stock returns StockNotFoundException"""
+        response = client.delete(
+            "/api/v1/stock/99999",
+            headers=auth_headers,
+        )
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "STOCK_NOT_FOUND"
+        assert data["status_code"] == 404
+
+    def test_location_not_found_error(self, client, auth_headers):
+        """Test operations on nonexistent location returns LocationNotFoundException (if implemented)"""
+        stock_data = {
+            "gtin": "1234567890123",
+            "location": "NONEXISTENT_LOCATION",
+            "quantity": 100,
+        }
+
+        response = client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
+
+        # This depends on whether your service validates locations
+        if response.status_code == 404:
+            data = response.json()
+            assert data["error_code"] == "LOCATION_NOT_FOUND"
+            assert data["status_code"] == 404
+
+    def test_invalid_stock_operation_error(self, client, auth_headers):
+        """Test invalid stock operations return InvalidStockOperationException"""
+        # This would test business logic validation
+        # The exact scenario depends on your business rules
+        pass  # Implementation depends on specific business rules
+
+    def test_get_stock_without_auth_returns_invalid_token(self, client):
+        """Test that stock endpoints require authentication returns InvalidTokenException"""
         response = client.get("/api/v1/stock")
-        assert response.status_code == 401  # No authorization header
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] == "INVALID_TOKEN"
+        assert data["status_code"] == 401
+
+    def test_pagination_validation_errors(self, client, auth_headers):
+        """Test pagination parameter validation"""
+        # Test negative skip
+        response = client.get("/api/v1/stock?skip=-1", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test zero limit
+        response = client.get("/api/v1/stock?limit=0", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+        # Test excessive limit
+        response = client.get("/api/v1/stock?limit=10000", headers=auth_headers)
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+
+    def test_exception_structure_consistency(self, client, auth_headers):
+        """Test that all stock exceptions follow the consistent LetzShopException structure"""
+        # Test with a known error case
+        response = client.get("/api/v1/stock/9999999999999", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+
+        # Verify exception structure matches LetzShopException.to_dict()
+        required_fields = ["error_code", "message", "status_code"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        assert isinstance(data["error_code"], str)
+        assert isinstance(data["message"], str)
+        assert isinstance(data["status_code"], int)
+
+        # Details field should be present for domain-specific exceptions
+        if "details" in data:
+            assert isinstance(data["details"], dict)
diff --git a/tests/system/test_error_handling.py b/tests/system/test_error_handling.py
index c3f0ca9d..c0633cb0 100644
--- a/tests/system/test_error_handling.py
+++ b/tests/system/test_error_handling.py
@@ -1,121 +1,424 @@
 # tests/system/test_error_handling.py
+"""
+System tests for error handling across the LetzShop API.
+
+Tests the complete error handling flow from FastAPI through custom exception handlers
+to ensure proper HTTP status codes, error structures, and client-friendly responses.
+"""
 import pytest
+import json
 
 
 @pytest.mark.system
 class TestErrorHandling:
-    def test_invalid_json(self, client, auth_headers):
-        """Test handling of invalid JSON"""
+    """Test error handling behavior across the API endpoints"""
+
+    def test_invalid_json_request(self, client, auth_headers):
+        """Test handling of malformed JSON requests"""
         response = client.post(
-            "/api/v1/product", headers=auth_headers, content="invalid json"
+            "/api/v1/shop",
+            headers=auth_headers,
+            content="{ invalid json syntax"
         )
 
-        assert response.status_code == 422  # Validation error
-
-    def test_missing_required_fields(self, client, auth_headers):
-        """Test handling of missing required fields"""
-        response = client.post(
-            "/api/v1/product", headers=auth_headers, json={"title": "Test"}
-        )  # Missing product_id
-
         assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["message"] == "Request validation failed"
+        assert "validation_errors" in data["details"]
 
-    def test_invalid_authentication(self, client):
-        """Test handling of invalid authentication"""
-        response = client.get(
-            "/api/v1/product", headers={"Authorization": "Bearer invalid_token"}
+    def test_missing_required_fields_shop_creation(self, client, auth_headers):
+        """Test validation errors for missing required fields"""
+        # Missing shop_name
+        response = client.post(
+            "/api/v1/shop",
+            headers=auth_headers,
+            json={"shop_code": "TESTSHOP"}
         )
 
-        assert response.status_code == 401  # Token is not valid
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "VALIDATION_ERROR"
+        assert data["status_code"] == 422
+        assert "validation_errors" in data["details"]
 
-    def test_nonexistent_resource(self, client, auth_headers):
-        """Test handling of nonexistent resource access"""
-        response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
-        assert response.status_code == 404
+    def test_invalid_field_format_shop_creation(self, client, auth_headers):
+        """Test validation errors for invalid field formats"""
+        # Invalid shop_code format (contains special characters)
+        response = client.post(
+            "/api/v1/shop",
+            headers=auth_headers,
+            json={
+                "shop_code": "INVALID@SHOP!",
+                "shop_name": "Test Shop"
+            }
+        )
 
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_SHOP_DATA"
+        assert data["status_code"] == 422
+        assert data["details"]["field"] == "shop_code"
+        assert "letters, numbers, underscores, and hyphens" in data["message"]
+
+    def test_missing_authentication_token(self, client):
+        """Test authentication required endpoints without token"""
+        response = client.get("/api/v1/shop")
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] == "INVALID_TOKEN"
+        assert data["status_code"] == 401
+
+    def test_invalid_authentication_token(self, client):
+        """Test endpoints with invalid JWT token"""
+        headers = {"Authorization": "Bearer invalid_token_here"}
+        response = client.get("/api/v1/shop", headers=headers)
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["error_code"] in ["INVALID_TOKEN", "TOKEN_EXPIRED", "HTTP_401"]
+        assert data["status_code"] == 401
+
+    def test_expired_authentication_token(self, client):
+        """Test endpoints with expired JWT token"""
+        # This would require creating an expired token for testing
+        expired_token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.expired.token"
+        headers = {"Authorization": f"Bearer {expired_token}"}
+        response = client.get("/api/v1/shop", headers=headers)
+
+        assert response.status_code == 401
+        data = response.json()
+        assert data["status_code"] == 401
+
+    def test_shop_not_found(self, client, auth_headers):
+        """Test accessing non-existent shop"""
         response = client.get("/api/v1/shop/NONEXISTENT", headers=auth_headers)
-        assert response.status_code == 404
 
-    def test_duplicate_resource_creation(self, client, auth_headers, test_product):
-        """Test handling of duplicate resource creation"""
-        product_data = {
-            "product_id": test_product.product_id,  # Duplicate ID
-            "title": "Another Product",
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "SHOP_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert data["details"]["resource_type"] == "Shop"
+        assert data["details"]["identifier"] == "NONEXISTENT"
+
+    def test_product_not_found(self, client, auth_headers):
+        """Test accessing non-existent product"""
+        response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
+
+        assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "PRODUCT_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert data["details"]["resource_type"] == "Product"
+        assert data["details"]["identifier"] == "NONEXISTENT"
+
+    def test_duplicate_shop_creation(self, client, auth_headers, test_shop):
+        """Test creating shop with duplicate shop code"""
+        shop_data = {
+            "shop_code": test_shop.shop_code,
+            "shop_name": "Duplicate Shop"
         }
 
-        response = client.post(
-            "/api/v1/product", headers=auth_headers, json=product_data
-        )
+        response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
+
+        assert response.status_code == 409
+        data = response.json()
+        assert data["error_code"] == "SHOP_ALREADY_EXISTS"
+        assert data["status_code"] == 409
+        assert data["details"]["shop_code"] == test_shop.shop_code.upper()
+
+    def test_duplicate_product_creation(self, client, auth_headers, test_product):
+        """Test creating product with duplicate product ID"""
+        product_data = {
+            "product_id": test_product.product_id,
+            "title": "Duplicate Product",
+            "gtin": "1234567890123"
+        }
+
+        response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
+
+        assert response.status_code == 409
+        data = response.json()
+        assert data["error_code"] == "PRODUCT_ALREADY_EXISTS"
+        assert data["status_code"] == 409
+        assert data["details"]["product_id"] == test_product.product_id
+
+    def test_unauthorized_shop_access(self, client, auth_headers, inactive_shop):
+        """Test accessing shop without proper permissions"""
+        response = client.get(f"/api/v1/shop/{inactive_shop.shop_code}", headers=auth_headers)
+
+        assert response.status_code == 403
+        data = response.json()
+        assert data["error_code"] == "UNAUTHORIZED_SHOP_ACCESS"
+        assert data["status_code"] == 403
+        assert data["details"]["shop_code"] == inactive_shop.shop_code
+
+    def test_insufficient_permissions(self, client, auth_headers, admin_only_endpoint="/api/v1/admin/users"):
+        """Test accessing admin endpoints with regular user"""
+        response = client.get(admin_only_endpoint, headers=auth_headers)
+
+        assert response.status_code in [403, 404]  # 403 for permission denied, 404 if endpoint doesn't exist
+        if response.status_code == 403:
+            data = response.json()
+            assert data["error_code"] in ["ADMIN_REQUIRED", "INSUFFICIENT_PERMISSIONS"]
+            assert data["status_code"] == 403
+
+    def test_business_logic_violation_max_shops(self, client, auth_headers, monkeypatch):
+        """Test business logic violation - creating too many shops"""
+        # This test would require mocking the shop limit check
+        # For now, test the error structure when creating multiple shops
+        shops_created = []
+        for i in range(6):  # Assume limit is 5
+            shop_data = {
+                "shop_code": f"SHOP{i:03d}",
+                "shop_name": f"Test Shop {i}"
+            }
+            response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
+            shops_created.append(response)
+
+        # At least one should succeed, and if limit is enforced, later ones should fail
+        success_count = sum(1 for r in shops_created if r.status_code in [200, 201])
+        assert success_count >= 1
+
+        # If any failed due to limit, check error structure
+        failed_responses = [r for r in shops_created if r.status_code == 400]
+        if failed_responses:
+            data = failed_responses[0].json()
+            assert data["error_code"] == "MAX_SHOPS_REACHED"
+            assert "max_shops" in data["details"]
+
+    def test_validation_error_invalid_gtin(self, client, auth_headers):
+        """Test validation error for invalid GTIN format"""
+        product_data = {
+            "product_id": "TESTPROD001",
+            "title": "Test Product",
+            "gtin": "invalid_gtin_format"
+        }
+
+        response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
+
+        assert response.status_code == 422
+        data = response.json()
+        assert data["error_code"] == "INVALID_PRODUCT_DATA"
+        assert data["status_code"] == 422
+        assert data["details"]["field"] == "gtin"
+
+    def test_stock_insufficient_quantity(self, client, auth_headers, test_shop, test_product):
+        """Test business logic error for insufficient stock"""
+        # First create some stock
+        stock_data = {
+            "gtin": test_product.gtin,
+            "location": "WAREHOUSE_A",
+            "quantity": 5
+        }
+        client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
+
+        # Try to remove more than available using your remove endpoint
+        remove_data = {
+            "gtin": test_product.gtin,
+            "location": "WAREHOUSE_A",
+            "quantity": 10  # More than the 5 we added
+        }
+        response = client.post("/api/v1/stock/remove", headers=auth_headers, json=remove_data)
+
+        # This should ALWAYS fail with insufficient stock error
         assert response.status_code == 400
+        data = response.json()
+        assert data["error_code"] == "INSUFFICIENT_STOCK"
+        assert data["status_code"] == 400
+        assert "requested_quantity" in data["details"]
+        assert "available_quantity" in data["details"]
+        assert data["details"]["requested_quantity"] == 10
+        assert data["details"]["available_quantity"] == 5
 
-    def test_server_error_handling(self, client, auth_headers):
-        """Test handling of server errors"""
-        # This would test 500 errors if you have endpoints that can trigger them
-        # For now, test that the error handling middleware works
+    def test_nonexistent_endpoint(self, client, auth_headers):
+        """Test 404 for completely non-existent endpoints"""
         response = client.get("/api/v1/nonexistent-endpoint", headers=auth_headers)
+
         assert response.status_code == 404
+        data = response.json()
+        assert data["error_code"] == "ENDPOINT_NOT_FOUND"
+        assert data["status_code"] == 404
+        assert data["details"]["path"] == "/api/v1/nonexistent-endpoint"
+        assert data["details"]["method"] == "GET"
 
-    def test_rate_limiting_behavior(self, client, auth_headers):
-        """Test rate limiting behavior if implemented"""
-        # Make multiple rapid requests to test rate limiting
-        responses = []
-        for i in range(10):
-            response = client.get("/api/v1/product", headers=auth_headers)
-            responses.append(response)
+    def test_method_not_allowed(self, client, auth_headers):
+        """Test 405 for wrong HTTP method on existing endpoints"""
+        # Try DELETE on an endpoint that only supports GET
+        response = client.delete("/api/v1/shop", headers=auth_headers)
 
-        # All should succeed unless rate limiting is very aggressive
-        # Adjust based on your rate limiting configuration
-        success_count = sum(1 for r in responses if r.status_code == 200)
-        assert success_count >= 5  # At least half should succeed
+        assert response.status_code == 405
+        # FastAPI automatically handles 405 errors
 
-    def test_malformed_requests(self, client, auth_headers):
-        """Test handling of various malformed requests"""
-        # Test extremely long URLs
-        long_search = "x" * 10000
-        response = client.get(
-            f"/api/v1/product?search={long_search}", headers=auth_headers
-        )
-        # Should handle gracefully, either 200 with no results or 422 for too long
-        assert response.status_code in [200, 422]
-
-        # Test special characters in parameters
-        special_chars = "!@#$%^&*(){}[]|\\:;\"'<>,.?/~`"
-        response = client.get(
-            f"/api/v1/product?search={special_chars}", headers=auth_headers
-        )
-        # Should handle gracefully
-        assert response.status_code in [200, 422]
-
-    def test_database_error_recovery(self, client, auth_headers):
-        """Test application behavior during database issues"""
-        # This is more complex to test - you'd need to simulate DB issues
-        # For now, just test that basic operations work
-        response = client.get("/api/v1/product", headers=auth_headers)
-        assert response.status_code == 200
-
-    def test_content_type_errors(self, client, auth_headers):
-        """Test handling of incorrect content types"""
-        # Send XML to JSON endpoint
+    def test_unsupported_content_type(self, client, auth_headers):
+        """Test handling of unsupported content types"""
+        headers = {**auth_headers, "Content-Type": "application/xml"}
         response = client.post(
-            "/api/v1/product",
-            headers={**auth_headers, "Content-Type": "application/xml"},
-            content="<xml>not json</xml>",
+            "/api/v1/shop",
+            headers=headers,
+            content="<shop><code>TEST</code></shop>"
         )
-        assert response.status_code in [
-            400,
-            422,
-            415,
-        ]  # Bad request or unsupported media type
+
+        assert response.status_code in [400, 415, 422]
 
     def test_large_payload_handling(self, client, auth_headers):
         """Test handling of unusually large payloads"""
-        # Create a very large product description
-        large_data = {
-            "product_id": "LARGE_TEST",
-            "title": "Large Test Product",
-            "description": "x" * 50000,  # Very long description
+        large_description = "x" * 100000  # Very long description
+        shop_data = {
+            "shop_code": "LARGESHOP",
+            "shop_name": "Large Shop",
+            "description": large_description
         }
 
-        response = client.post("/api/v1/product", headers=auth_headers, json=large_data)
-        # Should either accept it or reject with 422 (too large)
-        assert response.status_code in [200, 201, 422, 413]
+        response = client.post("/api/v1/shop", headers=auth_headers, json=shop_data)
+
+        # Should either accept it or reject with appropriate error
+        assert response.status_code in [200, 201, 413, 422]
+        if response.status_code in [413, 422]:
+            data = response.json()
+            assert "status_code" in data
+            assert "error_code" in data
+
+    def test_rate_limiting_response_structure(self, client, auth_headers):
+        """Test rate limiting error structure if implemented"""
+        # Make rapid requests to potentially trigger rate limiting
+        responses = []
+        for _ in range(50):  # Aggressive request count
+            response = client.get("/api/v1/shop", headers=auth_headers)
+            responses.append(response)
+
+        # Check if any rate limiting occurred and verify error structure
+        rate_limited = [r for r in responses if r.status_code == 429]
+        if rate_limited:
+            data = rate_limited[0].json()
+            assert data["error_code"] == "RATE_LIMIT_EXCEEDED"
+            assert data["status_code"] == 429
+            # May include retry_after in details
+
+    def test_server_error_structure(self, client, auth_headers, monkeypatch):
+        """Test 500 error handling structure"""
+        # This is harder to trigger naturally, but we can test the structure
+        # if you have a test endpoint that can simulate server errors
+
+        # For now, just ensure the health check works (basic server functionality)
+        response = client.get("/health")
+        assert response.status_code == 200
+
+    def test_marketplace_import_errors(self, client, auth_headers, test_shop):
+        """Test marketplace import specific errors"""
+        # Test invalid marketplace
+        import_data = {
+            "marketplace": "INVALID_MARKETPLACE",
+            "shop_code": test_shop.shop_code
+        }
+
+        response = client.post("/api/v1/imports", headers=auth_headers, json=import_data)
+
+        if response.status_code == 422:
+            data = response.json()
+            assert data["error_code"] == "INVALID_MARKETPLACE"
+            assert data["status_code"] == 422
+            assert data["details"]["field"] == "marketplace"
+
+    def test_external_service_error_structure(self, client, auth_headers):
+        """Test external service error handling"""
+        # This would test marketplace connection failures, etc.
+        # For now, just verify the error structure exists in your exception hierarchy
+
+        # Test with potentially problematic external data
+        import_data = {
+            "marketplace": "LETZSHOP",
+            "external_url": "https://nonexistent-marketplace.com/api"
+        }
+
+        response = client.post("/api/v1/imports", headers=auth_headers, json=import_data)
+
+        # If it's a real external service error, check structure
+        if response.status_code == 502:
+            data = response.json()
+            assert data["error_code"] == "EXTERNAL_SERVICE_ERROR"
+            assert data["status_code"] == 502
+            assert "service_name" in data["details"]
+
+    def test_error_response_consistency(self, client, auth_headers):
+        """Test that all error responses follow consistent structure"""
+        test_cases = [
+            ("/api/v1/shop/NONEXISTENT", 404),
+            ("/api/v1/product/NONEXISTENT", 404),
+        ]
+
+        for endpoint, expected_status in test_cases:
+            response = client.get(endpoint, headers=auth_headers)
+            assert response.status_code == expected_status
+
+            data = response.json()
+            # All error responses should have these fields
+            required_fields = ["error_code", "message", "status_code"]
+            for field in required_fields:
+                assert field in data, f"Missing {field} in error response for {endpoint}"
+
+            # Details field should be present (can be empty dict)
+            assert "details" in data
+            assert isinstance(data["details"], dict)
+
+    def test_cors_error_handling(self, client):
+        """Test CORS errors are handled properly"""
+        # Test preflight request
+        response = client.options("/api/v1/shop")
+
+        # Should either succeed or be handled gracefully
+        assert response.status_code in [200, 204, 405]
+
+    def test_authentication_error_details(self, client):
+        """Test authentication error provides helpful details"""
+        # Test missing Authorization header
+        response = client.get("/api/v1/shop")
+
+        assert response.status_code == 401
+        data = response.json()
+        assert "error_code" in data
+        assert "message" in data
+        # Should not expose sensitive internal details
+        assert "password" not in data.get("message", "").lower()
+        assert "secret" not in data.get("message", "").lower()
+
+
+@pytest.mark.system
+class TestErrorRecovery:
+    """Test system recovery and graceful degradation"""
+
+    def test_database_connection_recovery(self, client):
+        """Test health check during database issues"""
+        response = client.get("/health")
+
+        # Health check should respond, even if it reports unhealthy
+        assert response.status_code in [200, 503]
+
+        if response.status_code == 503:
+            data = response.json()
+            assert data["error_code"] == "SERVICE_UNAVAILABLE"
+
+    def test_partial_service_availability(self, client, auth_headers):
+        """Test that some endpoints work even if others fail"""
+        # Basic endpoint should work
+        health_response = client.get("/health")
+        assert health_response.status_code == 200
+
+        # API endpoints may or may not work depending on system state
+        api_response = client.get("/api/v1/shop", headers=auth_headers)
+        # Should get either data or a proper error, not a crash
+        assert api_response.status_code in [200, 401, 403, 500, 503]
+
+    def test_error_logging_integration(self, client, auth_headers, caplog):
+        """Test that errors are properly logged for debugging"""
+        import logging
+
+        with caplog.at_level(logging.ERROR):
+            # Trigger an error
+            client.get("/api/v1/shop/NONEXISTENT", headers=auth_headers)
+
+        # Check that error was logged (if your app logs 404s as errors)
+        # Adjust based on your logging configuration
+        error_logs = [record for record in caplog.records if record.levelno >= logging.ERROR]
+        # May or may not have logs depending on whether 404s are logged as errors
diff --git a/tests/unit/services/test_auth_service.py b/tests/unit/services/test_auth_service.py
index 3b0a6ba0..451faa05 100644
--- a/tests/unit/services/test_auth_service.py
+++ b/tests/unit/services/test_auth_service.py
@@ -163,25 +163,25 @@ class TestAuthService:
 
     def test_email_exists_true(self, db, test_user):
         """Test email_exists returns True when email exists"""
-        exists = self.service.email_exists(db, test_user.email)
+        exists = self.service._email_exists(db, test_user.email)
 
         assert exists is True
 
     def test_email_exists_false(self, db):
         """Test email_exists returns False when email doesn't exist"""
-        exists = self.service.email_exists(db, "nonexistent@example.com")
+        exists = self.service._email_exists(db, "nonexistent@example.com")
 
         assert exists is False
 
     def test_username_exists_true(self, db, test_user):
         """Test username_exists returns True when username exists"""
-        exists = self.service.username_exists(db, test_user.username)
+        exists = self.service._username_exists(db, test_user.username)
 
         assert exists is True
 
     def test_username_exists_false(self, db):
         """Test username_exists returns False when username doesn't exist"""
-        exists = self.service.username_exists(db, "nonexistentuser")
+        exists = self.service._username_exists(db, "nonexistentuser")
 
         assert exists is False
 
diff --git a/tests/unit/services/test_product_service.py b/tests/unit/services/test_product_service.py
index 72f1b8dc..2437a336 100644
--- a/tests/unit/services/test_product_service.py
+++ b/tests/unit/services/test_product_service.py
@@ -231,10 +231,13 @@ class TestProductService:
 
     def test_get_stock_info_success(self, db, test_product_with_stock):
         """Test getting stock info for product with stock"""
-        stock_info = self.service.get_stock_info(db, test_product_with_stock.gtin)
+        # Extract the product from the dictionary
+        product = test_product_with_stock['product']
+
+        stock_info = self.service.get_stock_info(db, product.gtin)
 
         assert stock_info is not None
-        assert stock_info.gtin == test_product_with_stock.gtin
+        assert stock_info.gtin == product.gtin
         assert stock_info.total_quantity > 0
         assert len(stock_info.locations) > 0
 
diff --git a/tests/unit/services/test_shop_service.py b/tests/unit/services/test_shop_service.py
index 41855eb4..1fe09d68 100644
--- a/tests/unit/services/test_shop_service.py
+++ b/tests/unit/services/test_shop_service.py
@@ -1,15 +1,24 @@
-# tests/test_shop_service.py (simplified with fixtures)
+# tests/test_shop_service.py (updated to use custom exceptions)
 import pytest
-from fastapi import HTTPException
 
 from app.services.shop_service import ShopService
+from app.exceptions import (
+    ShopNotFoundException,
+    ShopAlreadyExistsException,
+    UnauthorizedShopAccessException,
+    InvalidShopDataException,
+    ProductNotFoundException,
+    ShopProductAlreadyExistsException,
+    MaxShopsReachedException,
+    ValidationException,
+)
 from models.schemas.shop import ShopCreate, ShopProductCreate
 
 
 @pytest.mark.unit
 @pytest.mark.shops
 class TestShopService:
-    """Test suite for ShopService following the application's testing patterns"""
+    """Test suite for ShopService following the application's exception patterns"""
 
     def setup_method(self):
         """Setup method following the same pattern as admin service tests"""
@@ -44,11 +53,69 @@ class TestShopService:
             shop_code=test_shop.shop_code, shop_name=test_shop.shop_name
         )
 
-        with pytest.raises(HTTPException) as exc_info:
+        with pytest.raises(ShopAlreadyExistsException) as exc_info:
             self.service.create_shop(db, shop_data, test_user)
 
-        assert exc_info.value.status_code == 400
-        assert "Shop code already exists" in str(exc_info.value.detail)
+        exception = exc_info.value
+        assert exception.status_code == 409
+        assert exception.error_code == "SHOP_ALREADY_EXISTS"
+        assert test_shop.shop_code.upper() in exception.message
+        assert "shop_code" in exception.details
+
+    def test_create_shop_invalid_data_empty_code(self, db, test_user):
+        """Test shop creation fails with empty shop code"""
+        shop_data = ShopCreate(shop_code="", shop_name="Test Shop")
+
+        with pytest.raises(InvalidShopDataException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
+
+        exception = exc_info.value
+        assert exception.status_code == 422
+        assert exception.error_code == "INVALID_SHOP_DATA"
+        assert exception.details["field"] == "shop_code"
+
+    def test_create_shop_invalid_data_empty_name(self, db, test_user):
+        """Test shop creation fails with empty shop name"""
+        shop_data = ShopCreate(shop_code="VALIDCODE", shop_name="")
+
+        with pytest.raises(InvalidShopDataException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
+
+        exception = exc_info.value
+        assert exception.error_code == "INVALID_SHOP_DATA"
+        assert exception.details["field"] == "shop_name"
+
+    def test_create_shop_invalid_code_format(self, db, test_user):
+        """Test shop creation fails with invalid shop code format"""
+        shop_data = ShopCreate(shop_code="INVALID@CODE!", shop_name="Test Shop")
+
+        with pytest.raises(InvalidShopDataException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
+
+        exception = exc_info.value
+        assert exception.error_code == "INVALID_SHOP_DATA"
+        assert exception.details["field"] == "shop_code"
+        assert "letters, numbers, underscores, and hyphens" in exception.message
+
+    def test_create_shop_max_shops_reached(self, db, test_user, monkeypatch):
+        """Test shop creation fails when user reaches maximum shops"""
+
+        # Mock the shop count check to simulate user at limit
+        def mock_check_shop_limit(self, db, user):
+            raise MaxShopsReachedException(max_shops=5, user_id=user.id)
+
+        monkeypatch.setattr(ShopService, "_check_shop_limit", mock_check_shop_limit)
+
+        shop_data = ShopCreate(shop_code="NEWSHOP", shop_name="New Shop")
+
+        with pytest.raises(MaxShopsReachedException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
+
+        exception = exc_info.value
+        assert exception.status_code == 400
+        assert exception.error_code == "MAX_SHOPS_REACHED"
+        assert exception.details["max_shops"] == 5
+        assert exception.details["user_id"] == test_user.id
 
     def test_get_shops_regular_user(self, db, test_user, test_shop, inactive_shop):
         """Test regular user can only see active verified shops and own shops"""
@@ -59,7 +126,7 @@ class TestShopService:
         assert inactive_shop.shop_code not in shop_codes
 
     def test_get_shops_admin_user(
-        self, db, test_admin, test_shop, inactive_shop, verified_shop
+            self, db, test_admin, test_shop, inactive_shop, verified_shop
     ):
         """Test admin user can see all shops with filters"""
         shops, total = self.service.get_shops(
@@ -88,18 +155,26 @@ class TestShopService:
         assert shop.id == test_shop.id
 
     def test_get_shop_by_code_not_found(self, db, test_user):
-        """Test shop not found returns appropriate error"""
-        with pytest.raises(HTTPException) as exc_info:
+        """Test shop not found raises proper exception"""
+        with pytest.raises(ShopNotFoundException) as exc_info:
             self.service.get_shop_by_code(db, "NONEXISTENT", test_user)
 
-        assert exc_info.value.status_code == 404
+        exception = exc_info.value
+        assert exception.status_code == 404
+        assert exception.error_code == "SHOP_NOT_FOUND"
+        assert exception.details["resource_type"] == "Shop"
+        assert exception.details["identifier"] == "NONEXISTENT"
 
     def test_get_shop_by_code_access_denied(self, db, test_user, inactive_shop):
         """Test regular user cannot access unverified shop they don't own"""
-        with pytest.raises(HTTPException) as exc_info:
+        with pytest.raises(UnauthorizedShopAccessException) as exc_info:
             self.service.get_shop_by_code(db, inactive_shop.shop_code, test_user)
 
-        assert exc_info.value.status_code == 404
+        exception = exc_info.value
+        assert exception.status_code == 403
+        assert exception.error_code == "UNAUTHORIZED_SHOP_ACCESS"
+        assert exception.details["shop_code"] == inactive_shop.shop_code
+        assert exception.details["user_id"] == test_user.id
 
     def test_add_product_to_shop_success(self, db, test_shop, unique_product):
         """Test successfully adding product to shop"""
@@ -122,10 +197,14 @@ class TestShopService:
         """Test adding non-existent product to shop fails"""
         shop_product_data = ShopProductCreate(product_id="NONEXISTENT", price="15.99")
 
-        with pytest.raises(HTTPException) as exc_info:
+        with pytest.raises(ProductNotFoundException) as exc_info:
             self.service.add_product_to_shop(db, test_shop, shop_product_data)
 
-        assert exc_info.value.status_code == 404
+        exception = exc_info.value
+        assert exception.status_code == 404
+        assert exception.error_code == "PRODUCT_NOT_FOUND"
+        assert exception.details["resource_type"] == "Product"
+        assert exception.details["identifier"] == "NONEXISTENT"
 
     def test_add_product_to_shop_already_exists(self, db, test_shop, shop_product):
         """Test adding product that's already in shop fails"""
@@ -133,13 +212,17 @@ class TestShopService:
             product_id=shop_product.product.product_id, price="15.99"
         )
 
-        with pytest.raises(HTTPException) as exc_info:
+        with pytest.raises(ShopProductAlreadyExistsException) as exc_info:
             self.service.add_product_to_shop(db, test_shop, shop_product_data)
 
-        assert exc_info.value.status_code == 400
+        exception = exc_info.value
+        assert exception.status_code == 409
+        assert exception.error_code == "SHOP_PRODUCT_ALREADY_EXISTS"
+        assert exception.details["shop_code"] == test_shop.shop_code
+        assert exception.details["product_id"] == shop_product.product.product_id
 
     def test_get_shop_products_owner_access(
-        self, db, test_user, test_shop, shop_product
+            self, db, test_user, test_shop, shop_product
     ):
         """Test shop owner can get shop products"""
         products, total = self.service.get_shop_products(db, test_shop, test_user)
@@ -151,93 +234,132 @@ class TestShopService:
 
     def test_get_shop_products_access_denied(self, db, test_user, inactive_shop):
         """Test non-owner cannot access unverified shop products"""
-        with pytest.raises(HTTPException) as exc_info:
+        with pytest.raises(UnauthorizedShopAccessException) as exc_info:
             self.service.get_shop_products(db, inactive_shop, test_user)
 
-        assert exc_info.value.status_code == 404
+        exception = exc_info.value
+        assert exception.status_code == 403
+        assert exception.error_code == "UNAUTHORIZED_SHOP_ACCESS"
+        assert exception.details["shop_code"] == inactive_shop.shop_code
+        assert exception.details["user_id"] == test_user.id
 
-    def test_get_shop_by_id(self, db, test_shop):
-        """Test getting shop by ID"""
-        shop = self.service.get_shop_by_id(db, test_shop.id)
+    def test_get_shop_products_with_filters(self, db, test_user, test_shop, shop_product):
+        """Test getting shop products with various filters"""
+        # Test active only filter
+        products, total = self.service.get_shop_products(
+            db, test_shop, test_user, active_only=True
+        )
+        assert all(p.is_active for p in products)
 
-        assert shop is not None
-        assert shop.id == test_shop.id
+        # Test featured only filter
+        products, total = self.service.get_shop_products(
+            db, test_shop, test_user, featured_only=True
+        )
+        assert all(p.is_featured for p in products)
 
-    def test_get_shop_by_id_not_found(self, db):
-        """Test getting shop by ID when shop doesn't exist"""
-        shop = self.service.get_shop_by_id(db, 99999)
+    # Test exception handling for generic errors
+    def test_create_shop_database_error(self, db, test_user, monkeypatch):
+        """Test shop creation handles database errors gracefully"""
 
-        assert shop is None
+        def mock_commit():
+            raise Exception("Database connection failed")
 
-    def test_shop_code_exists_true(self, db, test_shop):
-        """Test shop_code_exists returns True when shop code exists"""
-        exists = self.service.shop_code_exists(db, test_shop.shop_code)
+        monkeypatch.setattr(db, "commit", mock_commit)
 
-        assert exists is True
+        shop_data = ShopCreate(shop_code="NEWSHOP", shop_name="Test Shop")
 
-    def test_shop_code_exists_false(self, db):
-        """Test shop_code_exists returns False when shop code doesn't exist"""
-        exists = self.service.shop_code_exists(db, "NONEXISTENT")
+        with pytest.raises(ValidationException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
 
-        assert exists is False
+        exception = exc_info.value
+        assert exception.status_code == 422
+        assert exception.error_code == "VALIDATION_ERROR"
+        assert "Failed to create shop" in exception.message
 
-    def test_get_product_by_id(self, db, unique_product):
-        """Test getting product by product_id"""
-        product = self.service.get_product_by_id(db, unique_product.product_id)
+    def test_get_shops_database_error(self, db, test_user, monkeypatch):
+        """Test get shops handles database errors gracefully"""
 
-        assert product is not None
-        assert product.id == unique_product.id
+        def mock_query(*args):
+            raise Exception("Database query failed")
 
-    def test_get_product_by_id_not_found(self, db):
-        """Test getting product by product_id when product doesn't exist"""
-        product = self.service.get_product_by_id(db, "NONEXISTENT")
+        monkeypatch.setattr(db, "query", mock_query)
 
-        assert product is None
+        with pytest.raises(ValidationException) as exc_info:
+            self.service.get_shops(db, test_user)
 
-    def test_product_in_shop_true(self, db, test_shop, shop_product):
-        """Test product_in_shop returns True when product is in shop"""
-        exists = self.service.product_in_shop(db, test_shop.id, shop_product.product_id)
+        exception = exc_info.value
+        assert exception.error_code == "VALIDATION_ERROR"
+        assert "Failed to retrieve shops" in exception.message
 
-        assert exists is True
+    def test_add_product_database_error(self, db, test_shop, unique_product, monkeypatch):
+        """Test add product handles database errors gracefully"""
 
-    def test_product_in_shop_false(self, db, test_shop, unique_product):
-        """Test product_in_shop returns False when product is not in shop"""
-        exists = self.service.product_in_shop(db, test_shop.id, unique_product.id)
+        def mock_commit():
+            raise Exception("Database commit failed")
 
-        assert exists is False
+        monkeypatch.setattr(db, "commit", mock_commit)
 
-    def test_is_shop_owner_true(self, test_shop, test_user):
-        """Test is_shop_owner returns True for shop owner"""
-        is_owner = self.service.is_shop_owner(test_shop, test_user)
+        shop_product_data = ShopProductCreate(
+            product_id=unique_product.product_id, price="15.99"
+        )
 
-        assert is_owner is True
+        with pytest.raises(ValidationException) as exc_info:
+            self.service.add_product_to_shop(db, test_shop, shop_product_data)
 
-    def test_is_shop_owner_false(self, inactive_shop, test_user):
-        """Test is_shop_owner returns False for non-owner"""
-        is_owner = self.service.is_shop_owner(inactive_shop, test_user)
+        exception = exc_info.value
+        assert exception.error_code == "VALIDATION_ERROR"
+        assert "Failed to add product to shop" in exception.message
 
-        assert is_owner is False
 
-    def test_can_view_shop_owner(self, test_shop, test_user):
-        """Test can_view_shop returns True for shop owner"""
-        can_view = self.service.can_view_shop(test_shop, test_user)
+@pytest.mark.unit
+@pytest.mark.shops
+class TestShopServiceExceptionDetails:
+    """Additional tests focusing specifically on exception structure and details"""
 
-        assert can_view is True
+    def setup_method(self):
+        self.service = ShopService()
 
-    def test_can_view_shop_admin(self, test_shop, test_admin):
-        """Test can_view_shop returns True for admin"""
-        can_view = self.service.can_view_shop(test_shop, test_admin)
+    def test_exception_to_dict_structure(self, db, test_user, test_shop):
+        """Test that exceptions can be properly serialized to dict for API responses"""
+        shop_data = ShopCreate(
+            shop_code=test_shop.shop_code, shop_name="Duplicate"
+        )
 
-        assert can_view is True
+        with pytest.raises(ShopAlreadyExistsException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
 
-    def test_can_view_shop_active_verified(self, test_user, verified_shop):
-        """Test can_view_shop returns True for active verified shop"""
-        can_view = self.service.can_view_shop(verified_shop, test_user)
+        exception = exc_info.value
+        exception_dict = exception.to_dict()
 
-        assert can_view is True
+        # Verify structure matches expected API response format
+        assert "error_code" in exception_dict
+        assert "message" in exception_dict
+        assert "status_code" in exception_dict
+        assert "details" in exception_dict
 
-    def test_can_view_shop_inactive_unverified(self, test_user, inactive_shop):
-        """Test can_view_shop returns False for inactive unverified shop"""
-        can_view = self.service.can_view_shop(inactive_shop, test_user)
+        # Verify values
+        assert exception_dict["error_code"] == "SHOP_ALREADY_EXISTS"
+        assert exception_dict["status_code"] == 409
+        assert isinstance(exception_dict["details"], dict)
 
-        assert can_view is False
+    def test_validation_exception_field_details(self, db, test_user):
+        """Test validation exceptions include field-specific details"""
+        shop_data = ShopCreate(shop_code="", shop_name="Test")
+
+        with pytest.raises(InvalidShopDataException) as exc_info:
+            self.service.create_shop(db, shop_data, test_user)
+
+        exception = exc_info.value
+        assert exception.details["field"] == "shop_code"
+        assert exception.status_code == 422
+        assert "required" in exception.message.lower()
+
+    def test_authorization_exception_user_details(self, db, test_user, inactive_shop):
+        """Test authorization exceptions include user context"""
+        with pytest.raises(UnauthorizedShopAccessException) as exc_info:
+            self.service.get_shop_by_code(db, inactive_shop.shop_code, test_user)
+
+        exception = exc_info.value
+        assert exception.details["shop_code"] == inactive_shop.shop_code
+        assert exception.details["user_id"] == test_user.id
+        assert "Unauthorized access" in exception.message
diff --git a/tests/unit/services/test_stats_service.py b/tests/unit/services/test_stats_service.py
index b0c8cd8e..0deeb822 100644
--- a/tests/unit/services/test_stats_service.py
+++ b/tests/unit/services/test_stats_service.py
@@ -214,7 +214,7 @@ class TestStatsService:
 
     def test_get_product_count(self, db, test_product):
         """Test getting total product count"""
-        count = self.service.get_product_count(db)
+        count = self.service._get_product_count(db)
 
         assert count >= 1
         assert isinstance(count, int)
@@ -245,7 +245,7 @@ class TestStatsService:
         db.add_all(brand_products)
         db.commit()
 
-        count = self.service.get_unique_brands_count(db)
+        count = self.service._get_unique_brands_count(db)
 
         assert (
             count >= 2
@@ -278,7 +278,7 @@ class TestStatsService:
         db.add_all(category_products)
         db.commit()
 
-        count = self.service.get_unique_categories_count(db)
+        count = self.service._get_unique_categories_count(db)
 
         assert count >= 2  # At least Electronics and Books
         assert isinstance(count, int)
@@ -307,7 +307,7 @@ class TestStatsService:
         db.add_all(marketplace_products)
         db.commit()
 
-        count = self.service.get_unique_marketplaces_count(db)
+        count = self.service._get_unique_marketplaces_count(db)
 
         assert count >= 2  # At least Amazon and eBay, plus test_product marketplace
         assert isinstance(count, int)
@@ -336,7 +336,7 @@ class TestStatsService:
         db.add_all(shop_products)
         db.commit()
 
-        count = self.service.get_unique_shops_count(db)
+        count = self.service._get_unique_shops_count(db)
 
         assert count >= 2  # At least ShopA and ShopB, plus test_product shop
         assert isinstance(count, int)
@@ -405,7 +405,7 @@ class TestStatsService:
         db.add_all(marketplace_products)
         db.commit()
 
-        brands = self.service.get_brands_by_marketplace(db, "SpecificMarket")
+        brands = self.service._get_brands_by_marketplace(db, "SpecificMarket")
 
         assert len(brands) == 2
         assert "SpecificBrand1" in brands
@@ -438,7 +438,7 @@ class TestStatsService:
         db.add_all(marketplace_products)
         db.commit()
 
-        shops = self.service.get_shops_by_marketplace(db, "TestMarketplace")
+        shops = self.service._get_shops_by_marketplace(db, "TestMarketplace")
 
         assert len(shops) == 2
         assert "TestShop1" in shops
@@ -476,13 +476,13 @@ class TestStatsService:
         db.add_all(marketplace_products)
         db.commit()
 
-        count = self.service.get_products_by_marketplace(db, "CountMarketplace")
+        count = self.service._get_products_by_marketplace_count(db, "CountMarketplace")
 
         assert count == 3
 
     def test_get_products_by_marketplace_not_found(self, db):
         """Test getting product count for non-existent marketplace"""
-        count = self.service.get_products_by_marketplace(db, "NonExistentMarketplace")
+        count = self.service._get_products_by_marketplace_count(db, "NonExistentMarketplace")
 
         assert count == 0
 
diff --git a/tests/unit/services/test_stock_service.py b/tests/unit/services/test_stock_service.py
index e8fc449e..c99f3ccb 100644
--- a/tests/unit/services/test_stock_service.py
+++ b/tests/unit/services/test_stock_service.py
@@ -4,6 +4,15 @@ import uuid
 import pytest
 
 from app.services.stock_service import StockService
+from app.exceptions import (
+    StockNotFoundException,
+    InsufficientStockException,
+    InvalidStockOperationException,
+    StockValidationException,
+    NegativeStockException,
+    InvalidQuantityException,
+    ValidationException,
+)
 from models.schemas.stock import StockAdd, StockCreate, StockUpdate
 from models.database.product import Product
 from models.database.stock import Stock
@@ -18,72 +27,50 @@ class TestStockService:
     def test_normalize_gtin_invalid(self):
         """Test GTIN normalization with invalid GTINs."""
         # Completely invalid values that should return None
-        assert self.service.normalize_gtin("invalid") is None
-        assert self.service.normalize_gtin("abcdef") is None
-        assert self.service.normalize_gtin("") is None
-        assert self.service.normalize_gtin(None) is None
-        assert self.service.normalize_gtin("   ") is None  # Only whitespace
-        assert self.service.normalize_gtin("!@#$%") is None  # Only special characters
+        assert self.service._normalize_gtin("invalid") is None
+        assert self.service._normalize_gtin("abcdef") is None
+        assert self.service._normalize_gtin("") is None
+        assert self.service._normalize_gtin(None) is None
+        assert self.service._normalize_gtin("   ") is None  # Only whitespace
+        assert self.service._normalize_gtin("!@#$%") is None  # Only special characters
 
         # Mixed invalid characters that become empty after filtering
-        assert self.service.normalize_gtin("abc-def-ghi") is None  # No digits
-
-        # Note: Based on your GTINProcessor implementation, short numeric values
-        # will be padded, not rejected. For example:
-        # - "123" becomes "000000000123" (padded to 12 digits)
-        # - "1" becomes "000000000001" (padded to 12 digits)
-
-        # If you want to test that short GTINs are padded (not rejected):
-        assert self.service.normalize_gtin("123") == "0000000000123"
-        assert self.service.normalize_gtin("1") == "0000000000001"
-        assert self.service.normalize_gtin("12345") == "0000000012345"
+        assert self.service._normalize_gtin("abc-def-ghi") is None  # No digits
 
     def test_normalize_gtin_valid(self):
         """Test GTIN normalization with valid GTINs."""
         # Test various valid GTIN formats - these should remain unchanged
-        assert self.service.normalize_gtin("1234567890123") == "1234567890123"  # EAN-13
-        assert self.service.normalize_gtin("123456789012") == "123456789012"  # UPC-A
-        assert self.service.normalize_gtin("12345678") == "12345678"  # EAN-8
-        assert (
-            self.service.normalize_gtin("12345678901234") == "12345678901234"
-        )  # GTIN-14
+        assert self.service._normalize_gtin("1234567890123") == "1234567890123"  # EAN-13
+        assert self.service._normalize_gtin("123456789012") == "123456789012"  # UPC-A
+        assert self.service._normalize_gtin("12345678") == "12345678"  # EAN-8
+        assert self.service._normalize_gtin("12345678901234") == "12345678901234"  # GTIN-14
 
         # Test with decimal points (should be removed)
-        assert self.service.normalize_gtin("1234567890123.0") == "1234567890123"
+        assert self.service._normalize_gtin("1234567890123.0") == "1234567890123"
 
         # Test with whitespace (should be trimmed)
-        assert self.service.normalize_gtin("  1234567890123  ") == "1234567890123"
+        assert self.service._normalize_gtin("  1234567890123  ") == "1234567890123"
 
         # Test short GTINs being padded
-        assert self.service.normalize_gtin("123") == "0000000000123"  # Padded to EAN-13
-        assert (
-            self.service.normalize_gtin("12345") == "0000000012345"
-        )  # Padded to EAN-13
+        assert self.service._normalize_gtin("123") == "0000000000123"  # Padded to EAN-13
+        assert self.service._normalize_gtin("12345") == "0000000012345"  # Padded to EAN-13
 
         # Test long GTINs being truncated
-        assert (
-            self.service.normalize_gtin("123456789012345") == "3456789012345"
-        )  # Truncated to 13
+        assert self.service._normalize_gtin("123456789012345") == "3456789012345"  # Truncated to 13
 
     def test_normalize_gtin_edge_cases(self):
         """Test GTIN normalization edge cases."""
         # Test numeric inputs
-        assert self.service.normalize_gtin(1234567890123) == "1234567890123"
-        assert self.service.normalize_gtin(123) == "0000000000123"
+        assert self.service._normalize_gtin(1234567890123) == "1234567890123"
+        assert self.service._normalize_gtin(123) == "0000000000123"
 
         # Test mixed valid/invalid characters
-        assert (
-            self.service.normalize_gtin("123-456-789-012") == "123456789012"
-        )  # Dashes removed
-        assert (
-            self.service.normalize_gtin("123 456 789 012") == "123456789012"
-        )  # Spaces removed
-        assert (
-            self.service.normalize_gtin("ABC123456789012DEF") == "123456789012"
-        )  # Letters removed
+        assert self.service._normalize_gtin("123-456-789-012") == "123456789012"  # Dashes removed
+        assert self.service._normalize_gtin("123 456 789 012") == "123456789012"  # Spaces removed
+        assert self.service._normalize_gtin("ABC123456789012DEF") == "123456789012"  # Letters removed
 
-    def test_set_stock_new_entry(self, db):
-        """Test setting stock for a new GTIN/location combination."""
+    def test_set_stock_new_entry_success(self, db):
+        """Test setting stock for a new GTIN/location combination successfully."""
         unique_id = str(uuid.uuid4())[:8]
         stock_data = StockCreate(
             gtin="1234567890123", location=f"WAREHOUSE_A_{unique_id}", quantity=100
@@ -95,8 +82,8 @@ class TestStockService:
         assert result.location.upper() == f"WAREHOUSE_A_{unique_id}".upper()
         assert result.quantity == 100
 
-    def test_set_stock_existing_entry(self, db, test_stock):
-        """Test setting stock for an existing GTIN/location combination."""
+    def test_set_stock_existing_entry_success(self, db, test_stock):
+        """Test setting stock for an existing GTIN/location combination successfully."""
         stock_data = StockCreate(
             gtin=test_stock.gtin,
             location=test_stock.location,  # Use exact same location as test_stock
@@ -106,21 +93,47 @@ class TestStockService:
         result = self.service.set_stock(db, stock_data)
 
         assert result.gtin == test_stock.gtin
-        # Fix: Handle case sensitivity properly - compare uppercase or use exact match
         assert result.location == test_stock.location
         assert result.quantity == 200  # Should replace the original quantity
 
-    def test_set_stock_invalid_gtin(self, db):
-        """Test setting stock with invalid GTIN."""
+    def test_set_stock_invalid_gtin_validation_error(self, db):
+        """Test setting stock with invalid GTIN returns StockValidationException."""
         stock_data = StockCreate(
             gtin="invalid_gtin", location="WAREHOUSE_A", quantity=100
         )
 
-        with pytest.raises(ValueError, match="Invalid GTIN format"):
+        with pytest.raises(StockValidationException) as exc_info:
             self.service.set_stock(db, stock_data)
 
-    def test_add_stock_new_entry(self, db):
-        """Test adding stock for a new GTIN/location combination."""
+        assert exc_info.value.error_code == "STOCK_VALIDATION_FAILED"
+        assert "Invalid GTIN format" in str(exc_info.value)
+        assert exc_info.value.details.get("field") == "gtin"
+
+    def test_set_stock_invalid_quantity_error(self, db):
+        """Test setting stock with invalid quantity through service validation."""
+
+        # Test the service validation directly instead of going through Pydantic schema
+        # This bypasses the Pydantic validation to test service layer validation
+
+        # Create a mock stock data object that bypasses Pydantic validation
+        class MockStockData:
+            def __init__(self, gtin, location, quantity):
+                self.gtin = gtin
+                self.location = location
+                self.quantity = quantity
+
+        mock_stock_data = MockStockData("1234567890123", "WAREHOUSE_A", -10)
+
+        # Test the internal validation method directly
+        with pytest.raises(InvalidQuantityException) as exc_info:
+            self.service._validate_quantity(-10, allow_zero=True)
+
+        assert exc_info.value.error_code == "INVALID_QUANTITY"
+        assert "Quantity cannot be negative" in str(exc_info.value)
+        assert exc_info.value.details.get("quantity") == -10
+
+    def test_add_stock_new_entry_success(self, db):
+        """Test adding stock for a new GTIN/location combination successfully."""
         unique_id = str(uuid.uuid4())[:8]
         stock_data = StockAdd(
             gtin="1234567890123", location=f"WAREHOUSE_B_{unique_id}", quantity=50
@@ -132,8 +145,8 @@ class TestStockService:
         assert result.location.upper() == f"WAREHOUSE_B_{unique_id}".upper()
         assert result.quantity == 50
 
-    def test_add_stock_existing_entry(self, db, test_stock):
-        """Test adding stock to an existing GTIN/location combination."""
+    def test_add_stock_existing_entry_success(self, db, test_stock):
+        """Test adding stock to an existing GTIN/location combination successfully."""
         original_quantity = test_stock.quantity
         stock_data = StockAdd(
             gtin=test_stock.gtin,
@@ -147,19 +160,31 @@ class TestStockService:
         assert result.location == test_stock.location
         assert result.quantity == original_quantity + 25
 
-    def test_add_stock_invalid_gtin(self, db):
-        """Test adding stock with invalid GTIN."""
+    def test_add_stock_invalid_gtin_validation_error(self, db):
+        """Test adding stock with invalid GTIN returns StockValidationException."""
         stock_data = StockAdd(gtin="invalid_gtin", location="WAREHOUSE_A", quantity=50)
 
-        with pytest.raises(ValueError, match="Invalid GTIN format"):
+        with pytest.raises(StockValidationException) as exc_info:
             self.service.add_stock(db, stock_data)
 
+        assert exc_info.value.error_code == "STOCK_VALIDATION_FAILED"
+        assert "Invalid GTIN format" in str(exc_info.value)
+
+    def test_add_stock_invalid_quantity_error(self, db):
+        """Test adding stock with invalid quantity through service validation."""
+        # Test zero quantity which should fail for add_stock (doesn't allow zero)
+        # This tests the service validation: allow_zero=False for add operations
+        with pytest.raises(InvalidQuantityException) as exc_info:
+            self.service._validate_quantity(0, allow_zero=False)
+
+        assert exc_info.value.error_code == "INVALID_QUANTITY"
+        assert "Quantity must be positive" in str(exc_info.value)
+
+
     def test_remove_stock_success(self, db, test_stock):
         """Test removing stock successfully."""
         original_quantity = test_stock.quantity
-        remove_quantity = min(
-            10, original_quantity
-        )  # Ensure we don't remove more than available
+        remove_quantity = min(10, original_quantity)  # Ensure we don't remove more than available
 
         stock_data = StockAdd(
             gtin=test_stock.gtin,
@@ -173,39 +198,64 @@ class TestStockService:
         assert result.location == test_stock.location
         assert result.quantity == original_quantity - remove_quantity
 
-    def test_remove_stock_insufficient_stock(self, db, test_stock):
-        """Test removing more stock than available."""
+    def test_remove_stock_insufficient_stock_error(self, db, test_stock):
+        """Test removing more stock than available returns InsufficientStockException."""
         stock_data = StockAdd(
             gtin=test_stock.gtin,
             location=test_stock.location,  # Use exact same location as test_stock
             quantity=test_stock.quantity + 10,  # More than available
         )
 
-        # Fix: Use more flexible regex pattern
-        with pytest.raises(
-            ValueError, match="Insufficient stock|Not enough stock|Cannot remove"
-        ):
+        with pytest.raises(InsufficientStockException) as exc_info:
             self.service.remove_stock(db, stock_data)
 
-    def test_remove_stock_nonexistent_entry(self, db):
-        """Test removing stock from non-existent GTIN/location."""
+        assert exc_info.value.error_code == "INSUFFICIENT_STOCK"
+        assert exc_info.value.details["gtin"] == test_stock.gtin
+        assert exc_info.value.details["location"] == test_stock.location
+        assert exc_info.value.details["requested_quantity"] == test_stock.quantity + 10
+        assert exc_info.value.details["available_quantity"] == test_stock.quantity
+
+    def test_remove_stock_nonexistent_entry_not_found(self, db):
+        """Test removing stock from non-existent GTIN/location returns StockNotFoundException."""
         unique_id = str(uuid.uuid4())[:8]
         stock_data = StockAdd(
             gtin="9999999999999", location=f"NONEXISTENT_{unique_id}", quantity=10
         )
 
-        with pytest.raises(ValueError, match="No stock found|Stock not found"):
+        with pytest.raises(StockNotFoundException) as exc_info:
             self.service.remove_stock(db, stock_data)
 
-    def test_remove_stock_invalid_gtin(self, db):
-        """Test removing stock with invalid GTIN."""
+        assert exc_info.value.error_code == "STOCK_NOT_FOUND"
+        assert "9999999999999" in str(exc_info.value)
+        assert exc_info.value.details["resource_type"] == "Stock"
+
+    def test_remove_stock_invalid_gtin_validation_error(self, db):
+        """Test removing stock with invalid GTIN returns StockValidationException."""
         stock_data = StockAdd(gtin="invalid_gtin", location="WAREHOUSE_A", quantity=10)
 
-        with pytest.raises(ValueError, match="Invalid GTIN format"):
+        with pytest.raises(StockValidationException) as exc_info:
             self.service.remove_stock(db, stock_data)
 
+        assert exc_info.value.error_code == "STOCK_VALIDATION_FAILED"
+        assert "Invalid GTIN format" in str(exc_info.value)
+
+    def test_remove_stock_negative_result_error(self, db, test_stock):
+        """Test removing stock that would result in negative quantity returns NegativeStockException."""
+        # This is handled by InsufficientStockException, but test the logic
+        stock_data = StockAdd(
+            gtin=test_stock.gtin,
+            location=test_stock.location,
+            quantity=test_stock.quantity + 1,  # One more than available
+        )
+
+        with pytest.raises(InsufficientStockException) as exc_info:
+            self.service.remove_stock(db, stock_data)
+
+        # The service prevents negative stock through InsufficientStockException
+        assert exc_info.value.error_code == "INSUFFICIENT_STOCK"
+
     def test_get_stock_by_gtin_success(self, db, test_stock, test_product):
-        """Test getting stock summary by GTIN."""
+        """Test getting stock summary by GTIN successfully."""
         result = self.service.get_stock_by_gtin(db, test_stock.gtin)
 
         assert result.gtin == test_stock.gtin
@@ -215,19 +265,14 @@ class TestStockService:
         assert result.locations[0].quantity == test_stock.quantity
         assert result.product_title == test_product.title
 
-    def test_get_stock_by_gtin_multiple_locations(self, db, test_product):
-        """Test getting stock summary with multiple locations."""
+    def test_get_stock_by_gtin_multiple_locations_success(self, db, test_product):
+        """Test getting stock summary with multiple locations successfully."""
         unique_gtin = test_product.gtin
-
         unique_id = str(uuid.uuid4())[:8]
 
         # Create multiple stock entries for the same GTIN with unique locations
-        stock1 = Stock(
-            gtin=unique_gtin, location=f"WAREHOUSE_A_{unique_id}", quantity=50
-        )
-        stock2 = Stock(
-            gtin=unique_gtin, location=f"WAREHOUSE_B_{unique_id}", quantity=30
-        )
+        stock1 = Stock(gtin=unique_gtin, location=f"WAREHOUSE_A_{unique_id}", quantity=50)
+        stock2 = Stock(gtin=unique_gtin, location=f"WAREHOUSE_B_{unique_id}", quantity=30)
 
         db.add(stock1)
         db.add(stock2)
@@ -239,18 +284,25 @@ class TestStockService:
         assert result.total_quantity == 80
         assert len(result.locations) == 2
 
-    def test_get_stock_by_gtin_not_found(self, db):
-        """Test getting stock for non-existent GTIN."""
-        with pytest.raises(ValueError, match="No stock found"):
+    def test_get_stock_by_gtin_not_found_error(self, db):
+        """Test getting stock for non-existent GTIN returns StockNotFoundException."""
+        with pytest.raises(StockNotFoundException) as exc_info:
             self.service.get_stock_by_gtin(db, "9999999999999")
 
-    def test_get_stock_by_gtin_invalid_gtin(self, db):
-        """Test getting stock with invalid GTIN."""
-        with pytest.raises(ValueError, match="Invalid GTIN format"):
+        assert exc_info.value.error_code == "STOCK_NOT_FOUND"
+        assert "9999999999999" in str(exc_info.value)
+        assert exc_info.value.details["resource_type"] == "Stock"
+
+    def test_get_stock_by_gtin_invalid_gtin_validation_error(self, db):
+        """Test getting stock with invalid GTIN returns StockValidationException."""
+        with pytest.raises(StockValidationException) as exc_info:
             self.service.get_stock_by_gtin(db, "invalid_gtin")
 
+        assert exc_info.value.error_code == "STOCK_VALIDATION_FAILED"
+        assert "Invalid GTIN format" in str(exc_info.value)
+
     def test_get_total_stock_success(self, db, test_stock, test_product):
-        """Test getting total stock for a GTIN."""
+        """Test getting total stock for a GTIN successfully."""
         result = self.service.get_total_stock(db, test_stock.gtin)
 
         assert result["gtin"] == test_stock.gtin
@@ -258,43 +310,52 @@ class TestStockService:
         assert result["product_title"] == test_product.title
         assert result["locations_count"] == 1
 
-    def test_get_total_stock_invalid_gtin(self, db):
-        """Test getting total stock with invalid GTIN."""
-        with pytest.raises(ValueError, match="Invalid GTIN format"):
+    def test_get_total_stock_invalid_gtin_validation_error(self, db):
+        """Test getting total stock with invalid GTIN returns StockValidationException."""
+        with pytest.raises(StockValidationException) as exc_info:
             self.service.get_total_stock(db, "invalid_gtin")
 
-    def test_get_all_stock_no_filters(self, db, test_stock):
-        """Test getting all stock without filters."""
+        assert exc_info.value.error_code == "STOCK_VALIDATION_FAILED"
+        assert "Invalid GTIN format" in str(exc_info.value)
+
+    def test_get_total_stock_not_found_error(self, db):
+        """Test getting total stock for non-existent GTIN returns StockNotFoundException."""
+        with pytest.raises(StockNotFoundException) as exc_info:
+            self.service.get_total_stock(db, "9999999999999")
+
+        assert exc_info.value.error_code == "STOCK_NOT_FOUND"
+
+    def test_get_all_stock_no_filters_success(self, db, test_stock):
+        """Test getting all stock without filters successfully."""
         result = self.service.get_all_stock(db)
 
         assert len(result) >= 1
         assert any(stock.gtin == test_stock.gtin for stock in result)
 
-    def test_get_all_stock_with_location_filter(self, db, test_stock):
-        """Test getting all stock with location filter."""
+    def test_get_all_stock_with_location_filter_success(self, db, test_stock):
+        """Test getting all stock with location filter successfully."""
         result = self.service.get_all_stock(db, location=test_stock.location)
 
         assert len(result) >= 1
-        # Fix: Handle case sensitivity in comparison
-        assert all(
-            stock.location.upper() == test_stock.location.upper() for stock in result
-        )
+        # Check that all returned stocks match the filter (case insensitive)
+        for stock in result:
+            assert test_stock.location.upper() in stock.location.upper()
 
-    def test_get_all_stock_with_gtin_filter(self, db, test_stock):
-        """Test getting all stock with GTIN filter."""
+    def test_get_all_stock_with_gtin_filter_success(self, db, test_stock):
+        """Test getting all stock with GTIN filter successfully."""
         result = self.service.get_all_stock(db, gtin=test_stock.gtin)
 
         assert len(result) >= 1
         assert all(stock.gtin == test_stock.gtin for stock in result)
 
-    def test_get_all_stock_with_pagination(self, db):
-        """Test getting all stock with pagination."""
+    def test_get_all_stock_with_pagination_success(self, db):
+        """Test getting all stock with pagination successfully."""
         unique_prefix = str(uuid.uuid4())[:8]
 
         # Create multiple stock entries with unique GTINs and locations
         for i in range(5):
             stock = Stock(
-                gtin=f"1234567890{i:03d}",  # Creates valid 13-digit GTINs: 1234567890000, 1234567890001, etc.
+                gtin=f"1234567890{i:03d}",  # Creates valid 13-digit GTINs
                 location=f"WAREHOUSE_{unique_prefix}_{i}",
                 quantity=10,
             )
@@ -303,12 +364,10 @@ class TestStockService:
 
         result = self.service.get_all_stock(db, skip=2, limit=2)
 
-        assert (
-            len(result) <= 2
-        )  # Should be at most 2, might be less if other records exist
+        assert len(result) <= 2  # Should be at most 2, might be less if other records exist
 
     def test_update_stock_success(self, db, test_stock):
-        """Test updating stock quantity."""
+        """Test updating stock quantity successfully."""
         stock_update = StockUpdate(quantity=150)
 
         result = self.service.update_stock(db, test_stock.id, stock_update)
@@ -316,15 +375,28 @@ class TestStockService:
         assert result.id == test_stock.id
         assert result.quantity == 150
 
-    def test_update_stock_not_found(self, db):
-        """Test updating non-existent stock entry."""
+    def test_update_stock_not_found_error(self, db):
+        """Test updating non-existent stock entry returns StockNotFoundException."""
         stock_update = StockUpdate(quantity=150)
 
-        with pytest.raises(ValueError, match="Stock entry not found"):
+        with pytest.raises(StockNotFoundException) as exc_info:
             self.service.update_stock(db, 99999, stock_update)
 
+        assert exc_info.value.error_code == "STOCK_NOT_FOUND"
+        assert "99999" in str(exc_info.value)
+
+    def test_update_stock_invalid_quantity_error(self, db, test_stock):
+        """Test updating stock with invalid quantity returns InvalidQuantityException."""
+        stock_update = StockUpdate(quantity=-10)
+
+        with pytest.raises(InvalidQuantityException) as exc_info:
+            self.service.update_stock(db, test_stock.id, stock_update)
+
+        assert exc_info.value.error_code == "INVALID_QUANTITY"
+        assert "Quantity cannot be negative" in str(exc_info.value)
+
     def test_delete_stock_success(self, db, test_stock):
-        """Test deleting stock entry."""
+        """Test deleting stock entry successfully."""
         stock_id = test_stock.id
 
         result = self.service.delete_stock(db, stock_id)
@@ -335,24 +407,85 @@ class TestStockService:
         deleted_stock = db.query(Stock).filter(Stock.id == stock_id).first()
         assert deleted_stock is None
 
-    def test_delete_stock_not_found(self, db):
-        """Test deleting non-existent stock entry."""
-        with pytest.raises(ValueError, match="Stock entry not found"):
+    def test_delete_stock_not_found_error(self, db):
+        """Test deleting non-existent stock entry returns StockNotFoundException."""
+        with pytest.raises(StockNotFoundException) as exc_info:
             self.service.delete_stock(db, 99999)
 
-    def test_get_stock_by_id_success(self, db, test_stock):
-        """Test getting stock entry by ID."""
-        result = self.service.get_stock_by_id(db, test_stock.id)
+        assert exc_info.value.error_code == "STOCK_NOT_FOUND"
+        assert "99999" in str(exc_info.value)
 
-        assert result is not None
-        assert result.id == test_stock.id
-        assert result.gtin == test_stock.gtin
+    def test_get_low_stock_items_success(self, db, test_stock, test_product):
+        """Test getting low stock items successfully."""
+        # Set stock to a low value
+        test_stock.quantity = 5
+        db.commit()
 
-    def test_get_stock_by_id_not_found(self, db):
-        """Test getting non-existent stock entry by ID."""
-        result = self.service.get_stock_by_id(db, 99999)
+        result = self.service.get_low_stock_items(db, threshold=10)
 
-        assert result is None
+        assert len(result) >= 1
+        low_stock_item = next((item for item in result if item["gtin"] == test_stock.gtin), None)
+        assert low_stock_item is not None
+        assert low_stock_item["current_quantity"] == 5
+        assert low_stock_item["location"] == test_stock.location
+        assert low_stock_item["product_title"] == test_product.title
+
+    def test_get_low_stock_items_invalid_threshold_error(self, db):
+        """Test getting low stock items with invalid threshold returns InvalidQuantityException."""
+        with pytest.raises(InvalidQuantityException) as exc_info:
+            self.service.get_low_stock_items(db, threshold=-5)
+
+        assert exc_info.value.error_code == "INVALID_QUANTITY"
+        assert "Threshold must be non-negative" in str(exc_info.value)
+
+    def test_get_stock_summary_by_location_success(self, db, test_stock):
+        """Test getting stock summary by location successfully."""
+        result = self.service.get_stock_summary_by_location(db, test_stock.location)
+
+        assert result["location"] == test_stock.location.upper()  # Service normalizes to uppercase
+        assert result["total_items"] >= 1
+        assert result["total_quantity"] >= test_stock.quantity
+        assert result["unique_gtins"] >= 1
+
+    def test_get_stock_summary_by_location_empty_result(self, db):
+        """Test getting stock summary for location with no stock."""
+        unique_id = str(uuid.uuid4())[:8]
+        result = self.service.get_stock_summary_by_location(db, f"EMPTY_LOCATION_{unique_id}")
+
+        assert result["total_items"] == 0
+        assert result["total_quantity"] == 0
+        assert result["unique_gtins"] == 0
+
+    def test_validate_quantity_edge_cases(self, db):
+        """Test quantity validation with edge cases."""
+        # Test zero quantity with allow_zero=True (should succeed)
+        stock_data = StockCreate(gtin="1234567890123", location="WAREHOUSE_A", quantity=0)
+        result = self.service.set_stock(db, stock_data)
+        assert result.quantity == 0
+
+        # Test zero quantity with add_stock (should fail - doesn't allow zero)
+        stock_data_add = StockAdd(gtin="1234567890123", location="WAREHOUSE_B", quantity=0)
+        with pytest.raises(InvalidQuantityException):
+            self.service.add_stock(db, stock_data_add)
+
+    def test_exception_structure_consistency(self, db):
+        """Test that all exceptions follow the consistent LetzShopException structure."""
+        # Test with a known error case
+        with pytest.raises(StockNotFoundException) as exc_info:
+            self.service.get_stock_by_gtin(db, "9999999999999")
+
+        exception = exc_info.value
+
+        # Verify exception structure matches LetzShopException.to_dict()
+        assert hasattr(exception, 'error_code')
+        assert hasattr(exception, 'message')
+        assert hasattr(exception, 'status_code')
+        assert hasattr(exception, 'details')
+
+        assert isinstance(exception.error_code, str)
+        assert isinstance(exception.message, str)
+        assert isinstance(exception.status_code, int)
+        assert isinstance(exception.details, dict)
 
 
 @pytest.fixture