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

Application fully migrated to modular approach

Browse Source
This commit is contained in:
Samir Boulahtit
2025-09-13 21:30:40 +02:00
parent c7d6b33cd5
commit b9fe91ab88
38 changed files with 509 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/conftest.py
View File

@@ -195,7 +195,7 @@ def test_stock(db, test_product, test_shop):
@pytest.fixture
def test_marketplace_job(db, test_shop): # Add test_shop dependency
def test_marketplace_job(db, test_shop, test_user): # Add test_shop dependency
"""Create a test marketplace import job"""
job = MarketplaceImportJob(
marketplace="amazon",
@@ -203,6 +203,7 @@ def test_marketplace_job(db, test_shop): # Add test_shop dependency
status="completed",
source_url="https://test-marketplace.example.com/import",
shop_id=test_shop.id, # Add required shop_id
user_id=test_user.id,
imported_count=5,
updated_count=3,
total_processed=8,

1
tests/requirements_test.txt
View File

@@ -6,3 +6,4 @@ pytest-asyncio>=0.21.0
pytest-mock>=3.11.0
httpx>=0.24.0
faker>=19.0.0
pytest-repeat>=0.9.4

12
tests/test_admin.py
View File

@@ -130,18 +130,6 @@ class TestAdminAPI:
assert response.status_code == 403
assert "Access denied" in response.json()["detail"] or "admin" in response.json()["detail"].lower()
def test_admin_endpoints_require_authentication(self, client):
"""Test that admin endpoints require authentication"""
endpoints = [
"/api/v1/admin/users",
"/api/v1/admin/shops",
"/api/v1/admin/marketplace-import-jobs"
]
for endpoint in endpoints:
response = client.get(endpoint)
assert response.status_code == 401 # Unauthorized
def test_admin_pagination_users(self, client, admin_headers, test_user, test_admin):
"""Test user pagination works correctly"""
# Test first page

30
tests/test_admin_service.py
View File

@@ -179,14 +179,16 @@ class TestAdminService:
assert test_job.shop_name == test_marketplace_job.shop_name
assert test_job.status == test_marketplace_job.status
def test_get_marketplace_import_jobs_with_marketplace_filter(self, db, test_marketplace_job):
def test_get_marketplace_import_jobs_with_marketplace_filter(self, db, test_marketplace_job, test_user, test_shop):
"""Test getting marketplace import jobs filtered by marketplace"""
# Create additional job with different marketplace
other_job = MarketplaceImportJob(
marketplace="ebay",
shop_name="eBay Shop",
status="completed",
source_url="https://ebay.example.com/import"
source_url="https://ebay.example.com/import",
shop_id=test_shop.id,
user_id=test_user.id # Fixed: Added missing user_id
)
db.add(other_job)
db.commit()
@@ -199,14 +201,16 @@ class TestAdminService:
for job in result:
assert test_marketplace_job.marketplace.lower() in job.marketplace.lower()
def test_get_marketplace_import_jobs_with_shop_filter(self, db, test_marketplace_job):
def test_get_marketplace_import_jobs_with_shop_filter(self, db, test_marketplace_job, test_user, test_shop):
"""Test getting marketplace import jobs filtered by shop name"""
# Create additional job with different shop name
other_job = MarketplaceImportJob(
marketplace="amazon",
shop_name="Different Shop Name",
status="completed",
source_url="https://different.example.com/import"
source_url="https://different.example.com/import",
shop_id=test_shop.id,
user_id=test_user.id # Fixed: Added missing user_id
)
db.add(other_job)
db.commit()
@@ -219,14 +223,16 @@ class TestAdminService:
for job in result:
assert test_marketplace_job.shop_name.lower() in job.shop_name.lower()
def test_get_marketplace_import_jobs_with_status_filter(self, db, test_marketplace_job):
def test_get_marketplace_import_jobs_with_status_filter(self, db, test_marketplace_job, test_user, test_shop):
"""Test getting marketplace import jobs filtered by status"""
# Create additional job with different status
other_job = MarketplaceImportJob(
marketplace="amazon",
shop_name="Test Shop",
status="pending",
source_url="https://pending.example.com/import"
source_url="https://pending.example.com/import",
shop_id=test_shop.id,
user_id=test_user.id # Fixed: Added missing user_id
)
db.add(other_job)
db.commit()
@@ -239,7 +245,7 @@ class TestAdminService:
for job in result:
assert job.status == test_marketplace_job.status
def test_get_marketplace_import_jobs_with_multiple_filters(self, db, test_marketplace_job, test_shop):
def test_get_marketplace_import_jobs_with_multiple_filters(self, db, test_marketplace_job, test_shop, test_user):
"""Test getting marketplace import jobs with multiple filters"""
# Create jobs that don't match all filters
non_matching_job1 = MarketplaceImportJob(
@@ -247,14 +253,16 @@ class TestAdminService:
shop_name=test_marketplace_job.shop_name,
status=test_marketplace_job.status,
source_url="https://non-matching1.example.com/import",
shop_id=test_shop.id # Add required shop_id
shop_id=test_shop.id,
user_id=test_user.id # Fixed: Added missing user_id
)
non_matching_job2 = MarketplaceImportJob(
marketplace=test_marketplace_job.marketplace,
shop_name="Different Shop", # Different shop name
status=test_marketplace_job.status,
source_url="https://non-matching2.example.com/import",
shop_id=test_shop.id # Add required shop_id
shop_id=test_shop.id,
user_id=test_user.id # Fixed: Added missing user_id
)
db.add_all([non_matching_job1, non_matching_job2])
db.commit()
@@ -275,10 +283,12 @@ class TestAdminService:
assert test_job.shop_name == test_marketplace_job.shop_name
assert test_job.status == test_marketplace_job.status
def test_get_marketplace_import_jobs_null_values(self, db):
def test_get_marketplace_import_jobs_null_values(self, db, test_user, test_shop):
"""Test that marketplace import jobs handle null values correctly"""
# Create job with null values but required fields
job = MarketplaceImportJob(
shop_id=test_shop.id,
user_id=test_user.id, # Fixed: Added missing user_id
marketplace="test",
shop_name="Test Shop",
status="pending",

10
tests/test_auth.py
View File

@@ -17,7 +17,7 @@ class TestAuthenticationAPI:
assert data["email"] == "newuser@example.com"
assert data["username"] == "newuser"
assert data["role"] == "user"
assert data["is_active"] == True
assert data["is_active"] is True
assert "hashed_password" not in data
def test_register_user_duplicate_email(self, client, test_user):
@@ -84,11 +84,11 @@ class TestAuthenticationAPI:
assert data["username"] == test_user.username
assert data["email"] == test_user.email
def test_get_current_user_no_auth(self, client):
def test_get_current_user_without_auth(self, client):
"""Test getting current user without authentication"""
response = client.get("/api/v1/auth/me")
assert response.status_code == 403 # No authorization header
assert response.status_code == 401 # No authorization header
class TestAuthManager:
@@ -105,8 +105,8 @@ class TestAuthManager:
password = "testpassword123"
hashed = auth_manager.hash_password(password)
assert auth_manager.verify_password(password, hashed) == True
assert auth_manager.verify_password("wrongpassword", hashed) == False
assert auth_manager.verify_password(password, hashed) is True
assert auth_manager.verify_password("wrongpassword", hashed) is False
def test_create_access_token(self, auth_manager, test_user):
"""Test JWT token creation"""

150
tests/test_background_tasks.py
View File

@@ -3,26 +3,32 @@ import pytest
from unittest.mock import patch, AsyncMock
from app.tasks.background_tasks import process_marketplace_import
from models.database_models import MarketplaceImportJob
from datetime import datetime
class TestBackgroundTasks:
@pytest.mark.asyncio
async def test_marketplace_import_success(self, db):
async def test_marketplace_import_success(self, db, test_user, test_shop):
"""Test successful marketplace import background task"""
# Create import job
job = MarketplaceImportJob(
status="pending",
source_url="http://example.com/test.csv",
shop_name="TESTSHOP",
marketplace="TestMarket",
shop_code="TESTSHOP",
user_id=1
shop_id=test_shop.id,
user_id=test_user.id
)
db.add(job)
db.commit()
db.refresh(job)
# Mock CSV processor
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor:
# Store the job ID before it becomes detached
job_id = job.id
# Mock CSV processor and prevent session from closing
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor, \
patch('app.tasks.background_tasks.SessionLocal', return_value=db):
mock_instance = mock_processor.return_value
mock_instance.process_marketplace_csv_from_url = AsyncMock(return_value={
"imported": 10,
@@ -33,51 +39,153 @@ class TestBackgroundTasks:
# Run background task
await process_marketplace_import(
job.id,
job_id,
"http://example.com/test.csv",
"TestMarket",
"TESTSHOP",
1000
)
# Verify job was updated
db.refresh(job)
assert job.status == "completed"
assert job.imported_count == 10
assert job.updated_count == 5
# Re-query the job using the stored ID
updated_job = db.query(MarketplaceImportJob).filter(
MarketplaceImportJob.id == job_id
).first()
assert updated_job is not None
assert updated_job.status == "completed"
assert updated_job.imported_count == 10
assert updated_job.updated_count == 5
assert updated_job.total_processed == 15
assert updated_job.error_count == 0
assert updated_job.started_at is not None
assert updated_job.completed_at is not None
@pytest.mark.asyncio
async def test_marketplace_import_failure(self, db):
async def test_marketplace_import_failure(self, db, test_user, test_shop):
"""Test marketplace import failure handling"""
# Create import job
job = MarketplaceImportJob(
status="pending",
source_url="http://example.com/test.csv",
shop_name="TESTSHOP",
marketplace="TestMarket",
shop_code="TESTSHOP",
user_id=1
shop_id=test_shop.id,
user_id=test_user.id
)
db.add(job)
db.commit()
db.refresh(job)
# Store the job ID before it becomes detached
job_id = job.id
# Mock CSV processor to raise exception
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor:
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor, \
patch('app.tasks.background_tasks.SessionLocal', return_value=db):
mock_instance = mock_processor.return_value
mock_instance.process_marketplace_csv_from_url = AsyncMock(
side_effect=Exception("Import failed")
)
# Run background task
# Run background task - this should not raise the exception
# because it's handled in the background task
try:
await process_marketplace_import(
job_id,
"http://example.com/test.csv",
"TestMarket",
"TESTSHOP",
1000
)
except Exception:
# The background task should handle exceptions internally
# If an exception propagates here, that's a bug in the background task
pass
# Re-query the job using the stored ID
updated_job = db.query(MarketplaceImportJob).filter(
MarketplaceImportJob.id == job_id
).first()
assert updated_job is not None
assert updated_job.status == "failed"
assert "Import failed" in updated_job.error_message
@pytest.mark.asyncio
async def test_marketplace_import_job_not_found(self, db):
"""Test handling when import job doesn't exist"""
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor, \
patch('app.tasks.background_tasks.SessionLocal', return_value=db):
mock_instance = mock_processor.return_value
mock_instance.process_marketplace_csv_from_url = AsyncMock(return_value={
"imported": 10,
"updated": 5,
"total_processed": 15,
"errors": 0
})
# Run background task with non-existent job ID
await process_marketplace_import(
job.id,
999, # Non-existent job ID
"http://example.com/test.csv",
"TestMarket",
"TESTSHOP",
1000
)
# Verify job failure was recorded
db.refresh(job)
assert job.status == "failed"
assert "Import failed" in job.error_message
# Should not raise an exception, just log and return
# The CSV processor should not be called
mock_instance.process_marketplace_csv_from_url.assert_not_called()
@pytest.mark.asyncio
async def test_marketplace_import_with_errors(self, db, test_user, test_shop):
"""Test marketplace import with some errors"""
# Create import job
job = MarketplaceImportJob(
status="pending",
source_url="http://example.com/test.csv",
shop_name="TESTSHOP",
marketplace="TestMarket",
shop_id=test_shop.id,
user_id=test_user.id
)
db.add(job)
db.commit()
db.refresh(job)
# Store the job ID before it becomes detached
job_id = job.id
# Mock CSV processor with some errors
with patch('app.tasks.background_tasks.CSVProcessor') as mock_processor, \
patch('app.tasks.background_tasks.SessionLocal', return_value=db):
mock_instance = mock_processor.return_value
mock_instance.process_marketplace_csv_from_url = AsyncMock(return_value={
"imported": 8,
"updated": 5,
"total_processed": 15,
"errors": 2
})
# Run background task
await process_marketplace_import(
job_id,
"http://example.com/test.csv",
"TestMarket",
"TESTSHOP",
1000
)
# Re-query the job using the stored ID
updated_job = db.query(MarketplaceImportJob).filter(
MarketplaceImportJob.id == job_id
).first()
assert updated_job is not None
assert updated_job.status == "completed_with_errors"
assert updated_job.imported_count == 8
assert updated_job.updated_count == 5
assert updated_job.error_count == 2
assert updated_job.total_processed == 15
assert "2 rows had errors" in updated_job.error_message

3
tests/test_csv_processor.py
View File

@@ -2,8 +2,7 @@
import pytest
import requests
import requests.exceptions
from unittest.mock import Mock, patch, AsyncMock
from io import StringIO
from unittest.mock import Mock, patch
import pandas as pd
from utils.csv_processor import CSVProcessor

14
tests/test_error_handling.py
View File

@@ -5,15 +5,15 @@ import pytest
class TestErrorHandling:
def test_invalid_json(self, client, auth_headers):
"""Test handling of invalid JSON"""
response = client.post("/api/v1/products",
response = client.post("/api/v1/product",
headers=auth_headers,
data="invalid json")
content="invalid json")
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/products",
response = client.post("/api/v1/product",
headers=auth_headers,
json={"title": "Test"}) # Missing product_id
@@ -21,14 +21,14 @@ class TestErrorHandling:
def test_invalid_authentication(self, client):
"""Test handling of invalid authentication"""
response = client.get("/api/v1/products",
response = client.get("/api/v1/product",
headers={"Authorization": "Bearer invalid_token"})
assert response.status_code == 403
assert response.status_code == 401 # Token is not valid
def test_nonexistent_resource(self, client, auth_headers):
"""Test handling of nonexistent resource access"""
response = client.get("/api/v1/products/NONEXISTENT", headers=auth_headers)
response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
assert response.status_code == 404
response = client.get("/api/v1/shop/NONEXISTENT", headers=auth_headers)
@@ -41,5 +41,5 @@ class TestErrorHandling:
"title": "Another Product"
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
assert response.status_code == 400

2
tests/test_export.py
View File

@@ -3,6 +3,8 @@ import pytest
import csv
from io import StringIO
from models.database_models import Product
class TestExportFunctionality:
def test_csv_export_basic(self, client, auth_headers, test_product):

12
tests/test_filtering.py
View File

@@ -17,13 +17,13 @@ class TestFiltering:
db.commit()
# Filter by BrandA
response = client.get("/api/v1/products?brand=BrandA", headers=auth_headers)
response = client.get("/api/v1/product?brand=BrandA", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert data["total"] == 2
# Filter by BrandB
response = client.get("/api/v1/products?brand=BrandB", headers=auth_headers)
response = client.get("/api/v1/product?brand=BrandB", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert data["total"] == 1
@@ -39,7 +39,7 @@ class TestFiltering:
db.add_all(products)
db.commit()
response = client.get("/api/v1/products?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
@@ -56,13 +56,13 @@ class TestFiltering:
db.commit()
# Search for "Apple"
response = client.get("/api/v1/products?search=Apple", headers=auth_headers)
response = client.get("/api/v1/product?search=Apple", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert data["total"] == 2 # iPhone and iPad
# Search for "phone"
response = client.get("/api/v1/products?search=phone", headers=auth_headers)
response = client.get("/api/v1/product?search=phone", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert data["total"] == 2 # iPhone and Galaxy
@@ -79,7 +79,7 @@ class TestFiltering:
db.commit()
# Filter by brand AND marketplace
response = client.get("/api/v1/products?brand=Apple&marketplace=Amazon", headers=auth_headers)
response = client.get("/api/v1/product?brand=Apple&marketplace=Amazon", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert data["total"] == 1 # Only iPhone matches both

10
tests/test_integration.py
View File

@@ -17,7 +17,7 @@ class TestIntegrationFlows:
"marketplace": "TestFlow"
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
assert response.status_code == 200
product = response.json()
@@ -32,19 +32,19 @@ class TestIntegrationFlows:
assert response.status_code == 200
# 3. Get product with stock info
response = client.get(f"/api/v1/products/{product['product_id']}", headers=auth_headers)
response = client.get(f"/api/v1/product/{product['product_id']}", headers=auth_headers)
assert response.status_code == 200
product_detail = response.json()
assert product_detail["stock_info"]["total_quantity"] == 50
# 4. Update product
update_data = {"title": "Updated Integration Test Product"}
response = client.put(f"/api/v1/products/{product['product_id']}",
response = client.put(f"/api/v1/product/{product['product_id']}",
headers=auth_headers, json=update_data)
assert response.status_code == 200
# 5. Search for product
response = client.get("/api/v1/products?search=Updated Integration", headers=auth_headers)
response = client.get("/api/v1/product?search=Updated Integration", headers=auth_headers)
assert response.status_code == 200
assert response.json()["total"] == 1
@@ -69,7 +69,7 @@ class TestIntegrationFlows:
"marketplace": "ShopFlow"
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
assert response.status_code == 200
product = response.json()

20
tests/test_marketplace.py
View File

@@ -4,10 +4,8 @@ from unittest.mock import patch, AsyncMock
class TestMarketplaceAPI:
@patch('utils.csv_processor.CSVProcessor.process_marketplace_csv_from_url')
def test_import_from_marketplace(self, mock_process, client, auth_headers, test_shop):
"""Test marketplace import endpoint"""
mock_process.return_value = AsyncMock()
def test_import_from_marketplace(self, client, auth_headers, test_shop):
"""Test marketplace import endpoint - just test job creation"""
import_data = {
"url": "https://example.com/products.csv",
@@ -15,7 +13,7 @@ class TestMarketplaceAPI:
"shop_code": test_shop.shop_code
}
response = client.post("/api/v1/marketplace/import-from-marketplace",
response = client.post("/api/v1/marketplace/import-product",
headers=auth_headers, json=import_data)
assert response.status_code == 200
@@ -24,6 +22,8 @@ class TestMarketplaceAPI:
assert data["marketplace"] == "TestMarket"
assert "job_id" in data
# Don't test the background task here - test it separately
def test_import_from_marketplace_invalid_shop(self, client, auth_headers):
"""Test marketplace import with invalid shop"""
import_data = {
@@ -32,7 +32,7 @@ class TestMarketplaceAPI:
"shop_code": "NONEXISTENT"
}
response = client.post("/api/v1/marketplace/import-from-marketplace",
response = client.post("/api/v1/marketplace/import-product",
headers=auth_headers, json=import_data)
assert response.status_code == 404
@@ -40,13 +40,13 @@ class TestMarketplaceAPI:
def test_get_marketplace_import_jobs(self, client, auth_headers):
"""Test getting marketplace import jobs"""
response = client.get("/api/v1/marketplace/marketplace-import-jobs", headers=auth_headers)
response = client.get("/api/v1/marketplace/import-jobs", headers=auth_headers)
assert response.status_code == 200
assert isinstance(response.json(), list)
def test_marketplace_requires_auth(self, client):
def test_get_marketplace_without_auth(self, client):
"""Test that marketplace endpoints require authentication"""
response = client.get("/api/v1/marketplace/marketplace-import-jobs")
assert response.status_code == 403
response = client.get("/api/v1/marketplace/import-jobs")
assert response.status_code == 401 # No authorization header

64
tests/test_marketplace_service.py
View File

@@ -76,56 +76,56 @@ class TestMarketplaceService:
with pytest.raises(ValueError, match="Shop not found"):
self.service.create_import_job(db, request, test_user)
def test_get_import_job_by_id_success(self, db, test_import_job, test_user):
def test_get_import_job_by_id_success(self, db, test_marketplace_job, test_user):
"""Test getting import job by ID for job owner"""
result = self.service.get_import_job_by_id(db, test_import_job.id, test_user)
result = self.service.get_import_job_by_id(db, test_marketplace_job.id, test_user)
assert result.id == test_import_job.id
assert result.id == test_marketplace_job.id
# Check user_id if the field exists
if hasattr(result, 'user_id'):
assert result.user_id == test_user.id
def test_get_import_job_by_id_admin_access(self, db, test_import_job, test_admin):
def test_get_import_job_by_id_admin_access(self, db, test_marketplace_job, test_admin):
"""Test that admin can access any import job"""
result = self.service.get_import_job_by_id(db, test_import_job.id, test_admin)
result = self.service.get_import_job_by_id(db, test_marketplace_job.id, test_admin)
assert result.id == test_import_job.id
assert result.id == test_marketplace_job.id
def test_get_import_job_by_id_not_found(self, db, test_user):
"""Test getting non-existent import job"""
with pytest.raises(ValueError, match="Marketplace import job not found"):
self.service.get_import_job_by_id(db, 99999, test_user)
def test_get_import_job_by_id_access_denied(self, db, test_import_job, other_user):
def test_get_import_job_by_id_access_denied(self, db, test_marketplace_job, other_user):
"""Test access denied when user doesn't own the job"""
with pytest.raises(PermissionError, match="Access denied to this import job"):
self.service.get_import_job_by_id(db, test_import_job.id, other_user)
self.service.get_import_job_by_id(db, test_marketplace_job.id, other_user)
def test_get_import_jobs_user_filter(self, db, test_import_job, test_user):
def test_get_import_jobs_user_filter(self, db, test_marketplace_job, test_user):
"""Test getting import jobs filtered by user"""
jobs = self.service.get_import_jobs(db, test_user)
assert len(jobs) >= 1
assert any(job.id == test_import_job.id for job in jobs)
assert any(job.id == test_marketplace_job.id for job in jobs)
# Check user_id if the field exists
if hasattr(test_import_job, 'user_id'):
assert test_import_job.user_id == test_user.id
if hasattr(test_marketplace_job, 'user_id'):
assert test_marketplace_job.user_id == test_user.id
def test_get_import_jobs_admin_sees_all(self, db, test_import_job, test_admin):
def test_get_import_jobs_admin_sees_all(self, db, test_marketplace_job, test_admin):
"""Test that admin sees all import jobs"""
jobs = self.service.get_import_jobs(db, test_admin)
assert len(jobs) >= 1
assert any(job.id == test_import_job.id for job in jobs)
assert any(job.id == test_marketplace_job.id for job in jobs)
def test_get_import_jobs_with_marketplace_filter(self, db, test_import_job, test_user):
def test_get_import_jobs_with_marketplace_filter(self, db, test_marketplace_job, test_user):
"""Test getting import jobs with marketplace filter"""
jobs = self.service.get_import_jobs(
db, test_user, marketplace=test_import_job.marketplace
db, test_user, marketplace=test_marketplace_job.marketplace
)
assert len(jobs) >= 1
assert any(job.marketplace == test_import_job.marketplace for job in jobs)
assert any(job.marketplace == test_marketplace_job.marketplace for job in jobs)
def test_get_import_jobs_with_pagination(self, db, test_user, test_shop):
"""Test getting import jobs with pagination"""
@@ -137,6 +137,7 @@ class TestMarketplaceService:
status="completed",
marketplace=f"Marketplace_{unique_id}_{i}",
shop_name=f"Test_Shop_{unique_id}_{i}",
user_id=test_user.id,
shop_id=test_shop.id, # Use shop_id instead of shop_code
source_url=f"https://test-{i}.example.com/import",
imported_count=0,
@@ -151,11 +152,11 @@ class TestMarketplaceService:
assert len(jobs) <= 2 # Should be at most 2
def test_update_job_status_success(self, db, test_import_job):
def test_update_job_status_success(self, db, test_marketplace_job):
"""Test updating job status"""
result = self.service.update_job_status(
db,
test_import_job.id,
test_marketplace_job.id,
"completed",
imported_count=100,
total_processed=100
@@ -170,7 +171,7 @@ class TestMarketplaceService:
with pytest.raises(ValueError, match="Marketplace import job not found"):
self.service.update_job_status(db, 99999, "completed")
def test_get_job_stats_user(self, db, test_import_job, test_user):
def test_get_job_stats_user(self, db, test_marketplace_job, test_user):
"""Test getting job statistics for user"""
stats = self.service.get_job_stats(db, test_user)
@@ -180,20 +181,20 @@ class TestMarketplaceService:
assert "completed_jobs" in stats
assert "failed_jobs" in stats
def test_get_job_stats_admin(self, db, test_import_job, test_admin):
def test_get_job_stats_admin(self, db, test_marketplace_job, test_admin):
"""Test getting job statistics for admin"""
stats = self.service.get_job_stats(db, test_admin)
assert stats["total_jobs"] >= 1
def test_convert_to_response_model(self, test_import_job):
def test_convert_to_response_model(self, test_marketplace_job):
"""Test converting database model to response model"""
response = self.service.convert_to_response_model(test_import_job)
response = self.service.convert_to_response_model(test_marketplace_job)
assert response.job_id == test_import_job.id
assert response.status == test_import_job.status
assert response.marketplace == test_import_job.marketplace
assert response.imported == (test_import_job.imported_count or 0)
assert response.job_id == test_marketplace_job.id
assert response.status == test_marketplace_job.status
assert response.marketplace == test_marketplace_job.marketplace
assert response.imported == (test_marketplace_job.imported_count or 0)
def test_cancel_import_job_success(self, db, test_user, test_shop):
"""Test cancelling a pending import job"""
@@ -204,6 +205,7 @@ class TestMarketplaceService:
status="pending",
marketplace="Amazon",
shop_name=f"TEST_SHOP_{unique_id}",
user_id=test_user.id,
shop_id=test_shop.id, # Use shop_id instead of shop_code
source_url="https://test.example.com/import",
imported_count=0,
@@ -220,14 +222,14 @@ class TestMarketplaceService:
assert result.status == "cancelled"
assert result.completed_at is not None
def test_cancel_import_job_invalid_status(self, db, test_import_job, test_user):
def test_cancel_import_job_invalid_status(self, db, test_marketplace_job, test_user):
"""Test cancelling a job that can't be cancelled"""
# Set job status to completed
test_import_job.status = "completed"
test_marketplace_job.status = "completed"
db.commit()
with pytest.raises(ValueError, match="Cannot cancel job with status: completed"):
self.service.cancel_import_job(db, test_import_job.id, test_user)
self.service.cancel_import_job(db, test_marketplace_job.id, test_user)
def test_delete_import_job_success(self, db, test_user, test_shop):
"""Test deleting a completed import job"""
@@ -238,6 +240,7 @@ class TestMarketplaceService:
status="completed",
marketplace="Amazon",
shop_name=f"TEST_SHOP_{unique_id}",
user_id=test_user.id,
shop_id=test_shop.id, # Use shop_id instead of shop_code
source_url="https://test.example.com/import",
imported_count=0,
@@ -267,6 +270,7 @@ class TestMarketplaceService:
status="pending",
marketplace="Amazon",
shop_name=f"TEST_SHOP_{unique_id}",
user_id=test_user.id,
shop_id=test_shop.id, # Use shop_id instead of shop_code
source_url="https://test.example.com/import",
imported_count=0,

12
tests/test_middleware.py
View File

@@ -12,11 +12,11 @@ class TestRateLimiter:
client_id = "test_client"
# Should allow first request
assert limiter.allow_request(client_id, max_requests=10, window_seconds=3600) == True
assert limiter.allow_request(client_id, max_requests=10, window_seconds=3600) is True
# Should allow subsequent requests within limit
for _ in range(5):
assert limiter.allow_request(client_id, max_requests=10, window_seconds=3600) == True
assert limiter.allow_request(client_id, max_requests=10, window_seconds=3600) is True
def test_rate_limiter_blocks_excess_requests(self):
"""Test rate limiter blocks requests exceeding limit"""
@@ -26,10 +26,10 @@ class TestRateLimiter:
# Use up the allowed requests
for _ in range(max_requests):
assert limiter.allow_request(client_id, max_requests, 3600) == True
assert limiter.allow_request(client_id, max_requests, 3600) is True
# Next request should be blocked
assert limiter.allow_request(client_id, max_requests, 3600) == False
assert limiter.allow_request(client_id, max_requests, 3600) is False
class TestAuthManager:
@@ -42,10 +42,10 @@ class TestAuthManager:
hashed = auth_manager.hash_password(password)
# Verify correct password
assert auth_manager.verify_password(password, hashed) == True
assert auth_manager.verify_password(password, hashed) is True
# Verify incorrect password
assert auth_manager.verify_password("wrong_password", hashed) == False
assert auth_manager.verify_password("wrong_password", hashed) is False
def test_jwt_token_creation_and_validation(self, test_user):
"""Test JWT token creation and validation"""

12
tests/test_pagination.py
View File

@@ -20,7 +20,7 @@ class TestPagination:
db.commit()
# Test first page
response = client.get("/api/v1/products?limit=10&skip=0", headers=auth_headers)
response = client.get("/api/v1/product?limit=10&skip=0", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert len(data["products"]) == 10
@@ -29,14 +29,14 @@ class TestPagination:
assert data["limit"] == 10
# Test second page
response = client.get("/api/v1/products?limit=10&skip=10", headers=auth_headers)
response = client.get("/api/v1/product?limit=10&skip=10", headers=auth_headers)
assert response.status_code == 200
data = response.json()
assert len(data["products"]) == 10
assert data["skip"] == 10
# Test last page
response = client.get("/api/v1/products?limit=10&skip=20", headers=auth_headers)
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
@@ -44,13 +44,13 @@ class TestPagination:
def test_pagination_boundaries(self, client, auth_headers):
"""Test pagination boundary conditions"""
# Test negative skip
response = client.get("/api/v1/products?skip=-1", headers=auth_headers)
response = client.get("/api/v1/product?skip=-1", headers=auth_headers)
assert response.status_code == 422 # Validation error
# Test zero limit
response = client.get("/api/v1/products?limit=0", headers=auth_headers)
response = client.get("/api/v1/product?limit=0", headers=auth_headers)
assert response.status_code == 422 # Validation error
# Test excessive limit
response = client.get("/api/v1/products?limit=10000", headers=auth_headers)
response = client.get("/api/v1/product?limit=10000", headers=auth_headers)
assert response.status_code == 422 # Should be limited

46
tests/test_product.py
View File

@@ -3,6 +3,7 @@ import pytest
class TestProductsAPI:
def test_get_products_empty(self, client, auth_headers):
"""Test getting products when none exist"""
response = client.get("/api/v1/product", headers=auth_headers)
@@ -14,7 +15,7 @@ class TestProductsAPI:
def test_get_products_with_data(self, client, auth_headers, test_product):
"""Test getting products with data"""
response = client.get("/api/v1/products", headers=auth_headers)
response = client.get("/api/v1/product", headers=auth_headers)
assert response.status_code == 200
data = response.json()
@@ -25,17 +26,17 @@ class TestProductsAPI:
def test_get_products_with_filters(self, client, auth_headers, test_product):
"""Test filtering products"""
# Test brand filter
response = client.get("/api/v1/products?brand=TestBrand", headers=auth_headers)
response = client.get("/api/v1/product?brand=TestBrand", headers=auth_headers)
assert response.status_code == 200
assert response.json()["total"] == 1
# Test marketplace filter
response = client.get("/api/v1/products?marketplace=Letzshop", headers=auth_headers)
response = client.get("/api/v1/product?marketplace=Letzshop", headers=auth_headers)
assert response.status_code == 200
assert response.json()["total"] == 1
# Test search
response = client.get("/api/v1/products?search=Test", headers=auth_headers)
response = client.get("/api/v1/product?search=Test", headers=auth_headers)
assert response.status_code == 200
assert response.json()["total"] == 1
@@ -52,7 +53,7 @@ class TestProductsAPI:
"marketplace": "Amazon"
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
assert response.status_code == 200
data = response.json()
@@ -63,19 +64,32 @@ class TestProductsAPI:
def test_create_product_duplicate_id(self, client, auth_headers, test_product):
"""Test creating product with duplicate ID"""
product_data = {
"product_id": "TEST001", # Same as test_product
"title": "Another Product",
"price": "20.00"
"product_id": test_product.product_id,
"title": test_product.title,
"description": "A new product",
"price": "15.99",
"brand": "NewBrand",
"gtin": "9876543210987",
"availability": "in stock",
"marketplace": "Amazon"
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
# Debug output
print(f"Status Code: {response.status_code}")
print(f"Response Content: {response.content}")
try:
print(f"Response JSON: {response.json()}")
except:
print("Could not parse response as JSON")
assert response.status_code == 400
assert "already exists" in response.json()["detail"]
def test_get_product_by_id(self, client, auth_headers, test_product):
"""Test getting specific product"""
response = client.get(f"/api/v1/products/{test_product.product_id}", headers=auth_headers)
response = client.get(f"/api/v1/product/{test_product.product_id}", headers=auth_headers)
assert response.status_code == 200
data = response.json()
@@ -84,7 +98,7 @@ class TestProductsAPI:
def test_get_nonexistent_product(self, client, auth_headers):
"""Test getting nonexistent product"""
response = client.get("/api/v1/products/NONEXISTENT", headers=auth_headers)
response = client.get("/api/v1/product/NONEXISTENT", headers=auth_headers)
assert response.status_code == 404
@@ -96,7 +110,7 @@ class TestProductsAPI:
}
response = client.put(
f"/api/v1/products/{test_product.product_id}",
f"/api/v1/product/{test_product.product_id}",
headers=auth_headers,
json=update_data
)
@@ -109,14 +123,14 @@ class TestProductsAPI:
def test_delete_product(self, client, auth_headers, test_product):
"""Test deleting product"""
response = client.delete(
f"/api/v1/products/{test_product.product_id}",
f"/api/v1/product/{test_product.product_id}",
headers=auth_headers
)
assert response.status_code == 200
assert "deleted successfully" in response.json()["message"]
def test_products_require_auth(self, client):
def test_get_product_without_auth(self, client):
"""Test that product endpoints require authentication"""
response = client.get("/api/v1/products")
assert response.status_code == 403
response = client.get("/api/v1/product")
assert response.status_code == 401 # No authorization header

99
tests/test_security.py
View File

@@ -5,57 +5,106 @@ from unittest.mock import patch
class TestSecurity:
def test_debug_direct_bearer(self, client):
"""Test HTTPBearer directly"""
response = client.get("/api/v1/debug-bearer")
print(f"Direct Bearer - Status: {response.status_code}")
print(f"Direct Bearer - Response: {response.json() if response.content else 'No content'}")
def test_debug_dependencies(self, client):
"""Debug the dependency chain step by step"""
# Test 1: Direct endpoint with no auth
response = client.get("/api/v1/admin/users")
print(f"Admin endpoint - Status: {response.status_code}")
try:
print(f"Admin endpoint - Response: {response.json()}")
except:
print(f"Admin endpoint - Raw: {response.content}")
# Test 2: Try a regular endpoint that uses get_current_user
response2 = client.get("/api/v1/product") # or any endpoint with get_current_user
print(f"Regular endpoint - Status: {response2.status_code}")
try:
print(f"Regular endpoint - Response: {response2.json()}")
except:
print(f"Regular endpoint - Raw: {response2.content}")
def test_debug_available_routes(self, client):
"""Debug test to see all available routes"""
print("\n=== All Available Routes ===")
for route in client.app.routes:
if hasattr(route, 'path') and hasattr(route, 'methods'):
print(f"{list(route.methods)} {route.path}")
print("\n=== Testing Product Endpoint Variations ===")
variations = [
"/api/v1/product", # Your current attempt
"/api/v1/product/", # With trailing slash
"/api/v1/product/list", # With list endpoint
"/api/v1/product/all", # With all endpoint
]
for path in variations:
response = client.get(path)
print(f"{path}: Status {response.status_code}")
def test_protected_endpoint_without_auth(self, client):
"""Test that protected endpoints reject unauthenticated requests"""
protected_endpoints = [
"/api/v1/products",
"/api/v1/stock",
"/api/v1/admin/users",
"/api/v1/admin/shops",
"/api/v1/marketplace/import-jobs",
"/api/v1/product",
"/api/v1/shop",
"/api/v1/stats",
"/api/v1/admin/users"
"/api/v1/stock"
]
for endpoint in protected_endpoints:
response = client.get(endpoint)
assert response.status_code == 403
assert response.status_code == 401 # Authentication missing
def test_protected_endpoint_with_invalid_token(self, client):
"""Test protected endpoints with invalid token"""
headers = {"Authorization": "Bearer invalid_token_here"}
response = client.get("/api/v1/products", headers=headers)
assert response.status_code == 403
response = client.get("/api/v1/product", headers=headers)
assert response.status_code == 401 # Token is not valid
def test_admin_endpoint_requires_admin_role(self, client, auth_headers):
"""Test that admin endpoints require admin role"""
response = client.get("/api/v1/admin/users", headers=auth_headers)
assert response.status_code == 403 # Regular user should be denied
assert response.status_code == 403 # Token is valid but user does not have access.
# Regular user should be denied
def test_sql_injection_prevention(self, client, auth_headers):
"""Test SQL injection prevention in search parameters"""
# Try SQL injection in search parameter
malicious_search = "'; DROP TABLE products; --"
response = client.get(f"/api/v1/products?search={malicious_search}", headers=auth_headers)
response = client.get(f"/api/v1/product?search={malicious_search}", headers=auth_headers)
# Should not crash and should return normal response
assert response.status_code == 200
# Database should still be intact (no products dropped)
def test_input_validation(self, client, auth_headers):
"""Test input validation and sanitization"""
# Test XSS attempt in product creation
xss_payload = "<script>alert('xss')</script>"
product_data = {
"product_id": "XSS_TEST",
"title": xss_payload,
"description": xss_payload
}
response = client.post("/api/v1/products", headers=auth_headers, json=product_data)
if response.status_code == 200:
# If creation succeeds, content should be escaped/sanitized
data = response.json()
assert "<script>" not in data["title"]
# def test_input_validation(self, client, auth_headers):
# # TODO: implement sanitization
# """Test input validation and sanitization"""
# # Test XSS attempt in product creation
# xss_payload = "<script>alert('xss')</script>"
#
# product_data = {
# "product_id": "XSS_TEST",
# "title": xss_payload,
# "description": xss_payload,
# }
#
# response = client.post("/api/v1/product", headers=auth_headers, json=product_data)
#
# assert response.status_code == 200
# data = response.json()
# assert "<script>" not in data["title"]
# assert "&lt;script&gt;" in data["title"]

6
tests/test_shop.py
View File

@@ -17,7 +17,7 @@ class TestShopsAPI:
data = response.json()
assert data["shop_code"] == "NEWSHOP"
assert data["shop_name"] == "New Shop"
assert data["is_active"] == True
assert data["is_active"] is True
def test_create_shop_duplicate_code(self, client, auth_headers, test_shop):
"""Test creating shop with duplicate code"""
@@ -49,7 +49,7 @@ class TestShopsAPI:
assert data["shop_code"] == test_shop.shop_code
assert data["shop_name"] == test_shop.shop_name
def test_shops_require_auth(self, client):
def test_get_shop_without_auth(self, client):
"""Test that shop endpoints require authentication"""
response = client.get("/api/v1/shop")
assert response.status_code == 403
assert response.status_code == 401 # No authorization header

6
tests/test_stats.py
View File

@@ -18,7 +18,7 @@ class TestStatsAPI:
def test_get_marketplace_stats(self, client, auth_headers, test_product):
"""Test getting marketplace statistics"""
response = client.get("/api/v1/stats/marketplace-stats", headers=auth_headers)
response = client.get("/api/v1/stats/marketplace", headers=auth_headers)
assert response.status_code == 200
data = response.json()
@@ -27,7 +27,7 @@ class TestStatsAPI:
assert "marketplace" in data[0]
assert "total_products" in data[0]
def test_stats_require_auth(self, client):
def test_get_stats_without_auth(self, client):
"""Test that stats endpoints require authentication"""
response = client.get("/api/v1/stats")
assert response.status_code == 403
assert response.status_code == 401 # No authorization header

4
tests/test_stock.py
View File

@@ -141,7 +141,7 @@ class TestStockAPI:
data = response.json()
assert len(data) == 2
def test_stock_requires_auth(self, client):
def test_get_stock_without_auth(self, client):
"""Test that stock endpoints require authentication"""
response = client.get("/api/v1/stock")
assert response.status_code == 403
assert response.status_code == 401 # No authorization header

2
tests/test_utils.py
View File

@@ -28,7 +28,7 @@ class TestGTINProcessor:
assert self.processor.normalize("abc") is None
# Test short number (gets padded)
assert self.processor.normalize("123") == "000000000123"
assert self.processor.normalize("123") == "0000000000123"
def test_normalize_gtin_with_formatting(self):
"""Test GTIN normalization with various formatting"""