@reactionary/provider-medusa 0.1.13 → 0.2.2

package/test/product.provider.spec.js

@@ -1,8 +1,12 @@
 import "dotenv/config";
-import { NoOpCache, ProductSchema, createInitialRequestContext } from "@reactionary/core";
+import {
+  NoOpCache,
+  ProductSchema,
+  createInitialRequestContext
+} from "@reactionary/core";
 import { MedusaProductProvider } from "../providers/product.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
-import { describe, expect, it, beforeAll, beforeEach } from "vitest";
+import { describe, expect, it, beforeAll, beforeEach, assert } from "vitest";
 import { MedusaClient } from "../index.js";
 const testData = {
   product: {
@@ -21,57 +25,77 @@ describe("Medusa Product Provider", () => {
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
     const client = new MedusaClient(getMedusaTestConfiguration(), reqCtx);
-    provider = new MedusaProductProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
+    provider = new MedusaProductProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
   });
   it("should be able to get a product by id", async () => {
-    const slugResult = await provider.getBySlug({ slug: testData.product.slug });
-    expect(slugResult).toBeTruthy();
-    const result = await provider.getById({ identifier: slugResult.identifier });
-    expect(result).toBeTruthy();
-    expect(result.identifier.key).toBe(slugResult?.identifier.key);
-    expect(result.meta.placeholder).toBe(false);
-    expect(result.name).toBe(testData.product.name);
-    expect(result.mainVariant).toBeDefined();
-    expect(result.mainVariant.identifier.sku).toBe(testData.product.sku);
-    expect(result.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
-    expect(result.sharedAttributes.length).toBeGreaterThan(1);
-    expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
-    expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
+    const slugResult = await provider.getBySlug({
+      slug: testData.product.slug
+    });
+    if (!slugResult.success) {
+      assert.fail();
+    }
+    const result = await provider.getById({
+      identifier: slugResult.value.identifier
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.identifier.key).toBe(slugResult.value.identifier.key);
+    expect(result.value.name).toBe(testData.product.name);
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.mainVariant.identifier.sku).toBe(testData.product.sku);
+    expect(result.value.mainVariant.images[0].sourceUrl).toBe(
+      testData.product.image
+    );
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
   });
   it("should be able to get a product with multiple variants by slug", async () => {
-    const result = await provider.getBySlug({ slug: testData.productWithMultiVariants.slug });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.meta.placeholder).toBe(false);
-      expect(result.identifier.key).toBeTruthy();
-      expect(result.slug).toBe(testData.productWithMultiVariants.slug);
-      expect(result.mainVariant).toBeDefined();
-      expect(result.variants.length).toBeGreaterThan(0);
-      expect(result.variants[0].identifier.sku).toBeTruthy();
-      expect(result.variants[0].identifier.sku).not.toBe(result.mainVariant.identifier.sku);
-      expect(result.sharedAttributes.length).toBeGreaterThan(1);
-      expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
-      expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
+    const result = await provider.getBySlug({
+      slug: testData.productWithMultiVariants.slug
+    });
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.key).toBeTruthy();
+    expect(result.value.slug).toBe(testData.productWithMultiVariants.slug);
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.variants.length).toBeGreaterThan(0);
+    expect(result.value.variants[0].identifier.sku).toBeTruthy();
+    expect(result.value.variants[0].identifier.sku).not.toBe(
+      result.value.mainVariant.identifier.sku
+    );
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
   });
   it("should be able to get a product by sku", async () => {
-    const slugResult = await provider.getBySlug({ slug: testData.product.slug });
-    expect(slugResult).toBeTruthy();
+    const slugResult = await provider.getBySlug({
+      slug: testData.product.slug
+    });
+    if (!slugResult.success) {
+      assert.fail();
+    }
     const result = await provider.getBySKU({
       variant: { sku: testData.product.sku }
     });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.meta.placeholder).toBe(false);
-      expect(result.identifier.key).toBe(slugResult?.identifier.key);
-      expect(result.name).toBe(testData.product.name);
-      expect(result.mainVariant).toBeDefined();
-      expect(result.mainVariant.identifier.sku).toBe(testData.product.sku);
-      expect(result.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
-      expect(result.sharedAttributes.length).toBeGreaterThan(1);
-      expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
-      expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.identifier.key).toBe(slugResult.value.identifier.key);
+    expect(result.value.name).toBe(testData.product.name);
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.mainVariant.identifier.sku).toBe(testData.product.sku);
+    expect(result.value.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
   });
   it("should return null for unknown slug", async () => {
     const result = await provider.getBySlug({ slug: "unknown-slug" });
@@ -79,14 +103,19 @@ describe("Medusa Product Provider", () => {
   });
   it("should contain both product level and variant level attributes", async () => {
     const result = await provider.getBySlug({ slug: testData.product.slug });
-    expect(result).toBeTruthy();
-    expect(result.sharedAttributes.length).toBeGreaterThan(1);
-    expect(result.sharedAttributes[1].values.length).toBeGreaterThan(0);
-    expect(result.sharedAttributes[1].values[0].value).toBeTruthy();
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
   });
   it("should return a placeholder product for unknown id", async () => {
-    const result = await provider.getById({ identifier: { key: "unknown-id" } });
-    expect(result).toBeTruthy();
-    expect(result.meta.placeholder).toBe(true);
+    const result = await provider.getById({
+      identifier: { key: "unknown-id" }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
   });
 });

package/test/search.provider.spec.js

@@ -1,6 +1,6 @@
 import "dotenv/config";
 import { createInitialRequestContext, NoOpCache, ProductSearchQueryByTermSchema, ProductSearchResultItemSchema } from "@reactionary/core";
-import { describe, expect, it } from "vitest";
+import { assert, describe, expect, it } from "vitest";
 import { MedusaSearchProvider } from "../providers/product-search.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
 import { MedusaClient } from "../index.js";
@@ -33,8 +33,11 @@ describe("Medusa Search Provider", () => {
       facets: [],
       filters: []
     } }));
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.facets.length).toBe(0);
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.facets.length).toBe(0);
   });
   it("should be able to paginate", async () => {
     const firstPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
@@ -55,10 +58,13 @@ describe("Medusa Search Provider", () => {
       facets: [],
       filters: []
     } }));
-    expect(firstPage.pageNumber).toBe(1);
-    expect(secondPage.pageNumber).toBe(2);
-    expect(firstPage.items[0].identifier.key).not.toEqual(
-      secondPage.items[0].identifier.key
+    if (!firstPage.success || !secondPage.success) {
+      assert.fail();
+    }
+    expect(firstPage.value.pageNumber).toBe(1);
+    expect(secondPage.value.pageNumber).toBe(2);
+    expect(firstPage.value.items[0].identifier.key).not.toEqual(
+      secondPage.value.items[0].identifier.key
     );
   });
   it("should be able to apply a top level category filter", async () => {
@@ -68,7 +74,10 @@ describe("Medusa Search Provider", () => {
         pageSize: 2
       }
     });
-    let candidate = categories.items[0];
+    if (!categories.success) {
+      assert.fail();
+    }
+    let candidate = categories.value.items[0];
     while (candidate) {
       const children = await categoryProvider.findChildCategories({
         parentId: candidate.identifier,
@@ -77,8 +86,11 @@ describe("Medusa Search Provider", () => {
           pageSize: 10
         }
       });
-      if (children.items.length > 0) {
-        candidate = children.items[0];
+      if (!children.success) {
+        assert.fail();
+      }
+      if (children.value.items.length > 0) {
+        candidate = children.value.items[0];
       } else {
         break;
       }
@@ -94,18 +106,27 @@ describe("Medusa Search Provider", () => {
         filters: []
       }
     });
-    expect(unfilteredSearch.totalCount).toBeGreaterThan(0);
+    if (!unfilteredSearch.success) {
+      assert.fail();
+    }
+    expect(unfilteredSearch.value.totalCount).toBeGreaterThan(0);
     const breadCrumb = await categoryProvider.getBreadcrumbPathToCategory({
       id: candidate.identifier
     });
-    expect(breadCrumb.length).toBeGreaterThan(0);
+    if (!breadCrumb.success) {
+      assert.fail();
+    }
+    expect(breadCrumb.value.length).toBeGreaterThan(0);
     const categoryFilter = await provider.createCategoryNavigationFilter({
-      categoryPath: breadCrumb
+      categoryPath: breadCrumb.value
     });
+    if (!categoryFilter.success) {
+      assert.fail();
+    }
     const filteredSearch = await provider.queryByTerm({
       search: {
         term: "",
-        categoryFilter,
+        categoryFilter: categoryFilter.value,
         paginationOptions: {
           pageNumber: 1,
           pageSize: 1
@@ -114,8 +135,11 @@ describe("Medusa Search Provider", () => {
         filters: []
       }
     });
-    expect(filteredSearch.totalCount).toBeLessThan(unfilteredSearch.totalCount);
-    expect(filteredSearch.totalCount).toBeGreaterThan(0);
+    if (!filteredSearch.success) {
+      assert.fail();
+    }
+    expect(filteredSearch.value.totalCount).toBeLessThan(unfilteredSearch.value.totalCount);
+    expect(filteredSearch.value.totalCount).toBeGreaterThan(0);
   });
   it("should be able to change page size", async () => {
     const smallPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
@@ -136,9 +160,12 @@ describe("Medusa Search Provider", () => {
       facets: [],
       filters: []
     } }));
-    expect(smallPage.items.length).toBe(2);
-    expect(smallPage.pageSize).toBe(2);
-    expect(largePage.items.length).toBe(30);
-    expect(largePage.pageSize).toBe(30);
+    if (!smallPage.success || !largePage.success) {
+      assert.fail();
+    }
+    expect(smallPage.value.items.length).toBe(2);
+    expect(smallPage.value.pageSize).toBe(2);
+    expect(largePage.value.items.length).toBe(30);
+    expect(largePage.value.pageSize).toBe(30);
   });
 });