>_ Shopping Cart Testing Checklist

Short answer

A Shopping Cart Testing Checklist is a list of checks for the cart in an e-commerce store, marketplace, SaaS checkout, booking flow, or any product where users first select products, plans, or services before moving to checkout.

Shopping cart testing helps make sure users can add an item to the cart, see the correct product, variant, quantity, and price, update quantity, remove items, apply discounts, keep the cart after refresh or login, continue to checkout, and avoid issues like duplicate items, wrong totals, broken cart state, or unexplained out-of-stock items.

The cart is an intermediate but critical step between product selection and checkout. If the cart works incorrectly, users may never reach purchase, even if the product page and checkout work correctly.

The main idea is: shopping cart testing checks whether the cart correctly stores, displays, and updates the items selected by the user before checkout.

This guide can also be used as a cart testing checklist, e-commerce cart QA checklist, add to cart testing checklist, cart page testing checklist, or shopping cart smoke checklist for online stores, marketplaces, and checkout-heavy products.

Shopping Cart Testing vs Checkout Testing

Shopping cart testing and checkout testing are connected, but they are not the same thing.

Shopping cart testing checks what happens before checkout:

• add to cart;
• cart drawer;
• cart page;
• product name;
• product image;
• selected variant;
• quantity;
• remove item;
• subtotal;
• discount preview;
• cart persistence;
• guest cart;
• logged-in cart;
• cart merge after login;
• out-of-stock handling;
• continue shopping;
• proceed to checkout.

Checkout testing checks order placement:

• contact information;
• shipping address;
• billing address;
• shipping method;
• order summary;
• tax;
• payment step;
• place order;
• confirmation page;
• confirmation email;
• order creation.

In simple terms: shopping cart testing answers “does the cart correctly store and show selected items?”, while checkout testing answers “can the user place the order?”

Shopping Cart Testing vs E-commerce QA

Shopping cart testing is part of e-commerce QA, but it is not the whole e-commerce QA process.

E-commerce QA is broader. It includes:

• catalog;
• product listing;
• product detail page;
• search;
• filters;
• cart;
• checkout;
• payment;
• shipping;
• inventory;
• order management;
• emails;
• admin panel;
• analytics.

Shopping cart QA focuses only on the cart experience and related cart scenarios.

For example, if the user selected size M and color Black, shopping cart testing checks that this exact variant appears in the cart, displays with the correct price, quantity, and subtotal, remains after refresh, and is passed correctly to checkout.

When to use a Shopping Cart Testing Checklist

Use this checklist whenever the product has a cart or any part of cart logic changes.

For example:

• a new e-commerce site is launching;
• a marketplace is launching;
• cart page is added;
• cart drawer or mini cart is added;
• add to cart button changes;
• product variant logic changes;
• quantity selector changes;
• cart subtotal changes;
• prices, discounts, or promo codes change;
• inventory logic changes;
• guest cart is added;
• logged-in cart changes;
• cart merge after login changes;
• save for later or wishlist changes;
• cart-to-checkout flow changes;
• mobile cart changes;
• add to cart analytics changes;
• there was a production bug: wrong cart total, duplicate cart item, lost cart, wrong variant, or checkout received wrong items.

For a small change, a short cart smoke test may be enough. For an e-commerce launch, checkout-related release, pricing change, or cart redesign, it is better to go through the full shopping cart testing checklist.

Short Shopping Cart Testing Checklist

If you need a minimal cart smoke test, check that:

• product can be added to cart;
• cart icon updates item count;
• cart drawer or cart page opens;
• product name is displayed correctly;
• product image is displayed;
• selected variant is displayed correctly;
• price is displayed correctly;
• quantity is displayed correctly;
• quantity can be updated;
• subtotal recalculates;
• item can be removed;
• empty cart state is displayed;
• cart remains after refresh;
• guest cart works;
• logged-in cart works;
• cart is saved or merged after login according to product rules;
• out-of-stock item is handled clearly;
• promo code or discount is displayed if applied in cart;
• proceed to checkout works;
• checkout receives the correct items and totals;
• mobile cart works;
• add to cart event is sent if analytics is important;
• there are no critical console errors or failed API requests.

This is not full checkout QA. It is a minimal check that helps quickly confirm whether the cart works at a basic level.

Shopping Cart Testing Checklist

1. Define the cart testing scope

Before cart testing starts, define which cart type is used and which scenarios need to be checked.

Check that:

• cart page exists, if expected;
• cart drawer exists, if expected;
• mini cart exists, if expected;
• cart icon exists in the header;
• guest cart is supported or not supported;
• logged-in cart is supported or not supported;
• cart merge after login is supported or not supported;
• multiple items can be added;
• product variants exist;
• quantity selector exists;
• promo codes can be applied in cart, if supported;
• discounts can be shown in cart, if supported;
• tax or shipping preview is shown, if supported;
• save for later exists, if supported;
• wishlist exists, if supported;
• inventory restrictions exist;
• cart expiration exists;
• critical scenarios are defined;
• the person responsible for pass / fail decision is known.

The main question is: which cart behaviors should work before the user moves to checkout?

2. Prepare test products and test data

Cart testing requires different types of products or items. One regular product will not reveal all possible cart bugs.

Check that you have:

• regular product;
• product with variants;
• discounted product;
• out-of-stock product;
• low-stock product;
• product with long name;
• product with long variant name;
• product with image;
• product without image, if possible;
• digital product, if supported;
• physical product, if supported;
• subscription plan, if the cart is used for SaaS;
• bundle, if supported;
• product with quantity limits;
• product excluded from discount, if promo rules exist.

If the cart supports different item types, each important type should be tested separately.

3. Check add to cart from product detail page

Product detail page is the most common source of add to cart action.

Check that:

• add to cart button is displayed;
• button is available when product is available;
• button is disabled when product is unavailable;
• product is added to cart;
• user sees confirmation after add to cart;
• cart icon updates;
• cart drawer opens if expected;
• user stays on product page if expected;
• user can continue shopping;
• user can go to cart;
• user can go to checkout;
• no duplicate item is created without reason;
• no broken state appears after add to cart.

The main question is: can the user add the selected product to the cart and understand that the action was successful?

4. Check add to cart from product listing page

Some stores allow users to add products to cart directly from product listing page, category page, or search results.

Check that:

• add to cart button is displayed on product card;
• product is added to cart;
• correct product is added;
• quick add works, if available;
• variant selection is required if the product has variants;
• user cannot accidentally add the wrong variant;
• cart count updates;
• price matches the product card;
• sale price is preserved;
• out-of-stock product cannot be added;
• user receives clear feedback after add to cart.

If the product requires selecting size or color, add to cart from listing page should either ask the user to select a variant or lead to the product page.

5. Check product variants in cart

Variants are one of the most important cart testing scenarios. An issue here can lead to purchasing the wrong product.

Check that:

• selected size is displayed in cart;
• selected color is displayed in cart;
• selected material is displayed, if available;
• selected plan is displayed, if this is SaaS;
• selected subscription interval is displayed, if available;
• selected SKU is correct;
• selected image is correct if the variant has a separate image;
• variant price is correct;
• unavailable variant cannot be added;
• selected variant remains after refresh;
• selected variant is passed to checkout;
• selected variant is displayed in order summary;
• user cannot accidentally buy a different variant.

For example, if the user selected Size M and Color Black, cart, checkout, email, and admin panel should all show Size M / Black.

6. Check cart drawer

Cart drawer or mini cart often appears immediately after add to cart and helps the user move quickly to checkout.

Check that:

• drawer opens after add to cart, if expected;
• drawer can be opened manually;
• drawer can be closed;
• close button works;
• product is displayed;
• variant is displayed;
• quantity is displayed;
• price is displayed;
• subtotal is displayed;
• remove item works;
• proceed to checkout button works;
• view cart button works, if available;
• drawer fits on mobile screen;
• drawer scroll works with several items;
• drawer does not block the page after closing.

Cart drawer should be fast and clear. It should not become a trap that the user cannot leave.

7. Check cart page

Cart page is the more detailed version of the cart where the user can review items before checkout.

Check that:

• cart page opens;
• all cart items are displayed;
• product names are correct;
• product images are correct;
• variants are correct;
• prices are correct;
• quantity is correct;
• subtotal is correct;
• discounts are displayed, if available;
• tax or shipping preview is displayed, if expected;
• remove item works;
• update quantity works;
• continue shopping link works;
• proceed to checkout works;
• cart page does not contain test content;
• cart page works on mobile.

Cart page should give the user confidence: “yes, this is exactly what I am about to buy.”

8. Check cart icon and item count

Cart icon is often used as an indicator of cart state.

Check that:

• cart icon is displayed;
• item count updates after add to cart;
• item count updates after remove;
• item count updates after quantity change if count shows total quantity;
• item count does not update incorrectly if count shows unique items;
• cart icon opens cart;
• cart icon works after refresh;
• cart icon works after login;
• cart icon works on mobile;
• cart count does not become negative;
• cart count is not duplicated after repeated actions.

Define the rule in advance: does cart count show unique items or total quantity?

9. Check update quantity

Quantity update affects subtotal, stock, discounts, and checkout.

Check that:

• user can increase quantity;
• user can decrease quantity;
• quantity cannot be lower than minimum;
• quantity cannot be higher than maximum;
• quantity cannot exceed available stock;
• quantity update recalculates item total;
• quantity update recalculates subtotal;
• quantity update updates cart count;
• invalid quantity is handled;
• decimal quantity is rejected if only integer is allowed;
• manual input works, if allowed;
• plus/minus buttons work, if available;
• quantity remains after refresh;
• updated quantity is passed to checkout.

Quantity bugs often lead to incorrect amount or inability to purchase the required quantity.

10. Check remove item

User should be able to remove an item from cart.

Check that:

• remove button is displayed;
• remove button works;
• item disappears from cart;
• subtotal recalculates;
• cart count updates;
• empty cart state appears if this was the last item;
• undo option works, if available;
• confirmation is not required for a normal remove if that is the product rule;
• remove does not delete another item;
• remove does not break cart drawer or cart page;
• removed item is not passed to checkout.

Removing an item should be fast, clear, and safe.

11. Check empty cart state

Empty cart state is an important UX scenario. The user should understand that the cart is empty and what to do next.

Check that:

• empty cart message is displayed;
• message is clear;
• continue shopping CTA works;
• recommended products are displayed, if available;
• cart count is zero;
• checkout button is hidden or disabled;
• user cannot move to checkout with empty cart if this is forbidden;
• empty cart state works after removing the last item;
• empty cart state works after cart expiration;
• empty cart state works on mobile.

Empty cart should not look like a broken page.

12. Check cart persistence after refresh

Cart should remain after refresh if this is expected.

Check that:

• cart remains after page refresh;
• items remain;
• variants remain;
• quantity remains;
• discounts remain, if expected;
• cart count remains;
• cart drawer shows correct items;
• cart page shows correct items;
• no duplicate items appear after refresh;
• no cart loss happens after refresh.

Cart loss after refresh is one of the most frustrating cart bugs for users.

13. Check guest cart

Guest cart is needed if users can add products before login.

Check that:

• guest user can add item to cart;
• guest cart remains after refresh;
• guest cart remains during navigation;
• guest cart remains in browser session;
• guest cart works without account;
• guest cart is not visible to another user;
• guest cart is cleared according to product rules;
• guest user can proceed to checkout if guest checkout is supported;
• guest user sees clear login/signup prompt if account is required;
• guest cart is not lost unexpectedly.

Guest cart is especially important for e-commerce conversion because users often start shopping before registration.

14. Check logged-in cart

Logged-in cart may be stored on the backend and available after the user logs in again.

Check that:

• logged-in user can add item to cart;
• cart remains after logout/login if expected;
• cart is saved on backend;
• cart is available on another device if supported;
• cart is not mixed with another user’s cart;
• cart updates after remove;
• cart updates after quantity change;
• cart is cleared after successful order if expected;
• old cart does not appear unexpectedly after login;
• cart history or saved cart works, if available.

Logged-in cart is especially important for SaaS checkout, marketplaces, and multi-device shopping.

15. Check cart merge after login

Cart merge is a complex scenario: guest user adds items, then logs into an account.

Check that:

• guest cart remains after login;
• guest cart merges with account cart;
• duplicate items are merged according to rules;
• same product + same variant quantity is merged if expected;
• same product + different variant remains as separate items;
• discounts are preserved or recalculated according to rules;
• out-of-stock items are handled;
• user sees final cart after login;
• no items are lost after merge;
• no unexpected duplicate items appear;
• merge does not add items from another user.

Cart merge bugs can be very frustrating: the user may lose selected items or receive extra items.

16. Check cart sync between tabs and devices

If cart syncs between tabs or devices, this should be tested separately.

Check that:

• cart update in one tab appears in another;
• remove item in one tab does not leave stale item in another;
• quantity update syncs;
• checkout from one tab handles cart state in another tab;
• logged-in cart syncs between devices, if supported;
• stale cart shows refresh or update message;
• duplicate updates do not create wrong quantity;
• conflict state is handled clearly.

Even if real-time sync is not supported, the product should handle stale cart predictably.

17. Check cart expiration

Some carts expire after time or after stock/price changes.

Check that:

• cart expiration works according to rules;
• user sees a clear message;
• expired cart does not lead to broken checkout;
• expired item is removed or marked clearly;
• expired price is recalculated;
• expired discount is handled;
• user can restore cart, if supported;
• user can continue shopping;
• expired cart does not create duplicate order;
• expired cart state works on mobile.

Cart expiration is especially important for booking, tickets, limited inventory, flash sales, and carts with reserved stock.

18. Check stock and availability in cart

Cart should respond correctly to inventory changes.

Check that:

• in-stock item can be added;
• out-of-stock item cannot be added;
• out-of-stock item in cart shows a warning;
• low-stock message is displayed, if available;
• quantity cannot exceed stock;
• item becoming out of stock after being added is handled;
• checkout is blocked or warning is displayed if item is unavailable;
• price/stock refresh works;
• unavailable variant is handled;
• backorder or preorder logic works, if supported;
• cart does not allow purchase of an item that cannot be bought.

Very important scenario: user adds an item to cart, but by the time they reach checkout, the item becomes unavailable.

19. Check pricing in cart

Cart should show correct prices before checkout.

Check that:

• product price is correct;
• variant price is correct;
• sale price is correct;
• original price is displayed if needed;
• item total is calculated correctly;
• subtotal is calculated correctly;
• quantity affects subtotal;
• currency is correct;
• rounding works;
• price in cart matches product page;
• price in cart is passed to checkout;
• price change after adding to cart is handled according to product rules;
• user sees a clear message after price change.

Cart price should be reliable. If product page and cart show different amounts without explanation, user trust drops.

20. Check discounts and promo codes in cart

If discounts are applied in cart, test them separately from checkout.

Check that:

• automatic discount is displayed;
• promo code field is displayed, if available;
• valid promo code is applied;
• invalid promo code shows an error;
• expired promo code is not applied;
• promo code can be removed;
• subtotal/total preview recalculates;
• discount applies to correct items;
• excluded items do not receive discount;
• discount remains after refresh, if expected;
• discount is passed to checkout;
• discount warning is shown if code applies only later;
• gift card works if supported in cart.

If promo code can only be entered in checkout, cart should not promise the discount too early.

21. Check tax and shipping preview, if available

Some carts show estimated tax or shipping before checkout.

Check that:

• estimated shipping is displayed, if expected;
• estimated tax is displayed, if expected;
• user understands this is an estimate;
• estimate updates after address or region selection;
• estimate is not shown as final amount if it is not final;
• free shipping threshold works;
• message “add X more for free shipping” is calculated correctly;
• preview is passed or recalculated in checkout;
• no misleading total appears before checkout.

Tax and shipping preview should be clear. The user should not think an estimate is the final amount if it is not.

22. Check cart-to-checkout transition

Cart should correctly pass data to checkout.

Check that:

• proceed to checkout button works;
• checkout opens;
• checkout receives correct items;
• checkout receives correct variants;
• checkout receives correct quantity;
• checkout receives correct subtotal;
• checkout receives discount if it should be passed;
• unavailable item blocking logic works;
• empty cart does not lead to checkout;
• guest user sees the correct path;
• logged-in user sees the correct path;
• cart is not cleared before successful order;
• checkout does not receive stale cart data.

This is the boundary between Shopping Cart Testing and Checkout Testing. Here, the key point is that cart data is passed correctly to the next step.

23. Check save for later and wishlist, if available

Some carts allow users to temporarily remove items without deleting them completely.

Check that:

• item can be moved to save for later;
• item disappears from active cart;
• subtotal recalculates;
• saved item appears in a separate section;
• saved item can be moved back to cart;
• saved item keeps variant;
• saved item keeps price or updates price according to rules;
• out-of-stock saved item is handled;
• wishlist action works, if available;
• user must log in for wishlist if expected;
• saved items are not passed to checkout.

Save for later should be clear: the item is no longer in the active cart, but it is not lost.

24. Check recommendations and cross-sell in cart

Cart often contains related products, upsell, or cross-sell blocks.

Check that:

• recommendations are displayed;
• recommended products are available;
• add recommended item to cart works;
• added recommended item does not break cart;
• recommendation block does not cover cart controls;
• recommendation price is correct;
• out-of-stock recommendation is not suggested or is displayed correctly;
• recommendations do not look like active cart items;
• block works on mobile;
• analytics tracking works if important.

Recommendations should not interfere with the main cart task: reviewing items and moving to checkout.

25. Check cart errors and recovery

Cart should handle errors clearly.

Check that:

• add to cart error is displayed;
• remove item error is displayed;
• quantity update error is displayed;
• promo code error is displayed;
• stock error is displayed;
• network error is displayed;
• user can retry;
• cart data is not lost after error;
• cart does not enter broken state;
• there is no endless loader;
• there is no silent failure;
• error message is clear.

Cart errors should help the user continue shopping, not abandon the cart.

26. Check duplicate items and idempotency

Repeated actions can create duplicate cart items or incorrect quantity.

Check that:

• double click add to cart does not create duplicate item without reason;
• repeated add to cart increases quantity or adds item according to product rules;
• same product same variant is handled correctly;
• same product different variant is displayed separately;
• retry after network error does not create unexpected duplicate;
• refresh after add to cart does not add item again;
• add to cart from multiple tabs is handled;
• cart count remains correct;
• subtotal remains correct.

Duplicate logic should be predictable. The user should understand why an item appeared as a separate line or increased quantity.

27. Check mobile cart experience

Mobile cart is especially important for e-commerce conversion.

Check that:

• cart opens on mobile;
• cart drawer fits the screen;
• cart page is readable;
• product name is not critically cut off;
• variant is readable;
• quantity controls are usable;
• remove button is reachable;
• subtotal is visible;
• checkout CTA is visible;
• sticky checkout button does not cover content;
• promo code field is usable;
• error messages are visible;
• there is no horizontal scroll;
• cart can be used end-to-end on a phone.

Mobile cart should be not only responsive, but comfortable for reviewing items and moving to checkout.

28. Check browser compatibility

Cart can break because of storage, cookies, scripts, frontend state, or browser-specific behavior.

Check that:

• cart works in Chrome;
• cart works in Safari;
• cart works in Firefox, if supported;
• cart works in Edge, if supported;
• mobile Safari works;
• mobile Chrome works;
• cart persistence works;
• local storage or cookies work if used;
• cart drawer works;
• quantity update works;
• there is no browser-specific layout issue;
• there are no critical console errors.

Safari should be checked especially carefully if cart persistence depends on cookies, local storage, or third-party scripts.

29. Check cart API and backend behavior, if applicable

If cart is stored on backend or through API, UI-only testing is not enough.

Check that:

• add to cart API works;
• update quantity API works;
• remove item API works;
• get cart API returns correct items;
• guest cart ID is created;
• logged-in cart is linked to user;
• cart merge works on backend;
• invalid product ID is rejected;
• invalid variant ID is rejected;
• unavailable item is rejected;
• API does not return another user’s cart;
• cart response schema is stable;
• backend does not create duplicate items without rules.

Cart API bugs may not appear immediately in UI, but later break checkout, sync, or analytics.

30. Check security and privacy basics

Cart can contain user-specific data, pricing, discounts, account information, or private offers.

Check that:

• user cannot open someone else’s cart;
• guest cart token does not grant access to another user’s data;
• cart API checks ownership;
• private discounts are not visible to the wrong user;
• hidden product cannot be purchased through direct request;
• price cannot be changed from frontend;
• quantity limits are enforced on backend;
• promo code restrictions are enforced on backend;
• sensitive user data is not displayed in cart unnecessarily;
• cart data is not logged with sensitive fields;
• admin-only fields are not returned to frontend.

Cart security is especially important for price manipulation, promo abuse, and user data isolation.

31. Check cart analytics

Cart analytics helps the team understand conversion, drop-off, and user behavior.

Check that:

• add to cart event is sent;
• remove from cart event is sent;
• update quantity event is sent, if tracked;
• view cart event is sent;
• begin checkout event is sent on transition;
• product ID is correct;
• variant ID is correct;
• price is correct;
• currency is correct;
• quantity is correct;
• discount is passed, if needed;
• events are not duplicated;
• UTM/source is preserved;
• analytics does not hurt performance.

Cart analytics is especially important for e-commerce, paid traffic, funnel analysis, and product recommendations.

32. Check cart performance

Cart should respond quickly. A slow cart reduces the chance of purchase.

Check that:

• add to cart gives feedback quickly;
• cart drawer opens quickly;
• cart page loads quickly;
• quantity update does not hang;
• remove item does not hang;
• promo code application does not hang;
• loading states are clear;
• cart works with several items;
• cart works with many items if this is a realistic scenario;
• cart does not create heavy frontend lag;
• backend cart response is fast enough;
• mobile cart performance is acceptable.

If the user clicks add to cart and nothing happens for several seconds, they may click again or leave.

33. Run production cart smoke after release

After a cart-related release, run a short production check.

Check that:

• production product page opens;
• add to cart works;
• cart icon updates;
• cart drawer or cart page opens;
• item is displayed correctly;
• quantity update works;
• remove item works;
• subtotal is correct;
• promo code works if critical;
• cart persists after refresh;
• proceed to checkout works;
• checkout receives correct items;
• mobile cart works;
• analytics receives add to cart event if important;
• there are no staging links;
• there is no test data;
• logs and monitoring do not show increased cart errors.

Production cart smoke should be short and safe. Its goal is to make sure real users can add products to cart and move to checkout after release.

Common mistakes

1. Testing only add to cart

Add to cart is only the beginning. Quantity, remove, subtotal, variants, persistence, guest cart, logged-in cart, and cart-to-checkout transition should also be checked.

2. Not testing variants

If the user selected one size or color and the cart contains another variant, that is a critical cart bug.

3. Not verifying prices

Product page, cart, checkout, and confirmation should be consistent. If cart shows the wrong price, the user loses trust.

4. Not testing cart persistence

Cart should not disappear after refresh, navigation, or login if the product is expected to preserve the cart.

5. Ignoring guest cart

Many users add items before registration. Guest cart bugs directly affect conversion.

6. Not testing cart merge after login

Guest cart + existing account cart can lead to lost items, duplicate items, or wrong quantity.

7. Not testing out-of-stock scenarios

An item can become unavailable after being added to cart. Cart should show a clear state and should not send the user into a broken checkout.

8. Not testing mobile cart

Cart may work on desktop but be inconvenient on mobile: small quantity controls, hidden CTA, covered drawer, unreadable variants.

9. Not testing duplicate actions

Double click, retry, refresh, or multiple tabs can create duplicate items or incorrect subtotal.

10. Not running production cart smoke

Cart may work on staging but fail in production because of pricing config, inventory sync, promo rules, scripts, cache, or backend environment.

FAQ

What is a Shopping Cart Testing Checklist?

A Shopping Cart Testing Checklist is a list of checks for the cart in an e-commerce store, marketplace, or web product. It helps test add to cart, cart drawer, cart page, product variants, quantity, remove item, subtotal, discounts, cart persistence, guest cart, logged-in cart, cart merge, stock, mobile cart, and cart-to-checkout transition.

What should be checked in shopping cart testing?

At minimum, check:

• add to cart;
• cart icon count;
• cart drawer or cart page;
• product name;
• product image;
• selected variant;
• price;
• quantity;
• subtotal;
• remove item;
• empty cart;
• cart persistence;
• guest cart;
• logged-in cart;
• cart merge;
• stock availability;
• proceed to checkout;
• mobile cart;
• cart analytics;
• production smoke.

How is shopping cart testing different from checkout testing?

Shopping cart testing checks the cart before checkout: items, variants, quantity, prices, remove, subtotal, persistence, and cart-to-checkout transition.

Checkout testing checks order placement: contact details, shipping, billing, payment step, place order, confirmation page, and order creation.

How do you test add to cart?

Check that:

• add to cart button works;
• correct product is added;
• selected variant is preserved;
• cart icon updates;
• cart drawer or cart page shows the item;
• price is correct;
• quantity is correct;
• no duplicate item appears without reason;
• user sees clear feedback;
• unavailable product cannot be added.

How do you test product variants in cart?

Check that selected size, color, material, plan, or subscription interval is displayed correctly in cart, passed to checkout, and not replaced with another variant.

Same product with different variants should usually appear as separate cart items unless product rules say otherwise.

How do you test cart quantity?

Check that:

• quantity can be increased;
• quantity can be decreased;
• subtotal recalculates;
• cart count updates;
• quantity cannot exceed stock;
• invalid quantity is rejected;
• manual input works, if supported;
• updated quantity remains after refresh;
• checkout receives the correct quantity.

How do you test guest cart?

Check that guest user can add items, cart remains after refresh/navigation, cart is not lost unexpectedly, and user can proceed to checkout or login/signup according to product rules.

If guest checkout is supported, guest cart should be passed to checkout.

How do you test cart merge after login?

Check the scenario where guest user adds items to cart and then logs in.

After login, cart should merge according to product rules: no lost items, no unexpected duplicates, correct quantity, correct variants, correct discounts, and correct checkout data.

How do you test out-of-stock item in cart?

Check that:

• out-of-stock item cannot be added;
• item that became out of stock after add to cart shows warning;
• quantity cannot exceed stock;
• checkout blocks unavailable item or clearly explains the issue;
• cart subtotal updates if item is removed;
• user can continue shopping.

Should cart analytics be tested?

Yes, if the team tracks funnel or conversion.

Check add to cart, remove from cart, update quantity, view cart, and begin checkout events. Also check product ID, variant ID, quantity, price, currency, and absence of duplicate events.

How do you know the shopping cart is ready for release?

Shopping cart can be considered ready for release when:

• user can add items to cart;
• variants display correctly;
• quantity update works;
• remove item works;
• subtotal is correct;
• discounts work if used;
• cart persists according to rules;
• guest cart works;
• logged-in cart works;
• cart merge works if supported;
• stock issues are handled clearly;
• mobile cart works;
• checkout receives correct cart data;
• no blocker or critical bugs remain;
• production cart smoke check has passed.