Update tests

Signed-off-by: Sam Biggins <sambiggins@gmail.com>

src/components/attack.ts

@@ -8,7 +8,7 @@ export class Attack implements IComponent {
         this._amount = amount;
     }
 
-    private _target?: string | undefined;
+    private _target = 'none';
 
     get target() {
         return this._target;
@@ -26,8 +26,11 @@ export class Attack implements IComponent {
 
     public subscribe(eventBus: EventBus) {
         this._eventBus = eventBus;
-        this._eventBus.subscribe('performAttack', this.performAttack);
-        this._eventBus.subscribe('focusChanged', this.focusChanged);
+        this._eventBus.subscribe(
+            'performAttack',
+            this.performAttack.bind(this)
+        );
+        this._eventBus.subscribe('focusChanged', this.focusChanged.bind(this));
     }
 
     public destroy() {

src/components/health.ts

@@ -12,7 +12,11 @@ export class Health implements IComponent {
     private readonly _brokenThreshold: number;
     private _eventBus!: EventBus;
 
-    constructor(amount: number, maxHealth: number, brokenThreshold: number) {
+    constructor(
+        amount: number,
+        maxHealth: number,
+        brokenThreshold = 1
+    ) {
         this._amount = amount;
         this._maxHealth = maxHealth;
         this._brokenThreshold = brokenThreshold;
@@ -28,13 +32,14 @@ export class Health implements IComponent {
         this._amount = amount;
         this._eventBus.publish('healthChanged', this._amount);
         if (this._amount <= 0) {
-            this.destroy();
+            log.info(`Object is destroyed`);
+            this._eventBus.publish('destroyed', this.amount);
         }
-        if (this._amount < this._brokenThreshold) {
+        if (this._amount <= this._brokenThreshold && !this._isBroken) {
             this._isBroken = true;
             this._eventBus.publish('broken', this._amount);
             log.info(`Object is broken`); // TODO: move logging to subscriber
-        } else {
+        } else if (this._amount >= this._brokenThreshold && this._isBroken) {
             this._isBroken = false;
             this._eventBus.publish('fixed', this._amount);
             log.info(`Object is no longer broken`);
@@ -53,16 +58,17 @@ export class Health implements IComponent {
 
     public subscribe(eventBus: EventBus) {
         this._eventBus = eventBus;
-        this._eventBus.subscribe('takeDamage', this.handleTakeDamage);
+        this._eventBus.subscribe(
+            'takeDamage',
+            this.handleTakeDamage.bind(this)
+        );
     }
 
     public update() {
         // do nothing
     }
 
     public destroy() {
-        this._eventBus.publish('destroyed', this.amount);
-        log.info(`Object is destroyed`);
         this.unsubscribe();
     }
 

src/components/healthBar.ts

@@ -10,8 +10,11 @@ export class HealthBarComponent implements IComponent {
 
     public subscribe(eventBus: EventBus) {
         this._eventBus = eventBus;
-        this._eventBus.subscribe('healthChanged', this.updateHealth);
-        this._eventBus.subscribe('positionChanged', this.updatePosition);
+        this._eventBus.subscribe('healthChanged', this.updateHealth.bind(this));
+        this._eventBus.subscribe(
+            'positionChanged',
+            this.updatePosition.bind(this)
+        );
     }
 
     public updateHealth(amount: number): void {

src/components/movement.ts

@@ -15,8 +15,8 @@ export class Movement implements IComponent {
 
     public subscribe(eventBus: EventBus) {
         this._eventBus = eventBus;
-        this._eventBus.subscribe('move', this.handleMove);
-        this._eventBus.subscribe('stop', this.handleStop);
+        this._eventBus.subscribe('move', this.handleMove.bind(this));
+        this._eventBus.subscribe('stop', this.handleStop.bind(this));
     }
 
     handleStop() {

src/components/sprite.ts

@@ -22,7 +22,10 @@ export class Sprite implements IComponent {
 
     public subscribe(eventBus: EventBus) {
         this._eventBus = eventBus;
-        this._eventBus.subscribe('spriteShouldUpdate', this.handleSpriteUpdate);
+        this._eventBus.subscribe(
+            'spriteShouldUpdate',
+            this.handleSpriteUpdate.bind(this)
+        );
     }
 
     public setPlayerSpriteProperties() {

src/entities/actor.ts

@@ -24,14 +24,14 @@ export class Actor extends Interactable {
         );
         this.universeEventBus.subscribe(
             'attackRequested',
-            this.handleAttackRequested
+            this.handleAttackRequested.bind(this)
         );
-        this.universeEventBus.subscribe('move', this.handleMove);
-        this.universeEventBus.subscribe('stop', this.handleStop);
+        this.universeEventBus.subscribe('move', this.handleMove.bind(this));
+        this.universeEventBus.subscribe('stop', this.handleStop.bind(this));
     }
 
     private handleAttackRequested(interactableId: string) {
-        if (interactableId === this.id) {
+        if (interactableId === this._id) {
             this.interactableEventBus.publish(
                 'performAttack',
                 this.universeEventBus

src/entities/interactable.ts

@@ -16,7 +16,10 @@ export class Interactable {
             'attackPerformed',
             this.handleAttackPerformed
         );
-        this.interactableEventBus.subscribe('destroyed', this.destroy);
+        this.interactableEventBus.subscribe(
+            'destroyed',
+            this.destroy.bind(this)
+        );
         this.interactableEventBus.subscribe(
             'componentDirty',
             this.markComponentDirty

test/features/player-interaction.feature

@@ -7,11 +7,10 @@ Feature: Basic player interaction
             When the player attacks the bench <times> times
             Then the bench should have a healthBar
             Then the bench should have <health> health left
-            Then the <texture> texture should show on the bench
-            Then the bench should be <destroyed> destroyed
+            Then the bench should be <state>
 
             Examples:
-                | times | health | texture      | destroyed |
-                | 1     | 2      | bench        | not       |
-                | 2     | 1      | bench-broken | not       |
-                | 3     | 0      | undefined    |           |
+                | times | health | state     |
+                | 1     | 2      | fine      |
+                | 2     | 1      | broken    |
+                | 3     | 0      | destroyed |

test/features/steps/interaction.steps.ts

@@ -1,55 +1,17 @@
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { Actor, Interactable } from '@src/entities';
-import { GameScene } from '@src/scenes/gameScene';
-import { gameConfig } from '@src/phaserGame';
-import Phaser from 'phaser';
-import GameConfig = Phaser.Types.Core.GameConfig;
-
-const mockBenchSprite = {
-    setTexture: jest
-        .fn()
-        .mockImplementation(function (
-            this: Phaser.Physics.Arcade.Sprite,
-            key: string
-        ) {
-            this.texture = { key };
-        }),
-    texture: {},
-    scene: {},
-    destroy: jest.fn()
-} as unknown as Phaser.Physics.Arcade.Sprite;
-jest.mock('@src/ui', () => ({
-    HealthBar: jest.fn().mockImplementation(() => {
-        return {
-            setHealth: jest.fn(),
-            updatePosition: jest.fn(),
-            destroy: jest.fn()
-        };
-    })
-}));
+import { EventBus } from '@src/systems';
+import { Health, HealthBarComponent } from '@src/components';
 
 const feature = loadFeature('test/features/player-interaction.feature');
 defineFeature(feature, (test) => {
     let player: Actor;
     let bench: Interactable;
-    let scene: GameScene;
-    let phaser: Phaser.Game;
-
-    beforeAll(async () => {
-        phaser = new Phaser.Game(gameConfig as GameConfig);
-        scene = phaser.scene.getScene('GameScene');
-        await scene.create();
-    });
 
     beforeEach(async () => {
-        jest.clearAllMocks();
-        const universeEventBus = scene.universe.eventBus;
-
+        const universeEventBus = new EventBus();
         player = new Actor('player', universeEventBus);
         bench = new Interactable('bench', universeEventBus);
-        mockBenchSprite.setTexture('bench');
-        mockBenchSprite.scene = scene;
-        bench.setSprite(mockBenchSprite);
     });
 
     test('A player attacking a bench', ({ given, when, then }) => {
@@ -62,26 +24,24 @@ defineFeature(feature, (test) => {
             }
         });
         then('the bench should have a healthBar', () => {
-            const healthBar = bench.getComponent('HealthBarComponent');
-            expect(bench.healthBar).not.toBeNull();
-        });
-        then(/^the bench should have (.*) health left$/, (arg0: string) => {
-            expect(bench.thing.health).toBe(parseInt(arg0));
+            const healthBar = bench.getComponent(HealthBarComponent);
+            expect(healthBar).not.toBeNull();
         });
-        then(/^the (.*) texture should show on the bench$/, (arg0: string) => {
-            if (arg0 === 'undefined') {
-                expect(bench.sprite?.texture.key).toBeUndefined();
+        then(/^the bench should have (\d+) health left$/, (amount) => {
+            const num = parseInt(amount);
+            const health = bench.getComponent(Health);
+            if (num > 0) {
+                expect(health?.amount).toBe(num);
             } else {
-                expect(bench.sprite?.texture.key).toBe(arg0);
+                expect(health).toBeUndefined();
             }
         });
-        then(/^the bench should be (.*) destroyed$/, (arg0) => {
-            if (arg0 === 'not') {
-                expect(bench.thing.health).toBeGreaterThan(0);
-                expect(bench.sprite).not.toBeNull();
-            } else {
-                expect(bench.thing.health).toBe(0);
-                expect(bench.sprite).toBeUndefined();
+        then(/^the bench should be (.*)$/, (arg0) => {
+            const health = bench.getComponent(Health);
+            if (arg0 === 'destroyed') {
+                expect(health).toBeUndefined();
+            } else if (arg0 === 'not destroyed') {
+                expect(health).toBeDefined();
             }
         });
     });

test/unit/App.test.tsx

@@ -5,21 +5,24 @@
 import ReactDOM from 'react-dom';
 import App from '../../src/App';
 import '../../src/phaserGame';
-import { render } from '@testing-library/react';
+import { act, render } from '@testing-library/react';
 import '@testing-library/jest-dom';
 
 jest.mock('../../src/phaserGame', () => jest.fn());
 
 describe('App', () => {
-  it('matches the snapshot', () => {
-    const app = render(<App />);
+    it('matches the snapshot', () => {
+        const app = render(<App />);
 
-    expect(app).toMatchSnapshot();
-  });
+        expect(app).toMatchSnapshot();
+    });
 
-  it('renders without crashing', () => {
-    const div = document.createElement('div');
-    ReactDOM.render(<App />, div);
-    ReactDOM.unmountComponentAtNode(div);
-  });
+    it('renders without crashing', () => {
+        const div = document.createElement('div');
+        act(() => {
+            ReactDOM.render(<App />, div);
+        });
+        ReactDOM.unmountComponentAtNode(div);
+        expect(div.innerHTML).toBe('');
+    });
 });