Integration tests (#37)

.eslintrc

@@ -1,10 +1,13 @@
 {
   "extends": "strongloop",
   "env": {
-    "node": true
+    "node": true,
+    "es6": true
   },
-  "parserOptions": { "ecmaVersion": 6 },
+  "parserOptions": { "ecmaVersion": 9 },
   "globals": {
+    "before": true,
+    "after": true,
     "describe": true,
     "it": true,
     "xit": true

.travis.yml

@@ -3,3 +3,9 @@ node_js:
   - "8"
   - "6"
   - "node"
+sudo: required
+services:
+  - docker
+before_install:
+  - docker run -d -p 9411:9411 openzipkin/zipkin
+  - while netstat -lnt | awk '$4 ~ /:9411$/ {exit 1}'; do sleep 10; done

package.json

@@ -15,11 +15,14 @@
     "eslint": "^3.14.1",
     "eslint-config-strongloop": "^2.1.0",
     "mocha": "^5.2.0",
+    "request-promise-native": "1.0.5",
     "sinon": "^6.1.3",
     "tap": "^10.0.1"
   },
   "scripts": {
-    "test": "mocha test/",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:unit": "mocha test/unit/",
+    "test:integration": "mocha -t 3000 test/integration/",
     "pretest": "eslint .",
     "pretravis": "eslint .",
     "travis": ""

test/integration/request.test.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { expect } = require('chai');
+
+const { request, createServer } = require('../utils/http');
+const { getTraces } = require('../utils/zipkinQuery');
+
+const zipkinHost = '127.0.0.1';
+const zipkinPort = 9411;
+const zipkinSampleRate = 1.0;
+const serviceName = 'frontend';
+
+function waitAndGetTraces() {
+  return new Promise(resolve => {
+    setTimeout(() => { // We want to let all background requests going to zipkin complete
+      resolve(getTraces({ zipkinHost, zipkinPort, serviceName }));
+    }, 1000);
+  });
+}
+
+describe('http requests', () => {
+  describe('outbound requests', () => {
+    let server;
+    let http;
+
+    before(() => {
+      require('../../')({
+        host: zipkinHost,
+        port: zipkinPort,
+        sampleRate: zipkinSampleRate,
+        serviceName
+      });
+
+      http = require('http');
+      return createServer({ http, port: 3000 })
+        .then(createdServer => {
+          server = createdServer;
+        });
+    });
+    after(() => {
+      if (server) server.close();
+    });
+    it('should reach zipkin with a simple http request (string options)', () => {
+      let outgoingTraceId;
+      return request({ http, options: 'http://localhost:3000' })
+        .then(({ request }) => {
+          const outgoingHeaders = request._headers;
+          outgoingTraceId = outgoingHeaders['x-b3-traceid'];
+        })
+        .then(waitAndGetTraces)
+        .then((traces) => {
+          expect(traces.length > 0).to.be.ok;
+          expect(traces.some(trace => trace[0].traceId === outgoingTraceId)).to.be.ok;
+        });
+    });
+    it('should reach zipkin with a simple http request (object options)', () => {
+      let outgoingTraceId;
+      return request({ http, options: { hostname: 'localhost', port: 3000 } })
+        .then(({ request }) => {
+          const outgoingHeaders = request._headers;
+          outgoingTraceId = outgoingHeaders['x-b3-traceid'];
+        })
+        .then(waitAndGetTraces)
+        .then((traces) => {
+          expect(traces.length > 0).to.be.ok;
+          expect(traces.some(trace => trace[0].traceId === outgoingTraceId)).to.be.ok;
+        });
+    });
+  });
+});

test/aspect.test.js → test/unit/aspect.test.js

@@ -2,7 +2,7 @@
 
 const { expect } = require('chai');
 const { stub } = require('sinon');
-const { before, after, around, findCallbackArg, aroundCallback } = require('../lib/aspect');
+const { before, after, around, findCallbackArg, aroundCallback } = require('../../lib/aspect');
 describe('aspect', () => {
   describe('before', () => {
     it('should call hook before target method', () => {
@@ -13,6 +13,15 @@ describe('aspect', () => {
       testObj.a();
       expect(hookStub.calledBefore(origStub)).to.be.ok;
     });
+    it('should pass original arguments', () => {
+      const origStub = stub();
+      const hookStub = stub();
+      const testObj = { a: origStub };
+      before(testObj, ['a'], hookStub);
+      const testString = 'This is a test string';
+      testObj.a(testString);
+      expect(origStub.calledWith(testString)).to.be.ok;
+    });
   });
   describe('after', () => {
     it('should call hook after target method', () => {

test/utils/http.js

@@ -0,0 +1,21 @@
+'use strict';
+
+module.exports.request = ({ http, options }) => {
+  return new Promise(resolve => {
+    http.get(options, (res) => {
+      resolve({ request: res.req, response: res });
+    });
+  });
+};
+
+module.exports.createServer = ({ http, port }) => {
+  return new Promise((resolve) => {
+    let server = http.createServer(function(req, res) {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('Hello World\n');
+    });
+    server.listen(port, function() {
+      resolve(server);
+    });
+  });
+};

test/utils/zipkinQuery.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const request = require('request-promise-native');
+
+const url = ({ zipkinHost, zipkinPort }) => `http://${zipkinHost}:${zipkinPort}`;
+
+module.exports.getTraces = ({ zipkinHost, zipkinPort, serviceName }) => {
+  const zipkinUrl = url({ zipkinHost, zipkinPort });
+  return request({
+    url: `${zipkinUrl}/api/v2/traces`,
+    qs: {
+      serviceName
+    },
+    json: true
+  });
+};
+