456 lines
17 KiB
Python
456 lines
17 KiB
Python
# tests/integration/api/v1/test_stock_endpoints.py
|
|
import pytest
|
|
|
|
from models.database.stock import Stock
|
|
|
|
|
|
@pytest.mark.integration
|
|
@pytest.mark.api
|
|
@pytest.mark.stock
|
|
class TestStockAPI:
|
|
|
|
def test_set_stock_new_success(self, client, auth_headers):
|
|
"""Test setting stock for new GTIN successfully"""
|
|
stock_data = {
|
|
"gtin": "1234567890123",
|
|
"location": "WAREHOUSE_A",
|
|
"quantity": 100,
|
|
}
|
|
|
|
response = client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["gtin"] == "1234567890123"
|
|
assert data["location"] == "WAREHOUSE_A"
|
|
assert data["quantity"] == 100
|
|
|
|
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)
|
|
db.commit()
|
|
|
|
stock_data = {
|
|
"gtin": "1234567890123",
|
|
"location": "WAREHOUSE_A",
|
|
"quantity": 75,
|
|
}
|
|
|
|
response = client.post("/api/v1/stock", headers=auth_headers, json=stock_data)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["quantity"] == 75 # Should be replaced, not added
|
|
|
|
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)
|
|
db.commit()
|
|
|
|
stock_data = {
|
|
"gtin": "1234567890123",
|
|
"location": "WAREHOUSE_A",
|
|
"quantity": 25,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/stock/add", headers=auth_headers, json=stock_data
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["quantity"] == 75 # 50 + 25
|
|
|
|
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)
|
|
db.commit()
|
|
|
|
stock_data = {
|
|
"gtin": "1234567890123",
|
|
"location": "WAREHOUSE_A",
|
|
"quantity": 15,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/stock/remove", headers=auth_headers, json=stock_data
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["quantity"] == 35 # 50 - 15
|
|
|
|
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)
|
|
db.commit()
|
|
|
|
stock_data = {
|
|
"gtin": "1234567890123",
|
|
"location": "WAREHOUSE_A",
|
|
"quantity": 20,
|
|
}
|
|
|
|
response = client.post(
|
|
"/api/v1/stock/remove", headers=auth_headers, json=stock_data
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
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_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)
|
|
db.add_all([stock1, stock2])
|
|
db.commit()
|
|
|
|
response = client.get("/api/v1/stock/1234567890123", headers=auth_headers)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["gtin"] == "1234567890123"
|
|
assert data["total_quantity"] == 75
|
|
assert len(data["locations"]) == 2
|
|
|
|
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)
|
|
db.add_all([stock1, stock2])
|
|
db.commit()
|
|
|
|
response = client.get("/api/v1/stock/1234567890123/total", headers=auth_headers)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["gtin"] == "1234567890123"
|
|
assert data["total_quantity"] == 75
|
|
assert data["locations_count"] == 2
|
|
|
|
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)
|
|
db.add_all([stock1, stock2])
|
|
db.commit()
|
|
|
|
response = client.get("/api/v1/stock", headers=auth_headers)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert len(data) >= 2
|
|
|
|
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
|
|
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)
|