fix(ref-imp): fix null delta throwing unexpected error (#957)

lib/core/versions/latest/ChunkFile.ts

@@ -54,7 +54,7 @@ export default class ChunkFile {
       }
 
       // Verify size of each delta does not exceed the maximum allowed limit.
-      Delta.validateDeltaSize(delta);
+      Delta.validateDelta(delta);
     }
   }
 

lib/core/versions/latest/Delta.ts

@@ -22,10 +22,21 @@ export default class Delta {
     }
   }
 
+  /**
+   * Validates that delta is not null or undefined
+   */
+  private static validateDeltaIsDefined (delta: any) {
+    if (delta === undefined || delta === null) {
+      throw new SidetreeError(ErrorCode.DeltaIsNullOrUndefined, `Delta is ${delta}`);
+    }
+  }
+
   /**
    * Validates size of the delta object
    */
-  public static validateDeltaSize (delta: object) {
+  public static validateDelta (delta: any) {
+    // null and undefined cannot be turned into buffer
+    Delta.validateDeltaIsDefined(delta);
     const size = Buffer.byteLength(JsonCanonicalizer.canonicalizeAsBuffer(delta));
     if (size > ProtocolParameters.maxDeltaSizeInBytes) {
       const errorMessage = `${size} bytes of 'delta' exceeded limit of ${ProtocolParameters.maxDeltaSizeInBytes} bytes.`;

lib/core/versions/latest/Did.ts

@@ -187,8 +187,8 @@ export default class Did {
       throw new SidetreeError(ErrorCode.DidInitialStateJcsIsNotJson, 'Long form initial state should be encoded jcs.');
     }
 
-    Did.validateInitialState(initialStateEncodedJcs, initialStateObject);
-    Delta.validateDeltaSize(initialStateObject.delta);
+    Did.validateInitialStateJcs(initialStateEncodedJcs, initialStateObject);
+    Delta.validateDelta(initialStateObject.delta);
 
     const createOperationRequest = {
       type: OperationType.Create,
@@ -203,7 +203,7 @@ export default class Did {
   /**
    * Make sure initial state is JCS
    */
-  private static validateInitialState (initialStateEncodedJcs: string, initialStateObject: any): void {
+  private static validateInitialStateJcs (initialStateEncodedJcs: string, initialStateObject: any): void {
     const expectedInitialState = Encoder.encode(JsonCanonicalizer.canonicalizeAsBuffer(initialStateObject));
     if (expectedInitialState !== initialStateEncodedJcs) {
       throw new SidetreeError(ErrorCode.DidInitialStateJcsIsNotJcs, 'Initial state object and JCS string mismatch.');

lib/core/versions/latest/ErrorCode.ts

@@ -46,6 +46,7 @@ export default {
   DeactivateOperationTypeIncorrect: 'deactivate_operation_type_incorrect',
   DeltaExceedsMaximumSize: 'delta_exceeds_maximum_size',
   DeltaIsNotObject: 'delta_is_not_object',
+  DeltaIsNullOrUndefined: 'delta_is_null_or_undefined',
   DeltaMissingOrNotString: 'delta_missing_or_not_string',
   DeltaMissingOrUnknownProperty: 'delta_missing_or_unknown_property',
   DidIncorrectPrefix: 'did_incorrect_prefix',

lib/core/versions/latest/RequestHandler.ts

@@ -44,7 +44,7 @@ export default class RequestHandler implements IRequestHandler {
       if (operationRequest.type === OperationType.Create ||
           operationRequest.type === OperationType.Recover ||
           operationRequest.type === OperationType.Update) {
-        Delta.validateDeltaSize(operationRequest.delta);
+        Delta.validateDelta(operationRequest.delta);
       }
 
       operationModel = await Operation.parse(request);

tests/core/Delta.spec.ts

@@ -0,0 +1,72 @@
+import Delta from '../../lib/core/versions/latest/Delta';
+import ErrorCode from '../../lib/core/versions/latest/ErrorCode';
+import JasmineSidetreeErrorValidator from '../JasmineSidetreeErrorValidator';
+
+function generateLongString (length: number): string {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result = result + 'a';
+  }
+  return result;
+}
+
+describe('Delta', () => {
+  describe('validateEncodedDeltaSize', () => {
+    it('should throw sidetree if encoded size exceeds max limit', () => {
+      const mockEncodedDelta = generateLongString(2000);
+      JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrown(
+        () => { Delta.validateEncodedDeltaSize(mockEncodedDelta); },
+        ErrorCode.DeltaExceedsMaximumSize
+      );
+    });
+
+    it('should not throw if encoded size does not exceed max limit', () => {
+      const mockEncodedDelta = generateLongString(1);
+      try {
+        Delta.validateEncodedDeltaSize(mockEncodedDelta);
+      } catch (e) {
+        fail(`Expected no error but got ${e}`);
+      }
+    });
+  });
+
+  describe('validateDelta', () => {
+    it('should throw sidetree error if delta size exceeds max limit', () => {
+      const mockDelta = {
+        someKey: generateLongString(2000)
+      };
+      JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrown(
+        () => { Delta.validateDelta(mockDelta); },
+        ErrorCode.DeltaExceedsMaximumSize
+      );
+    });
+
+    it('should throw sidetree error if delta is null', () => {
+      const mockDelta = null;
+      JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrown(
+        () => { Delta.validateDelta(mockDelta); },
+        ErrorCode.DeltaIsNullOrUndefined
+      );
+    });
+
+    it('should throw sidetree error if delta is undefined', () => {
+      const mockDelta = undefined;
+      JasmineSidetreeErrorValidator.expectSidetreeErrorToBeThrown(
+        () => { Delta.validateDelta(mockDelta); },
+        ErrorCode.DeltaIsNullOrUndefined
+      );
+    });
+
+    it('should not throw if delta size is valid', () => {
+      const mockDelta = {
+        someKey: 'some value'
+      };
+
+      try {
+        Delta.validateDelta(mockDelta);
+      } catch (e) {
+        fail(`Expected no error but got ${e}`);
+      }
+    });
+  });
+});