cloud_oadr-vtn/__tests__/unit/processes/registration.spec.js

'use strict';

const { expect } = require('chai');
const { v4 } = require('uuid');
const rewire = require('rewire');

const FakeNantumModule = require('../utils/fake-nantum-module');

describe('VEN registration', function() {
  let rewired;

  before(async () => {
    rewired = rewire('../../../processes/registration.js');
    rewired.__set__({
      nantum: new FakeNantumModule(),
    });
  });

  describe('registerParty', function() {
    let venId, commonName, registrationResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      registrationResponse = await rewired.registerParty(
        request,
        commonName,
        venId,
      );
    });

    it('allows registration of a new VEN', async () => {
      expect(registrationResponse.registrationId).to.be.a('string');
    });

    it('rejects VEN with non-matching venId', async () => {
      const venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      const commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let exception;
      try {
        await rewired.registerParty(request, commonName, `${venId}:FF`);
      } catch (e) {
        exception = e;
      }

      expect(exception).is.an('error');
      expect(exception.message).to.eql('VenID does not match certificate');
    });

    it('rejects registration when common name changes', async () => {
      const requestId = v4().replace(/-/g, '');
      const commonName2 = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let exception;
      try {
        await rewired.registerParty(request, commonName2, venId);
      } catch (e) {
        exception = e;
      }

      expect(exception).is.an('error');
      expect(exception.message).to.eql('Client certificate CN mismatch');
    });
  });

  describe('query', function() {
    let venId, commonName, queryResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
      };
      queryResponse = await rewired.query(request, commonName, venId);
    });

    it('does not return venId or registrationId for new device', async () => {
      expect(queryResponse.registrationId).to.be.undefined;
      expect(queryResponse.venId).to.be.undefined;
    });

    it('returns registrationId if already registered', async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const registerRequest = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      const registrationResponse = await rewired.registerParty(
        registerRequest,
        commonName,
        venId,
      );
      const initialRegistrationId = registrationResponse.registrationId;

      const queryRequest = {
        requestId: requestId,
      };
      queryResponse = await rewired.query(queryRequest, commonName, venId);
      expect(queryResponse.registrationId).to.eql(initialRegistrationId);
      expect(queryResponse.venId).to.eql(venId);
    });

    it('rejects XMPP client', async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const registerRequest = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'xmpp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let lastError;
      try {
        await rewired.registerParty(registerRequest, commonName, venId);
      } catch (e) {
        lastError = e;
      }
      expect(lastError).to.be.an('error');
      expect(lastError.message).to.eql('Transport name must be simpleHttp');
    });

    it('rejects 2.0a client', async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const registerRequest = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0a',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };

      let lastError;
      try {
        await rewired.registerParty(registerRequest, commonName, venId);
      } catch (e) {
        lastError = e;
      }
      expect(lastError).to.be.an('error');
      expect(lastError.message).to.eql('Profile name must be 2.0b');
    });
  });

  describe('cancelParty', function() {
    let venId, commonName, registrationResponse;

    beforeEach(async () => {
      venId = v4()
        .replace(/-/g, '')
        .substring(0, 20)
        .toUpperCase()
        .match(/.{2}/g)
        .join(':');
      const requestId = v4().replace(/-/g, '');
      commonName = v4()
        .replace(/-/g, '')
        .substring(0, 12);
      const request = {
        requestId: requestId,
        venId: venId,
        oadrProfileName: '2.0b',
        oadrTransportName: 'simpleHttp',
        oadrReportOnly: false,
        oadrXmlSignature: false,
        oadrVenName: `VEN ${commonName}`,
        oadrHttpPullModel: true,
      };
      registrationResponse = await rewired.registerParty(
        request,
        commonName,
        venId,
      );
    });

    it('successfully cancels an existing registration', async () => {
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        registrationId: registrationResponse.registrationId,
        venId: venId,
      };

      const cancelResponse = await rewired.cancelParty(
        cancelRequest,
        commonName,
        venId,
      );
      expect(cancelResponse.responseCode).to.eql('200');
      expect(cancelResponse.responseDescription).to.eql('OK');
      expect(cancelResponse.responseRequestId).to.eql(cancelRequestId);
      expect(cancelResponse.venId).to.eql(venId);
    });

    it('fails if venID does not match certificate', async () => {
      const otherVenId = v4().replace(/-/g, '');
      const cancelRequestId = v4().replace(/-/g, '');
      const cancelRequest = {
        requestId: cancelRequestId,
        registrationId: registrationResponse.registrationId,
        venId: venId,
      };

      let error;
      try {
        await rewired.cancelParty(cancelRequest, commonName, otherVenId);
      } catch (e) {
        error = e;
      }
      expect(error).to.be.an('error');
      expect(error.message).to.eql('VenID does not match certificate');
    });

  });
});