pretty

1 files changed, 175 insertions, 123 deletions

diff --git a/packages/merchant-backoffice-ui/src/hooks/order.test.ts b/packages/merchant-backoffice-ui/src/hooks/order.test.ts
index be4d1d804..2f4615729 100644
--- a/packages/merchant-backoffice-ui/src/hooks/order.test.ts
+++ b/packages/merchant-backoffice-ui/src/hooks/order.test.ts
@@ -29,11 +29,11 @@ import {
   API_DELETE_ORDER,
   API_FORGET_ORDER_BY_ID,
   API_GET_ORDER_BY_ID,
-  API_LIST_ORDERS, API_REFUND_ORDER_BY_ID
+  API_LIST_ORDERS,
+  API_REFUND_ORDER_BY_ID,
 } from "./urls.js";
 
 describe("order api interaction with listing", () => {
-
   it("should evict cache when creating an order", async () => {
     const env = new ApiMockEnvironment();
 
@@ -51,7 +51,6 @@ describe("order api interaction with listing", () => {
       },
     });
 
-
     const newDate = (d: Date) => {
       //console.log("new date", d);
     };
@@ -68,9 +67,11 @@ describe("order api interaction with listing", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [{ order_id: "1" }, { order_id: "2" }],
@@ -102,19 +103,22 @@ describe("order api interaction with listing", () => {
           } as any);
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
 
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [{ order_id: "1" }, { order_id: "2" }, { order_id: "3" }],
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
   });
 
   it("should evict cache when doing a refund", async () => {
@@ -123,16 +127,21 @@ describe("order api interaction with listing", () => {
     env.addRequestExpectation(API_LIST_ORDERS, {
       qparam: { delta: 0, paid: "yes" },
       response: {
-        orders: [{ order_id: "1", amount: 'EUR:12', refundable: true } as MerchantBackend.Orders.OrderHistoryEntry],
+        orders: [
+          {
+            order_id: "1",
+            amount: "EUR:12",
+            refundable: true,
+          } as MerchantBackend.Orders.OrderHistoryEntry,
+        ],
       },
     });
 
     env.addRequestExpectation(API_LIST_ORDERS, {
       qparam: { delta: -20, paid: "yes" },
-      response: { orders: [], },
+      response: { orders: [] },
     });
 
-
     const newDate = (d: Date) => {
       //console.log("new date", d);
     };
@@ -149,61 +158,72 @@ describe("order api interaction with listing", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
 
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            orders: [{
-              order_id: "1",
-              amount: 'EUR:12',
-              refundable: true,
-            }],
+            orders: [
+              {
+                order_id: "1",
+                amount: "EUR:12",
+                refundable: true,
+              },
+            ],
           });
-          env.addRequestExpectation(API_REFUND_ORDER_BY_ID('1'), {
+          env.addRequestExpectation(API_REFUND_ORDER_BY_ID("1"), {
             request: {
-              reason: 'double pay',
-              refund: 'EUR:1'
+              reason: "double pay",
+              refund: "EUR:1",
             },
           });
 
           env.addRequestExpectation(API_LIST_ORDERS, {
             qparam: { delta: 0, paid: "yes" },
             response: {
-              orders: [{ order_id: "1", amount: 'EUR:12', refundable: false } as any],
+              orders: [
+                { order_id: "1", amount: "EUR:12", refundable: false } as any,
+              ],
             },
           });
 
           env.addRequestExpectation(API_LIST_ORDERS, {
             qparam: { delta: -20, paid: "yes" },
-            response: { orders: [], },
+            response: { orders: [] },
           });
 
-          api.refundOrder('1', {
-            reason: 'double pay',
-            refund: 'EUR:1'
+          api.refundOrder("1", {
+            reason: "double pay",
+            refund: "EUR:1",
           });
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
 
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            orders: [{
-              order_id: "1",
-              amount: 'EUR:12',
-              refundable: false,
-            }],
+            orders: [
+              {
+                order_id: "1",
+                amount: "EUR:12",
+                refundable: false,
+              },
+            ],
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
 
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
   });
 
   it("should evict cache when deleting an order", async () => {
@@ -223,7 +243,6 @@ describe("order api interaction with listing", () => {
       },
     });
 
-
     const newDate = (d: Date) => {
       //console.log("new date", d);
     };
@@ -240,15 +259,17 @@ describe("order api interaction with listing", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [{ order_id: "1" }, { order_id: "2" }],
           });
 
-          env.addRequestExpectation(API_DELETE_ORDER('1'), {});
+          env.addRequestExpectation(API_DELETE_ORDER("1"), {});
 
           env.addRequestExpectation(API_LIST_ORDERS, {
             qparam: { delta: 0, paid: "yes" },
@@ -264,35 +285,36 @@ describe("order api interaction with listing", () => {
             },
           });
 
-          api.deleteOrder('1');
+          api.deleteOrder("1");
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [{ order_id: "2" }],
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
   });
-
 });
 
 describe("order api interaction with details", () => {
-
   it("should evict cache when doing a refund", async () => {
     const env = new ApiMockEnvironment();
 
-    env.addRequestExpectation(API_GET_ORDER_BY_ID('1'), {
+    env.addRequestExpectation(API_GET_ORDER_BY_ID("1"), {
       // qparam: { delta: 0, paid: "yes" },
       response: {
-        summary: 'description',
-        refund_amount: 'EUR:0',
+        summary: "description",
+        refund_amount: "EUR:0",
       } as unknown as MerchantBackend.Orders.CheckPaymentPaidResponse,
     });
 
@@ -302,7 +324,7 @@ describe("order api interaction with details", () => {
 
     const hookBehavior = await tests.hookBehaveLikeThis(
       () => {
-        const query = useOrderDetails('1')
+        const query = useOrderDetails("1");
         const api = useOrderAPI();
         return { query, api };
       },
@@ -312,58 +334,63 @@ describe("order api interaction with details", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).false;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            summary: 'description',
-            refund_amount: 'EUR:0',
+            summary: "description",
+            refund_amount: "EUR:0",
           });
-          env.addRequestExpectation(API_REFUND_ORDER_BY_ID('1'), {
+          env.addRequestExpectation(API_REFUND_ORDER_BY_ID("1"), {
             request: {
-              reason: 'double pay',
-              refund: 'EUR:1'
+              reason: "double pay",
+              refund: "EUR:1",
             },
           });
 
-          env.addRequestExpectation(API_GET_ORDER_BY_ID('1'), {
+          env.addRequestExpectation(API_GET_ORDER_BY_ID("1"), {
             response: {
-              summary: 'description',
-              refund_amount: 'EUR:1',
+              summary: "description",
+              refund_amount: "EUR:1",
             } as unknown as MerchantBackend.Orders.CheckPaymentPaidResponse,
           });
 
-          api.refundOrder('1', {
-            reason: 'double pay',
-            refund: 'EUR:1'
-          })
+          api.refundOrder("1", {
+            reason: "double pay",
+            refund: "EUR:1",
+          });
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).false;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            summary: 'description',
-            refund_amount: 'EUR:1',
+            summary: "description",
+            refund_amount: "EUR:1",
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
 
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
-  })
+  });
 
   it("should evict cache when doing a forget", async () => {
     const env = new ApiMockEnvironment();
 
-    env.addRequestExpectation(API_GET_ORDER_BY_ID('1'), {
+    env.addRequestExpectation(API_GET_ORDER_BY_ID("1"), {
       // qparam: { delta: 0, paid: "yes" },
       response: {
-        summary: 'description',
-        refund_amount: 'EUR:0',
+        summary: "description",
+        refund_amount: "EUR:0",
       } as unknown as MerchantBackend.Orders.CheckPaymentPaidResponse,
     });
 
@@ -373,7 +400,7 @@ describe("order api interaction with details", () => {
 
     const hookBehavior = await tests.hookBehaveLikeThis(
       () => {
-        const query = useOrderDetails('1')
+        const query = useOrderDetails("1");
         const api = useOrderAPI();
         return { query, api };
       },
@@ -383,48 +410,52 @@ describe("order api interaction with details", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).false;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            summary: 'description',
-            refund_amount: 'EUR:0',
+            summary: "description",
+            refund_amount: "EUR:0",
           });
-          env.addRequestExpectation(API_FORGET_ORDER_BY_ID('1'), {
+          env.addRequestExpectation(API_FORGET_ORDER_BY_ID("1"), {
             request: {
-              fields: ['$.summary']
+              fields: ["$.summary"],
             },
           });
 
-          env.addRequestExpectation(API_GET_ORDER_BY_ID('1'), {
+          env.addRequestExpectation(API_GET_ORDER_BY_ID("1"), {
             response: {
               summary: undefined,
             } as unknown as MerchantBackend.Orders.CheckPaymentPaidResponse,
           });
 
-          api.forgetOrder('1', {
-            fields: ['$.summary']
-          })
+          api.forgetOrder("1", {
+            fields: ["$.summary"],
+          });
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).false;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             summary: undefined,
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
-  })
-})
+  });
+});
 
 describe("order listing pagination", () => {
-
   it("should not load more if has reach the end", async () => {
     const env = new ApiMockEnvironment();
     env.addRequestExpectation(API_LIST_ORDERS, {
@@ -441,7 +472,6 @@ describe("order listing pagination", () => {
       },
     });
 
-
     const newDate = (d: Date) => {
       //console.log("new date", d);
     };
@@ -449,7 +479,7 @@ describe("order listing pagination", () => {
     const hookBehavior = await tests.hookBehaveLikeThis(
       () => {
         const date = new Date(12);
-        const query = useInstanceOrders({ wired: "yes", date }, newDate)
+        const query = useInstanceOrders({ wired: "yes", date }, newDate);
         const api = useOrderAPI();
         return { query, api };
       },
@@ -459,33 +489,40 @@ describe("order listing pagination", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [{ order_id: "1" }, { order_id: "2" }],
           });
-          expect(query.isReachingEnd).true
-          expect(query.isReachingStart).true
+          expect(query.isReachingEnd).true;
+          expect(query.isReachingStart).true;
 
           // should not trigger new state update or query
-          query.loadMore()
+          query.loadMore();
           query.loadMorePrev();
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
 
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
-
   });
 
   it("should load more if result brings more that PAGE_SIZE", async () => {
     const env = new ApiMockEnvironment();
 
-    const ordersFrom0to20 = Array.from({ length: 20 }).map((e, i) => ({ order_id: String(i) }))
-    const ordersFrom20to40 = Array.from({ length: 20 }).map((e, i) => ({ order_id: String(i + 20) }))
-    const ordersFrom20to0 = [...ordersFrom0to20].reverse()
+    const ordersFrom0to20 = Array.from({ length: 20 }).map((e, i) => ({
+      order_id: String(i),
+    }));
+    const ordersFrom20to40 = Array.from({ length: 20 }).map((e, i) => ({
+      order_id: String(i + 20),
+    }));
+    const ordersFrom20to0 = [...ordersFrom0to20].reverse();
 
     env.addRequestExpectation(API_LIST_ORDERS, {
       qparam: { delta: 20, wired: "yes", date_ms: 12 },
@@ -508,7 +545,7 @@ describe("order listing pagination", () => {
     const hookBehavior = await tests.hookBehaveLikeThis(
       () => {
         const date = new Date(12);
-        const query = useInstanceOrders({ wired: "yes", date }, newDate)
+        const query = useInstanceOrders({ wired: "yes", date }, newDate);
         const api = useOrderAPI();
         return { query, api };
       },
@@ -518,62 +555,77 @@ describe("order listing pagination", () => {
           expect(query.loading).true;
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
             orders: [...ordersFrom20to0, ...ordersFrom20to40],
           });
-          expect(query.isReachingEnd).false
-          expect(query.isReachingStart).false
+          expect(query.isReachingEnd).false;
+          expect(query.isReachingStart).false;
 
           env.addRequestExpectation(API_LIST_ORDERS, {
             qparam: { delta: -40, wired: "yes", date_ms: 13 },
             response: {
-              orders: [...ordersFrom20to40, { order_id: '41' }],
+              orders: [...ordersFrom20to40, { order_id: "41" }],
             },
           });
 
-          query.loadMore()
+          query.loadMore();
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).true;
         },
         ({ query, api }) => {
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            orders: [...ordersFrom20to0, ...ordersFrom20to40, { order_id: '41' }],
+            orders: [
+              ...ordersFrom20to0,
+              ...ordersFrom20to40,
+              { order_id: "41" },
+            ],
           });
 
           env.addRequestExpectation(API_LIST_ORDERS, {
             qparam: { delta: 40, wired: "yes", date_ms: 12 },
             response: {
-              orders: [...ordersFrom0to20, { order_id: '-1' }],
+              orders: [...ordersFrom0to20, { order_id: "-1" }],
             },
           });
 
-          query.loadMorePrev()
+          query.loadMorePrev();
         },
         ({ query, api }) => {
-          expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
+          expect(env.assertJustExpectedRequestWereMade()).deep.eq({
+            result: "ok",
+          });
           expect(query.loading).true;
         },
         ({ query, api }) => {
           expect(query.loading).undefined;
-          expect(query.ok).true
+          expect(query.ok).true;
           if (!query.ok) return;
           expect(query.data).deep.equals({
-            orders: [{ order_id: '-1' }, ...ordersFrom20to0, ...ordersFrom20to40, { order_id: '41' }],
+            orders: [
+              { order_id: "-1" },
+              ...ordersFrom20to0,
+              ...ordersFrom20to40,
+              { order_id: "41" },
+            ],
           });
         },
-      ], env.buildTestingContext());
+      ],
+      env.buildTestingContext(),
+    );
     expect(hookBehavior).deep.eq({ result: "ok" });
     expect(env.assertJustExpectedRequestWereMade()).deep.eq({ result: "ok" });
   });
-
-
 });