X-Git-Url: https://git.r.bdr.sh/rbdr/serpentity/blobdiff_plain/be2bf74b90d95adad5e61acaa3663ac2cb215955..4d4216690096dc8d300254e8752a4830df1c0f2d:/test/integration.js

diff --git a/test/integration.js b/test/integration.js
index 5b6e595..70109eb 100644
--- a/test/integration.js
+++ b/test/integration.js
@@ -1,11 +1,10 @@
-'use strict';
-
-const Code = require('code');   // assertion library
-const Lab = require('lab');
-const Serpentity = require('..');
+import Code from '@hapi/code';   // assertion library
+import Lab from '@hapi/lab';
+import Serpentity, { Component, Entity, Node, System } from '../lib/serpentity.js';
 
 const internals = {
-  system: class TestSystem extends Serpentity.System {
+  context: {},
+  system: class TestSystem extends System {
     added(engine) {
 
       this.testNodes = engine.getNodes(internals.node);
@@ -33,7 +32,7 @@ const internals = {
       while (Date.now() === this.updateCalled) { /* pass some time */ }
     }
   },
-  component: class TestComponent extends Serpentity.Component {
+  component: class TestComponent extends Component {
     constructor(config) {
 
       super(config);
@@ -41,7 +40,7 @@ const internals = {
       this.called = false;
     }
   },
-  node: class TestNode extends Serpentity.Node {},
+  node: class TestNode extends Node {},
   delta: 10
 };
 
@@ -50,261 +49,238 @@ internals.node.types = {
   test: internals.component
 };
 
-const lab = exports.lab = Lab.script();
+const lab = Lab.script({
+  schedule: false
+});
+
+const { beforeEach, experiment, test } = lab;
+const { expect } = Code;
 
-lab.experiment('loading', () => {
+experiment('loading', () => {
 
-  lab.test('Serpentity should be exported', (done) => {
+  test('Serpentity should be exported', () => {
 
-    Code.expect(typeof Serpentity).to.not.be.undefined();
-    done();
+    expect(typeof Serpentity).to.not.be.undefined();
   });
 
-  lab.test('Serpentity should include the Entity class', (done) => {
+  test('Serpentity should include the Entity class', () => {
 
-    Code.expect(typeof Serpentity.Entity).to.not.be.undefined();
-    done();
+    expect(typeof Entity).to.not.be.undefined();
   });
 
-  lab.test('Serpentity should include the Component class', (done) => {
+  test('Serpentity should include the Component class', () => {
 
-    Code.expect(typeof Serpentity.Component).to.not.be.undefined();
-    done();
+    expect(typeof Component).to.not.be.undefined();
   });
 
-  lab.test('Serpentity should include the System class', (done) => {
+  test('Serpentity should include the System class', () => {
 
-    Code.expect(typeof Serpentity.System).to.not.be.undefined();
-    done();
+    expect(typeof System).to.not.be.undefined();
   });
 
-  lab.test('Serpentity should include the Node class', (done) => {
+  test('Serpentity should include the Node class', () => {
 
-    Code.expect(typeof Serpentity.Node).to.not.be.undefined();
-    done();
+    expect(typeof Node).to.not.be.undefined();
   });
 
-  lab.test('Serpentity should include the NodeCollection class', (done) => {
+  test('Serpentity should include the NodeCollection class', () => {
 
-    Code.expect(typeof Serpentity.NodeCollection).to.not.be.undefined();
-    done();
+    expect(typeof NodeCollection).to.not.be.undefined();
   });
 });
 
-lab.experiment('Engine Tests', () => {
+experiment('Engine Tests', () => {
 
-  lab.beforeEach((done) => {
+  beforeEach(() => {
 
-    this.engine = new Serpentity();
+    internals.context.engine = new Serpentity();
 
-    this.regularSystem = new internals.system();
-    this.highPrioritySystem = new internals.system();
-    this.lowPrioritySystem = new internals.system();
+    internals.context.regularSystem = new internals.system();
+    internals.context.highPrioritySystem = new internals.system();
+    internals.context.lowPrioritySystem = new internals.system();
 
-    this.firstEntity = new Serpentity.Entity();
-    this.firstEntity.addComponent(new internals.component());
-    this.secondEntity = new Serpentity.Entity();
-    this.secondEntity.addComponent(new internals.component());
-    this.emptyEntity = new Serpentity.Entity();
+    internals.context.firstEntity = new Entity();
+    internals.context.firstEntity.addComponent(new internals.component());
+    internals.context.secondEntity = new Entity();
+    internals.context.secondEntity.addComponent(new internals.component());
+    internals.context.emptyEntity = new Entity();
 
     // Add entity before the systems
-    this.engine.addEntity(this.firstEntity);
+    internals.context.engine.addEntity(internals.context.firstEntity);
 
-    this.engine.addSystem(this.regularSystem, 100);
-    this.engine.addSystem(this.highPrioritySystem, 0);
-    this.engine.addSystem(this.lowPrioritySystem, 1000);
+    internals.context.engine.addSystem(internals.context.regularSystem, 100);
+    internals.context.engine.addSystem(internals.context.highPrioritySystem, 0);
+    internals.context.engine.addSystem(internals.context.lowPrioritySystem, 1000);
 
     // Add entity after the systems
-    this.engine.addEntity(this.secondEntity);
-    this.engine.addEntity(this.emptyEntity);
-
-    done();
+    internals.context.engine.addEntity(internals.context.secondEntity);
+    internals.context.engine.addEntity(internals.context.emptyEntity);
   });
 
-  lab.test('Engine should call added callback on added systems', (done) => {
+  test('Engine should call added callback on added systems', () => {
 
     // Ensure the added callback is being called
-    Code.expect(this.regularSystem.addedCalled).to.be.true();
-    Code.expect(this.highPrioritySystem.addedCalled).to.be.true();
-    Code.expect(this.lowPrioritySystem.addedCalled).to.be.true();
-
-    done();
+    expect(internals.context.regularSystem.addedCalled).to.be.true();
+    expect(internals.context.highPrioritySystem.addedCalled).to.be.true();
+    expect(internals.context.lowPrioritySystem.addedCalled).to.be.true();
   });
 
-  lab.test('Engine should send the engine instance in added callback', (done) => {
+  test('Engine should send the engine instance in added callback', () => {
 
     // Ensure the added callback is sending the engine
-    Code.expect(this.regularSystem.addedEngine instanceof Serpentity).to.be.true();
-    Code.expect(this.highPrioritySystem.addedEngine instanceof Serpentity).to.be.true();
-    Code.expect(this.lowPrioritySystem.addedEngine instanceof Serpentity).to.be.true();
-
-    done();
+    expect(internals.context.regularSystem.addedEngine instanceof Serpentity).to.be.true();
+    expect(internals.context.highPrioritySystem.addedEngine instanceof Serpentity).to.be.true();
+    expect(internals.context.lowPrioritySystem.addedEngine instanceof Serpentity).to.be.true();
   });
 
-  lab.test('Engine should not add duplicate systems', (done) => {
+  test('Engine should not add duplicate systems', () => {
 
-    const originalSystemsLength = this.engine.systems.length;
-    const added = this.engine.addSystem(this.regularSystem, 0);
-    const newSystemsLength = this.engine.systems.length;
+    const originalSystemsLength = internals.context.engine.systems.length;
+    const added = internals.context.engine.addSystem(internals.context.regularSystem, 0);
+    const newSystemsLength = internals.context.engine.systems.length;
 
     // Ensure we don't add the same system twice
-    Code.expect(added).to.be.false();
-    Code.expect(originalSystemsLength).to.be.equal(newSystemsLength);
-
-    done();
+    expect(added).to.be.false();
+    expect(originalSystemsLength).to.be.equal(newSystemsLength);
   });
 
-  lab.test('Engine should call update callback on added systems', (done) => {
+  test('Engine should call update callback on added systems', () => {
 
-    this.engine.update(internals.delta);
+    internals.context.engine.update(internals.delta);
 
     // Ensure update function called
-    Code.expect(!!this.regularSystem.updateCalled).to.be.true();
-    Code.expect(!!this.highPrioritySystem.updateCalled).to.be.true();
-    Code.expect(!!this.lowPrioritySystem.updateCalled).to.be.true();
-
-    done();
+    expect(!!internals.context.regularSystem.updateCalled).to.be.true();
+    expect(!!internals.context.highPrioritySystem.updateCalled).to.be.true();
+    expect(!!internals.context.lowPrioritySystem.updateCalled).to.be.true();
   });
 
-  lab.test('Engine should call update callback in the order of priorities', (done) => {
+  test('Engine should call update callback in the order of priorities', () => {
 
-    this.engine.update(internals.delta);
+    internals.context.engine.update(internals.delta);
 
     // Ensure order of priorities
-    Code.expect(this.regularSystem.updateCalled).to.be.lessThan(this.lowPrioritySystem.updateCalled);
-    Code.expect(this.regularSystem.updateCalled).to.be.greaterThan(this.highPrioritySystem.updateCalled);
-
-    done();
+    expect(internals.context.regularSystem.updateCalled).to.be.lessThan(internals.context.lowPrioritySystem.updateCalled);
+    expect(internals.context.regularSystem.updateCalled).to.be.greaterThan(internals.context.highPrioritySystem.updateCalled);
   });
 
-  lab.test('Engine should send the delta in the update callback', (done) => {
+  test('Engine should send the delta in the update callback', () => {
 
-    this.engine.update(internals.delta);
+    internals.context.engine.update(internals.delta);
 
     // Ensure delta is being sent
-    Code.expect(this.regularSystem.updateDt).to.be.equal(internals.delta);
-    Code.expect(this.highPrioritySystem.updateDt).to.be.equal(internals.delta);
-    Code.expect(this.lowPrioritySystem.updateDt).to.be.equal(internals.delta);
-
-    done();
+    expect(internals.context.regularSystem.updateDt).to.be.equal(internals.delta);
+    expect(internals.context.highPrioritySystem.updateDt).to.be.equal(internals.delta);
+    expect(internals.context.lowPrioritySystem.updateDt).to.be.equal(internals.delta);
   });
 
-  lab.test('System remove callback', (done) => {
+  test('System remove callback', () => {
 
-    const originalSystemLength = this.engine.systems.length;
-    const originalRemoved = this.engine.removeSystem(this.lowPrioritySystem);
-    const intermediateSystemLength = this.engine.systems.length;
-    const finalRemoved = this.engine.removeSystem(this.lowPrioritySystem);
-    const finalSystemLength = this.engine.systems.length;
-    this.engine.update(internals.delta);
+    const originalSystemLength = internals.context.engine.systems.length;
+    const originalRemoved = internals.context.engine.removeSystem(internals.context.lowPrioritySystem);
+    const intermediateSystemLength = internals.context.engine.systems.length;
+    const finalRemoved = internals.context.engine.removeSystem(internals.context.lowPrioritySystem);
+    const finalSystemLength = internals.context.engine.systems.length;
+    internals.context.engine.update(internals.delta);
 
-    // Check for return value 
-    Code.expect(originalRemoved).to.be.true();
-    Code.expect(finalRemoved).to.be.false();
+    // Check for return value
+    expect(originalRemoved).to.be.true();
+    expect(finalRemoved).to.be.false();
 
     // Confirm that only removed if found by checking length of systems
     // array
-    Code.expect(originalSystemLength).to.be.above(intermediateSystemLength);
-    Code.expect(finalSystemLength).to.be.equal(intermediateSystemLength);
+    expect(originalSystemLength).to.be.above(intermediateSystemLength);
+    expect(finalSystemLength).to.be.equal(intermediateSystemLength);
 
     // Ensure callback is sent
-    Code.expect(!!this.regularSystem.removedCalled).to.be.false();
-    Code.expect(!!this.highPrioritySystem.removedCalled).to.be.false();
-    Code.expect(!!this.lowPrioritySystem.removedCalled).to.be.true();
+    expect(!!internals.context.regularSystem.removedCalled).to.be.false();
+    expect(!!internals.context.highPrioritySystem.removedCalled).to.be.false();
+    expect(!!internals.context.lowPrioritySystem.removedCalled).to.be.true();
 
     // Ensure update is no longer sent
-    Code.expect(!!this.regularSystem.updateCalled).to.be.true();
-    Code.expect(!!this.highPrioritySystem.updateCalled).to.be.true();
-    Code.expect(!!this.lowPrioritySystem.updateCalled).to.be.false();
-
-    done();
+    expect(!!internals.context.regularSystem.updateCalled).to.be.true();
+    expect(!!internals.context.highPrioritySystem.updateCalled).to.be.true();
+    expect(!!internals.context.lowPrioritySystem.updateCalled).to.be.false();
   });
 
-  lab.test('Entity node selection', (done) => {
+  test('Entity node selection', () => {
 
-    this.engine.update(internals.delta);
+    internals.context.engine.update(internals.delta);
 
     // Ensure component is called for each entity
-    Code.expect(!!this.firstEntity._components[0].called).to.be.true();
-    Code.expect(!!this.secondEntity._components[0].called).to.be.true();
+    expect(!!internals.context.firstEntity._components[0].called).to.be.true();
+    expect(!!internals.context.secondEntity._components[0].called).to.be.true();
 
     // Ensure entity not in node collection not called
-    Code.expect(!!this.firstEntity.called).to.be.true();
-    Code.expect(!!this.secondEntity.called).to.be.true();
-    Code.expect(!!this.emptyEntity.called).to.be.false();
-
-    done();
+    expect(!!internals.context.firstEntity.called).to.be.true();
+    expect(!!internals.context.secondEntity.called).to.be.true();
+    expect(!!internals.context.emptyEntity.called).to.be.false();
   });
 
-  lab.test('Entity node removal', (done) => {
+  test('Entity node removal', () => {
 
-    this.engine.removeEntity(this.secondEntity);
-    this.engine.update(internals.delta);
+    internals.context.engine.removeEntity(internals.context.secondEntity);
+    internals.context.engine.update(internals.delta);
 
-    Code.expect(!!this.firstEntity._components[0].called).to.be.true();
-    Code.expect(!!this.secondEntity._components[0].called).to.be.false();
+    expect(!!internals.context.firstEntity._components[0].called).to.be.true();
+    expect(!!internals.context.secondEntity._components[0].called).to.be.false();
 
-    Code.expect(!!this.firstEntity.called).to.be.true();
-    Code.expect(!!this.secondEntity.called).to.be.false();
-    Code.expect(!!this.emptyEntity.called).to.be.false();
-
-    done();
+    expect(!!internals.context.firstEntity.called).to.be.true();
+    expect(!!internals.context.secondEntity.called).to.be.false();
+    expect(!!internals.context.emptyEntity.called).to.be.false();
   });
 
-  lab.test('Entity should not add duplicate components', (done) => {
-    const originalComponentsLength = this.secondEntity._components.length;
-    const result = this.secondEntity.addComponent(new internals.component());
-    const newComponentsLength = this.secondEntity._components.length;
+  test('Entity should not add duplicate components', () => {
 
-    Code.expect(result).to.be.false();
-    Code.expect(originalComponentsLength).to.be.equal(newComponentsLength);
+    const originalComponentsLength = internals.context.secondEntity._components.length;
+    const result = internals.context.secondEntity.addComponent(new internals.component());
+    const newComponentsLength = internals.context.secondEntity._components.length;
 
-    done();
+    expect(result).to.be.false();
+    expect(originalComponentsLength).to.be.equal(newComponentsLength);
   });
 
-  lab.test('Entity should allow access to components by class', (done) => {
-    const firstComponent = this.firstEntity.getComponent(internals.component);
-    const emptyComponent = this.emptyEntity.getComponent(internals.component);
+  test('Entity should allow access to components by class', () => {
 
-    Code.expect(firstComponent instanceof internals.component).to.be.true();
-    Code.expect(emptyComponent).to.be.equal(undefined);
+    const firstComponent = internals.context.firstEntity.getComponent(internals.component);
+    const emptyComponent = internals.context.emptyEntity.getComponent(internals.component);
 
-    done();
+    expect(firstComponent instanceof internals.component).to.be.true();
+    expect(emptyComponent).to.be.equal(undefined);
   });
 
-  lab.test('Engine should not add duplicate entities', (done) => {
-    const originalEntitiesLength = this.engine.entities.length;
-    const added = this.engine.addEntity(this.firstEntity);
-    const finalEntitiesLength = this.engine.entities.length;
+  test('Engine should not add duplicate entities', () => {
+
+    const originalEntitiesLength = internals.context.engine.entities.length;
+    const added = internals.context.engine.addEntity(internals.context.firstEntity);
+    const finalEntitiesLength = internals.context.engine.entities.length;
 
-    Code.expect(added).to.be.false();
+    expect(added).to.be.false();
 
-    Code.expect(originalEntitiesLength).to.be.equal(finalEntitiesLength);
-    done();
+    expect(originalEntitiesLength).to.be.equal(finalEntitiesLength);
   });
 
-  lab.test('Engine should remove entities', (done) => {
+  test('Engine should remove entities', () => {
 
-    const originalEntityLength = this.engine.entities.length;
-    const originalRemoved = this.engine.removeEntity(this.firstEntity);
-    const intermediateEntityLength = this.engine.entities.length;
-    const finalRemoved = this.engine.removeEntity(this.firstEntity);
-    const finalEntityLength = this.engine.entities.length;
-    this.engine.update(internals.delta);
+    const originalEntityLength = internals.context.engine.entities.length;
+    const originalRemoved = internals.context.engine.removeEntity(internals.context.firstEntity);
+    const intermediateEntityLength = internals.context.engine.entities.length;
+    const finalRemoved = internals.context.engine.removeEntity(internals.context.firstEntity);
+    const finalEntityLength = internals.context.engine.entities.length;
+    internals.context.engine.update(internals.delta);
 
-    // Check for return value 
-    Code.expect(originalRemoved).to.be.true();
-    Code.expect(finalRemoved).to.be.false();
+    // Check for return value
+    expect(originalRemoved).to.be.true();
+    expect(finalRemoved).to.be.false();
 
     // Confirm that only removed if found by checking length of systems
     // array
-    Code.expect(originalEntityLength).to.be.above(intermediateEntityLength);
-    Code.expect(finalEntityLength).to.be.equal(intermediateEntityLength);
+    expect(originalEntityLength).to.be.above(intermediateEntityLength);
+    expect(finalEntityLength).to.be.equal(intermediateEntityLength);
 
     // Ensure callback is sent
-    Code.expect(!!this.firstEntity.called).to.be.false();
-    Code.expect(!!this.secondEntity.called).to.be.true();
-
-    done();
+    expect(!!internals.context.firstEntity.called).to.be.false();
+    expect(!!internals.context.secondEntity.called).to.be.true();
   });
 });
+
+Lab.report(lab).then((result) => process.exit(result.code));