Exploratory Testing Session Notes
Shopping Cart Feature Investigation
Session Objective
Investigate shopping cart behavior with focus on edge cases, error handling, and user experience under unusual conditions. No predefined test cases — discovery-driven testing.
Test Charter
- How does the cart behave with maximum items?
- What happens when inventory runs out mid-session?
- How does the system handle price changes?
- What occurs during concurrent cart modifications?
- How robust is the quantity input validation?
Session Notes & Findings
Area 1: Cart Capacity & Item Limits
Testing Approach:
Added items to cart incrementally to discover behavior under high load.
Activities:
- Added 1 item → cart updated ✓
- Added 10 items (same product) → quantity shows 10 ✓
- Added 50 items → cart still functional, no performance issues ✓
- Added 100+ items → UI began to lag noticeably ⚠️
- Attempted to add 1000 items → browser became sluggish; UI updates delayed 3–5 seconds
Observation: Cart UI performance degrades when quantity exceeds 100 items. Not a hard limit, but UX becomes poor.
Severity: Medium — Unlikely scenario (user unlikely to order 100+ of same item), but possible.
Recommendation: Consider implementing UI virtualization or lazy loading for large quantities. Add client-side validation to warn user if quantity exceeds reasonable threshold (e.g., 999).
Area 2: Inventory & Out-of-Stock Behavior
Testing Approach:
Added item to cart, then manually reduced inventory in database to simulate sell-out.
Activities:
- Added product (50 units in stock) to cart ✓
- Reduced inventory to 20 units in backend database
- Refreshed cart page → quantity still shows original 50 ✗ (out of sync)
- Attempted checkout → system allowed checkout with invalid quantity ✗
- Submitted order → backend rejected with error "Insufficient inventory" (caught at last moment) ✓
Observation: Cart displays cached inventory count; changes in inventory not reflected until page refresh or checkout attempt.
Severity: High — Could result in checkout failures or customer disappointment ("Out of stock" error after proceeding to payment).
Recommendation: Implement real-time inventory sync. Before checkout, re-validate inventory server-side. Show warning if quantity exceeds available stock.
Area 3: Price Changes & Promotions
Testing Approach:
Added item to cart at original price, then simulated a price change.
Activities:
- Added product at $50 to cart ✓
- Changed product price in backend to $30
- Refreshed cart → price still shows $50 ✗ (stale price)
- Applied promo code (should reduce price) → promo worked, but final total still used cached $50 price ✗
- Navigated away and back to cart → price updated to $30 ✓
Observation: Product prices in cart are cached; price changes not reflected until page reload or session refresh.
Severity: High — Customers expect current pricing. Promotional discounts not showing correctly; customer may abandon cart if prices seem incorrect.
Recommendation: Fetch current prices server-side on cart page load. Display if price has changed since item was added. Recalculate total with current prices before checkout.
Area 4: Quantity Input Validation
Testing Approach:
Manually edited quantity field with various inputs (negative, decimal, text, extreme values).
Activities:
- Changed quantity to 0 → item remained in cart with qty=0 ⚠️ (appears in checkout)
- Changed quantity to -5 → system accepted negative quantity ✗ (order would have -5 items)
- Changed quantity to 3.5 → accepted decimal value; backend later rounded or truncated ⚠️
- Changed quantity to "abc" → field accepted text; form submission failed with server error ✗
- Changed quantity to 999999999 → accepted; page sluggish but didn't crash
Observation: Quantity input field accepts invalid values: negative numbers, decimals, text. No client-side validation.
Severity: High — Could result in malformed orders, server errors, or security vulnerability (if not validated server-side).
Recommendation: Add HTML5 input type="number" with min="1" and max attributes. Implement client-side validation with user-friendly error messages. Validate server-side before processing order.
Area 5: Concurrent Cart Modifications
Testing Approach:
Opened cart in two browser windows simultaneously and modified items in parallel.
Activities:
- Window A: Added 5 units of Product X
- Window B: Added 3 units of Product Y (simultaneously)
- Window A: Increased quantity to 10 units
- Window B: Refresh cart (to sync with server)
- Window B: Shows Product X (5 units) and Product Y (3 units) — stale data ✗
- Window A: Product X shows 10 units ✓
- Window B: After refresh, shows updated quantities ✓ (eventually consistent)
Observation: Cart state is not synchronized across multiple browser sessions. Changes in one session may not be visible in another until manual refresh.
Severity: Medium — Unlikely for typical single-user scenario, but problematic for shared devices or account sharing. Could result in duplicate items or data loss.
Recommendation: Implement server-side cart session management. Use polling or WebSocket to sync cart state across sessions. Show warning if cart was modified elsewhere.
Summary of Findings
| Finding | Severity | Impact |
|---|---|---|
| Performance degradation at scale (100+ items) | Medium | Poor UX, unlikely scenario |
| Inventory cache not refreshed | High | Checkout failures, customer dissatisfaction |
| Price staleness in cart | High | Incorrect pricing, lost promotions, cart abandonment |
| Weak input validation on quantity | High | Malformed orders, server errors, potential security issue |
| Cart state inconsistency across sessions | Medium | Unlikely but problematic for shared accounts |
Recommendations for Development
- Urgent: Fix inventory cache and price staleness issues
- Urgent: Add input validation to quantity field (client + server)
- Important: Implement server-side cart session management
- Consider: Optimize cart UI rendering for performance at scale
- Test: Create regression test cases for each finding
Session Artifacts
- Browser console logs (captured errors)
- Network request logs (Chrome DevTools)
- Screenshots of edge case scenarios
- Database query results (inventory/pricing validation)