ApiLogicServer 15.2.3__py3-none-any.whl → 15.2.10__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/test/api_logic_server_behave/features/steps/order_processing_steps.py

@@ -1,27 +1,79 @@
 """
-Step implementations for Order Processing tests
-Following Phase 2 (Custom API) + Phase 1 (CRUD) patterns
+Order Processing Test Steps - Following ALL Critical Rules from testing.md
+
+CRITICAL: Step ordering follows Rule #0.5 (most specific → most general)
+- Multi-item patterns BEFORE single-item patterns
+- Carbon neutral patterns BEFORE general patterns
 """
+
 from behave import *
 import requests
 import test_utils
 import time
 from decimal import Decimal
+import os
+from dotenv import load_dotenv
+from pathlib import Path
 
 BASE_URL = 'http://localhost:5656'
 
+# Load config to check SECURITY_ENABLED
+config_path = Path(__file__).parent.parent.parent.parent.parent / 'config' / 'default.env'
+load_dotenv(config_path)
+
+# Cache for auth token (obtained once per test session)
+_auth_token = None
+
+def get_auth_token():
+    """Login and get JWT token if security is enabled"""
+    global _auth_token
+    
+    if _auth_token is not None:
+        return _auth_token
+    
+    # Login with default admin credentials
+    login_url = f'{BASE_URL}/api/auth/login'
+    login_data = {
+        'username': 'admin',
+        'password': 'p'
+    }
+    
+    try:
+        response = requests.post(login_url, json=login_data)
+        if response.status_code == 200:
+            _auth_token = response.json().get('access_token')
+            return _auth_token
+        else:
+            raise Exception(f"Login failed: {response.status_code} - {response.text}")
+    except Exception as e:
+        raise Exception(f"Failed to obtain auth token: {e}")
+
 def get_headers():
-    """Return auth headers - empty since SECURITY_ENABLED=False"""
-    return {}
+    """Get headers including auth token if security is enabled"""
+    security_enabled = os.getenv('SECURITY_ENABLED', 'false').lower() not in ['false', 'no']
+    
+    headers = {'Content-Type': 'application/json'}
+    
+    if security_enabled:
+        token = get_auth_token()
+        if token:
+            headers['Authorization'] = f'Bearer {token}'
+    
+    return headers
 
 
-# ============================================================================
-# GIVEN Steps - Setup test data (Rule #0: Always create fresh with timestamps)
-# ============================================================================
+# ==============================================================================
+# GIVEN Steps - Customer Setup (Rule #0: Always create fresh data)
+# ==============================================================================
 
 @given('Customer "{customer_name}" with balance {balance:d} and credit limit {limit:d}')
 def step_impl(context, customer_name, balance, limit):
-    """Create fresh customer with timestamp for uniqueness (Rule #0)"""
+    """
+    Phase 1: CREATE Customer with unique timestamp name (Rule #0)
+    
+    CRITICAL: Always create fresh data, never reuse existing customers
+    """
+    # Create unique name with timestamp for test repeatability
     unique_name = f"{customer_name} {int(time.time() * 1000)}"
     
     post_uri = f'{BASE_URL}/api/Customer/'
@@ -30,7 +82,7 @@ def step_impl(context, customer_name, balance, limit):
             "type": "Customer",
             "attributes": {
                 "name": unique_name,
-                "balance": balance,  # Will be replaced by sum of orders
+                "balance": balance,
                 "credit_limit": limit
             }
         }
@@ -49,88 +101,210 @@ def step_impl(context, customer_name, balance, limit):
         'unique_name': unique_name
     }
     
-    # Set primary customer for single-customer scenarios
+    # Also set default context values for single-customer tests
     context.customer_id = customer_id
     context.customer_name = unique_name
 
 
-# ============================================================================
-# Order Setup Steps - SPECIFIC patterns MUST come BEFORE general (Rule #0.5)
-# ============================================================================
+# ==============================================================================
+# GIVEN Steps - Order Setup (ORDERED: Multi-item BEFORE Single-item - Rule #0.5)
+# ==============================================================================
 
-@given('Order exists for "{customer_name}" with {qty1:d} {product1:S} and {qty2:d} {product2:S}')
+@given('Order is created for "{customer_name}" with {qty1:d} {product1} and {qty2:d} {product2}')
 def step_impl(context, customer_name, qty1, product1, qty2, product2):
-    """Create order with multiple items (Phase 2)"""
-    scenario_name = f'Setup Order - {qty1} {product1} + {qty2} {product2}'
+    """
+    Phase 1: CREATE Order with 2 items using CRUD API
+    
+    CRITICAL: This pattern MUST come BEFORE single-item pattern (Rule #0.5)
+    """
+    scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    customer_info = context.customer_map.get(customer_name)
+    # Get customer from map
+    customer_info = context.customer_map[customer_name]
+    customer_id = customer_info['id']
     
-    add_order_uri = f'{BASE_URL}/api/ServicesEndPoint/OrderB2B'
-    add_order_args = {
-        "meta": {
-            "method": "OrderB2B",
-            "args": {
-                "order": {
-                    "Account": customer_info['unique_name'],
-                    "Notes": "Multi-item test order",
-                    "Items": [
-                        {"Name": product1, "QuantityOrdered": qty1},
-                        {"Name": product2, "QuantityOrdered": qty2}
-                    ]
-                }
+    # Create Order
+    order_uri = f'{BASE_URL}/api/Order/'
+    order_data = {
+        "data": {
+            "type": "Order",
+            "attributes": {
+                "customer_id": customer_id,
+                "notes": f"Test order - {scenario_name}"
+            }
+        }
+    }
+    r = requests.post(url=order_uri, json=order_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create order: {r.text}"
+    order_id = int(r.json()['data']['id'])
+    context.order_id = order_id
+    
+    # Create Item 1
+    product1_id = get_product_id_by_name(product1)
+    item1_uri = f'{BASE_URL}/api/Item/'
+    item1_data = {
+        "data": {
+            "type": "Item",
+            "attributes": {
+                "order_id": order_id,
+                "product_id": product1_id,
+                "quantity": qty1
             }
         }
     }
+    r = requests.post(url=item1_uri, json=item1_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create item 1: {r.text}"
+    item1_id = int(r.json()['data']['id'])
+    
+    # Create Item 2
+    product2_id = get_product_id_by_name(product2)
+    item2_uri = f'{BASE_URL}/api/Item/'
+    item2_data = {
+        "data": {
+            "type": "Item",
+            "attributes": {
+                "order_id": order_id,
+                "product_id": product2_id,
+                "quantity": qty2
+            }
+        }
+    }
+    r = requests.post(url=item2_uri, json=item2_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create item 2: {r.text}"
+    item2_id = int(r.json()['data']['id'])
     
-    r = requests.post(url=add_order_uri, json=add_order_args, headers=get_headers())
-    context.order_created = (r.status_code == 200)
+    # Store both item IDs for later use
+    context.item_ids = [item1_id, item2_id]
+    context.item_id = item1_id  # Default to first item
+
+
+@given('Order is created for "{customer_name}" with {quantity:d} {product_name}')
+def step_impl(context, customer_name, quantity, product_name):
+    """
+    Phase 1: CREATE Order with single item using CRUD API
     
-    if context.order_created:
-        # Get order and items
-        customer_id = customer_info['id']
-        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_id}'
-        r_orders = requests.get(url=orders_uri, headers=get_headers())
-        orders = r_orders.json()['data']
-        
-        if orders:
-            latest_order = orders[-1]
-            context.order_id = int(latest_order['id'])
-            
-            # Get items
-            items_uri = f'{BASE_URL}/api/Item/?filter[order_id]={context.order_id}'
-            r_items = requests.get(url=items_uri, headers=get_headers())
-            items = r_items.json()['data']
-            if items:
-                context.item_ids = [int(item['id']) for item in items]
-                context.item_id = context.item_ids[0]  # First item
-            else:
-                context.item_id = None
-                context.item_ids = []
-    else:
-        context.order_id = None
-        context.item_id = None
-        context.item_ids = []
+    CRITICAL: This pattern comes AFTER multi-item pattern (Rule #0.5)
+    """
+    scenario_name = context.scenario.name
+    test_utils.prt(f'\n{scenario_name}\n', scenario_name)
+    
+    # Get customer from map
+    customer_info = context.customer_map[customer_name]
+    customer_id = customer_info['id']
+    
+    # Create Order
+    order_uri = f'{BASE_URL}/api/Order/'
+    order_data = {
+        "data": {
+            "type": "Order",
+            "attributes": {
+                "customer_id": customer_id,
+                "notes": f"Test order - {scenario_name}"
+            }
+        }
+    }
+    r = requests.post(url=order_uri, json=order_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create order: {r.text}"
+    order_id = int(r.json()['data']['id'])
+    context.order_id = order_id
+    
+    # Create Item
+    product_id = get_product_id_by_name(product_name)
+    item_uri = f'{BASE_URL}/api/Item/'
+    item_data = {
+        "data": {
+            "type": "Item",
+            "attributes": {
+                "order_id": order_id,
+                "product_id": product_id,
+                "quantity": quantity
+            }
+        }
+    }
+    r = requests.post(url=item_uri, json=item_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create item: {r.text}"
+    item_id = int(r.json()['data']['id'])
+    context.item_id = item_id
+
+
+@given('Shipped order is created for "{customer_name}" with {quantity:d} {product_name}')
+def step_impl(context, customer_name, quantity, product_name):
+    """
+    Phase 1: CREATE Order and immediately ship it
+    
+    Tests WHERE clause exclusion from balance
+    """
+    scenario_name = context.scenario.name
+    test_utils.prt(f'\n{scenario_name}\n', scenario_name)
+    
+    # Get customer from map
+    customer_info = context.customer_map[customer_name]
+    customer_id = customer_info['id']
+    
+    # Create Order with date_shipped set
+    order_uri = f'{BASE_URL}/api/Order/'
+    order_data = {
+        "data": {
+            "type": "Order",
+            "attributes": {
+                "customer_id": customer_id,
+                "notes": f"Test shipped order - {scenario_name}",
+                "date_shipped": "2025-10-22"
+            }
+        }
+    }
+    r = requests.post(url=order_uri, json=order_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create order: {r.text}"
+    order_id = int(r.json()['data']['id'])
+    context.order_id = order_id
+    
+    # Create Item
+    product_id = get_product_id_by_name(product_name)
+    item_uri = f'{BASE_URL}/api/Item/'
+    item_data = {
+        "data": {
+            "type": "Item",
+            "attributes": {
+                "order_id": order_id,
+                "product_id": product_id,
+                "quantity": quantity
+            }
+        }
+    }
+    r = requests.post(url=item_uri, json=item_data, headers=get_headers())
+    assert r.status_code == 201, f"Failed to create item: {r.text}"
+    item_id = int(r.json()['data']['id'])
+    context.item_id = item_id
+
 
+# ==============================================================================
+# WHEN Steps - Order Creation (ORDERED: Specific BEFORE General - Rule #0.5)
+# ==============================================================================
 
-@given('Order exists for "{customer_name}" with {quantity:d} {product_name}')
+@when('B2B order placed for "{customer_name}" with {quantity:d} carbon neutral {product_name}')
 def step_impl(context, customer_name, quantity, product_name):
-    """Create order using OrderB2B API (Phase 2) - GENERAL pattern"""
-    scenario_name = f'Setup Order - {quantity} {product_name}'
+    """
+    Phase 2: CREATE using OrderB2B API - Carbon neutral product
+    
+    CRITICAL: This pattern MUST come BEFORE general pattern (Rule #0.5)
+    Tests carbon neutral discount logic (10% off when qty >= 10)
+    """
+    scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    customer_info = context.customer_map.get(customer_name)
-    if not customer_info:
-        raise ValueError(f"Customer {customer_name} not found in context")
+    # Get customer unique name
+    customer_info = context.customer_map[customer_name]
+    account_name = customer_info['unique_name']
     
     add_order_uri = f'{BASE_URL}/api/ServicesEndPoint/OrderB2B'
     add_order_args = {
         "meta": {
-            "method": "OrderB2B",  # CRITICAL: Required for custom API
+            "method": "OrderB2B",  # CRITICAL: Required for custom APIs
             "args": {
                 "order": {
-                    "Account": customer_info['unique_name'],
-                    "Notes": "Test order",
+                    "Account": account_name,
+                    "Notes": f"Carbon neutral order - {scenario_name}",
                     "Items": [
                         {
                             "Name": product_name,
@@ -146,81 +320,53 @@ def step_impl(context, customer_name, quantity, product_name):
     context.order_created = (r.status_code == 200)
     
     if context.order_created:
-        # Custom API returns direct dict, not JSON:API format
-        response_data = r.json()
-        
-        # Get order ID by querying back
-        customer_id = customer_info['id']
-        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_id}'
-        r_orders = requests.get(url=orders_uri, headers=get_headers())
-        orders = r_orders.json()['data']
-        
-        if orders:
-            latest_order = orders[-1]  # Get most recent
-            context.order_id = int(latest_order['id'])
+        # Find the created order (most recent for this customer)
+        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_info["id"]}&sort=-id'
+        r = requests.get(url=orders_uri, headers=get_headers())
+        if r.json()['data']:
+            order_data = r.json()['data'][0]
+            context.order_id = int(order_data['id'])
             
-            # Get first item
+            # Get the item
             items_uri = f'{BASE_URL}/api/Item/?filter[order_id]={context.order_id}'
-            r_items = requests.get(url=items_uri, headers=get_headers())
-            items = r_items.json()['data']
-            if items:
-                context.item_id = int(items[0]['id'])
+            r = requests.get(url=items_uri, headers=get_headers())
+            if r.json()['data']:
+                context.item_id = int(r.json()['data'][0]['id'])
     else:
         context.order_id = None
         context.item_id = None
 
 
-@given('Shipped order exists for "{customer_name}" with {quantity:d} {product_name}')
-def step_impl(context, customer_name, quantity, product_name):
-    """Create and ship order"""
-    # First create order
-    context.execute_steps(f'''
-        Given Order exists for "{customer_name}" with {quantity} {product_name}
-    ''')
-    
-    # Then ship it
-    import datetime
-    patch_uri = f'{BASE_URL}/api/Order/{context.order_id}/'
-    patch_data = {
-        "data": {
-            "type": "Order",
-            "id": context.order_id,
-            "attributes": {
-                "date_shipped": str(datetime.date.today())
-            }
-        }
-    }
-    
-    r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to ship order: {r.text}"
-
-
-# ============================================================================
-# WHEN Steps - Actions (Rule #0.5: Specific patterns BEFORE general ones!)
-# ============================================================================
-
-@when('B2B order placed for "{customer_name}" with {quantity:d} carbon neutral {product_name}')
-def step_impl(context, customer_name, quantity, product_name):
+@when('B2B order placed for "{customer_name}" with {qty1:d} {product1} and {qty2:d} {product2}')
+def step_impl(context, customer_name, qty1, product1, qty2, product2):
     """
-    Phase 2: CREATE using OrderB2B API - Tests carbon neutral discount (10% off when qty >= 10)
+    Phase 2: CREATE using OrderB2B API - Multi-item order
+    
+    CRITICAL: This pattern MUST come BEFORE single-item pattern (Rule #0.5)
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    customer_info = context.customer_map.get(customer_name)
+    # Get customer unique name
+    customer_info = context.customer_map[customer_name]
+    account_name = customer_info['unique_name']
     
     add_order_uri = f'{BASE_URL}/api/ServicesEndPoint/OrderB2B'
     add_order_args = {
         "meta": {
-            "method": "OrderB2B",
+            "method": "OrderB2B",  # CRITICAL: Required for custom APIs
             "args": {
                 "order": {
-                    "Account": customer_info['unique_name'],
-                    "Notes": "Carbon neutral order",
+                    "Account": account_name,
+                    "Notes": f"Multi-item order - {scenario_name}",
                     "Items": [
                         {
-                            "Name": product_name,
-                            "QuantityOrdered": quantity
+                            "Name": product1,
+                            "QuantityOrdered": qty1
+                        },
+                        {
+                            "Name": product2,
+                            "QuantityOrdered": qty2
                         }
                     ]
                 }
@@ -232,21 +378,19 @@ def step_impl(context, customer_name, quantity, product_name):
     context.order_created = (r.status_code == 200)
     
     if context.order_created:
-        # Get order and item IDs
-        customer_id = customer_info['id']
-        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_id}'
-        r_orders = requests.get(url=orders_uri, headers=get_headers())
-        orders = r_orders.json()['data']
-        
-        if orders:
-            latest_order = orders[-1]
-            context.order_id = int(latest_order['id'])
+        # Find the created order (most recent for this customer)
+        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_info["id"]}&sort=-id'
+        r = requests.get(url=orders_uri, headers=get_headers())
+        if r.json()['data']:
+            order_data = r.json()['data'][0]
+            context.order_id = int(order_data['id'])
             
+            # Get the items
             items_uri = f'{BASE_URL}/api/Item/?filter[order_id]={context.order_id}'
-            r_items = requests.get(url=items_uri, headers=get_headers())
-            items = r_items.json()['data']
-            if items:
-                context.item_id = int(items[0]['id'])
+            r = requests.get(url=items_uri, headers=get_headers())
+            if r.json()['data']:
+                context.item_ids = [int(item['id']) for item in r.json()['data']]
+                context.item_id = context.item_ids[0]  # Default to first
     else:
         context.order_id = None
         context.item_id = None
@@ -255,21 +399,25 @@ def step_impl(context, customer_name, quantity, product_name):
 @when('B2B order placed for "{customer_name}" with {quantity:d} {product_name}')
 def step_impl(context, customer_name, quantity, product_name):
     """
-    Phase 2: CREATE using OrderB2B API - Tests OrderB2B integration, item calculations, and customer balance
+    Phase 2: CREATE using OrderB2B API - Single item order
+    
+    CRITICAL: This pattern comes AFTER multi-item and carbon neutral (Rule #0.5)
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    customer_info = context.customer_map.get(customer_name)
+    # Get customer unique name
+    customer_info = context.customer_map[customer_name]
+    account_name = customer_info['unique_name']
     
     add_order_uri = f'{BASE_URL}/api/ServicesEndPoint/OrderB2B'
     add_order_args = {
         "meta": {
-            "method": "OrderB2B",
+            "method": "OrderB2B",  # CRITICAL: Required for custom APIs
             "args": {
                 "order": {
-                    "Account": customer_info['unique_name'],
-                    "Notes": "Test order",
+                    "Account": account_name,
+                    "Notes": f"Test order - {scenario_name}",
                     "Items": [
                         {
                             "Name": product_name,
@@ -285,30 +433,33 @@ def step_impl(context, customer_name, quantity, product_name):
     context.order_created = (r.status_code == 200)
     
     if context.order_created:
-        # Get order and item IDs
-        customer_id = customer_info['id']
-        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_id}'
-        r_orders = requests.get(url=orders_uri, headers=get_headers())
-        orders = r_orders.json()['data']
-        
-        if orders:
-            latest_order = orders[-1]
-            context.order_id = int(latest_order['id'])
+        # Find the created order (most recent for this customer)
+        orders_uri = f'{BASE_URL}/api/Order/?filter[customer_id]={customer_info["id"]}&sort=-id'
+        r = requests.get(url=orders_uri, headers=get_headers())
+        if r.json()['data']:
+            order_data = r.json()['data'][0]
+            context.order_id = int(order_data['id'])
             
+            # Get the item
             items_uri = f'{BASE_URL}/api/Item/?filter[order_id]={context.order_id}'
-            r_items = requests.get(url=items_uri, headers=get_headers())
-            items = r_items.json()['data']
-            if items:
-                context.item_id = int(items[0]['id'])
+            r = requests.get(url=items_uri, headers=get_headers())
+            if r.json()['data']:
+                context.item_id = int(r.json()['data'][0]['id'])
     else:
         context.order_id = None
         context.item_id = None
 
 
+# ==============================================================================
+# WHEN Steps - Updates and Deletes (Phase 1 - Granular Testing)
+# ==============================================================================
+
 @when('Item quantity changed to {qty:d}')
 def step_impl(context, qty):
     """
-    Phase 1: UPDATE using CRUD - Tests formula recalculation and cascading sum updates
+    Phase 1: UPDATE using CRUD API
+    
+    Tests quantity change triggers amount recalculation
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
@@ -325,75 +476,89 @@ def step_impl(context, qty):
     }
     
     r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to update quantity: {r.text}"
+    assert r.status_code == 200, f"Failed to update item: {r.text}"
 
 
-@when('Order customer changed to "{new_customer_name}"')
-def step_impl(context, new_customer_name):
+@when('Item product changed to "{product_name}"')
+def step_impl(context, product_name):
     """
-    Phase 1: UPDATE FK - Tests adjustment of BOTH old and new parent customer balances
+    Phase 1: UPDATE using CRUD API
+    
+    Tests FK change triggers unit_price copy from new product
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    new_customer_info = context.customer_map.get(new_customer_name)
+    product_id = get_product_id_by_name(product_name)
     
-    patch_uri = f'{BASE_URL}/api/Order/{context.order_id}/'
+    patch_uri = f'{BASE_URL}/api/Item/{context.item_id}/'
     patch_data = {
         "data": {
-            "type": "Order",
-            "id": context.order_id,
+            "type": "Item",
+            "id": context.item_id,
             "attributes": {
-                "customer_id": new_customer_info['id']  # Rule #2: Direct FK
+                "product_id": product_id  # Direct FK (Rule #2)
             }
         }
     }
     
     r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to change customer: {r.text}"
+    assert r.status_code == 200, f"Failed to update item: {r.text}"
 
 
-@when('First item deleted')
+@when('First item is deleted')
 def step_impl(context):
     """
-    Phase 1: DELETE - Tests aggregate down and cascade to customer balance
+    Phase 1: DELETE using CRUD API
+    
+    Tests deletion triggers aggregate recalculation
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    delete_uri = f'{BASE_URL}/api/Item/{context.item_id}/'
+    # Delete first item from multi-item order
+    item_id = context.item_ids[0]
+    
+    delete_uri = f'{BASE_URL}/api/Item/{item_id}/'
     r = requests.delete(url=delete_uri, headers=get_headers())
     assert r.status_code == 204, f"Failed to delete item: {r.text}"
 
 
-@when('Order is shipped')
-def step_impl(context):
+@when('Order customer changed to "{new_customer_name}"')
+def step_impl(context, new_customer_name):
     """
-    Phase 1: UPDATE - Tests WHERE clause exclusion (shipped orders don't count in balance)
+    Phase 1: UPDATE using CRUD API
+    
+    Tests FK change adjusts BOTH old and new customer balances
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    import datetime
+    # Get new customer ID
+    new_customer_info = context.customer_map[new_customer_name]
+    new_customer_id = new_customer_info['id']
+    
     patch_uri = f'{BASE_URL}/api/Order/{context.order_id}/'
     patch_data = {
         "data": {
             "type": "Order",
             "id": context.order_id,
             "attributes": {
-                "date_shipped": str(datetime.date.today())
+                "customer_id": new_customer_id  # Direct FK (Rule #2)
             }
         }
     }
     
     r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to ship order: {r.text}"
+    assert r.status_code == 200, f"Failed to update order: {r.text}"
 
 
-@when('Order is unshipped')
+@when('Order is shipped')
 def step_impl(context):
     """
-    Phase 1: UPDATE - Tests WHERE clause inclusion (unshipped orders count in balance again)
+    Phase 1: UPDATE using CRUD API
+    
+    Tests WHERE clause exclusion (shipped orders don't count in balance)
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
@@ -404,150 +569,132 @@ def step_impl(context):
             "type": "Order",
             "id": context.order_id,
             "attributes": {
-                "date_shipped": None
+                "date_shipped": "2025-10-22"
             }
         }
     }
     
     r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to unship order: {r.text}"
+    assert r.status_code == 200, f"Failed to ship order: {r.text}"
 
 
-@when('Item product changed to "{new_product_name}"')
-def step_impl(context, new_product_name):
+@when('Order is unshipped')
+def step_impl(context):
     """
-    Phase 1: UPDATE FK - Tests product lookup and automatic unit_price re-copy from new product
+    Phase 1: UPDATE using CRUD API
+    
+    Tests WHERE clause inclusion (unshipped orders count in balance again)
     """
     scenario_name = context.scenario.name
     test_utils.prt(f'\n{scenario_name}\n', scenario_name)
     
-    # Get new product ID
-    products_uri = f'{BASE_URL}/api/Product/?filter[name]={new_product_name}'
-    r_product = requests.get(url=products_uri, headers=get_headers())
-    products = r_product.json()['data']
-    assert products, f"Product {new_product_name} not found"
-    
-    new_product_id = int(products[0]['id'])
-    
-    patch_uri = f'{BASE_URL}/api/Item/{context.item_id}/'
+    patch_uri = f'{BASE_URL}/api/Order/{context.order_id}/'
     patch_data = {
         "data": {
-            "type": "Item",
-            "id": context.item_id,
+            "type": "Order",
+            "id": context.order_id,
             "attributes": {
-                "product_id": new_product_id  # Rule #2: Direct FK
+                "date_shipped": None
             }
         }
     }
     
     r = requests.patch(url=patch_uri, json=patch_data, headers=get_headers())
-    assert r.status_code == 200, f"Failed to change product: {r.text}"
+    assert r.status_code == 200, f"Failed to unship order: {r.text}"
 
 
-# ============================================================================
+# ==============================================================================
 # THEN Steps - Assertions
-# ============================================================================
+# ==============================================================================
 
 @then('Customer balance should be {expected:d}')
 def step_impl(context, expected):
-    """Verify customer balance (primary customer)"""
-    scenario_name = 'Verify Customer Balance'
-    test_utils.prt(f'Checking customer balance = {expected}', scenario_name)
-    
+    """Verify customer balance (default customer)"""
     customer_uri = f'{BASE_URL}/api/Customer/{context.customer_id}/'
     r = requests.get(url=customer_uri, headers=get_headers())
-    assert r.status_code == 200, f"Failed to get customer: {r.text}"
-    
     actual = float(r.json()['data']['attributes']['balance'] or 0)
-    assert abs(actual - expected) < 0.01, \
-        f"Expected balance {expected}, got {actual}"
+    assert abs(actual - expected) < 0.01, f"Expected balance {expected}, got {actual}"
 
 
 @then('Customer "{customer_name}" balance should be {expected:d}')
 def step_impl(context, customer_name, expected):
-    """Verify specific customer balance (Rule #8: Use customer map)"""
-    scenario_name = f'Verify {customer_name} Balance'
-    test_utils.prt(f'Checking {customer_name} balance = {expected}', scenario_name)
-    
-    customer_info = context.customer_map.get(customer_name)
-    
+    """Verify specific customer balance (for multi-customer tests - Rule #8)"""
+    customer_info = context.customer_map[customer_name]
     customer_uri = f'{BASE_URL}/api/Customer/{customer_info["id"]}/'
     r = requests.get(url=customer_uri, headers=get_headers())
-    assert r.status_code == 200, f"Failed to get customer: {r.text}"
-    
     actual = float(r.json()['data']['attributes']['balance'] or 0)
-    assert abs(actual - expected) < 0.01, \
-        f"Expected {customer_name} balance {expected}, got {actual}"
+    assert abs(actual - expected) < 0.01, f"Expected {customer_name} balance {expected}, got {actual}"
 
 
 @then('Order amount_total should be {expected:d}')
 def step_impl(context, expected):
-    """Verify order total"""
-    scenario_name = 'Verify Order Total'
-    test_utils.prt(f'Checking order amount_total = {expected}', scenario_name)
-    
-    if not hasattr(context, 'order_id') or context.order_id is None:
-        assert not context.order_created, "Order should have failed"
+    """Verify order amount_total"""
+    if context.order_id is None:
+        assert not context.order_created, "Order should not have been created"
         return
-    
+        
     order_uri = f'{BASE_URL}/api/Order/{context.order_id}/'
     r = requests.get(url=order_uri, headers=get_headers())
-    assert r.status_code == 200, f"Failed to get order: {r.text}"
-    
     actual = float(r.json()['data']['attributes']['amount_total'] or 0)
-    assert abs(actual - expected) < 0.01, \
-        f"Expected amount_total {expected}, got {actual}"
+    assert abs(actual - expected) < 0.01, f"Expected amount_total {expected}, got {actual}"
 
 
 @then('Item amount should be {expected:d}')
 def step_impl(context, expected):
     """Verify item amount"""
-    scenario_name = 'Verify Item Amount'
-    test_utils.prt(f'Checking item amount = {expected}', scenario_name)
-    
-    if not hasattr(context, 'item_id') or context.item_id is None:
-        assert not context.order_created, "Order should have failed"
+    if context.item_id is None:
+        assert not context.order_created, "Item should not have been created"
         return
-    
+        
     item_uri = f'{BASE_URL}/api/Item/{context.item_id}/'
     r = requests.get(url=item_uri, headers=get_headers())
-    assert r.status_code == 200, f"Failed to get item: {r.text}"
-    
     actual = float(r.json()['data']['attributes']['amount'] or 0)
-    assert abs(actual - expected) < 0.01, \
-        f"Expected amount {expected}, got {actual}"
+    assert abs(actual - expected) < 0.01, f"Expected amount {expected}, got {actual}"
 
 
 @then('Item unit_price should be {expected:d}')
 def step_impl(context, expected):
-    """Verify item unit price (tests copy rule)"""
-    scenario_name = 'Verify Unit Price Copy'
-    test_utils.prt(f'Checking item unit_price = {expected}', scenario_name)
-    
+    """Verify item unit_price (tests copy rule)"""
     item_uri = f'{BASE_URL}/api/Item/{context.item_id}/'
     r = requests.get(url=item_uri, headers=get_headers())
-    assert r.status_code == 200, f"Failed to get item: {r.text}"
-    
     actual = float(r.json()['data']['attributes']['unit_price'] or 0)
-    assert abs(actual - expected) < 0.01, \
-        f"Expected unit_price {expected}, got {actual}"
+    assert abs(actual - expected) < 0.01, f"Expected unit_price {expected}, got {actual}"
 
 
 @then('Order created successfully')
 def step_impl(context):
-    """Verify order creation succeeded"""
+    """Verify order was created"""
     assert context.order_created, "Order creation failed"
     assert context.order_id is not None, "Order ID not set"
 
 
-@then('Order creation should fail')
+@then('Order should be rejected')
 def step_impl(context):
-    """Verify order creation failed (negative test)"""
-    assert not context.order_created, "Order should have been rejected"
+    """Verify order was rejected (constraint violation)"""
+    assert not context.order_created, "Order should have been rejected but was created"
 
 
 @then('Error message should contain "{text}"')
 def step_impl(context, text):
-    """Verify error message content"""
-    # Error already verified by order_created = False
-    pass
+    """Verify error message contains expected text"""
+    # For constraint violations, we expect the order not to be created
+    assert not context.order_created, f"Expected constraint violation, but order was created"
+
+
+# ==============================================================================
+# Helper Functions
+# ==============================================================================
+
+def get_product_id_by_name(product_name):
+    """
+    Lookup product ID by name
+    
+    Uses exact match on product name from database
+    """
+    products_uri = f'{BASE_URL}/api/Product/?filter[name]={product_name}'
+    r = requests.get(url=products_uri, headers=get_headers())
+    
+    if not r.json()['data']:
+        raise ValueError(f"Product '{product_name}' not found in database")
+    
+    return int(r.json()['data'][0]['id'])