elevators

Author: ericminio

challenges/elevators/elevator.js

@@ -0,0 +1,51 @@
+class Elevator {
+    constructor(ding) {
+        this.ding = ding;
+        this.floor = 0;
+        this.calls = [];
+        this.thenWhat();
+    }
+    queues(floor) {
+        this.calls.push(floor);
+        this.thenWhat();
+    }
+    thenWhat() {
+        if (this.calls.length === 0) {
+            this.direction = 'waiting';
+            return;
+        }
+        if (this.direction === 'up' && this.ups().length === 0) {
+            this.direction = 'waiting';
+        }
+        if (this.direction === 'down' && this.downs().length === 0) {
+            this.direction = 'waiting';
+        }
+        if (this.direction === 'waiting') {
+            this.direction = this.calls[0] > this.floor ? 'up' : 'down';
+        }
+    }
+    ups() {
+        return this.calls.filter((c) => c > this.floor);
+    }
+    downs() {
+        return this.calls.filter((c) => c < this.floor);
+    }
+    move() {
+        this.called = (
+            this.direction === 'up' ? this.ups() : this.downs()
+        ).sort();
+        this.floor = this.called[0];
+        if (this.ding) {
+            this.ding(this.floor);
+        }
+        this.calls.splice(this.calls.indexOf(this.floor), 1);
+        this.thenWhat();
+    }
+    moveAll() {
+        while (this.calls.length > 0) {
+            this.move();
+        }
+    }
+}
+
+module.exports = { Elevator };

challenges/elevators/elevators.test.js

@@ -0,0 +1,92 @@
+const { describe, it } = require('node:test');
+const { strict: assert } = require('node:assert');
+
+const { Elevator } = require('./elevator');
+
+describe('https://kata-log.rocks/lift-kata', () => {
+    it('starts from the ground', () => {
+        const elevator = new Elevator();
+
+        assert.deepStrictEqual(elevator.floor, 0);
+    });
+    it('starts waiting', () => {
+        const elevator = new Elevator();
+
+        assert.deepStrictEqual(elevator.direction, 'waiting');
+    });
+    it('records calls', () => {
+        const elevator = new Elevator();
+        elevator.queues(3);
+        elevator.queues(5);
+
+        assert.deepStrictEqual(elevator.calls, [3, 5]);
+    });
+    it('knows when the next direction is up', () => {
+        const elevator = new Elevator();
+        elevator.queues(3);
+        elevator.queues(5);
+
+        assert.deepStrictEqual(elevator.direction, 'up');
+    });
+    it('knows when the next direction is down', () => {
+        const elevator = new Elevator();
+        elevator.floor = 5;
+        elevator.queues(3);
+        elevator.queues(10);
+
+        assert.deepStrictEqual(elevator.direction, 'down');
+    });
+    it('can move to called floor', () => {
+        const elevator = new Elevator();
+        elevator.floor = 3;
+        elevator.queues(5);
+        elevator.move();
+
+        assert.deepStrictEqual(elevator.floor, 5);
+        assert.deepStrictEqual(elevator.calls, []);
+        assert.deepStrictEqual(elevator.direction, 'waiting');
+    });
+    it('can visit three floors up in expected order', () => {
+        const elevator = new Elevator();
+        elevator.queues(3);
+        elevator.queues(5);
+        elevator.queues(4);
+        elevator.moveAll();
+
+        assert.deepStrictEqual(elevator.floor, 5);
+        assert.deepStrictEqual(elevator.calls, []);
+        assert.deepStrictEqual(elevator.direction, 'waiting');
+    });
+    it('dings', () => {
+        let dings = [];
+        const ding = (floor) => dings.push(floor);
+        const elevator = new Elevator(ding);
+        elevator.queues(3);
+        elevator.queues(5);
+        elevator.moveAll();
+
+        assert.deepStrictEqual(dings, [3, 5]);
+    });
+    it('can go up and then down', () => {
+        let dings = [];
+        const ding = (floor) => dings.push(floor);
+        const elevator = new Elevator(ding);
+        elevator.floor = 3;
+        elevator.queues(5);
+        elevator.queues(2);
+        elevator.moveAll();
+
+        assert.deepStrictEqual(dings, [5, 2]);
+    });
+    it('can go down and then up', () => {
+        let dings = [];
+        const ding = (floor) => dings.push(floor);
+        const elevator = new Elevator(ding);
+        elevator.floor = 3;
+        elevator.queues(2);
+        elevator.queues(5);
+        elevator.moveAll();
+
+        assert.deepStrictEqual(dings, [2, 5]);
+    });
+});

challenges/elevators/orchestrator.js

@@ -0,0 +1,13 @@
+const { Elevator } = require('./elevator');
+
+class ElevatorOrchestrator {
+    constructor(n) {
+        this.elevators = Array.from({ length: n }, () => new Elevator());
+    }
+    queues(floor) {
+        const freeElevator = this.elevators.find((e) => e.calls.length === 0);
+        freeElevator.queues(floor);
+    }
+}
+
+module.exports = { ElevatorOrchestrator };

challenges/elevators/orchestrator.test.js

@@ -0,0 +1,21 @@
+const { describe, it } = require('node:test');
+const { strict: assert } = require('node:assert');
+
+const { ElevatorOrchestrator } = require('./orchestrator');
+
+describe('orchestrator', () => {
+    it('manages several elevators', () => {
+        const orchestrator = new ElevatorOrchestrator(3);
+        assert.deepStrictEqual(orchestrator.elevators.length, 3);
+    });
+    it('prefers elevator with empty queue', () => {
+        const orchestrator = new ElevatorOrchestrator(3);
+        orchestrator.queues(3);
+        orchestrator.queues(4);
+        orchestrator.queues(5);
+
+        assert.deepStrictEqual(orchestrator.elevators[0].calls, [3]);
+        assert.deepStrictEqual(orchestrator.elevators[1].calls, [4]);
+        assert.deepStrictEqual(orchestrator.elevators[2].calls, [5]);
+    });
+});