@tvkitchen/countertop/dist/tools/utils/__tests__/jest.unit.test.js

The entry point for developers who want to set up a TV Kitchen.

"use strict";

var _baseInterfaces = require("@tvkitchen/base-interfaces");

var _classes = require("../../../classes");

var _jest = require("../jest");

describe('jest', () => {
  describe('loadTestData', () => {
    it('should load data when valid json is provided', () => {
      expect((0, _jest.loadTestData)(__dirname, 'loadTestData.json')).toEqual(['this loads valid json']);
    });
  });
  describe('generateMockAppliance', () => {
    it('Should generate an IAppliance with the proper input / output types', () => {
      const MockAppliance = (0, _jest.generateMockAppliance)({
        inputTypes: ['foo'],
        outputTypes: ['bar']
      });
      const mockAppliance = new MockAppliance();
      expect(_baseInterfaces.IAppliance.isIAppliance(mockAppliance)).toBe(true);
      expect(MockAppliance.getInputTypes()).toEqual(['foo']);
      expect(MockAppliance.getOutputTypes()).toEqual(['bar']);
    });
    it('Should generate an IAppliance with custom input / output type getters', () => {
      const MockAppliance = (0, _jest.generateMockAppliance)({
        getInputTypes: settings => settings.inputTypes,
        getOutputTypes: settings => settings.outputTypes
      });
      const mockAppliance = new MockAppliance();
      const mockSettings = {
        inputTypes: ['foo'],
        outputTypes: ['bar']
      };
      expect(_baseInterfaces.IAppliance.isIAppliance(mockAppliance)).toBe(true);
      expect(MockAppliance.getInputTypes(mockSettings)).toEqual(['foo']);
      expect(MockAppliance.getOutputTypes(mockSettings)).toEqual(['bar']);
    });
  });
  describe('normalizeTributaryMap', () => {
    it('should replace stations with the correct index in a single tributary map', () => {
      const stationA = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationB = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo'],
        outputTypes: ['bar', 'baz']
      }));
      const stationC = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationD = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo', 'bar'],
        outputTypes: ['baz']
      }));
      const stations = [stationA, stationB, stationC, stationD];
      const streamA = new _classes.CountertopStream(stationA);
      const streamB = new _classes.CountertopStream(stationB, new Map([['foo', streamA]]));
      const tributaryMap = new Map([['foo', streamA], ['bar', streamB]]);
      const result = (0, _jest.normalizeTributaryMap)(tributaryMap, stations);
      expect(result).toMatchSnapshot();
    });
  });
  describe('normalizeTributaryMaps', () => {
    it('should replace stations with correct index in an array of tributary maps', () => {
      const stationA = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationB = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo'],
        outputTypes: ['bar', 'baz']
      }));
      const stationC = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationD = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo', 'bar'],
        outputTypes: ['baz']
      }));
      const stations = [stationA, stationB, stationC, stationD];
      const streamA = new _classes.CountertopStream(stationA);
      const streamB = new _classes.CountertopStream(stationB, new Map([['foo', streamA]]));
      const streamC = new _classes.CountertopStream(stationC);
      const tributaryMapA = new Map([['foo', streamA], ['bar', streamB]]);
      const tributaryMapB = new Map([['foo', streamC]]);
      const tributaryMaps = [tributaryMapA, tributaryMapB];
      const result = (0, _jest.normalizeTributaryMaps)(tributaryMaps, stations);
      expect(result).toMatchSnapshot();
    });
  });
  describe('normalizeStream', () => {
    it('should replace stations with the correct index in a stream', () => {
      const stationA = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationB = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo'],
        outputTypes: ['bar', 'baz']
      }));
      const stationC = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationD = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo', 'bar'],
        outputTypes: ['baz']
      }));
      const stations = [stationA, stationB, stationC, stationD];
      const streamA = new _classes.CountertopStream(stationA);
      const streamB = new _classes.CountertopStream(stationB, new Map([['foo', streamA]]));
      const result = (0, _jest.normalizeStream)(streamB, stations);
      expect(result).toMatchSnapshot();
    });
  });
  describe('normalizeStreams', () => {
    it('should replace stations with the correct index in an array of streams', () => {
      const stationA = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationB = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo'],
        outputTypes: ['bar', 'baz']
      }));
      const stationC = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: [],
        outputTypes: ['foo']
      }));
      const stationD = new _classes.CountertopStation((0, _jest.generateMockAppliance)({
        inputTypes: ['foo', 'bar'],
        outputTypes: ['baz']
      }));
      const stations = [stationA, stationB, stationC, stationD];
      const streamA = new _classes.CountertopStream(stationA);
      const streamB = new _classes.CountertopStream(stationB, new Map([['foo', streamA]]));
      const streams = [streamA, streamB];
      const result = (0, _jest.normalizeStreams)(streams, stations);
      expect(result).toMatchSnapshot();
    });
  });
});