express-prom-bundle/spec/index.spec.js

'use strict';
/* eslint-env jasmine */

const express = require('express');
const supertest = require('supertest');
const bundle = require('../');
const koa = require('koa');
const c2k = require('koa-connect');
const supertestKoa = require('supertest-koa-agent');
const promClient = require('prom-client');

describe('index', () => {
  beforeEach(() => {
    promClient.register.clear();
  });

  it('metrics returns up=1', done => {
    const app = express();
    const bundled = bundle({
      whitelist: ['up']
    });
    app.use(bundled);
    app.use('/test', (req, res) => res.send('it worked'));

    const agent = supertest(app);
    agent.get('/test').end(() => {
      agent
        .get('/metrics')
        .end((err, res) => {
          expect(res.status).toBe(200);
          expect(res.text).toMatch(/up\s1/);
          done();
        });
    });
  });

  it('metrics should be attached to /metrics by default', done => {
    const app = express();
    const bundled = bundle({
      whitelist: ['up']
    });
    app.use(bundled);

    const agent = supertest(app);
    agent.get('/metrics')
      .end((err, res) => {
        expect(res.status).toBe(200);
        done();
      });
  });

  it('metrics can be attached to /metrics programatically', done => {
    const app = express();
    const bundled = bundle({
      autoregister: false
    });
    app.use(bundled.metricsMiddleware);
    app.use(bundled);

    app.use('/test', (req, res) => res.send('it worked'));

    const agent = supertest(app);
    agent.get('/metrics')
      .end((err, res) => {
        expect(res.status).toBe(200);
        done();
      });
  });

  it('metrics can be filtered using exect match', () => {
    const instance = bundle({blacklist: ['up']});
    expect(instance.metrics.up).not.toBeDefined();
    expect(instance.metrics.http_request_duration_seconds).toBeDefined();
  });
  it('metrics can be filtered using regex', () => {
    const instance = bundle({blacklist: [/http/]});
    expect(instance.metrics.up).toBeDefined();
    expect(instance.metrics.http_request_duration_seconds).not.toBeDefined();
  });
  it('metrics can be whitelisted', () => {
    const instance = bundle({whitelist: [/^up$/]});
    expect(instance.metrics.up).toBeDefined();
    expect(instance.metrics.nodejs_memory_heap_total_bytes).not.toBeDefined();
    expect(instance.metrics.http_request_duration_seconds).not.toBeDefined();
  });
  it('throws on both white and blacklist', () => {
    expect(() => {
      bundle({whitelist: [/up/], blacklist: [/up/]});
    }).toThrow();
  });
  it('returns error 500 on incorrect middleware usage', done => {
    const app = express();
    app.use(bundle);
    supertest(app)
      .get('/metrics')
      .end((err, res) => {
        expect(res.status).toBe(500);
        done();
      });
  });
  it('http latency gets counted', done => {
    const app = express();
    const instance = bundle();
    app.use(instance);
    app.use('/test', (req, res) => res.send('it worked'));
    const agent = supertest(app);
    agent
      .get('/test')
      .end(() => {
        const metricHashMap = instance.metrics.http_request_duration_seconds.hashMap;
        expect(metricHashMap['status_code:200']).toBeDefined();
        const labeled = metricHashMap['status_code:200'];
        expect(labeled.count).toBe(1);

        agent
          .get('/metrics')
          .end((err, res) => {
            expect(res.status).toBe(200);
            done();
          });
      });
  });

  it('filters out the excludeRoutes', done => {
    const app = express();
    const instance = bundle({
      excludeRoutes: ['/test']
    });
    app.use(instance);
    app.use('/test', (req, res) => res.send('it worked'));
    const agent = supertest(app);
    agent
      .get('/test')
      .end(() => {
        const metricHashMap = instance.metrics.http_request_duration_seconds.hashMap;
        expect(metricHashMap['status_code:200']).not.toBeDefined();

        agent
          .get('/metrics')
          .end((err, res) => {
            expect(res.status).toBe(200);
            done();
          });
      });
  });

  it('complains about deprecated options', () => {
    expect(() => bundle({prefix: 'hello'})).toThrow();
  });

  it('tolerates includePath, includeMethod', done => {
    const app = express();
    const instance = bundle({
      includePath: true,
      includeMethod: true
    });
    app.use(instance);
    app.use('/test', (req, res) => res.send('it worked'));
    const agent = supertest(app);
    agent
      .get('/test')
      .end(() => {
        agent
          .get('/metrics')
          .end((err, res) => {
            expect(res.status).toBe(200);
            done();
          });
      });
  });

  it('Koa: metrics returns up=1', done => {
    const app = koa();
    const bundled = bundle({
      whitelist: ['up']
    });
    app.use(c2k(bundled));

    app.use(function*(next) {
      if (this.path !== 'test') {
        return yield next;
      }
      this.body = 'it worked';
    });

    const agent = supertestKoa(app);
    agent.get('/test').end(() => {
      agent
        .get('/metrics')
        .end((err, res) => {
          expect(res.status).toBe(200);
          expect(res.text).toMatch(/^up\s1/m);
          done();
        });
    });
  });
});