-'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);
while (Date.now() === this.updateCalled) { /* pass some time */ }
}
},
- component: class TestComponent extends Serpentity.Component {
+ component: class TestComponent extends Component {
constructor(config) {
super(config);
this.called = false;
}
},
- node: class TestNode extends Serpentity.Node {},
+ node: class TestNode extends Node {},
delta: 10
};
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));
git.r.bdr.sh / rbdr / serpentity / blobdiff