No shipping option for the cart

pip install requests

export MEDUSA_BACKEND_URL="http://localhost:9000"
export MEDUSA_ADMIN_EMAIL="admin@example.com"
export MEDUSA_ADMIN_PASSWORD="supersecret"
export DRY_RUN="true"   # start safe, change to false to write

npm install @medusajs/js-sdk

export MEDUSA_BACKEND_URL="http://localhost:9000"
export MEDUSA_ADMIN_EMAIL="admin@example.com"
export MEDUSA_ADMIN_PASSWORD="supersecret"
export DRY_RUN="true"   // start safe, change to false to write

import os, requests

BACKEND_URL = os.environ["MEDUSA_BACKEND_URL"]
ADMIN_EMAIL = os.environ["MEDUSA_ADMIN_EMAIL"]
ADMIN_PASSWORD = os.environ["MEDUSA_ADMIN_PASSWORD"]

def get_admin_token():
    r = requests.post(
        f"{BACKEND_URL}/auth/user/emailpass",
        json={"email": ADMIN_EMAIL, "password": ADMIN_PASSWORD},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["token"]

def get_regions(token):
    r = requests.get(
        f"{BACKEND_URL}/admin/regions",
        headers={"Authorization": f"Bearer {token}"},
        params={"fields": "id,name,*countries"},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["regions"]

import Medusa from "@medusajs/js-sdk";

const sdk = new Medusa({
  baseUrl: process.env.MEDUSA_BACKEND_URL,
  auth: { type: "jwt" },
});

async function login() {
  return sdk.auth.login("user", "emailpass", {
    email: process.env.MEDUSA_ADMIN_EMAIL,
    password: process.env.MEDUSA_ADMIN_PASSWORD,
  });
}

async function getRegions() {
  const { regions } = await sdk.admin.region.list({
    fields: "id,name,*countries",
  });
  return regions;
}

def get_stock_locations(token):
    r = requests.get(
        f"{BACKEND_URL}/admin/stock-locations",
        headers={"Authorization": f"Bearer {token}"},
        params={
            "fields": "id,name,*sales_channels,*fulfillment_sets,"
                      "*fulfillment_sets.service_zones,"
                      "*fulfillment_sets.service_zones.geo_zones,"
                      "*fulfillment_sets.service_zones.shipping_options",
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["stock_locations"]

async function getStockLocations() {
  const { stock_locations } = await sdk.admin.stockLocation.list({
    fields:
      "id,name,*sales_channels,*fulfillment_sets," +
      "*fulfillment_sets.service_zones," +
      "*fulfillment_sets.service_zones.geo_zones," +
      "*fulfillment_sets.service_zones.shipping_options",
  });
  return stock_locations;
}

def find_uncovered_regions(regions, stock_locations):
    results = []
    for region in regions:
        for sales_channel_id in region.get("salesChannelIds", []):
            locations_for_channel = [
                loc for loc in stock_locations
                if sales_channel_id in loc.get("salesChannelIds", [])
            ]
            for country_code in region.get("countryCodes", []):
                matched_zone = None
                for loc in locations_for_channel:
                    for fset in loc.get("fulfillmentSets", []):
                        for zone in fset.get("serviceZones", []):
                            for gz in zone.get("geoZones", []):
                                if gz.get("type") == "country" and gz.get("countryCode") == country_code:
                                    matched_zone = zone
                                    break
                            if matched_zone:
                                break
                        if matched_zone:
                            break
                    if matched_zone:
                        break

                if matched_zone is None:
                    results.append({
                        "salesChannelId": sales_channel_id,
                        "countryCode": country_code,
                        "reason": "no_geo_zone_match",
                    })
                    continue

                options = matched_zone.get("shippingOptions", [])
                if not options or all(_excluded(opt) for opt in options):
                    results.append({
                        "salesChannelId": sales_channel_id,
                        "countryCode": country_code,
                        "reason": "zone_matched_no_shipping_options",
                    })
    return results


def _excluded(option):
    for rule in option.get("rules", []) or []:
        if rule.get("attribute") == "cart.subtotal" and rule.get("operator") in ("gt", "gte") \
                and isinstance(rule.get("value"), (int, float)) and rule["value"] > 0:
            return True
    return False

export function findUncoveredRegions(regions, stockLocations) {
  const results = [];
  for (const region of regions) {
    for (const salesChannelId of region.salesChannelIds || []) {
      const locationsForChannel = stockLocations.filter((loc) =>
        (loc.salesChannelIds || []).includes(salesChannelId)
      );
      for (const countryCode of region.countryCodes || []) {
        let matchedZone = null;
        outer: for (const loc of locationsForChannel) {
          for (const fset of loc.fulfillmentSets || []) {
            for (const zone of fset.serviceZones || []) {
              for (const gz of zone.geoZones || []) {
                if (gz.type === "country" && gz.countryCode === countryCode) {
                  matchedZone = zone;
                  break outer;
                }
              }
            }
          }
        }

        if (!matchedZone) {
          results.push({ salesChannelId, countryCode, reason: "no_geo_zone_match" });
          continue;
        }

        const options = matchedZone.shippingOptions || [];
        if (options.length === 0 || options.every(isExcluded)) {
          results.push({ salesChannelId, countryCode, reason: "zone_matched_no_shipping_options" });
        }
      }
    }
  }
  return results;
}

function isExcluded(option) {
  return (option.rules || []).some(
    (rule) =>
      rule.attribute === "cart.subtotal" &&
      (rule.operator === "gt" || rule.operator === "gte") &&
      typeof rule.value === "number" &&
      rule.value > 0
  );
}

def log_gaps(gaps, log):
    if not gaps:
        log.info("No gaps found. Every region country has a matching service zone with usable shipping options.")
        return
    for gap in gaps:
        log.info(
            "Gap: sales_channel=%s country=%s reason=%s",
            gap["salesChannelId"], gap["countryCode"], gap["reason"],
        )
    log.info("Done. %d uncovered (sales_channel, country) pair(s) found.", len(gaps))

function logGaps(gaps) {
  if (gaps.length === 0) {
    console.log("No gaps found. Every region country has a matching service zone with usable shipping options.");
    return;
  }
  for (const gap of gaps) {
    console.log(`Gap: sales_channel=${gap.salesChannelId} country=${gap.countryCode} reason=${gap.reason}`);
  }
  console.log(`Done. ${gaps.length} uncovered (sales_channel, country) pair(s) found.`);
}

"""Find Medusa regions whose countries have no matching shipping coverage, safely.

Shipping availability for a cart is resolved by walking cart to sales channel
to stock location to FulfillmentSet to ServiceZone to GeoZone, and matching
the cart's shipping_address.country_code against a GeoZone. Regions control
checkout availability and currency, and are configured independently of
service zone geo zones, so a merchant can add a country to a Region without
ever adding a matching GeoZone to any ServiceZone, or without linking the
right stock location to the sales channel. That leaves the country's carts
with a zero length shipping_options array even though the region, product,
and pricing all look correct.

This script reports every uncovered (sales_channel, country) pair. It does
not create service zones, geo zones, or shipping options automatically,
since that is a business decision about which countries to actually ship
to, carrier rates, and tax nexus. Run once, or on a schedule.

Guide: https://www.allanninal.dev/medusa/no-shipping-option-for-the-cart/
"""
import os
import logging
import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("find_uncovered_regions")

BACKEND_URL = os.environ["MEDUSA_BACKEND_URL"]
ADMIN_EMAIL = os.environ["MEDUSA_ADMIN_EMAIL"]
ADMIN_PASSWORD = os.environ["MEDUSA_ADMIN_PASSWORD"]
DRY_RUN = os.environ.get("DRY_RUN", "true").lower() == "true"

# Only used if an operator explicitly opts into the guarded repair path.
FULFILLMENT_SET_ID = os.environ.get("FULFILLMENT_SET_ID", "").strip() or None
SERVICE_ZONE_ID = os.environ.get("SERVICE_ZONE_ID", "").strip() or None
SHIPPING_PROFILE_ID = os.environ.get("SHIPPING_PROFILE_ID", "").strip() or None
PROVIDER_ID = os.environ.get("PROVIDER_ID", "").strip() or None


def get_admin_token():
    r = requests.post(
        f"{BACKEND_URL}/auth/user/emailpass",
        json={"email": ADMIN_EMAIL, "password": ADMIN_PASSWORD},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["token"]


def get_regions(token):
    r = requests.get(
        f"{BACKEND_URL}/admin/regions",
        headers={"Authorization": f"Bearer {token}"},
        params={"fields": "id,name,*countries"},
        timeout=30,
    )
    r.raise_for_status()
    regions = []
    for region in r.json()["regions"]:
        regions.append({
            "id": region["id"],
            "countryCodes": [c["iso_2"] for c in region.get("countries", []) if c.get("iso_2")],
            "salesChannelIds": [sc["id"] for sc in region.get("sales_channels", []) or []] or [region["id"]],
        })
    return regions


def get_stock_locations(token):
    r = requests.get(
        f"{BACKEND_URL}/admin/stock-locations",
        headers={"Authorization": f"Bearer {token}"},
        params={
            "fields": "id,name,*sales_channels,*fulfillment_sets,"
                      "*fulfillment_sets.service_zones,"
                      "*fulfillment_sets.service_zones.geo_zones,"
                      "*fulfillment_sets.service_zones.shipping_options",
        },
        timeout=30,
    )
    r.raise_for_status()
    locations = []
    for loc in r.json()["stock_locations"]:
        locations.append({
            "id": loc["id"],
            "salesChannelIds": [sc["id"] for sc in loc.get("sales_channels", []) or []],
            "fulfillmentSets": [
                {
                    "serviceZones": [
                        {
                            "geoZones": [
                                {"type": gz.get("type"), "countryCode": gz.get("country_code")}
                                for gz in zone.get("geo_zones", []) or []
                            ],
                            "shippingOptions": [
                                {"id": opt["id"], "rules": opt.get("rules", [])}
                                for opt in zone.get("shipping_options", []) or []
                            ],
                        }
                        for zone in fset.get("service_zones", []) or []
                    ]
                }
                for fset in loc.get("fulfillment_sets", []) or []
            ],
        })
    return locations


def find_uncovered_regions(regions, stock_locations):
    """Pure decision function. No I/O.

    regions: [{"id": str, "countryCodes": [str], "salesChannelIds": [str]}, ...]
    stock_locations: [{"id": str, "salesChannelIds": [str],
                        "fulfillmentSets": [{"serviceZones": [{"geoZones": [...], "shippingOptions": [...]}]}]}, ...]

    Returns a list of {"salesChannelId": str, "countryCode": str, "reason": str}
    for every (salesChannelId, countryCode) pair a region requires but that has
    no matching geo zone, or matches a service zone with no usable shipping
    option. Covered pairs are omitted.
    """
    results = []
    for region in regions:
        for sales_channel_id in region.get("salesChannelIds", []):
            locations_for_channel = [
                loc for loc in stock_locations
                if sales_channel_id in loc.get("salesChannelIds", [])
            ]
            for country_code in region.get("countryCodes", []):
                matched_zone = None
                for loc in locations_for_channel:
                    for fset in loc.get("fulfillmentSets", []):
                        for zone in fset.get("serviceZones", []):
                            for gz in zone.get("geoZones", []):
                                if gz.get("type") == "country" and gz.get("countryCode") == country_code:
                                    matched_zone = zone
                                    break
                            if matched_zone:
                                break
                        if matched_zone:
                            break
                    if matched_zone:
                        break

                if matched_zone is None:
                    results.append({
                        "salesChannelId": sales_channel_id,
                        "countryCode": country_code,
                        "reason": "no_geo_zone_match",
                    })
                    continue

                options = matched_zone.get("shippingOptions", [])
                if not options or all(_excluded(opt) for opt in options):
                    results.append({
                        "salesChannelId": sales_channel_id,
                        "countryCode": country_code,
                        "reason": "zone_matched_no_shipping_options",
                    })
    return results


def _excluded(option):
    for rule in option.get("rules", []) or []:
        if rule.get("attribute") == "cart.subtotal" and rule.get("operator") in ("gt", "gte") \
                and isinstance(rule.get("value"), (int, float)) and rule["value"] > 0:
            return True
    return False


def print_planned_repair(gap):
    log.info(
        "  [DRY RUN] would POST /admin/fulfillment-sets/%s/service-zones/%s/geo-zones "
        "{type: 'country', country_code: '%s'}",
        FULFILLMENT_SET_ID, SERVICE_ZONE_ID, gap["countryCode"],
    )
    log.info(
        "  [DRY RUN] would POST /admin/shipping-options "
        "{service_zone_id: '%s', shipping_profile_id: '%s', provider_id: '%s', prices: [...]}",
        SERVICE_ZONE_ID, SHIPPING_PROFILE_ID, PROVIDER_ID,
    )


def apply_repair(token, gap):
    r = requests.post(
        f"{BACKEND_URL}/admin/fulfillment-sets/{FULFILLMENT_SET_ID}/service-zones/{SERVICE_ZONE_ID}/geo-zones",
        headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
        json={"type": "country", "country_code": gap["countryCode"]},
        timeout=30,
    )
    r.raise_for_status()


def verify_cart_has_options(token, cart_id):
    r = requests.get(
        f"{BACKEND_URL}/store/shipping-options",
        headers={"Authorization": f"Bearer {token}"},
        params={"cart_id": cart_id},
        timeout=30,
    )
    r.raise_for_status()
    return len(r.json().get("shipping_options", [])) > 0


def run():
    token = get_admin_token()
    regions = get_regions(token)
    stock_locations = get_stock_locations(token)

    gaps = find_uncovered_regions(regions, stock_locations)

    if not gaps:
        log.info("No gaps found. Every region country has a matching service zone with usable shipping options.")
        return

    for gap in gaps:
        log.info(
            "Gap: sales_channel=%s country=%s reason=%s",
            gap["salesChannelId"], gap["countryCode"], gap["reason"],
        )
        can_repair = FULFILLMENT_SET_ID and SERVICE_ZONE_ID and SHIPPING_PROFILE_ID and PROVIDER_ID
        if can_repair:
            print_planned_repair(gap)
            if not DRY_RUN:
                apply_repair(token, gap)
                log.info("  Applied. Re-verify with a synthetic cart before trusting checkout.")

    log.info("Done. %d uncovered (sales_channel, country) pair(s) found.", len(gaps))


if __name__ == "__main__":
    run()

/**
 * Find Medusa regions whose countries have no matching shipping coverage, safely.
 *
 * Shipping availability for a cart is resolved by walking cart to sales channel
 * to stock location to FulfillmentSet to ServiceZone to GeoZone, and matching
 * the cart's shipping_address.country_code against a GeoZone. Regions control
 * checkout availability and currency, and are configured independently of
 * service zone geo zones, so a merchant can add a country to a Region without
 * ever adding a matching GeoZone to any ServiceZone, or without linking the
 * right stock location to the sales channel. That leaves the country's carts
 * with a zero length shipping_options array even though the region, product,
 * and pricing all look correct.
 *
 * This script reports every uncovered (sales_channel, country) pair. It does
 * not create service zones, geo zones, or shipping options automatically,
 * since that is a business decision about which countries to actually ship
 * to, carrier rates, and tax nexus. Run once, or on a schedule.
 *
 * Guide: https://www.allanninal.dev/medusa/no-shipping-option-for-the-cart/
 */
import { pathToFileURL } from "node:url";

const BACKEND_URL = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000";
const ADMIN_EMAIL = process.env.MEDUSA_ADMIN_EMAIL || "admin@example.com";
const ADMIN_PASSWORD = process.env.MEDUSA_ADMIN_PASSWORD || "supersecret";
const DRY_RUN = (process.env.DRY_RUN || "true").toLowerCase() === "true";

// Only used if an operator explicitly opts into the guarded repair path.
const FULFILLMENT_SET_ID = (process.env.FULFILLMENT_SET_ID || "").trim() || null;
const SERVICE_ZONE_ID = (process.env.SERVICE_ZONE_ID || "").trim() || null;
const SHIPPING_PROFILE_ID = (process.env.SHIPPING_PROFILE_ID || "").trim() || null;
const PROVIDER_ID = (process.env.PROVIDER_ID || "").trim() || null;

export function findUncoveredRegions(regions, stockLocations) {
  const results = [];
  for (const region of regions) {
    for (const salesChannelId of region.salesChannelIds || []) {
      const locationsForChannel = stockLocations.filter((loc) =>
        (loc.salesChannelIds || []).includes(salesChannelId)
      );
      for (const countryCode of region.countryCodes || []) {
        let matchedZone = null;
        outer: for (const loc of locationsForChannel) {
          for (const fset of loc.fulfillmentSets || []) {
            for (const zone of fset.serviceZones || []) {
              for (const gz of zone.geoZones || []) {
                if (gz.type === "country" && gz.countryCode === countryCode) {
                  matchedZone = zone;
                  break outer;
                }
              }
            }
          }
        }

        if (!matchedZone) {
          results.push({ salesChannelId, countryCode, reason: "no_geo_zone_match" });
          continue;
        }

        const options = matchedZone.shippingOptions || [];
        if (options.length === 0 || options.every(isExcluded)) {
          results.push({ salesChannelId, countryCode, reason: "zone_matched_no_shipping_options" });
        }
      }
    }
  }
  return results;
}

function isExcluded(option) {
  return (option.rules || []).some(
    (rule) =>
      rule.attribute === "cart.subtotal" &&
      (rule.operator === "gt" || rule.operator === "gte") &&
      typeof rule.value === "number" &&
      rule.value > 0
  );
}

async function getSdk() {
  const { default: Medusa } = await import("@medusajs/js-sdk");
  const sdk = new Medusa({ baseUrl: BACKEND_URL, auth: { type: "jwt" } });
  await sdk.auth.login("user", "emailpass", { email: ADMIN_EMAIL, password: ADMIN_PASSWORD });
  return sdk;
}

async function getRegions(sdk) {
  const { regions } = await sdk.admin.region.list({ fields: "id,name,*countries" });
  return regions.map((region) => ({
    id: region.id,
    countryCodes: (region.countries || []).map((c) => c.iso_2).filter(Boolean),
    salesChannelIds: (region.sales_channels || []).map((sc) => sc.id).length
      ? region.sales_channels.map((sc) => sc.id)
      : [region.id],
  }));
}

async function getStockLocations(sdk) {
  const { stock_locations } = await sdk.admin.stockLocation.list({
    fields:
      "id,name,*sales_channels,*fulfillment_sets," +
      "*fulfillment_sets.service_zones," +
      "*fulfillment_sets.service_zones.geo_zones," +
      "*fulfillment_sets.service_zones.shipping_options",
  });
  return stock_locations.map((loc) => ({
    id: loc.id,
    salesChannelIds: (loc.sales_channels || []).map((sc) => sc.id),
    fulfillmentSets: (loc.fulfillment_sets || []).map((fset) => ({
      serviceZones: (fset.service_zones || []).map((zone) => ({
        geoZones: (zone.geo_zones || []).map((gz) => ({
          type: gz.type,
          countryCode: gz.country_code,
        })),
        shippingOptions: (zone.shipping_options || []).map((opt) => ({
          id: opt.id,
          rules: opt.rules || [],
        })),
      })),
    })),
  }));
}

function printPlannedRepair(gap) {
  console.log(
    `  [DRY RUN] would POST /admin/fulfillment-sets/${FULFILLMENT_SET_ID}/service-zones/${SERVICE_ZONE_ID}/geo-zones ` +
      `{type: "country", country_code: "${gap.countryCode}"}`
  );
  console.log(
    `  [DRY RUN] would POST /admin/shipping-options ` +
      `{service_zone_id: "${SERVICE_ZONE_ID}", shipping_profile_id: "${SHIPPING_PROFILE_ID}", provider_id: "${PROVIDER_ID}", prices: [...]}`
  );
}

async function applyRepair(sdk, gap) {
  return sdk.admin.fulfillmentSet.createServiceZoneGeoZones(FULFILLMENT_SET_ID, SERVICE_ZONE_ID, {
    type: "country",
    country_code: gap.countryCode,
  });
}

export async function run() {
  const sdk = await getSdk();
  const regions = await getRegions(sdk);
  const stockLocations = await getStockLocations(sdk);

  const gaps = findUncoveredRegions(regions, stockLocations);

  if (gaps.length === 0) {
    console.log("No gaps found. Every region country has a matching service zone with usable shipping options.");
    return;
  }

  const canRepair = FULFILLMENT_SET_ID && SERVICE_ZONE_ID && SHIPPING_PROFILE_ID && PROVIDER_ID;
  for (const gap of gaps) {
    console.log(`Gap: sales_channel=${gap.salesChannelId} country=${gap.countryCode} reason=${gap.reason}`);
    if (canRepair) {
      printPlannedRepair(gap);
      if (!DRY_RUN) {
        await applyRepair(sdk, gap);
        console.log("  Applied. Re-verify with a synthetic cart before trusting checkout.");
      }
    }
  }

  console.log(`Done. ${gaps.length} uncovered (sales_channel, country) pair(s) found.`);
}

if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  run().catch((err) => { console.error(err); process.exit(1); });
}

from find_uncovered_regions import find_uncovered_regions


def region(**over):
    base = {"id": "reg_1", "countryCodes": ["us"], "salesChannelIds": ["sc_1"]}
    base.update(over)
    return base


def geo_zone(country_code, zone_type="country"):
    return {"type": zone_type, "countryCode": country_code}


def option(id_="so_1", rules=None):
    return {"id": id_, "rules": rules or []}


def loc(sales_channel_ids, service_zones):
    return {
        "id": "sloc_1",
        "salesChannelIds": sales_channel_ids,
        "fulfillmentSets": [{"serviceZones": service_zones}],
    }


def test_country_with_matching_geo_zone_and_options_is_covered():
    locations = [loc(["sc_1"], [{"geoZones": [geo_zone("us")], "shippingOptions": [option()]}])]
    gaps = find_uncovered_regions([region()], locations)
    assert gaps == []


def test_country_with_no_geo_zone_match_is_reported():
    locations = [loc(["sc_1"], [{"geoZones": [geo_zone("ca")], "shippingOptions": [option()]}])]
    gaps = find_uncovered_regions([region()], locations)
    assert gaps == [{"salesChannelId": "sc_1", "countryCode": "us", "reason": "no_geo_zone_match"}]


def test_matched_zone_with_no_shipping_options_is_reported():
    locations = [loc(["sc_1"], [{"geoZones": [geo_zone("us")], "shippingOptions": []}])]
    gaps = find_uncovered_regions([region()], locations)
    assert gaps == [{"salesChannelId": "sc_1", "countryCode": "us", "reason": "zone_matched_no_shipping_options"}]


def test_matched_zone_where_all_options_excluded_by_subtotal_rule_is_reported():
    excluded_option = option(rules=[{"attribute": "cart.subtotal", "operator": "gte", "value": 10000}])
    locations = [loc(["sc_1"], [{"geoZones": [geo_zone("us")], "shippingOptions": [excluded_option]}])]
    gaps = find_uncovered_regions([region()], locations)
    assert gaps == [{"salesChannelId": "sc_1", "countryCode": "us", "reason": "zone_matched_no_shipping_options"}]


def test_stock_location_not_linked_to_sales_channel_is_ignored():
    locations = [loc(["sc_other"], [{"geoZones": [geo_zone("us")], "shippingOptions": [option()]}])]
    gaps = find_uncovered_regions([region()], locations)
    assert gaps == [{"salesChannelId": "sc_1", "countryCode": "us", "reason": "no_geo_zone_match"}]


def test_multiple_countries_each_get_their_own_verdict():
    locations = [loc(["sc_1"], [{"geoZones": [geo_zone("us")], "shippingOptions": [option()]}])]
    gaps = find_uncovered_regions([region(countryCodes=["us", "ca"])], locations)
    assert gaps == [{"salesChannelId": "sc_1", "countryCode": "ca", "reason": "no_geo_zone_match"}]

import { test } from "node:test";
import assert from "node:assert/strict";
import { findUncoveredRegions } from "./find-uncovered-regions.js";

const region = (over = {}) => ({ id: "reg_1", countryCodes: ["us"], salesChannelIds: ["sc_1"], ...over });
const geoZone = (countryCode, type = "country") => ({ type, countryCode });
const option = (id = "so_1", rules = []) => ({ id, rules });
const loc = (salesChannelIds, serviceZones) => ({
  id: "sloc_1",
  salesChannelIds,
  fulfillmentSets: [{ serviceZones }],
});

test("country with matching geo zone and options is covered", () => {
  const locations = [loc(["sc_1"], [{ geoZones: [geoZone("us")], shippingOptions: [option()] }])];
  const gaps = findUncoveredRegions([region()], locations);
  assert.deepEqual(gaps, []);
});

test("country with no geo zone match is reported", () => {
  const locations = [loc(["sc_1"], [{ geoZones: [geoZone("ca")], shippingOptions: [option()] }])];
  const gaps = findUncoveredRegions([region()], locations);
  assert.deepEqual(gaps, [{ salesChannelId: "sc_1", countryCode: "us", reason: "no_geo_zone_match" }]);
});

test("matched zone with no shipping options is reported", () => {
  const locations = [loc(["sc_1"], [{ geoZones: [geoZone("us")], shippingOptions: [] }])];
  const gaps = findUncoveredRegions([region()], locations);
  assert.deepEqual(gaps, [{ salesChannelId: "sc_1", countryCode: "us", reason: "zone_matched_no_shipping_options" }]);
});

test("matched zone where all options are excluded by a subtotal rule is reported", () => {
  const excludedOption = option("so_1", [{ attribute: "cart.subtotal", operator: "gte", value: 10000 }]);
  const locations = [loc(["sc_1"], [{ geoZones: [geoZone("us")], shippingOptions: [excludedOption] }])];
  const gaps = findUncoveredRegions([region()], locations);
  assert.deepEqual(gaps, [{ salesChannelId: "sc_1", countryCode: "us", reason: "zone_matched_no_shipping_options" }]);
});

test("stock location not linked to the sales channel is ignored", () => {
  const locations = [loc(["sc_other"], [{ geoZones: [geoZone("us")], shippingOptions: [option()] }])];
  const gaps = findUncoveredRegions([region()], locations);
  assert.deepEqual(gaps, [{ salesChannelId: "sc_1", countryCode: "us", reason: "no_geo_zone_match" }]);
});

test("multiple countries each get their own verdict", () => {
  const locations = [loc(["sc_1"], [{ geoZones: [geoZone("us")], shippingOptions: [option()] }])];
  const gaps = findUncoveredRegions([region({ countryCodes: ["us", "ca"] })], locations);
  assert.deepEqual(gaps, [{ salesChannelId: "sc_1", countryCode: "ca", reason: "no_geo_zone_match" }]);
});