@code-o-mat/globals/test/o-mat-type-validations-and-assertions.js

Abstract Package to support CodeOMat series of apps.

import Bunyan from 'bunyan';
const  log = Bunyan.createLogger({name: "KernelTest"});

import 'mocha';
import { expect } from 'chai';

import * as FakeOMats from './test-objects';

const codePath
        = process.env.NODE_ENV === "PRODUCTION"
          ? 'lib' : 'src';

const TYPES = require(`../${codePath}/constants/types`);
const { 
  O_MAT,
  METHOD_O_MAT,
  ACCESSOR_O_MAT,
  CONNECTOR_O_MAT,
  CLASS_O_MAT,
  CODE_O_MAT,
} = TYPES;


const { 
  OMat,
  MethodOMat, 
  AccessorOMat,
  ConnectorOMat,
  ClassOMat,
  CodeOMat,
} = FakeOMats;

const validations = require(`../${codePath}/validations/o-mat-types`);
const { 
  isOMat,
  isMethodOMat,
  isAccessorOMat,
  isConnectorOMat,
  isClassOMat,
  isCodeOMat,
} = validations;

const assertions = require(`../${codePath}/assertions/o-mat-types`);
const { 
  assertIsOMat,
  assertIsMethodOMat,
  assertIsAccessorOMat,
  assertIsConnectorOMat,
  assertIsClassOMat,
  assertIsCodeOMat,
} = assertions;

describe( 
  `Test of the OMatGlobals OMat Validations`,
  () => {

    let methodOMat;
    let accessorOMat;
    let connectorOMat;
    let classOMat;
    let codeOMat;

    let oMats;

    before(
      () => { 
        methodOMat = new MethodOMat();
        accessorOMat = new AccessorOMat();
        connectorOMat = new ConnectorOMat();
        classOMat = new ClassOMat();
        codeOMat = new CodeOMat();

        oMats = [ 
          methodOMat,
          accessorOMat,
          connectorOMat,
          classOMat,
          codeOMat,
        ];
      }
    );

    it(`all the classes should be OMat derived types`,
      () => { 
        Object.keys(FakeOMats).forEach(
          (key) => {
            const OMat = FakeOMats[key];
            expect(isOMat(OMat)).to.equal(true);
            expect(()=>assertIsOMat(OMat)).to.not.throw(Error);
          }
        );
      }
    );

    it(`test validation and assertion for MethodOMat`,
      () => { 
        expect(MethodOMat.TYPE).to.equal(METHOD_O_MAT);
        expect(isMethodOMat(MethodOMat)).to.equal(true);
        expect(()=>assertIsMethodOMat(MethodOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for AccessorOMat`,
      () => { 
        expect(AccessorOMat.TYPE).to.equal(ACCESSOR_O_MAT);
        expect(isAccessorOMat(AccessorOMat)).to.equal(true);
        expect(()=>assertIsAccessorOMat(AccessorOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for ConnectorOMat`,
      () => { 
        expect(ConnectorOMat.TYPE).to.equal(CONNECTOR_O_MAT);
        expect(isConnectorOMat(ConnectorOMat)).to.equal(true);
        expect(()=>assertIsConnectorOMat(ConnectorOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for ClassOMat`,
      () => { 
        expect(ClassOMat.TYPE).to.equal(CLASS_O_MAT);
        expect(isClassOMat(ClassOMat)).to.equal(true);
        expect(()=>assertIsClassOMat(ClassOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for CodeOMat`,
      () => { 
        expect(CodeOMat.TYPE).to.equal(CODE_O_MAT);
        expect(isCodeOMat(CodeOMat)).to.equal(true);
        expect(()=>assertIsCodeOMat(CodeOMat)).to.not.throw(Error);        
      }
    );

    it(`all the OMat instances should be OMat derived types`,
      () => { 
        oMats.forEach(
          (oMat) => { 
            expect(isOMat(OMat)).to.equal(true);
            expect(()=>assertIsOMat(oMat)).to.not.throw(Error);
          }
        );
      }
    );

    it(`test validation and assertion for MethodOMat instance`,
      () => { 
        expect(methodOMat.TYPE).to.equal(METHOD_O_MAT);
        expect(isMethodOMat(methodOMat)).to.equal(true);
        expect(()=>assertIsMethodOMat(methodOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for AccessorOMat instance`,
      () => { 
        expect(accessorOMat.TYPE).to.equal(ACCESSOR_O_MAT);
        expect(isAccessorOMat(accessorOMat)).to.equal(true);
        expect(()=>assertIsAccessorOMat(accessorOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for ConnectorOMat instance`,
      () => { 
        expect(connectorOMat.TYPE).to.equal(CONNECTOR_O_MAT);
        expect(isConnectorOMat(connectorOMat)).to.equal(true);
        expect(()=>assertIsConnectorOMat(connectorOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for ClassOMat instance`,
      () => { 
        expect(classOMat.TYPE).to.equal(CLASS_O_MAT);
        expect(isClassOMat(classOMat)).to.equal(true);
        expect(()=>assertIsClassOMat(classOMat)).to.not.throw(Error);        
      }
    );

    it(`test validation and assertion for CodeOMat`,
      () => { 
        expect(CodeOMat.TYPE).to.equal(CODE_O_MAT);
        expect(isCodeOMat(CodeOMat)).to.equal(true);
        expect(()=>assertIsCodeOMat(CodeOMat)).to.not.throw(Error);        
      }
    );


  }
);