Platform

Solutions

Resources

Platform

Solutions

Resources

Platform

Solutions

Resources

Blog

Shopify Plus Testing: How to Protect Checkout and Revenue

Rishabh Kumar

Published on

Shopify plus testing

Table of contents

Lorem ipsum

Lorem ipsum

Lorem ipsum

Lorem ipsum

Lorem ipsum

On a normal Tuesday, a broken discount costs a few complaints. During a Black Friday drop, the same bug can cost a day’s revenue in an hour, and the damage is done before anyone in the office has opened a dashboard.

Shopify Plus gives enterprise retailers a lot of power: Checkout Extensibility, Shopify Functions, Markets, B2B, headless storefronts and an app for almost everything. Every one of those is something that can break. Shopify Plus testing is how you find out before your customers do.

Shopify plus testing



What is Shopify Plus Testing?

Shopify Plus testing checks that your enterprise store works correctly from the first product view to the last fulfilment update. It covers your storefront and theme, checkout and payments, discounts and Functions, apps, inventory and orders, B2B features, international markets and every integration with your ERP, CRM, marketing and fulfilment systems.

Shopify runs and tests the platform itself. What you need to test is everything you’ve built or switched on around it: your theme, your apps, your checkout customisations, your pricing rules, your markets and your integrations.



Why Shopify Plus Stores Need Their Own Testing Approach

Reason

Why It Matters

Checkout is where revenue lives

A bug anywhere else is annoying. A bug in checkout stops money arriving, often silently

Traffic arrives in spikes

Drops, launches and seasonal sales can bring many times your usual traffic in minutes

Apps change your store without you

Most Plus stores run many apps, and each one can update, conflict with another or slow the site down

Integrations run on webhooks and APIs

A missed webhook can mean an order that never reaches the warehouse

Selling in many markets

Prices, taxes, duties, payment methods and languages all differ by country

Shopify keeps evolving

New API versions arrive every quarter, and older features get retired on fixed dates



Scripts Are Gone: What That Means for Testing

Shopify Scripts, the Ruby-based way Plus stores customised discounts, shipping and payment rules, stopped running on 30 June 2026. The older checkout.liquid customisation has also been retired. Their replacements are Shopify Functions and Checkout Extensibility.

If your store migrated in a hurry, this is one of the most important things to test right now. Logic that used to live in Scripts, like tiered pricing, BOGO offers, hidden shipping methods or B2B payment rules, has been rebuilt in a different way, and small differences in behaviour are easy to miss.

What Scripts Used to Do

What to Retest Now

Line item discounts, like tiered or volume pricing

Each tier gives the right discount, at the exact quantity boundaries

Combining discounts

Which discounts stack, and which don’t, matches your promotion rules

Hiding or renaming shipping methods

The right methods show for each country, basket and customer type

Hiding or reordering payment methods

B2B customers see payment terms, and restricted methods stay hidden

Blocking certain baskets

Cart validation rules stop orders that break your rules, with a clear message



What to Test on a Shopify Plus Store


  1. Storefront and Theme

Whether you use a Liquid theme, Online Store 2.0 sections or a headless Hydrogen storefront, test that pages render correctly on every device and browser, that sections and app blocks appear where they should, that metafields show the right product details, and that filters, search and sorting return the right results.

For headless storefronts, also test the Storefront API calls behind each page, cart persistence between visits and what happens when an API call fails or is slowed by rate limits.

Small theme updates often shift a “Buy now” button or a price label without anyone noticing, which is why many retailers add visual regression testing to their release checks.


  1. Checkout and Payments

  • Guest and logged-in checkout, express wallets like Shop Pay, Apple Pay and Google Pay

  • Card payments that trigger 3D Secure, which strong customer authentication rules require for many UK and EU payments

  • Local payment methods for each market, like iDEAL in the Netherlands or Klarna in the Nordics

  • Checkout UI extensions and post-purchase offers, including what happens when an offer is declined

  • Declined cards, failed payments and timeouts, and the message customers see

  • Subscription orders from apps, with the right billing schedule


  1. Discounts, Pricing and Functions

Discounts are where small rule changes cost the most. Test every live promotion, including combinations, minimum spends, free shipping thresholds, customer-specific prices and codes that should only work once. Test the boundaries: exactly £50 for free delivery, exactly 10 units for a volume tier.


  1. Inventory and Orders

  • Stock levels across warehouses, stores and dropship suppliers

  • Pre-orders, back-orders and limited drops, without overselling

  • Order routing to the right location, split shipments and click-and-collect

  • Edits, cancellations, returns and refunds, with stock updated correctly

The basket is where most of these rules meet, and our list of add to cart test cases is a quick way to make sure none are missed.


  1. B2B and Customer Accounts

Shopify’s B2B features add company accounts, locations, custom catalogues, volume pricing and payment terms. Test that each buyer sees only their company’s catalogue and prices, that minimum quantities and payment terms apply, that approvals route correctly and that retail customers never see wholesale prices.


  1. Markets, Tax and Duties

Area

What to Test

Currency

Prices show in the right currency, with your rounding rules applied

VAT and sales tax

UK VAT is charged at checkout on orders up to £135, EU VAT is handled correctly for low-value orders up to €150, and US sales tax applies by state

Duties

Duties and import taxes are calculated at checkout where you’ve chosen to collect them

Shipping

Each country sees the right carriers, rates and delivery estimates

Restricted products

Products you can’t ship to a country can’t be bought there

Language

Translations, right-to-left layouts and local date and number formats

Returns

The 14-day cancellation right for online orders in the UK and EU is reflected in your returns flow


  1. Apps

Test the apps that touch revenue first: search, reviews, loyalty, subscriptions, bundles and checkout apps. Check they work together, don’t slow pages down and fail gracefully, so a broken review widget never blocks the “Add to bag” button.


  1. Integrations and Webhooks

Test that orders reach your ERP and warehouse, that customers sync with your CRM and marketing tools, and that webhooks are handled once each, even when Shopify retries them. Here’s a simple check that your webhook endpoint rejects messages that didn’t come from Shopify:

Python (pytest)

import base64, hashlib, hmac, json, requests

SECRET = b"test-webhook-secret"
ENDPOINT = "https://integrations.example.com/shopify/orders-create"

def sign(body: bytes) -> str:
    digest = hmac.new(SECRET, body, hashlib.sha256).digest()
    return base64.b64encode(digest).decode()

def test_rejects_unsigned_webhook():
    body = json.dumps({"id": 5550001, "total_price": "64.00"}).encode()
    r = requests.post(ENDPOINT, data=body,
                      headers={"X-Shopify-Hmac-Sha256": "not-a-real-signature"})
    assert r.status_code == 401

def test_duplicate_webhook_creates_one_erp_order(erp):
    body = json.dumps({"id": 5550002, "total_price": "64.00"}).encode()
    headers = {"X-Shopify-Hmac-Sha256": sign(body),
               "X-Shopify-Webhook-Id": "b54557e4-retry-test"}
    requests.post(ENDPOINT, data=body, headers=headers)
    requests.post(ENDPOINT, data=body, headers=headers)   # Shopify retry
    assert erp.count_orders(shopify_id=5550002) == 1
import base64, hashlib, hmac, json, requests

SECRET = b"test-webhook-secret"
ENDPOINT = "https://integrations.example.com/shopify/orders-create"

def sign(body: bytes) -> str:
    digest = hmac.new(SECRET, body, hashlib.sha256).digest()
    return base64.b64encode(digest).decode()

def test_rejects_unsigned_webhook():
    body = json.dumps({"id": 5550001, "total_price": "64.00"}).encode()
    r = requests.post(ENDPOINT, data=body,
                      headers={"X-Shopify-Hmac-Sha256": "not-a-real-signature"})
    assert r.status_code == 401

def test_duplicate_webhook_creates_one_erp_order(erp):
    body = json.dumps({"id": 5550002, "total_price": "64.00"}).encode()
    headers = {"X-Shopify-Hmac-Sha256": sign(body),
               "X-Shopify-Webhook-Id": "b54557e4-retry-test"}
    requests.post(ENDPOINT, data=body, headers=headers)
    requests.post(ENDPOINT, data=body, headers=headers)   # Shopify retry
    assert erp.count_orders(shopify_id=5550002) == 1
import base64, hashlib, hmac, json, requests

SECRET = b"test-webhook-secret"
ENDPOINT = "https://integrations.example.com/shopify/orders-create"

def sign(body: bytes) -> str:
    digest = hmac.new(SECRET, body, hashlib.sha256).digest()
    return base64.b64encode(digest).decode()

def test_rejects_unsigned_webhook():
    body = json.dumps({"id": 5550001, "total_price": "64.00"}).encode()
    r = requests.post(ENDPOINT, data=body,
                      headers={"X-Shopify-Hmac-Sha256": "not-a-real-signature"})
    assert r.status_code == 401

def test_duplicate_webhook_creates_one_erp_order(erp):
    body = json.dumps({"id": 5550002, "total_price": "64.00"}).encode()
    headers = {"X-Shopify-Hmac-Sha256": sign(body),
               "X-Shopify-Webhook-Id": "b54557e4-retry-test"}
    requests.post(ENDPOINT, data=body, headers=headers)
    requests.post(ENDPOINT, data=body, headers=headers)   # Shopify retry
    assert erp.count_orders(shopify_id=5550002) == 1
import base64, hashlib, hmac, json, requests

SECRET = b"test-webhook-secret"
ENDPOINT = "https://integrations.example.com/shopify/orders-create"

def sign(body: bytes) -> str:
    digest = hmac.new(SECRET, body, hashlib.sha256).digest()
    return base64.b64encode(digest).decode()

def test_rejects_unsigned_webhook():
    body = json.dumps({"id": 5550001, "total_price": "64.00"}).encode()
    r = requests.post(ENDPOINT, data=body,
                      headers={"X-Shopify-Hmac-Sha256": "not-a-real-signature"})
    assert r.status_code == 401

def test_duplicate_webhook_creates_one_erp_order(erp):
    body = json.dumps({"id": 5550002, "total_price": "64.00"}).encode()
    headers = {"X-Shopify-Hmac-Sha256": sign(body),
               "X-Shopify-Webhook-Id": "b54557e4-retry-test"}
    requests.post(ENDPOINT, data=body, headers=headers)
    requests.post(ENDPOINT, data=body, headers=headers)   # Shopify retry
    assert erp.count_orders(shopify_id=5550002) == 1

If NetSuite sits on the other end of those webhooks, NetSuite testing for retail covers the order, inventory and finance checks on the ERP side.


  1. Security, Privacy and Accessibility

  • Payments: card data is handled only by Shopify’s checkout or certified providers, keeping you within PCI DSS scope

  • Privacy: tracking and marketing pixels only fire with consent where GDPR, UK GDPR and PECR require it, and customer data requests can be fulfilled

  • Accessibility: since June 2025, the European Accessibility Act covers many online shops selling to EU customers, so test keyboard use, screen readers, contrast and alt text against WCAG

  • Accounts: password resets are secure, and customers can’t see each other’s orders



Example Shopify Plus Test Cases

ID

Area

Scenario

Expected Result

SP-01

Checkout

Guest buys one item with a card that triggers 3D Secure

Challenge appears, payment succeeds and the order confirmation shows

SP-02

Discounts

Basket of exactly £50.00 with free delivery over £50

Delivery is free, matching your rule on “£50 or more”

SP-03

Discounts

Two automatic discounts that shouldn’t combine

Only the better one applies

SP-04

Functions

B2B buyer reaches the 10-unit volume tier

The tier price applies at 10 units, not 9

SP-05

Payments

A retail customer in Germany at checkout

Local methods show, and B2B payment terms don’t

SP-06

Markets

A €120 order shipped to France

VAT is charged at checkout, and no import VAT is due on delivery

SP-07

Inventory

Last unit bought on the website and in a store at the same moment

Only one order succeeds, and stock never goes negative

SP-08

B2B

A buyer from Company A logs in

Only Company A’s catalogue and prices are shown

SP-09

Apps

The reviews app fails to load

The product page still loads, and “Add to bag” works

SP-10

Integrations

An order is placed

It appears in the ERP once, with matching totals, tax and shipping

SP-11

Returns

Return requested 20 days after delivery, with a 14-day policy

The return is refused with a clear message, or routed to support

SP-12

Accessibility

Complete checkout using only a keyboard

Every step can be reached and completed



Common Shopify Plus Testing Challenges

Challenge

What Goes Wrong

What Helps

API rate limits

Integrations drop or delay data during busy periods

Test throttling and retries, and watch for data that never arrives

App updates you didn’t schedule

An app changes how your store behaves overnight

Run smoke tests on key journeys every day

Dynamic, personalised pages

Recommendations, prices and countdowns change on every visit, so fixed checks fail

Tests that find elements by label and context, and check rules rather than fixed values

Too many combinations

Markets, customer types, payment methods and discounts multiply quickly

Data-driven tests that run one journey with many combinations

Shared test stores

Teams change products and stock under each other’s tests

Dedicated development or sandbox stores, with tests that create their own data

Quarterly API versions

An integration uses a version that’s about to be retired

Track API versions, and retest integrations before each upgrade



Preparing for Peak Events

Black Friday, product drops and influencer campaigns are where testing pays for itself.

When

What to Do

6 to 8 weeks before

Freeze major theme and app changes. Run full regression on checkout, discounts, payments and integrations

4 weeks before

Set up every campaign discount and Launchpad schedule in a test store, and test them with real basket combinations

2 weeks before

Load test your own services, like your ERP connector, search and custom APIs, since Shopify scales its platform but not your systems

1 week before

Rehearse rollback: restore the previous theme, switch off an app and turn on checkout queue settings

Day of the event

Run smoke tests on key journeys every 15 to 30 minutes, with alerts to the on-call team

After the event

Review what broke or nearly broke, and add tests for it

Shopify handles the platform’s scaling, but your connectors, search and custom services still need checking under strain, and stress testing shows where they give way first.



How to Set Up Shopify Plus Testing

Test Stores

Use development or sandbox stores that mirror production, with the same theme, apps, markets, discounts and Functions. Keep one stable store for release testing, and separate stores for feature work. Use Shopify’s test payment gateway or your payment provider’s test mode for checkout, never real cards.

Shopify CLI lets you push a theme to a development store for testing before it goes live:

Bash (Shopify CLI)





Test Data

  • Products: simple items, items with many variants, bundles, subscriptions, digital products and restricted items

  • Customers: guests, account holders, loyalty members, B2B buyers and customers in every market you sell to

  • Stock: in stock, low stock, out of stock, pre-order and stock split across locations

  • Discounts: every live promotion, plus the ones planned for your next campaign

Run Tests in Your Pipeline

Trigger

What to Run

Theme or app code change

Theme check, plus smoke tests on product, basket and checkout

New or changed Function

Discount, shipping and payment tests for every affected rule

Nightly

Full regression across markets, customer types and payment methods

Before a campaign

Every campaign discount and schedule, in combination

Every 15 to 30 minutes on live

Scripted checks on key journeys, using test products and test payments



Best Practices for Shopify Plus Testing

Practice

Why

Rank tests by revenue impact

A checkout or pricing bug costs far more than a blog formatting issue

Test every promotion before it goes live

Discount mistakes are expensive and often exploited quickly

Test the boundaries

Exactly £50, exactly 10 units and the last item in stock are where bugs hide

Test apps together, not one by one

Conflicts only show up when apps share a page

Make sure failures fail safely

A broken widget should never stop someone buying

Test each market as a customer would

Prices, tax, payment methods and language all change by country

Rehearse rollback before peak

You won’t have time to work it out on the day

Many of these practices apply to any online shop, and our wider guide to e-commerce testing covers the rest of the customer journey in more depth.



Metrics to Track

Metric

What It Tells You

Checkout journeys covered by automated tests

How much of your revenue path is protected

Test checkout success rate, by payment method and market

Whether each route to payment still works

Pricing and discount bugs found before launch

Whether promotions are being checked properly

Bugs reaching production

Whether testing is catching what matters

Time to run full regression

Whether testing fits around your release and campaign calendar

Orders missing from the ERP or warehouse

Whether integrations are reliable

Core Web Vitals on key pages

Whether apps and theme changes are slowing the store down



Where Shopify Plus Testing is Heading

  • More logic in Functions: with Scripts gone, discount, shipping, payment and validation rules all live in Functions, so testing them becomes a core release check.

  • More headless storefronts: Hydrogen and other frameworks mean testing the front end and the APIs behind it as one journey.

  • AI in the store: AI-written product content, search and recommendations need checks for accuracy, brand tone and relevance.

  • Unified commerce: online, in-store and social channels share stock and customers, so tests follow customers across channels.



Testing Your Shopify Plus Store with Virtuoso QA

Retail QA teams rarely lack ideas for what to test. They lack time before the next campaign goes live.

Virtuoso QA is built to get your revenue journeys tested quickly in language your e-commerce team already uses, and to keep those tests working as themes, apps and promotions change week to week.

Store Testing Need

How Virtuoso QA Helps

Merchandisers and QA working from one test

Journeys read like the steps a shopper takes, so a trading manager can check a promotion test is right without reading code

Tests for every campaign brief

Touchstone reads your promotion briefs and acceptance criteria and drafts journeys from them, each tied back to the rule it checks, for someone to approve

Themes and apps that keep moving

When a theme update moves “Add to bag”, the broken step comes back as a suggested edit to accept or reject, rather than a failed run

Every market and customer type

One checkout journey runs across a data table of countries, currencies, payment methods and customer types

Checking the order really landed

A journey can finish checkout on screen, then check the order through the API and in connected systems

Every browser your shoppers use

Runs in parallel across 2,000+ browser and OS combinations, including mobile web

Proof before a big launch

Every run records what was tested, the result and who approved the test, so the go-live decision rests on evidence

Here’s a promotion test a trading team could read and sign off:

Plain English (Virtuoso QA)





Following an order from the storefront click through payment and into the warehouse feed is the kind of journey Virtuoso QA’s end-to-end testing is built for.


Shopify Plus Testing FAQs

What is Shopify Plus testing?

Do I still need to test after migrating from Scripts to Functions?

How do I test Shopify Plus checkout without real payments?

How do I prepare a Shopify Plus store for Black Friday?

How do I test apps on Shopify Plus?

Can Shopify Plus testing be automated without code?

Written by

Rishabh Kumar

AI Testing & Quality Engineering Contributor

Rishabh leads business development and marketing at Virtuoso QA. He writes about AI-powered test automation, end-to-end testing, self-healing tests, and quality engineering, exploring how these capabilities can improve test coverage, reduce test maintenance, and support reliable software releases.

See what your next release looks like with Virtuoso

Book a walkthrough on your applications and your workflows. Bring a requirement, a user journey, or a brittle Selenium script, and watch the loop run on something you recognise.

See what your next release looks like with Virtuoso

Book a walkthrough on your applications and your workflows. Bring a requirement, a user journey, or a brittle Selenium script, and watch the loop run on something you recognise.

See what your next release looks like with Virtuoso

Book a walkthrough on your applications and your workflows. Bring a requirement, a user journey, or a brittle Selenium script, and watch the loop run on something you recognise.

Virtuoso QA is establishing the standard of proof for software releases. Its governed QA loop turns business requirements into tests for any browser-based application: AI proposes, a deterministic engine executes, a person approves what matters, and every decision leaves evidence.

Trust Center

AICPA

SOC

WAVE STRONG PERFORMER

@ Copyright 2026 SpotQA, Creators of Virtuoso QA

Virtuoso QA is establishing the standard of proof for software releases. Its governed QA loop turns business requirements into tests for any browser-based application: AI proposes, a deterministic engine executes, a person approves what matters, and every decision leaves evidence.

Trust Center

AICPA

SOC

WAVE STRONG PERFORMER

@ Copyright 2026 SpotQA, Creators of Virtuoso QA

Virtuoso QA is establishing the standard of proof for software releases. Its governed QA loop turns business requirements into tests for any browser-based application: AI proposes, a deterministic engine executes, a person approves what matters, and every decision leaves evidence.

Trust Center

AICPA

SOC

WAVE STRONG PERFORMER

@ Copyright 2026 SpotQA, Creators of Virtuoso QA