Merge pull request #412 from univapay/feature/pierreh/merchant-2855/a…

…dd-poll-iteration-callback Add poll iteration callback and more tests
univapay · May 30, 2022 · b94b437 · b94b437
2 parents c5aaf4d + 6ba1d56
commit b94b437
Show file tree

Hide file tree

Showing 9 changed files with 230 additions and 18 deletions.
diff --git a/src/api/RestAPI.ts b/src/api/RestAPI.ts
@@ -296,28 +296,30 @@ export class RestAPI extends EventEmitter {
     /**
      * @internal
      */
-    async longPolling<A>(
-        promise: PromiseCreator<A>,
-        condition: (response: A) => boolean,
-        cancelCondition?: (response: A) => boolean,
-        callback?: ResponseCallback<A>,
+    async longPolling<Response>(
+        promise: PromiseCreator<Response>,
+        condition: (response: Response) => boolean,
+        cancelCondition?: (response: Response) => boolean,
+        callback?: ResponseCallback<Response>,
         timeout: number = POLLING_TIMEOUT,
-        interval: number = POLLING_INTERVAL
-    ): Promise<A> {
+        interval: number = POLLING_INTERVAL,
+        iterationCallback?: (response: Response) => void
+    ): Promise<Response> {
         return execRequest(async () => {
             let timedOut = false;
 
             return Promise.race([
                 // Timeout
-                new Promise<A>((_, reject) => {
+                new Promise<Response>((_, reject) => {
                     setTimeout(() => {
                         timedOut = true;
                         reject(new TimeoutError(timeout));
                     }, timeout);
                 }),
                 // Repeater
-                (async function repeater(): Promise<A> {
+                (async function repeater(): Promise<Response> {
                     const result = await promise();
+                    iterationCallback?.(result);
 
                     if (cancelCondition?.(result)) {
                         return null;

diff --git a/src/resources/Cancels.ts b/src/resources/Cancels.ts
@@ -87,11 +87,20 @@ export class Cancels extends CRUDResource {
          * Condition to cancel the polling and return `null`,
          */
         cancelCondition?: (response: ResponseCancel) => boolean,
-        successCondition: ({ status }: ResponseCancel) => boolean = ({ status }) => status !== CancelStatus.PENDING
+        successCondition: ({ status }: ResponseCancel) => boolean = ({ status }) => status !== CancelStatus.PENDING,
+        iterationCallback?: (response: ResponseCancel) => void
     ): Promise<ResponseCancel> {
         const pollingData = { ...data, polling: true };
         const promise: () => Promise<ResponseCancel> = () => this.get(storeId, chargeId, id, pollingData, auth);
 
-        return this.api.longPolling(promise, successCondition, cancelCondition, callback);
+        return this.api.longPolling(
+            promise,
+            successCondition,
+            cancelCondition,
+            callback,
+            undefined,
+            undefined,
+            iterationCallback
+        );
     }
 }
diff --git a/src/resources/Charges.ts b/src/resources/Charges.ts
@@ -138,11 +138,20 @@ export class Charges extends CRUDResource {
          * Condition for the resource to be successfully loaded. Default to pending status check.
          */
         cancelCondition?: (response: ResponseCharge) => boolean,
-        successCondition: ({ status }: ResponseCharge) => boolean = ({ status }) => status !== ChargeStatus.PENDING
+        successCondition: ({ status }: ResponseCharge) => boolean = ({ status }) => status !== ChargeStatus.PENDING,
+        iterationCallback?: (response: ResponseCharge) => void
     ): Promise<ResponseCharge> {
         const pollingData = { ...data, polling: true };
         const promise: () => Promise<ResponseCharge> = () => this.get(storeId, id, pollingData, auth);
 
-        return this.api.longPolling(promise, successCondition, cancelCondition, callback);
+        return this.api.longPolling(
+            promise,
+            successCondition,
+            cancelCondition,
+            callback,
+            undefined,
+            undefined,
+            iterationCallback
+        );
     }
 }
diff --git a/src/resources/Refunds.ts b/src/resources/Refunds.ts
@@ -123,11 +123,20 @@ export class Refunds extends CRUDResource {
          * Condition for the resource to be successfully loaded. Default to pending status check.
          */
         cancelCondition?: (response: ResponseRefund) => boolean,
-        successCondition: ({ status }: ResponseRefund) => boolean = ({ status }) => status !== RefundStatus.PENDING
+        successCondition: ({ status }: ResponseRefund) => boolean = ({ status }) => status !== RefundStatus.PENDING,
+        iterationCallback?: (response: ResponseRefund) => void
     ): Promise<ResponseRefund> {
         const pollData = { ...data, polling: true };
         const promise: () => Promise<ResponseRefund> = () => this.get(storeId, chargeId, id, pollData, auth);
 
-        return this.api.longPolling(promise, successCondition, cancelCondition, callback);
+        return this.api.longPolling(
+            promise,
+            successCondition,
+            cancelCondition,
+            callback,
+            undefined,
+            undefined,
+            iterationCallback
+        );
     }
 }
diff --git a/src/resources/Subscriptions.ts b/src/resources/Subscriptions.ts
@@ -368,12 +368,21 @@ export class Subscriptions extends CRUDResource {
          */
         cancelCondition?: (response: ResponseSubscription) => boolean,
         successCondition: ({ status }: ResponseSubscription) => boolean = ({ status }) =>
-            status !== SubscriptionStatus.UNVERIFIED
+            status !== SubscriptionStatus.UNVERIFIED,
+        iterationCallback?: (response: ResponseSubscription) => void
     ): Promise<ResponseSubscription> {
         const pollData = { ...data, polling: true };
         const promise: () => Promise<ResponseSubscription> = () => this.get(storeId, id, pollData, auth);
 
-        return this.api.longPolling(promise, successCondition, cancelCondition, callback);
+        return this.api.longPolling(
+            promise,
+            successCondition,
+            cancelCondition,
+            callback,
+            undefined,
+            undefined,
+            iterationCallback
+        );
     }
 
     async pollSubscriptionWithFirstCharge(

diff --git a/test/specs/cancels.specs.ts b/test/specs/cancels.specs.ts
@@ -126,10 +126,54 @@ describe("Cancels", () => {
 
             const request = cancels.poll(uuid(), uuid(), uuid());
 
-            sandbox.clock.tick(POLLING_TIMEOUT);
+            await sandbox.clock.tick(POLLING_TIMEOUT);
 
             await expect(request).to.eventually.be.rejectedWith(TimeoutError);
         });
+
+        it("cancel polling", async () => {
+            const recordPendingData = { ...recordData, status: CancelStatus.PENDING };
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: recordPendingData,
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "pending",
+                }
+            );
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: { ...recordData, status: CancelStatus.FAILED },
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "failed",
+                }
+            );
+
+            const request = cancels.poll(
+                uuid(),
+                uuid(),
+                uuid(),
+                undefined,
+                undefined,
+                undefined,
+                ({ status }) => status === CancelStatus.FAILED
+            );
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+
+            await expect(request).to.eventually.eql(null);
+        });
     });
 
     it("should return request error when parameters for route are invalid", async () => {

diff --git a/test/specs/charges.specs.ts b/test/specs/charges.specs.ts
@@ -152,6 +152,49 @@ describe("Charges", () => {
 
             await expect(request).to.eventually.be.rejectedWith(TimeoutError);
         });
+
+        it("cancel polling", async () => {
+            const recordPendingData = { ...recordData, status: ChargeStatus.PENDING };
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: recordPendingData,
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "pending",
+                }
+            );
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: { ...recordData, status: ChargeStatus.FAILED },
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "failed",
+                }
+            );
+
+            const request = charges.poll(
+                uuid(),
+                uuid(),
+                undefined,
+                undefined,
+                undefined,
+                ({ status }) => status === ChargeStatus.FAILED
+            );
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+
+            await expect(request).to.eventually.eql(null);
+        });
     });
 
     context("GET /stores/:storeId/charges/:chargeId/issuerToken", () => {

diff --git a/test/specs/refunds.specs.ts b/test/specs/refunds.specs.ts
@@ -157,6 +157,50 @@ describe("Refunds", () => {
 
             await expect(request).to.eventually.be.rejectedWith(TimeoutError);
         });
+
+        it("cancel polling", async () => {
+            const recordPendingData = { ...recordData, status: RefundStatus.PENDING };
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: recordPendingData,
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "pending",
+                }
+            );
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: { ...recordData, status: RefundStatus.FAILED },
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "failed",
+                }
+            );
+
+            const request = refunds.poll(
+                uuid(),
+                uuid(),
+                uuid(),
+                undefined,
+                undefined,
+                undefined,
+                ({ status }) => status === RefundStatus.FAILED
+            );
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+
+            await expect(request).to.eventually.eql(null);
+        });
     });
 
     context("PATCH /stores/:storeId/charges/:chargeId/refunds/:id", () => {

diff --git a/test/specs/subscriptions.specs.ts b/test/specs/subscriptions.specs.ts
@@ -167,6 +167,49 @@ describe("Subscriptions", () => {
 
             await expect(request).to.eventually.be.rejectedWith(TimeoutError);
         });
+
+        it("cancel polling", async () => {
+            const recordPendingData = { ...recordData, status: SubscriptionStatus.UNVERIFIED };
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: recordPendingData,
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "pending",
+                }
+            );
+
+            fetchMock.getOnce(
+                recordPathMatcher,
+                {
+                    status: 200,
+                    body: { ...recordData, status: SubscriptionStatus.SUSPENDED },
+                    headers: { "Content-Type": "application/json" },
+                },
+                {
+                    method: HTTPMethod.GET,
+                    name: "failed",
+                }
+            );
+
+            const request = subscriptions.poll(
+                uuid(),
+                uuid(),
+                undefined,
+                undefined,
+                undefined,
+                ({ status }) => status === SubscriptionStatus.SUSPENDED
+            );
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+            await sandbox.clock.tickAsync(POLLING_INTERVAL);
+
+            await expect(request).to.eventually.eql(null);
+        });
     });
 
     context("PATCH /stores/:storeId/subscriptions/:id", () => {