class-o-mat/test/singleton-child-test.js

ALPHA VERSION ONLY: class-o-mats will help to create getter-setter functionality with validations that can be attached to a container class for easier coding. Some basic validations are included. class-o-mats also has the ability to store params as bloc

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

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

import { NONE, 
        TEST_CLASS, 
        CLASS_O_MAT,
        FIELD_O_MAT, 
        RADIO_O_MAT,
         } from '../src/constants';
         
import ClassOMat from '../src/class-o-mat';

describe(`Test of singleton child`,
  ()=>{ 

    class TestClass { 
      TYPE = 'TEST';
    }

    class ChildClass { 
      TYPE = 'CHILD';
    }

    var classOMat;
    var childOMat;
    var testClass;

    it(`create a basic classOMat created class`,
      ()=>{ 
        classOMat = new ClassOMat('classOMat');
        classOMat.BaseClass(TestClass)
                 .$();
        testClass = new (classOMat.$())();
        expect(classOMat.TYPE).to.equal(CLASS_O_MAT);
        expect(testClass.TYPE).to.equal('TEST');
      }
    );

    it(`create a childOMat with the singleton option `, 
      ()=>{ 
        childOMat = new ClassOMat().BaseClass(ChildClass).field('name').$();
        classOMat.addChild(childOMat).singleton().as$('child');

        const minion = new (classOMat.$())();

        expect(typeof minion.child).to.equal('function');
        const childMinion = minion.child();
        childMinion.name('one');

        expect(childMinion.TYPE).to.equal('CHILD');
        expect(minion.___child('child').TYPE).to.equal('CHILD');
        const childMinionAgain = minion.child();

        expect(childMinionAgain.TYPE).to.equal('CHILD');
        expect(childMinion.name()).to.equal(childMinionAgain.name());
      }
    );

    it(`create a childOMat with the singleton option and with an intializer`, 
      ()=>{ 
        let childMarker = true;
        const childInit =(child, parent)=>childMarker = child.TYPE;

        childOMat = new ClassOMat().BaseClass(ChildClass).field('name').$();
        classOMat.addChild(childOMat)
                 .singleton()
                 .initializer(childInit)
                 .as$('child');

        const minion = new (classOMat.$())();

        expect(typeof minion.child).to.equal('function');
        const childMinion = minion.child();
        childMinion.name('one');

        expect(childMinion.TYPE).to.equal('CHILD');
        expect(minion.___child('child').TYPE).to.equal('CHILD');
        const childMinionAgain = minion.child();

        expect(childMinionAgain.TYPE).to.equal('CHILD');
        expect(childMinion.name()).to.equal(childMinionAgain.name());
        expect(childMarker).to.equal('CHILD')
      }
    );

    it(`create a childOMat WITHOUT the singleton option `, 
      ()=>{ 
        childOMat = new ClassOMat().BaseClass(ChildClass).field('name').$();
        classOMat.addChild(childOMat).as$('child');

        const minion = new (classOMat.$())();

        expect(typeof minion.child).to.equal('function');
        const childMinion = minion.child().name('why')

        expect(childMinion.TYPE).to.equal('CHILD');
        expect(minion.___child('child').TYPE).to.equal('CHILD');
        
        const childMinionAgain = minion.child();

        expect(childMinionAgain.TYPE).to.equal('CHILD');
        expect(childMinion.name()).to.not.equal(childMinionAgain.name());
      }
    );


  }
);