adjust unit tests

Author: SeddikBellamine

packages/sdk/tests/test-utils.ts

@@ -211,6 +211,32 @@ export const mockWorkerpoolOrderbook = {
   count: 1,
 };
 
+export const mockAppOrderbook = {
+  orders: [
+    {
+      order: {
+        app: '0xc8c5E295D2BedA01D1fB8DD4d85A1Cb769185a34',
+        appprice: 0,
+        volume: 10000000,
+        tag: '0x0000000000000000000000000000000000000000000000000000000000000003',
+        datasetrestrict: '0x0000000000000000000000000000000000000000',
+        workerpoolrestrict: '0x0000000000000000000000000000000000000000',
+        requesterrestrict: '0x0000000000000000000000000000000000000000',
+        salt: '0x82107d3b5694d3ab4cd4e5f2057e1bdeb7da359518ccfb15638405c619fa12b0',
+        sign: '0x0112d6f1b53777a001054daf62f542a5f94679f88885515a2126a6794505d6993e425c3a432b4c2cdbf004f6f0c8c9908493135dedb829f6c958e67daa068dd61c',
+      },
+      orderHash:
+        '0x64208bc3580bbee092c4a4efb26629cf885a2f1e99b6b4d9bd809ea85b58332f',
+      chainId: 134,
+      publicationTimestamp: '2025-02-05T14:35:51.271Z',
+      signer: '0x9cfFa14604A6836E9d6fBAcCc624cfE0bE3Be5B4',
+      status: 'open',
+      remaining: 9999961,
+    },
+  ],
+  count: 1,
+};
+
 export function observableMockComplete() {
   const mockObservable: any = {
     subscribe: jest.fn(({ complete }) => {

packages/sdk/tests/unit/dataProtectorCore/processProtectedData/processProtectedData.test.ts

@@ -11,6 +11,7 @@ import {
 import {
   getRandomAddress,
   getRequiredFieldMessage,
+  mockAppOrderbook,
   mockWorkerpoolOrderbook,
   resolveWithNoOrder,
 } from '../../../test-utils.js';
@@ -40,7 +41,7 @@ jest.unstable_mockModule(
 jest.unstable_mockModule(
   '../../../../src/utils/processProtectedData.models.js',
   () => ({
-    findWorkerpoolOrders: jest.fn(
+    filterWorkerpoolOrders: jest.fn(
       () => mockWorkerpoolOrderbook.orders[0].order
     ),
     checkUserVoucher: jest.fn(),
@@ -184,10 +185,10 @@ describe('processProtectedData', () => {
       });
     });
 
-    describe('When maxPrice is not a positive number', () => {
+    describe('When DatamaxPrice is not a positive number', () => {
       it('should throw a yup ValidationError with the correct message', async () => {
         // --- GIVEN
-        const invalidMaxPrice = -1;
+        const invalidDataMaxPrice = -1;
 
         await expect(
           // --- WHEN
@@ -196,11 +197,55 @@ describe('processProtectedData', () => {
             iexec: {},
             protectedData: getRandomAddress(),
             app: getRandomAddress(),
-            maxPrice: invalidMaxPrice,
+            dataMaxPrice: invalidDataMaxPrice,
           })
           // --- THEN
         ).rejects.toThrow(
-          new ValidationError('maxPrice must be greater than or equal to 0')
+          new ValidationError('dataMaxPrice must be greater than or equal to 0')
+        );
+      });
+    });
+
+    describe('When WorkerpoolmaxPrice is not a positive number', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        // --- GIVEN
+        const invalidWorkerpoolMaxPrice = -1;
+
+        await expect(
+          // --- WHEN
+          processProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            protectedData: getRandomAddress(),
+            app: getRandomAddress(),
+            workerpoolMaxPrice: invalidWorkerpoolMaxPrice,
+          })
+          // --- THEN
+        ).rejects.toThrow(
+          new ValidationError(
+            'workerpoolMaxPrice must be greater than or equal to 0'
+          )
+        );
+      });
+    });
+
+    describe('When appMaxPrice is not a positive number', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        // --- GIVEN
+        const invalidAppMaxPrice = -1;
+
+        await expect(
+          // --- WHEN
+          processProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            protectedData: getRandomAddress(),
+            app: getRandomAddress(),
+            appMaxPrice: invalidAppMaxPrice,
+          })
+          // --- THEN
+        ).rejects.toThrow(
+          new ValidationError('appMaxPrice must be greater than or equal to 0')
         );
       });
     });
@@ -344,7 +389,9 @@ describe('processProtectedData', () => {
           fetchDatasetOrderbook: jest
             .fn<() => Promise<{ orders: []; count: number }>>()
             .mockResolvedValue(resolveWithNoOrder()),
-          fetchAppOrderbook: jest.fn(),
+          fetchAppOrderbook: jest
+            .fn<() => Promise<any>>()
+            .mockResolvedValue(mockAppOrderbook),
           fetchWorkerpoolOrderbook: jest
             .fn<() => Promise<any>>()
             .mockResolvedValue(mockWorkerpoolOrderbook),
@@ -363,7 +410,7 @@ describe('processProtectedData', () => {
       ).rejects.toThrow(
         new WorkflowError({
           message: processProtectedDataErrorMessage,
-          errorCause: Error('No dataset orders found'),
+          errorCause: Error('No Dataset order found for the desired price'),
         })
       );
     });
@@ -401,7 +448,7 @@ describe('processProtectedData', () => {
       ).rejects.toThrow(
         new WorkflowError({
           message: processProtectedDataErrorMessage,
-          errorCause: Error('No app orders found'),
+          errorCause: Error('No App order found for the desired price'),
         })
       );
     });
@@ -425,16 +472,17 @@ describe('processProtectedData', () => {
       });
 
       // --- THEN
-      expect(fetchWorkerpoolOrderbookMock).toHaveBeenCalledWith({
-        workerpool: 'any', // <-- What we want to test
-        app: expect.any(String),
-        dataset: expect.any(String),
-        requester: expect.any(String),
-        category: 0,
-        minTag: SCONE_TAG,
-        maxTag: SCONE_TAG,
-        isRequesterStrict: expect.any(Boolean),
-      });
+      expect(fetchWorkerpoolOrderbookMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          workerpool: 'any', // <-- the core of what you're testing
+          dataset: expect.any(String),
+          requester: expect.any(String),
+          category: 0,
+          minTag: SCONE_TAG,
+          maxTag: SCONE_TAG,
+          isRequesterStrict: expect.any(Boolean),
+        })
+      );
     });
   });
 
@@ -511,24 +559,29 @@ describe('processProtectedData', () => {
       });
 
       // --- THEN
-      expect(fetchDatasetOrderbookMock).toHaveBeenCalledWith(
-        expect.any(String),
-        {
-          app: expect.any(String),
-          workerpool: expect.any(String),
-          requester: validWhitelistAddress.toLowerCase(), // <-- whitelist address instead of user wallet address
-        }
+      const calls = fetchDatasetOrderbookMock.mock.calls;
+
+      expect(calls).toEqual(
+        expect.arrayContaining([
+          [
+            expect.any(String),
+            expect.objectContaining({
+              app: expect.any(String),
+              requester: validWhitelistAddress.toLowerCase(),
+            }),
+          ],
+        ])
       );
     });
   });
 
   describe('When there is NO workerpool orders', () => {
     it('should throw a WorkflowError with the correct message', async () => {
-      const { findWorkerpoolOrders } = await import(
+      const { filterWorkerpoolOrders } = await import(
         '../../../../src/utils/processProtectedData.models.js'
       );
 
-      (findWorkerpoolOrders as jest.Mock).mockReturnValue(null);
+      (filterWorkerpoolOrders as jest.Mock).mockReturnValue(null);
       // --- GIVEN
       const iexec = {
         wallet: {
@@ -557,7 +610,7 @@ describe('processProtectedData', () => {
       ).rejects.toThrow(
         new WorkflowError({
           message: processProtectedDataErrorMessage,
-          errorCause: Error('No Workerpool order found.'),
+          errorCause: Error('No Workerpool order found for the desired price'),
         })
       );
     });