fixup: make send accept an alternate URL

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

Author: lance

lib/bindings/http/http_emitter.js

@@ -18,35 +18,46 @@ class HTTPEmitter {
    * Creates a new instance of {HTTPEmitter}. The default emitter uses the 1.0
    * protocol specification in binary mode.
    *
-   * @param {string} [version] The HTTP binding specification version. Default: "1.0"
+   * @param {Object} [options] The configuration options for this event emitter
+   * @param {URL} options.url The endpoint that will receive the sent events.
+   * @param {string} [options.version] The HTTP binding specification version. Default: "1.0"
    * @throws {TypeError} if no options.url is provided or an unknown specification version is provided.
    */
-  constructor(version = SPEC_V1) {
+  constructor({ url, version = SPEC_V1 } = {}) {
     if (version !== SPEC_V03 && version !== SPEC_V1) {
       throw new TypeError(
         `Unknown CloudEvent specification version: ${version}`);
     }
+    if (!url) {
+      throw new TypeError("A default endpoint URL is required for a CloudEvent emitter");
+    }
     this.binary = new BinaryHTTPEmitter(version);
     this.structured = new StructuredEmitter();
+    this.url = url;
   }
 
   /**
    * Sends the {CloudEvent} to an event receiver over HTTP POST
    *
-   * @param {Object} options The configuration options for this event. Options
+   * @param {CloudEvent} event the CloudEvent to be sent
+   * @param {Object} [options] The configuration options for this event. Options
    * provided will be passed along to Node.js `http.request()`.
    * https://nodejs.org/api/http.html#http_http_request_options_callback
-   * @param {URL} options.url The HTTP/S url that should receive this event
-   * @param {CloudEvent} event the CloudEvent to be sent
-   * @param {string} [mode] the message mode for sending this event.
+   * @param {URL} [options.url] The HTTP/S url that should receive this event.
+   * The URL is optional if one was provided when this emitter was constructed.
+   * In that case, it will be used as the recipient endpoint. The endpoint can
+   * be overridden by providing a URL here.
+   * @param {string} [options.mode] the message mode for sending this event.
    * Possible values are "binary" and "structured". Default: structured
    * @returns {Promise} Promise with an eventual response from the receiver
    */
-  send(options, event, mode = "binary") {
+  send(event, { url, mode = "binary", ...httpOpts } = {}) {
+    if (!url) { url = this.url; }
+    httpOpts.url = url;
     if (mode === "binary") {
-      return this.binary.emit(options, event);
+      return this.binary.emit(httpOpts, event);
     } else if (mode === "structured") {
-      return this.structured.emit(options, event);
+      return this.structured.emit(httpOpts, event);
     }
     throw new TypeError(`Unknown transport mode ${mode}.`);
   }

test/bindings/http/http_emitter_test.js

@@ -45,7 +45,7 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
   });
 
   describe("V1", () => {
-    const emitter = new HTTPEmitter();
+    const emitter = new HTTPEmitter({ url: receiver });
     const event = new CloudEvent(V1Spec)
       .type(type)
       .source(source)
@@ -55,7 +55,7 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
       .addExtension(ext2Name, ext2Value);
 
     it("Sends a binary 1.0 CloudEvent by default", () => {
-      emitter.send({ url: receiver }, event)
+      emitter.send(event)
         .then((response) => {
           // A binary message will have a ce-id header
           expect(response.data[BINARY_HEADERS_1.ID]).to.equal(event.getId());
@@ -65,8 +65,36 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
         }).catch(expect.fail);
     });
 
-    it("Sends a structured 1.0 CloudEvent if created that way", () => {
-      emitter.send({ url: receiver }, event, "structured")
+    it("Sends a structured 1.0 CloudEvent if specified", () => {
+      emitter.send(event, { mode: "structured" })
+        .then((response) => {
+          // A structured message will have a cloud event content type
+          expect(response.data["content-type"]).to.equal(DEFAULT_CE_CONTENT_TYPE);
+          // Ensure other CE headers don't exist - just testing for ID
+          expect(response.data[BINARY_HEADERS_1.ID]).to.equal(undefined);
+          // The spec version would have been specified in the body
+          expect(response.data.specversion).to.equal(SPEC_V1);
+          expect(response.data.data.lunchBreak).to.equal(data.lunchBreak);
+        }).catch(expect.fail);
+    });
+
+    it("Sends to an alternate URL if specified", () => {
+      nock(receiver)
+        .post("/alternate")
+        .reply(function(uri, requestBody) {
+          // return the request body and the headers so they can be
+          // examined in the test
+          if (typeof requestBody === "string") {
+            requestBody = JSON.parse(requestBody);
+          }
+          const returnBody = { ...requestBody, ...this.req.headers };
+          return [
+            201,
+            returnBody
+          ];
+        });
+
+      emitter.send(event, { mode: "structured", url: `${receiver}alternate` })
         .then((response) => {
           // A structured message will have a cloud event content type
           expect(response.data["content-type"]).to.equal(DEFAULT_CE_CONTENT_TYPE);
@@ -80,7 +108,7 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
   });
 
   describe("V03", () => {
-    const emitter = new HTTPEmitter(SPEC_V03);
+    const emitter = new HTTPEmitter({ url: receiver, version: SPEC_V03 });
     const event = new CloudEvent(V03Spec)
       .type(type)
       .source(source)
@@ -90,7 +118,7 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
       .addExtension(ext2Name, ext2Value);
 
     it("Sends a binary 0.3 CloudEvent", () => {
-      emitter.send({ url: receiver }, event)
+      emitter.send(event)
         .then((response) => {
           // A binary message will have a ce-id header
           expect(response.data[BINARY_HEADERS_03.ID]).to.equal(event.getId());
@@ -100,8 +128,35 @@ describe("HTTP Transport Binding Emitter for CloudEvents", () => {
         }).catch(expect.fail);
     });
 
-    it("Sends a structured 0.3 CloudEvent", () => {
-      emitter.send({ url: receiver }, event, "structured")
+    it("Sends a structured 0.3 CloudEvent if specified", () => {
+      emitter.send(event, { mode: "structured", foo: "bar" })
+        .then((response) => {
+          // A structured message will have a cloud event content type
+          expect(response.data["content-type"]).to.equal(DEFAULT_CE_CONTENT_TYPE);
+          // Ensure other CE headers don't exist - just testing for ID
+          expect(response.data[BINARY_HEADERS_03.ID]).to.equal(undefined);
+          // The spec version would have been specified in the body
+          expect(response.data.specversion).to.equal(SPEC_V03);
+          expect(response.data.data.lunchBreak).to.equal(data.lunchBreak);
+        }).catch(expect.fail);
+    });
+    it("Sends to an alternate URL if specified", () => {
+      nock(receiver)
+        .post("/alternate")
+        .reply(function(uri, requestBody) {
+          // return the request body and the headers so they can be
+          // examined in the test
+          if (typeof requestBody === "string") {
+            requestBody = JSON.parse(requestBody);
+          }
+          const returnBody = { ...requestBody, ...this.req.headers };
+          return [
+            201,
+            returnBody
+          ];
+        });
+
+      emitter.send(event, { mode: "structured", url: `${receiver}alternate` })
         .then((response) => {
           // A structured message will have a cloud event content type
           expect(response.data["content-type"]).to.equal(DEFAULT_CE_CONTENT_TYPE);

test/sdk_test.js

@@ -19,7 +19,9 @@ describe("The SDK Requirements", () => {
   });
 
   it("should expose an HTTPEmitter type", () => {
-    const emitter = new HTTPEmitter();
+    const emitter = new HTTPEmitter({
+      url: "http://example.com"
+    });
     expect(emitter instanceof HTTPEmitter).to.equal(true);
   });