@reactionary/examples-node 0.3.11 → 0.3.13

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@reactionary/examples-node",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.11",
-    "@reactionary/provider-commercetools": "0.3.11",
-    "@reactionary/provider-algolia": "0.3.11",
-    "@reactionary/provider-medusa": "0.3.11",
-    "@reactionary/provider-meilisearch": "0.3.11"
+    "@reactionary/core": "0.3.13",
+    "@reactionary/provider-commercetools": "0.3.13",
+    "@reactionary/provider-algolia": "0.3.13",
+    "@reactionary/provider-medusa": "0.3.13",
+    "@reactionary/provider-meilisearch": "0.3.13",
+    "@reactionary/provider-fake": "0.3.13"
   },
   "type": "module"
 }

package/src/capabilities/product-review.spec.ts

@@ -0,0 +1,177 @@
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+import type { ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+
+const testData = {
+  product: {
+    id: 'product_878198',
+  },
+};
+
+describe.each([PrimaryProvider.FAKE, PrimaryProvider.COMMERCETOOLS])('Product Reviews', (provider) => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    client = createClient(provider);
+  });
+
+  it('can get a rating summary for a product that has it', async () => {
+    const result = await client.productReviews.getRatingSummary({
+      product: { key: testData.product.id },
+    });
+
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+
+    expect(result.value.averageRating).toBeGreaterThan(0);
+    expect(result.value.totalRatings).toBeGreaterThan(0);
+  });
+
+  it('should return an empty result for an unknown product', async () => {
+    const result = await client.productReviews.getRatingSummary({
+      product: { key: 'unknown-product-id' },
+    });
+
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+
+    expect(result.value.averageRating).toBe(0);
+    expect(result.value.totalRatings).toBeUndefined();
+  });
+
+  it('can return a list of reviews for a product', async () => {
+    const result = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
+    });
+
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+
+    expect(result.value.items.length).toBeLessThanOrEqual(2);
+    if (result.value.items.length > 0) {
+      expect(result.value.items[0].identifier.key).toBeDefined();
+      expect(result.value.items[0].authorName).toBeDefined();
+      expect(result.value.items[0].rating).toBeGreaterThan(0);
+      expect(result.value.items[0].content).toBeDefined();
+    }
+  });
+
+  it('should return an empty list of reviews for an unknown product', async () => {
+    const result = await client.productReviews.findReviews({
+      product: { key: 'unknown-product-id' },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
+    });
+
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+    expect(result.value.items.length).toBe(0);
+  });
+
+  it('can paginate the list of reviews for a product', async () => {
+    const firstPageResult = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 1,
+      },
+    });
+
+    if (!firstPageResult.success) {
+      assert.fail(JSON.stringify(firstPageResult.error));
+    }
+
+    expect(firstPageResult.value.items.length).toBe(1);
+    const firstReview = firstPageResult.value.items[0];
+    expect(firstReview.identifier.key).toBeDefined();
+
+    const secondPageResult = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 2,
+        pageSize: 1,
+      },
+    });
+
+    if (!secondPageResult.success) {
+      assert.fail(JSON.stringify(secondPageResult.error));
+    }
+  });
+
+  describe('Submitting Reviews', () => {
+    it('cannot submit review if not authenticated', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 4,
+        title: 'Great product!',
+        content: 'I really enjoyed using this product. Highly recommend it.',
+        authorName: 'John Doe',
+      });
+
+      if (result.success) {
+        assert.fail('Expected it to return an error for unauthenticated user');
+      } else {
+        expect(result.error.type).toBe('InvalidInput');
+      }
+    });
+
+    it('can submit a review for a product', async () => {
+      if (provider === PrimaryProvider.FAKE) {
+        return;
+      }
+      const newIdentity = await client.identity.register({
+        username: `testuser_${Date.now()}@example.com`,
+        password: 'password123',
+      });
+
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 4,
+        title: 'Great product!',
+        content: 'I really enjoyed using this product. Highly recommend it.',
+        authorName: 'John Doe',
+      });
+
+      if (!result.success) {
+        assert.fail(JSON.stringify(result.error));
+      }
+    });
+
+    it('can submit a rating without review', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 5,
+        title: '',
+        content: '',
+        authorName: 'Jane Doe',
+      });
+    });
+
+    it('should return an error when submitting a review with invalid rating', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 6, // Invalid rating, should be between 1 and 5
+        title: 'Invalid rating',
+        content: 'This review has an invalid rating.',
+        authorName: 'Invalid User',
+      });
+
+      if (result.success) {
+        assert.fail('Expected it to return an error for invalid rating');
+      } else {
+        expect(result.error.type).toBe('InvalidInput');
+      }
+    });
+  });
+});

package/src/utils.ts

@@ -8,6 +8,8 @@ import { withCommercetoolsCapabilities } from '@reactionary/provider-commercetoo
 import { withAlgoliaCapabilities } from '@reactionary/provider-algolia';
 import { withMedusaCapabilities } from '@reactionary/provider-medusa';
 import { withMeilisearchCapabilities } from '@reactionary/provider-meilisearch';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+import type { FakeConfiguration } from '@reactionary/provider-fake';
 
 export function getAlgoliaTestConfiguration() {
   return {
@@ -39,6 +41,20 @@ export function getMedusaTestConfiguration() {
 }
 
 
+export function getFakeConfiguration(): FakeConfiguration {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0,
+    },
+    seeds: {
+      product: 1,
+      search: 1,
+      category: 1,
+    },
+  } satisfies FakeConfiguration;
+}
+
 export function getCommercetoolsTestConfiguration() {
   return {
     apiUrl: process.env['CTP_API_URL'] || '',
@@ -71,7 +87,8 @@ export enum PrimaryProvider {
   ALGOLIA = 'Algolia',
   COMMERCETOOLS = 'Commercetools',
   MEDUSA = 'Medusa',
-  MEILISEARCH = 'Meilisearch'
+  MEILISEARCH = 'Meilisearch',
+  FAKE = 'Fake',
 }
 
 export function createClient(provider: PrimaryProvider) {
@@ -99,7 +116,13 @@ export function createClient(provider: PrimaryProvider) {
       );
     }
 
-
+    if (provider === PrimaryProvider.FAKE) {
+      builder = builder.withCapability(
+        withFakeCapabilities( getFakeConfiguration() , {
+          productReviews: true
+        }
+      ))
+    }
 
     if (provider === PrimaryProvider.COMMERCETOOLS) {
       builder = builder.withCapability(
@@ -113,6 +136,7 @@ export function createClient(provider: PrimaryProvider) {
           order: true,
           price: true,
           productSearch: true,
+          productReviews: true,
           orderSearch: true,
           store: true,
           profile: true,