[SDK] Add optional path param in processProtectedData (#394)

Author: ErwanDecoster

packages/sdk/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 ## Next
 
+### Added
+
+- Added optional `path` parameter to `processProtectedData` method
+
 ### Changed
 
 - Moved `getResultFromCompletedTask` method from DataProtectorSharing module (DPS) to DataProtectorCore module (DPC).

packages/sdk/src/lib/dataProtectorCore/processProtectedData.ts

@@ -41,6 +41,7 @@ export const processProtectedData = async ({
   app,
   userWhitelist,
   maxPrice = DEFAULT_MAX_PRICE,
+  path,
   args,
   inputFiles,
   secrets,
@@ -62,6 +63,7 @@ export const processProtectedData = async ({
   const vMaxPrice = positiveNumberSchema()
     .label('maxPrice')
     .validateSync(maxPrice);
+  const vPath = stringSchema().label('path').validateSync(path);
   const vInputFiles = urlArraySchema()
     .label('inputFiles')
     .validateSync(inputFiles);
@@ -236,6 +238,7 @@ export const processProtectedData = async ({
     const { result } = await getResultFromCompletedTask({
       iexec,
       taskId,
+      path: vPath,
       onStatusUpdate: vOnStatusUpdate,
     });
 

packages/sdk/src/lib/dataProtectorSharing/consumeProtectedData.ts

@@ -17,6 +17,7 @@ import {
   throwIfMissing,
   validateOnStatusUpdateCallback,
   positiveNumberSchema,
+  stringSchema,
 } from '../../utils/validators.js';
 import {
   ConsumeProtectedDataParams,
@@ -56,6 +57,7 @@ export const consumeProtectedData = async ({
   const vMaxPrice = positiveNumberSchema()
     .label('maxPrice')
     .validateSync(maxPrice);
+  const vPath = stringSchema().label('path').validateSync(path);
   let vApp = addressOrEnsSchema().required().label('app').validateSync(app);
   let vWorkerpool = addressOrEnsSchema()
     .label('workerpool')
@@ -215,7 +217,7 @@ export const consumeProtectedData = async ({
     const { result } = await getResultFromCompletedTask({
       iexec,
       taskId,
-      path,
+      path: vPath,
       pemPrivateKey: privateKey,
       onStatusUpdate: vOnStatusUpdate,
     });

packages/sdk/src/lib/types/coreTypes.ts

@@ -308,6 +308,11 @@ export type ProcessProtectedDataParams = {
   */
   maxPrice?: number;
 
+  /**
+   * The file name of the desired file in the returned ZIP file.
+   */
+  path?: string;
+
   /**
    * Arguments to pass to the application during execution.
    */

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

@@ -108,6 +108,7 @@ describe.skip('dataProtectorCore.processProtectedData()', () => {
           2: 'email content for test processData',
         },
         args: '_args_test_process_data_',
+        path: 'computed.json',
         onStatusUpdate: onStatusUpdateMock,
       });
 

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

@@ -153,6 +153,26 @@ describe('processProtectedData', () => {
       });
     });
 
+    describe('When given path is NOT a valid string', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        // --- GIVEN
+        const invalidPath = 42;
+
+        await expect(
+          // --- WHEN
+          processProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            protectedData: getRandomAddress(),
+            app: getRandomAddress(),
+            // @ts-expect-error Type 'number' is not assignable to type 'string'
+            path: invalidPath,
+          })
+          // --- THEN
+        ).rejects.toThrow(new ValidationError('path should be a string'));
+      });
+    });
+
     describe('When maxPrice is not a positive number', () => {
       it('should throw a yup ValidationError with the correct message', async () => {
         // --- GIVEN

packages/sdk/tests/unit/dataProtectorSharing/consumeProtectedData.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from '@jest/globals';
+import { ValidationError } from 'yup';
+import { consumeProtectedData } from '../../../src/lib/dataProtectorSharing/consumeProtectedData.js';
+import { getRandomAddress, getRequiredFieldMessage } from '../../test-utils.js';
+import { DEFAULT_SHARING_CONTRACT_ADDRESS } from '../../../src/config/config.js';
+
+describe('consumeProtectedData', () => {
+  describe('Check validation for input parameters', () => {
+    describe('When protected data is NOT given', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const missingProtectedData = undefined;
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: missingProtectedData,
+            app: getRandomAddress(),
+          })
+        ).rejects.toThrow(
+          new ValidationError(getRequiredFieldMessage('protectedData'))
+        );
+      });
+    });
+
+    describe('When given protected data is NOT valid', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const invalidProtectedData = '0x123456...';
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: invalidProtectedData,
+            app: getRandomAddress(),
+          })
+        ).rejects.toThrow(
+          new ValidationError(
+            'protectedData should be an ethereum address or a ENS name'
+          )
+        );
+      });
+    });
+
+    describe('When app address is NOT given', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const missingAppAddress = undefined;
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: getRandomAddress(),
+            app: missingAppAddress,
+          })
+        ).rejects.toThrow(new ValidationError(getRequiredFieldMessage('app')));
+      });
+    });
+
+    describe('When given app address is NOT valid', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const invalidAppAddress = '0x123456...';
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: getRandomAddress(),
+            app: invalidAppAddress,
+          })
+        ).rejects.toThrow(
+          new ValidationError('app should be an ethereum address or a ENS name')
+        );
+      });
+    });
+
+    describe('When maxPrice is not a positive number', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const invalidMaxPrice = -1;
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: getRandomAddress(),
+            app: getRandomAddress(),
+            maxPrice: invalidMaxPrice,
+          })
+        ).rejects.toThrow(
+          new ValidationError('maxPrice must be greater than or equal to 0')
+        );
+      });
+    });
+
+    describe('When path is not a valid string', () => {
+      it('should throw a yup ValidationError with the correct message', async () => {
+        const invalidPath = 42;
+
+        await expect(
+          consumeProtectedData({
+            // @ts-expect-error No need for iexec here
+            iexec: {},
+            sharingContractAddress: DEFAULT_SHARING_CONTRACT_ADDRESS,
+            protectedData: getRandomAddress(),
+            app: getRandomAddress(),
+            // @ts-expect-error Type 'number' is not assignable to type 'string'
+            path: invalidPath,
+          })
+        ).rejects.toThrow(new ValidationError('path should be a string'));
+      });
+    });
+  });
+});