445 lines
17 KiB
TypeScript
445 lines
17 KiB
TypeScript
/*
|
|
Copyright 2021 The CloudEvents Authors
|
|
SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import path from "path";
|
|
import fs from "fs";
|
|
|
|
import { expect } from "chai";
|
|
import { IncomingHttpHeaders } from "http";
|
|
import { CloudEvent, CONSTANTS, V1, V03 } from "../../src";
|
|
import { asBase64 } from "../../src/event/validation";
|
|
import { Message, HTTP } from "../../src/message";
|
|
|
|
const type = "org.cncf.cloudevents.example";
|
|
const source = "urn:event:from:myapi/resource/123";
|
|
const time = new Date().toISOString();
|
|
const subject = "subject.ext";
|
|
const dataschema = "http://cloudevents.io/schema.json";
|
|
const datacontenttype = "application/json";
|
|
const id = "b46cf653-d48a-4b90-8dfa-355c01061361";
|
|
const data = {
|
|
foo: "bar",
|
|
};
|
|
|
|
// Attributes for v03 events
|
|
const schemaurl = "https://cloudevents.io/schema.json";
|
|
|
|
const ext1Name = "extension1";
|
|
const ext1Value = "foobar";
|
|
const ext2Name = "extension2";
|
|
const ext2Value = "acme";
|
|
|
|
// Binary data as base64
|
|
const dataBinary = Uint32Array.from(JSON.stringify(data), (c) => c.codePointAt(0) as number);
|
|
const data_base64 = asBase64(dataBinary);
|
|
|
|
// Since the above is a special case (string as binary), let's test
|
|
// with a real binary file one is likely to encounter in the wild
|
|
const imageData = new Uint32Array(fs.readFileSync(path.join(process.cwd(), "test", "integration", "ce.png")));
|
|
const image_base64 = asBase64(imageData);
|
|
|
|
describe("HTTP transport", () => {
|
|
it("validates extension attribute names for incoming messages", () => {
|
|
// create a new Message
|
|
const msg: Message = {
|
|
headers: {
|
|
"ce-id": "213",
|
|
"ce-source": "test",
|
|
"ce-type": "test",
|
|
"ce-bad-extension": "value"
|
|
},
|
|
body: undefined
|
|
};
|
|
const evt = HTTP.toEvent(msg) as CloudEvent;
|
|
expect(() => evt.validate()).to.throw(TypeError);
|
|
});
|
|
|
|
it("Includes extensions in binary mode when type is 'boolean' with a false value", () => {
|
|
const evt = new CloudEvent({ source: "test", type: "test", extboolean: false });
|
|
expect(evt.hasOwnProperty("extboolean")).to.equal(true);
|
|
expect(evt["extboolean"]).to.equal(false);
|
|
const message = HTTP.binary(evt);
|
|
expect(message.headers.hasOwnProperty("ce-extboolean")).to.equal(true);
|
|
expect(message.headers["ce-extboolean"]).to.equal(false);
|
|
});
|
|
|
|
it("Includes extensions in structured when type is 'boolean' with a false value", () => {
|
|
const evt = new CloudEvent({ source: "test", type: "test", extboolean: false });
|
|
expect(evt.hasOwnProperty("extboolean")).to.equal(true);
|
|
expect(evt["extboolean"]).to.equal(false);
|
|
const message = HTTP.structured(evt);
|
|
const body = JSON.parse(message.body as string);
|
|
expect(body.hasOwnProperty("extboolean")).to.equal(true);
|
|
expect(body.extboolean).to.equal(false);
|
|
});
|
|
|
|
it("Handles big integers in structured mode", () => {
|
|
process.env[CONSTANTS.USE_BIG_INT_ENV] = "true";
|
|
const ce = HTTP.toEvent({
|
|
headers: { "content-type": "application/cloudevents+json" },
|
|
body: `{"data": 1524831183200260097}`
|
|
}) as CloudEvent;
|
|
expect(ce.data).to.equal(1524831183200260097n);
|
|
process.env[CONSTANTS.USE_BIG_INT_ENV] = undefined;
|
|
});
|
|
|
|
it("Handles big integers in binary mode", () => {
|
|
process.env[CONSTANTS.USE_BIG_INT_ENV] = "true";
|
|
const ce = HTTP.toEvent({
|
|
headers: { "content-type": "application/json", "ce-id": "1234" },
|
|
body: `{"data": 1524831183200260097}`
|
|
}) as CloudEvent<Record<string, never>>;
|
|
expect((ce.data as Record<string, never>).data).to.equal(1524831183200260097n);
|
|
process.env[CONSTANTS.USE_BIG_INT_ENV] = undefined;
|
|
});
|
|
|
|
it("Handles events with no content-type and no datacontenttype", () => {
|
|
const body = "{Something[Not:valid}JSON";
|
|
const message: Message<undefined> = {
|
|
body,
|
|
headers: {
|
|
"ce-source": "/test/type",
|
|
"ce-type": "test.type",
|
|
"ce-id": "1234",
|
|
},
|
|
};
|
|
const event: CloudEvent = HTTP.toEvent(message) as CloudEvent;
|
|
expect(event.data).to.equal(body);
|
|
expect(event.datacontentype).to.equal(undefined);
|
|
});
|
|
|
|
it("Can detect invalid CloudEvent Messages", () => {
|
|
// Create a message that is not an actual event
|
|
const message: Message<undefined> = {
|
|
body: "Hello world!",
|
|
headers: {
|
|
"Content-type": "text/plain",
|
|
},
|
|
};
|
|
expect(HTTP.isEvent(message)).to.be.false;
|
|
});
|
|
|
|
it("Can detect valid CloudEvent Messages", () => {
|
|
// Now create a message that is an event
|
|
const message = HTTP.binary(
|
|
new CloudEvent({
|
|
source: "/message-test",
|
|
type: "example",
|
|
data,
|
|
}),
|
|
);
|
|
expect(HTTP.isEvent(message)).to.be.true;
|
|
});
|
|
|
|
it("Handles CloudEvents with datacontenttype of text/plain", () => {
|
|
const message: Message = HTTP.binary(
|
|
new CloudEvent({
|
|
source: "/test",
|
|
type: "example",
|
|
datacontenttype: "text/plain",
|
|
data: "Hello, friends!",
|
|
}),
|
|
);
|
|
const event = HTTP.toEvent(message) as CloudEvent<string>;
|
|
expect(event.validate()).to.be.true;
|
|
});
|
|
|
|
it("Respects extension attribute casing (even if against spec)", () => {
|
|
// Now create a message that is an event
|
|
const message = {
|
|
body: `{ "greeting": "hello" }`,
|
|
headers: {
|
|
[CONSTANTS.CE_HEADERS.ID]: "1234",
|
|
[CONSTANTS.CE_HEADERS.SOURCE]: "test",
|
|
[CONSTANTS.CE_HEADERS.TYPE]: "test.event",
|
|
[CONSTANTS.CE_HEADERS.SPEC_VERSION]: V1,
|
|
"ce-LUNCH": "tacos",
|
|
},
|
|
};
|
|
expect(HTTP.isEvent(message)).to.be.true;
|
|
const event = HTTP.toEvent(message) as CloudEvent;
|
|
expect(event.LUNCH).to.equal("tacos");
|
|
expect(function () {
|
|
event.validate();
|
|
}).to.throw("invalid attribute name: \"LUNCH\"");
|
|
});
|
|
|
|
it("Can detect CloudEvent binary Messages with weird versions", () => {
|
|
// Now create a message that is an event
|
|
const message = {
|
|
body: `{ "greeting": "hello" }`,
|
|
headers: {
|
|
[CONSTANTS.CE_HEADERS.ID]: "1234",
|
|
[CONSTANTS.CE_HEADERS.SOURCE]: "test",
|
|
[CONSTANTS.CE_HEADERS.TYPE]: "test.event",
|
|
[CONSTANTS.CE_HEADERS.SPEC_VERSION]: "11.8",
|
|
},
|
|
};
|
|
expect(HTTP.isEvent(message)).to.be.true;
|
|
const event = HTTP.toEvent(message) as CloudEvent;
|
|
expect(event.specversion).to.equal("11.8");
|
|
expect(event.validate()).to.be.false;
|
|
});
|
|
|
|
it("Can detect CloudEvent structured Messages with weird versions", () => {
|
|
// Now create a message that is an event
|
|
const message = {
|
|
body: `{ "source": "test", "type": "test.event", "specversion": "11.8"}`,
|
|
headers: {
|
|
[CONSTANTS.CE_HEADERS.ID]: "1234",
|
|
},
|
|
};
|
|
expect(HTTP.isEvent(message)).to.be.true;
|
|
expect(HTTP.toEvent(message)).not.to.throw;
|
|
});
|
|
// Allow for external systems to send bad events - do what we can
|
|
// to accept them
|
|
it("Does not throw an exception when converting an invalid Message to a CloudEvent", () => {
|
|
const message: Message<undefined> = {
|
|
body: `"hello world"`,
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"ce-id": "1234",
|
|
"ce-type": "example.bad.event",
|
|
"ce-specversion": "1.0",
|
|
// no required ce-source header, thus an invalid event
|
|
},
|
|
};
|
|
const event = HTTP.toEvent(message) as CloudEvent;
|
|
expect(event).to.be.instanceOf(CloudEvent);
|
|
// ensure that we actually now have an invalid event
|
|
expect(event.validate).to.throw;
|
|
});
|
|
|
|
it("Does not allow an invalid CloudEvent to be converted to a Message", () => {
|
|
const badEvent = new CloudEvent(
|
|
{
|
|
source: "/example.source",
|
|
type: "", // type is required, empty string will throw with strict validation
|
|
},
|
|
false, // turn off strict validation
|
|
);
|
|
expect(() => {
|
|
HTTP.binary(badEvent);
|
|
}).to.throw;
|
|
expect(() => {
|
|
HTTP.structured(badEvent);
|
|
}).to.throw;
|
|
});
|
|
|
|
it("Can be created with Node's IncomingHttpHeaders", () => {
|
|
const headers: IncomingHttpHeaders = {
|
|
"content-type": CONSTANTS.DEFAULT_CE_CONTENT_TYPE,
|
|
};
|
|
const body = JSON.stringify({
|
|
id,
|
|
type,
|
|
source,
|
|
specversion: V1,
|
|
data: { lunch: "tacos" },
|
|
});
|
|
const message: Message<undefined> = {
|
|
headers,
|
|
body,
|
|
};
|
|
const event = HTTP.toEvent(message) as CloudEvent;
|
|
expect(event.data).to.deep.equal({ lunch: "tacos" });
|
|
});
|
|
|
|
describe("Specification version V1", () => {
|
|
const fixture = new CloudEvent({
|
|
specversion: V1,
|
|
id,
|
|
type,
|
|
source,
|
|
datacontenttype,
|
|
subject,
|
|
time,
|
|
dataschema,
|
|
data,
|
|
[ext1Name]: ext1Value,
|
|
[ext2Name]: ext2Value,
|
|
});
|
|
|
|
it("Binary Messages can be created from a CloudEvent", () => {
|
|
const message: Message = HTTP.binary(fixture);
|
|
expect(message.body).to.equal(JSON.stringify(data));
|
|
// validate all headers
|
|
expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(datacontenttype);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SPEC_VERSION]).to.equal(V1);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.ID]).to.equal(id);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.TYPE]).to.equal(type);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SOURCE]).to.equal(source);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SUBJECT]).to.equal(subject);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.TIME]).to.equal(fixture.time);
|
|
expect(message.headers[CONSTANTS.BINARY_HEADERS_1.DATA_SCHEMA]).to.equal(dataschema);
|
|
expect(message.headers[`ce-${ext1Name}`]).to.equal(ext1Value);
|
|
expect(message.headers[`ce-${ext2Name}`]).to.equal(ext2Value);
|
|
});
|
|
|
|
it("Structured Messages can be created from a CloudEvent", () => {
|
|
const message: Message<string> = HTTP.structured(fixture);
|
|
expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(CONSTANTS.DEFAULT_CE_CONTENT_TYPE);
|
|
// Parse the message body as JSON, then validate the attributes
|
|
const body = JSON.parse(message.body as string);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SPEC_VERSION]).to.equal(V1);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.ID]).to.equal(id);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.TYPE]).to.equal(type);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SOURCE]).to.equal(source);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SUBJECT]).to.equal(subject);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.TIME]).to.equal(fixture.time);
|
|
expect(body[CONSTANTS.STRUCTURED_ATTRS_1.DATA_SCHEMA]).to.equal(dataschema);
|
|
expect(body[ext1Name]).to.equal(ext1Value);
|
|
expect(body[ext2Name]).to.equal(ext2Value);
|
|
});
|
|
|
|
it("A CloudEvent can be converted from a binary Message", () => {
|
|
const message = HTTP.binary(fixture);
|
|
const event = HTTP.toEvent(message);
|
|
expect(event).to.deep.equal(fixture);
|
|
});
|
|
|
|
it("A CloudEvent can be converted from a structured Message", () => {
|
|
const message = HTTP.structured(fixture);
|
|
const event = HTTP.toEvent(message);
|
|
expect(event).to.deep.equal(fixture);
|
|
});
|
|
|
|
it("Converts binary data to base64 when serializing structured messages", () => {
|
|
const event = fixture.cloneWith({ data: imageData, datacontenttype: "image/png" });
|
|
expect(event.data).to.equal(imageData);
|
|
const message = HTTP.structured(event);
|
|
const messageBody = JSON.parse(message.body as string);
|
|
expect(messageBody.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Converts base64 encoded data to binary when deserializing structured messages", () => {
|
|
const message = HTTP.structured(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(imageData);
|
|
expect(eventDeserialized.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Does not parse binary data from structured messages with content type application/json", () => {
|
|
const message = HTTP.structured(fixture.cloneWith({ data: dataBinary }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(dataBinary);
|
|
expect(eventDeserialized.data_base64).to.equal(data_base64);
|
|
});
|
|
|
|
it("Converts base64 encoded data to binary when deserializing binary messages", () => {
|
|
const message = HTTP.binary(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(imageData);
|
|
expect(eventDeserialized.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Keeps binary data binary when serializing binary messages", () => {
|
|
const event = fixture.cloneWith({ data: dataBinary });
|
|
expect(event.data).to.equal(dataBinary);
|
|
const message = HTTP.binary(event);
|
|
expect(message.body).to.equal(dataBinary);
|
|
});
|
|
|
|
it("Does not parse binary data from binary messages with content type application/json", () => {
|
|
const message = HTTP.binary(fixture.cloneWith({ data: dataBinary }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(dataBinary);
|
|
expect(eventDeserialized.data_base64).to.equal(data_base64);
|
|
});
|
|
});
|
|
|
|
describe("Specification version V03", () => {
|
|
const fixture = new CloudEvent({
|
|
specversion: V03,
|
|
id,
|
|
type,
|
|
source,
|
|
datacontenttype,
|
|
subject,
|
|
time,
|
|
schemaurl,
|
|
data,
|
|
[ext1Name]: ext1Value,
|
|
[ext2Name]: ext2Value,
|
|
});
|
|
|
|
it("Binary Messages can be created from a CloudEvent", () => {
|
|
const message: Message = HTTP.binary(fixture);
|
|
expect(message.body).to.equal(JSON.stringify(data));
|
|
// validate all headers
|
|
expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(datacontenttype);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SPEC_VERSION]).to.equal(V03);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.ID]).to.equal(id);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.TYPE]).to.equal(type);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SOURCE]).to.equal(source);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.SUBJECT]).to.equal(subject);
|
|
expect(message.headers[CONSTANTS.CE_HEADERS.TIME]).to.equal(fixture.time);
|
|
expect(message.headers[CONSTANTS.BINARY_HEADERS_03.SCHEMA_URL]).to.equal(schemaurl);
|
|
expect(message.headers[`ce-${ext1Name}`]).to.equal(ext1Value);
|
|
expect(message.headers[`ce-${ext2Name}`]).to.equal(ext2Value);
|
|
});
|
|
|
|
it("Structured Messages can be created from a CloudEvent", () => {
|
|
const message: Message = HTTP.structured(fixture);
|
|
expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(CONSTANTS.DEFAULT_CE_CONTENT_TYPE);
|
|
// Parse the message body as JSON, then validate the attributes
|
|
const body = JSON.parse(message.body as string);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SPEC_VERSION]).to.equal(V03);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.ID]).to.equal(id);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.TYPE]).to.equal(type);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SOURCE]).to.equal(source);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.SUBJECT]).to.equal(subject);
|
|
expect(body[CONSTANTS.CE_ATTRIBUTES.TIME]).to.equal(fixture.time);
|
|
expect(body[CONSTANTS.STRUCTURED_ATTRS_03.SCHEMA_URL]).to.equal(schemaurl);
|
|
expect(body[ext1Name]).to.equal(ext1Value);
|
|
expect(body[ext2Name]).to.equal(ext2Value);
|
|
});
|
|
|
|
it("A CloudEvent can be converted from a binary Message", () => {
|
|
const message = HTTP.binary(fixture);
|
|
const event = HTTP.toEvent(message);
|
|
expect(event).to.deep.equal(fixture);
|
|
});
|
|
|
|
it("A CloudEvent can be converted from a structured Message", () => {
|
|
const message = HTTP.structured(fixture);
|
|
const event = HTTP.toEvent(message);
|
|
expect(event).to.deep.equal(fixture);
|
|
});
|
|
|
|
it("Converts binary data to base64 when serializing structured messages", () => {
|
|
const event = fixture.cloneWith({ data: imageData, datacontenttype: "image/png" });
|
|
expect(event.data).to.equal(imageData);
|
|
const message = HTTP.structured(event);
|
|
const messageBody = JSON.parse(message.body as string);
|
|
expect(messageBody.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Converts base64 encoded data to binary when deserializing structured messages", () => {
|
|
// Creating an event with binary data automatically produces base64 encoded data
|
|
// which is then set as the 'data' attribute on the message body
|
|
const message = HTTP.structured(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(imageData);
|
|
expect(eventDeserialized.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Converts base64 encoded data to binary when deserializing binary messages", () => {
|
|
const message = HTTP.binary(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
|
|
const eventDeserialized = HTTP.toEvent(message) as CloudEvent<Uint32Array>;
|
|
expect(eventDeserialized.data).to.deep.equal(imageData);
|
|
expect(eventDeserialized.data_base64).to.equal(image_base64);
|
|
});
|
|
|
|
it("Keeps binary data binary when serializing binary messages", () => {
|
|
const event = fixture.cloneWith({ data: dataBinary });
|
|
expect(event.data).to.equal(dataBinary);
|
|
const message = HTTP.binary(event);
|
|
expect(message.body).to.equal(dataBinary);
|
|
});
|
|
});
|
|
});
|