@reactionary/provider-medusa 0.1.13 → 0.2.2

package/test/checkout.spec.js

@@ -3,10 +3,11 @@ import {
   createInitialRequestContext,
   NoOpCache,
   PaymentInstructionSchema,
-  ShippingInstructionSchema
+  ShippingInstructionSchema,
+  unwrapValue
 } from "@reactionary/core";
 import "dotenv/config";
-import { beforeEach, describe, expect, it } from "vitest";
+import { assert, beforeEach, describe, expect, it } from "vitest";
 import { withMedusaCapabilities } from "../core/initialize.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
 const testData = {
@@ -39,15 +40,14 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
   describe("anonymous sessions", () => {
     let cart;
     beforeEach(async () => {
-      cart = await client.cart.add(
+      cart = unwrapValue(await client.cart.add(
         {
-          cart: { key: "" },
           variant: {
             sku: testData.skuWithoutTiers
           },
           quantity: 1
         }
-      );
+      ));
     });
     it("can create a checkout session from a cart", async () => {
       const checkout = await client.checkout.initiateCheckoutForCart(
@@ -67,16 +67,19 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
           notificationPhone: "+4512345678"
         }
       );
-      expect(checkout.identifier.key).toBeDefined();
-      expect(checkout.originalCartReference.key).toBe(cart.identifier.key);
-      expect(checkout.billingAddress?.firstName).toBe("John");
-      expect(checkout.items.length).toBe(1);
-      expect(checkout.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      if (!checkout.success) {
+        assert.fail();
+      }
+      expect(checkout.value.identifier.key).toBeDefined();
+      expect(checkout.value.originalCartReference.key).toBe(cart.identifier.key);
+      expect(checkout.value.billingAddress?.firstName).toBe("John");
+      expect(checkout.value.items.length).toBe(1);
+      expect(checkout.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
     });
     describe("checkout actions", () => {
       let checkout;
       beforeEach(async () => {
-        checkout = await client.checkout.initiateCheckoutForCart(
+        checkout = unwrapValue(await client.checkout.initiateCheckoutForCart(
           {
             cart,
             billingAddress: {
@@ -92,7 +95,7 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             notificationEmail: "sample@example.com",
             notificationPhone: "+4512345678"
           }
-        );
+        ));
       });
       it("can list payment methods", async () => {
         const paymentMethods = await client.checkout.getAvailablePaymentMethods(
@@ -100,9 +103,12 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             checkout: checkout.identifier
           }
         );
-        expect(paymentMethods.length).toBeGreaterThan(0);
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+        expect(paymentMethods.value.length).toBeGreaterThan(0);
         expect(
-          paymentMethods.find((x) => x.identifier.method === "pp_stripe_stripe")
+          paymentMethods.value.find((x) => x.identifier.method === "pp_stripe_stripe")
         ).toBeDefined();
       });
       it("can list shipping methods", async () => {
@@ -111,9 +117,12 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             checkout: checkout.identifier
           }
         );
-        expect(shippingMethods.length).toBeGreaterThan(0);
+        if (!shippingMethods.success) {
+          assert.fail();
+        }
+        expect(shippingMethods.value.length).toBeGreaterThan(0);
         expect(
-          shippingMethods.find((x) => x.name === "Standard Shipping")
+          shippingMethods.value.find((x) => x.name === "Standard Shipping")
         ).toBeDefined();
       });
       it("can add a payment instruction", async () => {
@@ -122,7 +131,10 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             checkout: checkout.identifier
           }
         );
-        const pm = paymentMethods.find((x) => x.identifier.method === "pp_stripe_stripe");
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+        const pm = paymentMethods.value.find((x) => x.identifier.method === "pp_stripe_stripe");
         expect(pm).toBeDefined();
         const checkoutWithPi = await client.checkout.addPaymentInstruction(
           {
@@ -134,11 +146,14 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             }
           }
         );
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
-        expect(checkoutWithPi.paymentInstructions[0].paymentMethod.method).toBe(
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
+        expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
+        expect(checkoutWithPi.value.paymentInstructions[0].paymentMethod.method).toBe(
           "pp_stripe_stripe"
         );
-        expect(checkoutWithPi.paymentInstructions[0].protocolData.find((x) => x.key === "client_secret")?.value).toBeDefined();
+        expect(checkoutWithPi.value.paymentInstructions[0].protocolData.find((x) => x.key === "client_secret")?.value).toBeDefined();
       });
       it.skip("can cancel an in-progress payment", async () => {
         const paymentMethods = await client.checkout.getAvailablePaymentMethods(
@@ -146,7 +161,10 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             checkout: checkout.identifier
           }
         );
-        const pm = paymentMethods.find((x) => x.identifier.method === "pp_stripe_stripe");
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+        const pm = paymentMethods.value.find((x) => x.identifier.method === "pp_stripe_stripe");
         expect(pm).toBeDefined();
         const checkoutWithPi = await client.checkout.addPaymentInstruction(
           {
@@ -158,14 +176,20 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             }
           }
         );
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
+        expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
         const checkoutAfterCancel = await client.checkout.removePaymentInstruction(
           {
             checkout: checkout.identifier,
-            paymentInstruction: checkoutWithPi.paymentInstructions[0].identifier
+            paymentInstruction: checkoutWithPi.value.paymentInstructions[0].identifier
           }
         );
-        expect(checkoutAfterCancel.paymentInstructions.length).toBe(0);
+        if (!checkoutAfterCancel.success) {
+          assert.fail();
+        }
+        expect(checkoutAfterCancel.value.paymentInstructions.length).toBe(0);
       });
       it("can set shipping address", async () => {
         const checkoutWithShipping = await client.checkout.setShippingAddress(
@@ -183,8 +207,11 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             }
           }
         );
-        expect(checkoutWithShipping.shippingAddress).toBeDefined();
-        expect(checkoutWithShipping.shippingAddress?.firstName).toBe("Jane");
+        if (!checkoutWithShipping.success) {
+          assert.fail();
+        }
+        expect(checkoutWithShipping.value.shippingAddress).toBeDefined();
+        expect(checkoutWithShipping.value.shippingAddress?.firstName).toBe("Jane");
       });
       it("can set shipping instructions", async () => {
         const shippingMethods = await client.checkout.getAvailableShippingMethods(
@@ -192,20 +219,16 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             checkout: checkout.identifier
           }
         );
-        const sm = shippingMethods.find((x) => x.name === "Standard Shipping");
+        if (!shippingMethods.success) {
+          assert.fail();
+        }
+        const sm = shippingMethods.value.find((x) => x.name === "Standard Shipping");
         expect(sm).toBeDefined();
         const shippingInstruction = {
           shippingMethod: sm?.identifier || { key: "" },
           instructions: "Leave at front door if not home",
           consentForUnattendedDelivery: true,
-          pickupPoint: "4190asx141",
-          meta: {
-            cache: {
-              hit: false,
-              key: ""
-            },
-            placeholder: false
-          }
+          pickupPoint: "4190asx141"
         };
         const checkoutWithShipping = await client.checkout.setShippingInstruction(
           {
@@ -213,29 +236,34 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             shippingInstruction
           }
         );
+        if (!checkoutWithShipping.success) {
+          assert.fail();
+        }
         expect(checkout.price.totalShipping.value).toBe(0);
-        expect(checkoutWithShipping.price.totalShipping.value).toBeGreaterThan(0);
-        expect(checkoutWithShipping.shippingInstruction).toBeDefined();
+        expect(checkoutWithShipping.value.price.totalShipping.value).toBeGreaterThan(0);
+        expect(checkoutWithShipping.value.shippingInstruction).toBeDefined();
         expect(
-          checkoutWithShipping.shippingInstruction?.shippingMethod.key
+          checkoutWithShipping.value.shippingInstruction?.shippingMethod.key
         ).toBe(sm?.identifier.key);
-        expect(checkoutWithShipping.shippingInstruction?.instructions).toBe(
+        expect(checkoutWithShipping.value.shippingInstruction?.instructions).toBe(
           "Leave at front door if not home"
         );
-        expect(checkoutWithShipping.shippingInstruction?.pickupPoint).toBe(
+        expect(checkoutWithShipping.value.shippingInstruction?.pickupPoint).toBe(
           "4190asx141"
         );
         expect(
-          checkoutWithShipping.shippingInstruction?.consentForUnattendedDelivery
+          checkoutWithShipping.value.shippingInstruction?.consentForUnattendedDelivery
         ).toBe(true);
       });
       it.skip("wont report it finalizable until everything is paid/authorized", async () => {
         expect(checkout.readyForFinalization).toBe(false);
-        const pm = (await client.checkout.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier
-          }
-        )).find((x) => x.identifier.method === "stripe");
+        const pm = unwrapValue(
+          await client.checkout.getAvailablePaymentMethods(
+            {
+              checkout: checkout.identifier
+            }
+          )
+        ).find((x) => x.identifier.method === "stripe");
         expect(pm).toBeDefined();
         const checkoutWithPi = await client.checkout.addPaymentInstruction(
           {
@@ -247,13 +275,16 @@ describe.each(["Medusa"])("Checkout Capability - %s", (provider) => {
             }
           }
         );
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
         const checkoutReady = await client.checkout.getById(
-          { identifier: checkoutWithPi.identifier }
+          { identifier: checkoutWithPi.value.identifier }
         );
-        if (!checkoutReady) {
+        if (!checkoutReady.success || !checkoutReady) {
           expect.fail("checkout not found");
         }
-        expect(checkoutReady.readyForFinalization).toBe(true);
+        expect(checkoutReady.value.readyForFinalization).toBe(true);
       });
     });
   });

package/test/identity.provider.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect, beforeEach, assert } from "vitest";
 import { MedusaIdentityProvider } from "../providers/identity.provider.js";
 import { IdentitySchema, NoOpCache, createInitialRequestContext } from "@reactionary/core";
 import { getMedusaTestConfiguration } from "./test-utils.js";
@@ -20,8 +20,11 @@ describe("Medusa Identity Provider", () => {
   });
   it("should return anonymous identity when not authenticated", async () => {
     const result = await provider.getSelf({});
-    expect(result).toBeTruthy();
-    expect(result.type).toBe("Anonymous");
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value).toBeTruthy();
+    expect(result.value.type).toBe("Anonymous");
   });
   it("should be able to register a new user", async () => {
     const testEmail = `test-user+${(/* @__PURE__ */ new Date()).getTime()}@example.com`;
@@ -29,8 +32,11 @@ describe("Medusa Identity Provider", () => {
       username: testEmail,
       password: testData.testPassword
     });
+    if (!result.success) {
+      assert.fail();
+    }
     expect(result).toBeTruthy();
-    expect(["Registered", "Anonymous"]).toContain(result.type);
+    expect(["Registered", "Anonymous"]).toContain(result.value.type);
   });
   it("should be able to login with valid credentials", async () => {
     try {
@@ -45,8 +51,11 @@ describe("Medusa Identity Provider", () => {
       username: testData.testEmail,
       password: testData.testPassword
     });
+    if (!result.success) {
+      assert.fail();
+    }
     expect(result).toBeTruthy();
-    expect(["Registered", "Anonymous"]).toContain(result.type);
+    expect(["Registered", "Anonymous"]).toContain(result.value.type);
   });
   it("should be able to logout", async () => {
     await provider.login({
@@ -54,8 +63,11 @@ describe("Medusa Identity Provider", () => {
       password: testData.testPassword
     });
     const result = await provider.logout({});
+    if (!result.success) {
+      assert.fail();
+    }
     expect(result).toBeTruthy();
-    expect(result.type).toBe("Anonymous");
+    expect(result.value.type).toBe("Anonymous");
   });
   it("should return registered identity when authenticated", async () => {
     await provider.login({
@@ -63,8 +75,11 @@ describe("Medusa Identity Provider", () => {
       password: testData.testPassword
     });
     const result = await provider.getSelf({});
+    if (!result.success) {
+      assert.fail();
+    }
     expect(result).toBeTruthy();
-    expect(["Registered", "Anonymous"]).toContain(result.type);
+    expect(["Registered", "Anonymous"]).toContain(result.value.type);
   });
   it("should handle login errors gracefully", async () => {
     await expect(async () => {

package/test/inventory.provider.spec.js

@@ -1,6 +1,10 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect, beforeEach, assert } from "vitest";
 import { MedusaInventoryProvider } from "../providers/inventory.provider.js";
-import { InventorySchema, NoOpCache, createInitialRequestContext } from "@reactionary/core";
+import {
+  InventorySchema,
+  NoOpCache,
+  createInitialRequestContext
+} from "@reactionary/core";
 import { getMedusaTestConfiguration } from "./test-utils.js";
 import { MedusaClient } from "../core/client.js";
 const testData = {
@@ -15,22 +19,28 @@ describe("Medusa Inventory Provider", () => {
     reqCtx = createInitialRequestContext();
     const config = getMedusaTestConfiguration();
     const client = new MedusaClient(config, reqCtx);
-    provider = new MedusaInventoryProvider(config, new NoOpCache(), reqCtx, client);
+    provider = new MedusaInventoryProvider(
+      config,
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
   });
   it("should be able to get inventory for a SKU with stock", async () => {
     const result = await provider.getBySKU({
       variant: { sku: testData.skuInStock },
       fulfilmentCenter: { key: testData.fulfillmentCenter }
     });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe(testData.skuInStock);
-      expect(result.identifier.fulfillmentCenter.key).toBe(testData.fulfillmentCenter);
-      expect(result.quantity).toBeGreaterThanOrEqual(0);
-      if (result.quantity > 0) {
-        expect(result.status).toBe("inStock");
-      }
-      expect(result.meta?.placeholder).toBeDefined();
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.identifier.variant.sku).toBe(testData.skuInStock);
+    expect(result.value.identifier.fulfillmentCenter.key).toBe(
+      testData.fulfillmentCenter
+    );
+    expect(result.value.quantity).toBeGreaterThanOrEqual(0);
+    if (result.value.quantity > 0) {
+      expect(result.value.status).toBe("inStock");
     }
   });
   it("should return out of stock for a SKU without inventory", async () => {
@@ -38,25 +48,26 @@ describe("Medusa Inventory Provider", () => {
       variant: { sku: testData.skuOutOfStock },
       fulfilmentCenter: { key: testData.fulfillmentCenter }
     });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe(testData.skuOutOfStock);
-      expect(result.identifier.fulfillmentCenter.key).toBe(testData.fulfillmentCenter);
-      expect(result.quantity).toBe(0);
-      expect(result.status).toBe("outOfStock");
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.variant.sku).toBe(testData.skuOutOfStock);
+    expect(result.value.identifier.fulfillmentCenter.key).toBe(
+      testData.fulfillmentCenter
+    );
+    expect(result.value.quantity).toBe(0);
+    expect(result.value.status).toBe("outOfStock");
   });
   it("should return placeholder inventory for an unknown SKU", async () => {
     const result = await provider.getBySKU({
       variant: { sku: "unknown-sku" },
       fulfilmentCenter: { key: testData.fulfillmentCenter }
     });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe("unknown-sku");
-      expect(result.quantity).toBe(0);
-      expect(result.status).toBe("outOfStock");
-      expect(result.meta?.placeholder).toBe(true);
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.variant.sku).toBe("unknown-sku");
+    expect(result.value.quantity).toBe(0);
+    expect(result.value.status).toBe("outOfStock");
   });
 });

package/test/large-cart.provider.spec.js

@@ -1,5 +1,11 @@
-import { CartSchema, NoOpCache, ProductSearchQueryByTermSchema, ProductSearchResultItemSchema, createInitialRequestContext } from "@reactionary/core";
-import { beforeAll, beforeEach, describe, expect, it } from "vitest";
+import {
+  CartSchema,
+  NoOpCache,
+  ProductSearchQueryByTermSchema,
+  ProductSearchResultItemSchema,
+  createInitialRequestContext
+} from "@reactionary/core";
+import { assert, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { MedusaCartProvider } from "../providers/cart.provider.js";
 import { MedusaSearchProvider } from "../providers/product-search.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
@@ -11,46 +17,66 @@ describe("Medusa Cart Provider - Large Scenarios", () => {
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaClient(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaCartProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
-    searchProvider = new MedusaSearchProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
+    provider = new MedusaCartProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
+    searchProvider = new MedusaSearchProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
   });
   describe("large carts", () => {
     it("should be able to add an 50 items to a cart in less than 30 seconds", async () => {
-      let cart = await provider.getById({
-        cart: { key: "" }
-      });
-      const searchResult = await searchProvider.queryByTerm(ProductSearchQueryByTermSchema.parse({
-        search: {
-          term: "phil",
-          paginationOptions: {
-            pageNumber: 1,
-            pageSize: 50
-          },
-          filters: [],
-          facets: []
-        }
-      }));
-      expect(searchResult.items.length).toBeGreaterThanOrEqual(50);
-      for (const product of searchResult.items) {
+      const searchResult = await searchProvider.queryByTerm(
+        ProductSearchQueryByTermSchema.parse({
+          search: {
+            term: "phil",
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 50
+            },
+            filters: [],
+            facets: []
+          }
+        })
+      );
+      if (!searchResult.success) {
+        assert.fail();
+      }
+      expect(searchResult.value.items.length).toBeGreaterThanOrEqual(50);
+      let cartIdentifier = void 0;
+      let cart;
+      for (const product of searchResult.value.items) {
         cart = await provider.add({
-          cart: cart.identifier,
+          cart: cartIdentifier,
           variant: {
             sku: product.variants[0].variant.sku
           },
           quantity: 1
         });
+        if (!cart.success) {
+          assert.fail();
+        }
+        cartIdentifier = cart.value.identifier;
       }
-      if (cart) {
-        expect(cart.identifier.key).toBeDefined();
-        expect(cart.items.length).toBe(50);
-        expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-        expect(cart.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-        expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-        expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
-        expect(cart.meta?.placeholder).toBeFalsy();
-      } else {
-        throw new Error("Cart is undefined");
+      if (!cart) {
+        assert.fail();
       }
+      expect(cart.value.identifier.key).toBeDefined();
+      expect(cart.value.items.length).toBe(50);
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      expect(cart.value.items[0].price.totalPrice.currency).toBe(
+        reqCtx.languageContext.currencyCode
+      );
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.value.price.grandTotal.currency).toBe(
+        reqCtx.languageContext.currencyCode
+      );
     }, 3e4);
   });
 });

package/test/price.provider.spec.js

@@ -1,6 +1,10 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, vi, assert } from "vitest";
 import { MedusaPriceProvider } from "../providers/price.provider.js";
-import { PriceSchema, NoOpCache, createInitialRequestContext } from "@reactionary/core";
+import {
+  PriceSchema,
+  NoOpCache,
+  createInitialRequestContext
+} from "@reactionary/core";
 import { getMedusaTestConfiguration } from "./test-utils.js";
 import { MedusaClient } from "../core/client.js";
 const testData = {
@@ -17,47 +21,64 @@ describe("Medusa Price Provider", () => {
     provider = new MedusaPriceProvider(config, new NoOpCache(), reqCtx, client);
   });
   it("should be able to get prices for a product without tiers", async () => {
-    const result = await provider.getCustomerPrice({ variant: { sku: testData.skuWithoutTiers } });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe(testData.skuWithoutTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-      expect(result.tieredPrices.length).toBe(0);
+    const result = await provider.getCustomerPrice({
+      variant: { sku: testData.skuWithoutTiers }
+    });
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+    expect(result.value.unitPrice.value).toBeGreaterThan(0);
+    expect(result.value.unitPrice.currency).toBe(
+      reqCtx.languageContext.currencyCode
+    );
+    expect(result.value.tieredPrices.length).toBe(0);
   });
   it.skip("should be able to get prices for a product with tiers", async () => {
-    const result = await provider.getCustomerPrice({ variant: { sku: testData.skuWithTiers } });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe(testData.skuWithTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-      expect(result.tieredPrices.length).toBeGreaterThan(0);
-      expect(result.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
-      expect(result.tieredPrices[0].price.value).toBeLessThanOrEqual(result.unitPrice.value);
-      expect(result.tieredPrices[0].price.currency).toBe(reqCtx.languageContext.currencyCode);
+    const result = await provider.getCustomerPrice({
+      variant: { sku: testData.skuWithTiers }
+    });
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.variant.sku).toBe(testData.skuWithTiers);
+    expect(result.value.unitPrice.value).toBeGreaterThan(0);
+    expect(result.value.unitPrice.currency).toBe(reqCtx.languageContext.currencyCode);
+    expect(result.value.tieredPrices.length).toBeGreaterThan(0);
+    expect(result.value.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
+    expect(result.value.tieredPrices[0].price.value).toBeLessThanOrEqual(
+      result.value.unitPrice.value
+    );
+    expect(result.value.tieredPrices[0].price.currency).toBe(
+      reqCtx.languageContext.currencyCode
+    );
   });
-  it("should return a placeholder price for an unknown SKU", async () => {
-    const result = await provider.getCustomerPrice({ variant: { sku: "unknown-sku" } });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.variant.sku).toBe("unknown-sku");
-      expect(result.unitPrice.value).toBe(-1);
-      expect(result.unitPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-      expect(result.tieredPrices.length).toBe(0);
-      expect(result.meta?.placeholder).toBe(true);
+  it("should return NotFound for an unknown SKU", async () => {
+    const result = await provider.getCustomerPrice({
+      variant: { sku: "unknown-sku" }
+    });
+    if (result.success) {
+      assert.fail();
     }
   });
   it("can look up multiple prices at once", async () => {
-    const skus = [testData.skuWithTiers, testData.skuWithoutTiers, "unknown-sku"];
-    const results = await Promise.all(skus.map((sku) => provider.getCustomerPrice({ variant: { sku } })));
-    expect(results).toHaveLength(skus.length);
-    expect(results[0].identifier.variant.sku).toBe(testData.skuWithTiers);
-    expect(results[0].unitPrice.value).toBeGreaterThan(0);
-    expect(results[1].identifier.variant.sku).toBe(testData.skuWithoutTiers);
-    expect(results[1].unitPrice.value).toBeGreaterThan(0);
-    expect(results[2].identifier.variant.sku).toBe("unknown-sku");
+    const skus = [
+      testData.skuWithTiers,
+      testData.skuWithoutTiers,
+      "unknown-sku"
+    ];
+    const results = await Promise.all(
+      skus.map((sku) => provider.getCustomerPrice({ variant: { sku } }))
+    );
+    const success = results.filter((x) => x.success);
+    if (results.length !== success.length) {
+      assert.fail();
+    }
+    expect(success).toHaveLength(skus.length);
+    expect(success[0].value.identifier.variant.sku).toBe(testData.skuWithTiers);
+    expect(success[0].value.unitPrice.value).toBeGreaterThan(0);
+    expect(success[1].value.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+    expect(success[1].value.unitPrice.value).toBeGreaterThan(0);
+    expect(success[2].value.identifier.variant.sku).toBe("unknown-sku");
   });
 });