Tests for parsing errors for some rpc handlers

Author: emmacasolin

src/validation/errors.ts

@@ -5,14 +5,14 @@ import { ErrorPolykey, sysexits } from '../errors';
  * Generic error containing all parsing errors that occurred during
  * execution.
  */
- class ErrorValidation extends ErrorPolykey {
+class ErrorValidation extends ErrorPolykey {
   description = 'Input data failed validation';
   exitCode = sysexits.DATAERR;
   public errors: Array<ErrorParse>;
   constructor(message, data) {
     super(message, data);
     if (data.errors != null) {
-      let errors: Array<ErrorParse> = [];
+      const errors: Array<ErrorParse> = [];
       for (const eData of data.errors) {
         const errorParse = new ErrorParse(eData.message);
         errorParse.keyPath = eData.keyPath;

tests/client/service/identitiesAuthenticate.test.ts

@@ -16,6 +16,7 @@ import {
 import identitiesAuthenticate from '@/client/service/identitiesAuthenticate';
 import * as identitiesPB from '@/proto/js/polykey/v1/identities/identities_pb';
 import { utils as nodesUtils } from '@/nodes';
+import * as validationErrors from '@/validation/errors';
 import TestProvider from '../../identities/TestProvider';
 
 describe('identitiesAuthenticate', () => {
@@ -87,7 +88,6 @@ describe('identitiesAuthenticate', () => {
   test('authenticates identity', async () => {
     const request = new identitiesPB.Provider();
     request.setProviderId(testToken.providerId);
-    request.setIdentityId(testToken.identityId);
     const response = grpcClient.identitiesAuthenticate(
       request,
       clientUtils.encodeAuthFromPassword(password),
@@ -123,4 +123,16 @@ describe('identitiesAuthenticate', () => {
       testToken.identityId,
     );
   });
+  test('cannot authenticate invalid provider', async () => {
+    const request = new identitiesPB.Provider();
+    request.setProviderId('');
+    await expect(
+      grpcClient
+        .identitiesAuthenticate(
+          request,
+          clientUtils.encodeAuthFromPassword(password),
+        )
+        .next(),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });

tests/client/service/identitiesClaim.test.ts

@@ -22,6 +22,7 @@ import {
 import identitiesClaim from '@/client/service/identitiesClaim';
 import * as identitiesPB from '@/proto/js/polykey/v1/identities/identities_pb';
 import * as claimsUtils from '@/claims/utils';
+import * as validationErrors from '@/validation/errors';
 import TestProvider from '../../identities/TestProvider';
 import * as testUtils from '../../utils';
 
@@ -199,4 +200,31 @@ describe('identitiesClaim', () => {
       testToken.identityId,
     );
   });
+  test('cannot claim invalid identity', async () => {
+    const request = new identitiesPB.Provider();
+    request.setIdentityId('');
+    request.setProviderId(testToken.providerId);
+    await expect(
+      grpcClient.identitiesClaim(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+    request.setIdentityId(testToken.identityId);
+    request.setProviderId('');
+    await expect(
+      grpcClient.identitiesClaim(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+    request.setIdentityId('');
+    request.setProviderId('');
+    await expect(
+      grpcClient.identitiesClaim(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });

tests/client/service/nodesAdd.test.ts

@@ -19,6 +19,7 @@ import nodesAdd from '@/client/service/nodesAdd';
 import * as nodesPB from '@/proto/js/polykey/v1/nodes/nodes_pb';
 import * as utilsPB from '@/proto/js/polykey/v1/utils/utils_pb';
 import { utils as nodesUtils } from '@/nodes';
+import * as validationErrors from '@/validation/errors';
 import * as testUtils from '../../utils';
 
 describe('nodesAdd', () => {
@@ -155,4 +156,37 @@ describe('nodesAdd', () => {
     expect(result!.host).toBe('127.0.0.1');
     expect(result!.port).toBe(11111);
   });
+  test('cannot add invalid node', async () => {
+    // Invalid host
+    const addressMessage = new nodesPB.Address();
+    addressMessage.setHost('');
+    addressMessage.setPort(11111);
+    const request = new nodesPB.NodeAddress();
+    request.setNodeId('vrsc24a1er424epq77dtoveo93meij0pc8ig4uvs9jbeld78n9nl0');
+    request.setAddress(addressMessage);
+    await expect(
+      grpcClient.nodesAdd(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+    // Invalid port
+    addressMessage.setHost('127.0.0.1');
+    addressMessage.setPort(111111);
+    await expect(
+      grpcClient.nodesAdd(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+    // Invalid nodeid
+    addressMessage.setPort(11111);
+    request.setNodeId('nodeId');
+    await expect(
+      grpcClient.nodesAdd(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });

tests/client/service/nodesClaim.test.ts

@@ -22,6 +22,7 @@ import {
 import nodesClaim from '@/client/service/nodesClaim';
 import * as nodesPB from '@/proto/js/polykey/v1/nodes/nodes_pb';
 import * as utilsPB from '@/proto/js/polykey/v1/utils/utils_pb';
+import * as validationErrors from '@/validation/errors';
 import * as testUtils from '../../utils';
 
 describe('nodesClaim', () => {
@@ -212,4 +213,14 @@ describe('nodesClaim', () => {
     expect(response).toBeInstanceOf(utilsPB.StatusMessage);
     expect(response.getSuccess()).toBeTruthy();
   });
+  test('cannot claim an invalid node', async () => {
+    const request = new nodesPB.Claim();
+    request.setNodeId('nodeId');
+    await expect(
+      grpcClient.nodesClaim(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });

tests/client/service/nodesFind.test.ts

@@ -17,6 +17,7 @@ import {
 } from '@/client';
 import nodesFind from '@/client/service/nodesFind';
 import * as nodesPB from '@/proto/js/polykey/v1/nodes/nodes_pb';
+import * as validationErrors from '@/validation/errors';
 import * as testUtils from '../../utils';
 
 describe('nodesFind', () => {
@@ -153,4 +154,14 @@ describe('nodesFind', () => {
     expect(response.getAddress()!.getHost()).toBe('127.0.0.1');
     expect(response.getAddress()!.getPort()).toBe(11111);
   });
+  test('cannot find an invalid node', async () => {
+    const request = new nodesPB.Node();
+    request.setNodeId('nodeId');
+    await expect(
+      grpcClient.nodesFind(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });

tests/client/service/nodesPing.test.ts

@@ -18,6 +18,7 @@ import {
 import nodesPing from '@/client/service/nodesPing';
 import * as nodesPB from '@/proto/js/polykey/v1/nodes/nodes_pb';
 import * as utilsPB from '@/proto/js/polykey/v1/utils/utils_pb';
+import * as validationErrors from '@/validation/errors';
 import * as testUtils from '../../utils';
 
 describe('nodesPing', () => {
@@ -158,4 +159,14 @@ describe('nodesPing', () => {
     expect(response).toBeInstanceOf(utilsPB.StatusMessage);
     expect(response.getSuccess()).toBeTruthy();
   });
+  test('cannot ping an invalid node', async () => {
+    const request = new nodesPB.Node();
+    request.setNodeId('nodeId');
+    await expect(
+      grpcClient.nodesPing(
+        request,
+        clientUtils.encodeAuthFromPassword(password),
+      ),
+    ).rejects.toThrow(validationErrors.ErrorValidation);
+  });
 });