lib: uncomment tests and move data decoding to CloudEvent object

Signed-off-by: Lance Ball <[email protected]>

Author: lance

src/event/cloudevent.ts

@@ -2,7 +2,9 @@ import { v4 as uuidv4 } from "uuid";
 
 import { CloudEventV1, validateV1, CloudEventV1Attributes } from "./v1";
 import { CloudEventV03, validateV03, CloudEventV03Attributes } from "./v03";
-import { ValidationError } from "./validation";
+import { ValidationError, isBinary, asBase64 } from "./validation";
+import CONSTANTS from "../constants";
+import { isString } from "util";
 
 export const enum Version {
   V1 = "1.0",
@@ -23,7 +25,7 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
   dataschema?: string;
   subject?: string;
   #_time?: string | Date;
-  data?: Record<string, unknown | string | number | boolean> | string | number | boolean | null | unknown;
+  #_data?: Record<string, unknown | string | number | boolean> | string | number | boolean | null | unknown;
   data_base64?: string;
 
   // Extensions should not exist as it's own object, but instead
@@ -60,21 +62,21 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
     this.#_time = properties.time;
     delete properties.time;
 
-    this.data = properties.data;
-    delete properties.data;
+    this.datacontentencoding = properties.datacontentencoding as string;
+    delete properties.datacontentencoding;
 
     this.dataschema = properties.dataschema as string;
     delete properties.dataschema;
 
     this.data_base64 = properties.data_base64 as string;
     delete properties.data_base64;
 
-    this.datacontentencoding = properties.datacontentencoding as string;
-    delete properties.datacontentencoding;
-
     this.schemaurl = properties.schemaurl as string;
     delete properties.schemaurl;
 
+    this._setData(properties.data);
+    delete properties.data;
+
     // Make sure time has a default value and whatever is provided is formatted
     if (!this.#_time) {
       this.#_time = new Date().toISOString();
@@ -103,9 +105,35 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
     this.#_time = new Date(val).toISOString();
   }
 
+  get data(): unknown {
+    if (
+      this.datacontenttype === CONSTANTS.MIME_JSON &&
+      !(this.datacontentencoding === CONSTANTS.ENCODING_BASE64) &&
+      isString(this.#_data)
+    ) {
+      return JSON.parse(this.#_data as string);
+    } else if (isBinary(this.#_data)) {
+      return asBase64(this.#_data as Uint32Array);
+    }
+    return this.#_data;
+  }
+
+  set data(value: unknown) {
+    this._setData(value);
+  }
+
+  private _setData(value: unknown): void {
+    if (isBinary(value)) {
+      this.#_data = value;
+      this.data_base64 = asBase64(value as Uint32Array);
+    }
+    this.#_data = value;
+  }
+
   toJSON(): Record<string, unknown> {
     const event = { ...this };
     event.time = this.time;
+    event.data = this.data;
     return event;
   }
 
@@ -119,12 +147,19 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
    * @return {boolean} true if this event is valid
    */
   validate(): boolean {
-    if (this.specversion === Version.V1) {
-      return validateV1(this);
-    } else if (this.specversion === Version.V03) {
-      return validateV03(this);
-    } else {
+    try {
+      if (this.specversion === Version.V1) {
+        return validateV1(this);
+      } else if (this.specversion === Version.V03) {
+        return validateV03(this);
+      }
       throw new ValidationError("invalid payload");
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        throw e;
+      } else {
+        throw new ValidationError("invalid payload", e);
+      }
     }
   }
 

src/transport/http/binary_emitter.ts

@@ -9,9 +9,8 @@ import CONSTANTS from "../../constants";
 export async function emitBinary(event: CloudEvent, options: TransportOptions): Promise<AxiosResponse> {
   if (event.specversion !== Version.V1 && event.specversion !== Version.V03) {
     return Promise.reject(`Unknown spec version ${event.specversion}`);
-  } else {
-    return emit(event, options, headersFor(event));
   }
+  return emit(event, options, headersFor(event));
 }
 
 async function emit(event: CloudEvent, options: TransportOptions, headers: Headers): Promise<AxiosResponse> {

src/transport/http/headers.ts

@@ -17,6 +17,12 @@ export const requiredHeaders = [
   CONSTANTS.CE_HEADERS.SPEC_VERSION,
 ];
 
+/**
+ * Validates cloud event headers and their values
+ * @param {Headers} headers event transport headers for validation
+ * @throws {ValidationError} if the headers are invalid
+ * @return {boolean} true if headers are valid
+ */
 export function validate(headers: Headers): Headers {
   const sanitizedHeaders = sanitize(headers);
 
@@ -75,7 +81,13 @@ export function headersFor(event: CloudEvent): Headers {
   return headers;
 }
 
-export function sanitize(headers: Headers): Record<string, string> {
+/**
+ * Sanitizes incoming headers by lowercasing them and potentially removing
+ * encoding from the content-type header.
+ * @param {Headers} headers HTTP headers as key/value pairs
+ * @returns {Headers} the sanitized headers
+ */
+export function sanitize(headers: Headers): Headers {
   const sanitized: Headers = {};
 
   Array.from(Object.keys(headers))

src/transport/http/structured_emitter.ts

@@ -1,7 +1,6 @@
 import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
 import { CloudEvent } from "../../event";
 import { TransportOptions } from "../emitter";
-import { asBase64, isBinary } from "../../event/validation";
 import CONSTANTS from "../../constants";
 
 const defaults = {
@@ -15,16 +14,7 @@ export function emitStructured(event: CloudEvent, options: TransportOptions): Pr
     ...defaults,
     ...options,
     method: "POST",
-    data: format(event),
+    data: event,
   };
   return axios.request(config as AxiosRequestConfig);
 }
-
-function format(event: CloudEvent): string {
-  if (isBinary(event.data)) {
-    event.data_base64 = asBase64(event.data as Uint32Array);
-  }
-  const json = JSON.stringify(event);
-  delete event.data_base64;
-  return json;
-}

src/transport/http/structured_receiver.ts

@@ -4,14 +4,7 @@ import { Parser, JSONParser } from "../../parsers";
 import { parserByContentType } from "../../parsers";
 import { structuredParsers as v1Parsers } from "./v1/parsers";
 import { structuredParsers as v03Parsers } from "./v03/parsers";
-import {
-  isString,
-  isBase64,
-  ValidationError,
-  isStringOrObjectOrThrow,
-  isBinary,
-  asBase64,
-} from "../../event/validation";
+import { isString, isBase64, ValidationError, isStringOrObjectOrThrow } from "../../event/validation";
 import { CloudEventV1, validateV1 } from "../../event/v1";
 import { CloudEventV03, validateV03 } from "../../event/v03";
 import CONSTANTS from "../../constants";
@@ -64,11 +57,6 @@ export class StructuredHTTPReceiver {
     const eventObj: { [key: string]: unknown } = {};
     const parserMap = this.version === Version.V1 ? v1Parsers : v03Parsers;
 
-    // if the incoming data is in binary form, encode to base64
-    if (isBinary(incoming.data)) {
-      eventObj.data_base64 = asBase64(incoming.data as Buffer);
-    }
-
     parserMap.forEach((value, key) => {
       if (incoming[key]) {
         eventObj[value.name] = value.parser.parse(incoming[key] as string);

test/receiver_structured_0_3_test.ts

@@ -199,7 +199,7 @@ describe("HTTP Transport Binding Structured Receiver CloudEvents v0.3", () => {
       const actual = receiver.parse(payload, headers);
 
       // assert
-      expect(actual.data).to.deep.equal(JSON.stringify(data));
+      expect(actual.data).to.deep.equal(data);
     });
   });
 });

test/spec_03_tests.ts

@@ -167,7 +167,7 @@ describe("CloudEvents Spec v0.3", () => {
       it("should convert data with stringified json to a json object", () => {
         cloudevent.datacontenttype = Constants.MIME_JSON;
         cloudevent.data = JSON.stringify(data);
-        expect(cloudevent.data).to.deep.equal(JSON.stringify(data));
+        expect(cloudevent.data).to.deep.equal(data);
       });
     });
 

test/spec_1_tests.ts

@@ -1,6 +1,6 @@
 import "mocha";
 import { expect } from "chai";
-import { CloudEvent, Version, ValidationError } from "../src";
+import { CloudEvent, Version, ValidationError, asBase64 } from "../src";
 import Constants from "../src/constants";
 
 const id = "97699ec2-a8d9-47c1-bfa0-ff7aa526f838";
@@ -168,37 +168,38 @@ describe("CloudEvents Spec v1.0", () => {
     });
   });
 
-  // describe("Event data constraints", () => {
-  //   it("Should have 'data'", () => {
-  //     expect(cloudevent.data).to.deep.equal(data);
-  //   });
+  describe("Event data constraints", () => {
+    it("Should have 'data'", () => {
+      expect(cloudevent.data).to.deep.equal(data);
+    });
 
-  //   it("should maintain the type of data when no data content type", () => {
-  //     delete cloudevent.spec.payload.datacontenttype;
-  //     cloudevent.data = JSON.stringify(data);
+    it("should maintain the type of data when no data content type", () => {
+      const dct = cloudevent.datacontenttype;
+      delete cloudevent.datacontenttype;
+      cloudevent.data = JSON.stringify(data);
 
-  //     expect(typeof cloudevent.data).to.equal("string");
-  //     cloudevent.dataContentType = dataContentType;
-  //   });
+      expect(typeof cloudevent.data).to.equal("string");
+      cloudevent.datacontenttype = dct;
+    });
 
-  //   it("should convert data with stringified json to a json object", () => {
-  //     cloudevent.dataContentType = dataContentType;
-  //     cloudevent.data = JSON.stringify(data);
-  //     expect(cloudevent.data).to.deep.equal(data);
-  //   });
+    it("should convert data with stringified json to a json object", () => {
+      cloudevent.datacontenttype = Constants.MIME_JSON;
+      cloudevent.data = JSON.stringify(data);
+      expect(cloudevent.data).to.deep.equal(data);
+    });
 
-  //   it("should be ok when type is 'Uint32Array' for 'Binary'", () => {
-  //     const dataString = ")(*~^my data for ce#@#$%";
+    it("should be ok when type is 'Uint32Array' for 'Binary'", () => {
+      const dataString = ")(*~^my data for ce#@#$%";
 
-  //     const dataBinary = Uint32Array.from(dataString, (c) => c.codePointAt(0));
-  //     const expected = asBase64(dataBinary);
-  //     const olddct = cloudevent.dataContentType;
+      const dataBinary = Uint32Array.from(dataString, (c) => c.codePointAt(0) as number);
+      const expected = asBase64(dataBinary);
+      const olddct = cloudevent.datacontenttype;
 
-  //     cloudevent.dataContentType = "text/plain";
-  //     cloudevent.data = dataBinary;
-  //     expect(cloudevent.data).to.deep.equal(expected);
+      cloudevent.datacontenttype = "text/plain";
+      cloudevent.data = dataBinary;
+      expect(cloudevent.data_base64).to.equal(expected);
 
-  //     cloudevent.dataContentType = olddct;
-  //   });
-  // });
+      cloudevent.datacontenttype = olddct;
+    });
+  });
 });