anear-js-api 0.4.1 → 0.4.3

package/lib/models/AnearParticipant.js

@@ -1,15 +1,45 @@
 "use strict"
+
 const JsonApiResource = require('./JsonApiResource')
+const ParticipantTimer = require('../utils/ParticipantTimer')
+const logger = require('../utils/Logger')
+
 const HostUserType = "host"
 
 class AnearParticipant extends JsonApiResource {
+  constructor(json, anearEvent) {
+    super(json)
+    this.anearEvent = anearEvent
+    this.timer = null
+    this._state = json.state
+    this._timestamp = json.timestamp
+    this._geoLocation = null
+  }
+
   toJSON() {
     return {
       ...super.toJSON(),
-      geoLocation: this._geoLocation || null,
+      state: this.state,
+      timestamp: this.timestamp
     }
   }
 
+  get state() {
+    return this._state
+  }
+
+  set state(s) {
+    this._state = s
+  }
+
+  get timestamp() {
+    return this._timestamp
+  }
+
+  set timestamp(t) {
+    this._timestamp = t
+  }
+
   set geoLocation(loc) {
     this._geoLocation = loc
   }
@@ -18,10 +48,6 @@ class AnearParticipant extends JsonApiResource {
     return this._geoLocation
   }
 
-  get identity() {
-    return (({ id, userId, name, avatarUrl, geoLocation}) => ({ id, userId, name, avatarUrl, geoLocation}))(this)
-  }
-
   get userId() {
     return this.relationships.user.data.id
   }
@@ -57,6 +83,59 @@ class AnearParticipant extends JsonApiResource {
   get privateChannelName() {
     return this.attributes['private-channel-name']
   }
+
+  ensureTimer(timeoutMsecs) {
+    // this is called when a new timer is being started for a privateMessage
+    // sent to a participant, or public message to all participants
+    // If the timer already exists and is paused, it is resumed with the timeRemaining
+    // [a starter function, timeRemaining] is returned
+    let timeRemaining = timeoutMsecs
+    let timerStarter = () => {}
+
+    if (timeoutMsecs > 0) {
+
+      this.timer ||= new ParticipantTimer(
+        this.id,
+        async () => await this.timerExpired(timeoutMsecs)
+      )
+
+      if (this.timer.isRunning) {
+        timeRemaining = this.timer.interrupt()
+      } else {
+        timerStarter = () => this.timer.start(timeoutMsecs)
+      }
+    }
+    logger.debug(`ensureTimer(timeRemaining: ${timeRemaining})`)
+
+    return [timerStarter, timeRemaining]
+  }
+
+  destroyTimer() {
+    // participant will not be receiving any more display messages
+    // so we close out and delete the timer
+    if (this.timer) {
+      this.timer.reset()
+      this.timer = null
+    }
+  }
+
+  async timerExpired(timeoutMsecs) {
+    logger.debug(`participant (${this.anearEvent.id}, ${this.id}) TIMED OUT after ${timeoutMsecs} msecs`)
+
+    this.timer = null
+
+    await this.anearEvent.participantTimedOut(this)
+    await this.anearEvent.update()
+  }
+
+  interruptTimer() {
+    if (this.timer && this.timer.isRunning) this.timer.interrupt()
+  }
+
+  resetTimer() {
+    // called after participant takes Action before timer expires
+    if (this.timer) this.timer.reset()
+  }
 }
 
 module.exports = AnearParticipant

package/lib/utils/AnearXstate.js

@@ -4,8 +4,9 @@ const { createMachine, interpret, State } = require('xstate')
 const logger = require('../utils/Logger')
 
 const JoinEvent = 'JOIN'
+const ParticipantExitEvent = 'PARTICIPANT_EXIT'
 const RefreshEvent = 'REFRESH'
-const CloseEvent = 'CLOSE'
+const CloseEvent = 'EVENT_CLOSE'
 const TimeoutEvent = 'TIMEOUT'
 
 class AnearXstate {
@@ -50,6 +51,10 @@ class AnearXstate {
     this.send(CloseEvent, params)
   }
 
+  sendParticipantExitEvent(params) {
+    this.send(ParticipantExitEvent, params)
+  }
+
   sendTimeoutEvent(params) {
     this.send(TimeoutEvent, params)
   }

package/lib/utils/AnearXstateDefaults.js

@@ -35,8 +35,8 @@ const DefaultConfigFunc = (anearEvent) => {
           REFRESH: {
             target: 'refresh'
           },
-          CLOSE: {
-            target: 'close'
+          PARTICIPANT_EXIT: {
+            target: 'participant_exit'
           },
           TIMEOUT: {
             target: 'timeout'
@@ -62,10 +62,10 @@ const DefaultConfigFunc = (anearEvent) => {
           ...PromiseResolveReject
         }
       },
-      close: {
+      participant_exit: {
         invoke: {
-          id: 'close',
-          src: 'closeEventHandler',
+          id: 'participant_exit',
+          src: 'participantExitEventHandler',
           ...PromiseResolveReject
         }
       },
@@ -95,7 +95,7 @@ const DefaultOptionsFunc = anearEvent => {
     services: {
       joinEventHandler: (context, event) => anearEvent.participantEnterEventCallback(event.participant),
       refreshEventHandler: (context, event) => anearEvent.participantRefreshEventCallback(event.participant, event.remainingTimeout),
-      closeEventHandler: (context, event) => anearEvent.participantCloseEventCallback(event.participant),
+      participantExitEventHandler: (context, event) => anearEvent.participantExitEventCallback(event.participant),
       timeoutEventHandler: (context, event) => anearEvent.participantTimedOutEventCallback(event.participant),
       actionEventHandler: (context, event) => anearEvent.participantActionEventCallback(event.participant, event.type, event.payload)
     }

package/lib/utils/Participants.js

@@ -6,41 +6,43 @@ const IdleState   = "idle"
 const MINUTES = (60 * 1000)
 const HOURS = (60 * MINUTES)
 const DefaultIdleMsecs = (30 * MINUTES)
-const DefaultPurgeMsecs = (2 * HOURS)
-
-const DefaultSettings = {
-  participants: {},
-  host: {},
-  idleMsecs: DefaultIdleMsecs,
-  purgeMsecs: DefaultPurgeMsecs
-}
+const DefaultPurgeMsecs = (2 * HOURS) // after Idle
 
 class Participants {
 
-  constructor(json) {
-    const init = json || JSON.parse(JSON.stringify(DefaultSettings))
-    this._participants = init.participants
-    this._host = init.host
-    this.idleMsecs = init.idleMsecs // how long Active participants
-    this.purgeMsecs = init.purgeMsecs
+  constructor(anearEvent, {idleMsecs = DefaultIdleMsecs, purgeMsecs = DefaultPurgeMsecs, ids = []} = {}) {
+    this.anearEvent = anearEvent
+    this.idleMsecs = idleMsecs
+    this.purgeMsecs = purgeMsecs
+    this._participants = {}
+    for (const id of ids) {
+      // app restart logic ...
+      // seeds from ids with empty objects awaiting full
+      // anearParticipant rehydration from redis
+      this._participants[id] = {}
+    }
+    this._host = null
   }
 
   toJSON() {
     return {
-      participants: this._participants,
-      host: this._host,
+      ids: this.all.map(p => p.id),
       idleMsecs: this.idleMsecs,
       purgeMsecs: this.purgeMsecs
     }
   }
 
+  get ids() {
+    return Object.keys(this._participants)
+  }
+
   indexedById() {
     // returns an object that has AnearParticipant.id as key
     return this._participants
   }
 
-  getById(anearParticipantId) {
-    return this._participants[anearParticipantId]
+  getById(participantId) {
+    return this._participants[participantId]
   }
 
   exists({id}) {
@@ -55,29 +57,33 @@ class Participants {
     return this._host
   }
 
+  set host(h) {
+    this._host = h
+  }
+
   get all() {
     return Object.values(this._participants).
       sort((ca, cb) => ca.timestamp - cb.timestamp)
   }
 
-  active() {
+  get active() {
     return Object.values(this._participants).filter(c => c.state === ActiveState)
   }
 
-  idle() {
+  get idle() {
     return Object.values(this._participants).filter(c => c.state === IdleState)
   }
 
   get count() {
-    return Object.keys(this._participants).length
+    return this.ids.length
   }
 
-  numActive() {
-    return this.active().length
+  get numActive() {
+    return this.active.length
   }
 
-  numIdle() {
-    return this.idle().length
+  get numIdle() {
+    return this.idle.length
   }
 
   isIdle(c, currentTimestamp) {
@@ -108,8 +114,7 @@ class Participants {
       }
     }
 
-    const keys = Object.keys(this._participants)
-    keys.forEach(
+    this.ids.forEach(
       k => {
         const c = this._participants[k]
         sweeper(c)
@@ -117,34 +122,33 @@ class Participants {
     )
   }
 
-  add(anearEvent, anearParticipant) {
-    const rec = this.participantRec(anearParticipant)
-
-    if (anearParticipant.isHost() && anearEvent.hosted) {
+  add(anearParticipant, withTimestamp = this.currentTimestamp) {
+    if (anearParticipant.isHost() && this.anearEvent.hosted) {
       // the host is not an eligible participant and isn't active nor idle
-      this._host = rec
+      this.host = anearParticipant
     } else {
-      this.markActive(anearParticipant)
+      this._participants[anearParticipant.id] = anearParticipant
+      this.markActive(anearParticipant, withTimestamp)
     }
-    return rec
+    return anearParticipant
   }
 
-  markActive(anearParticipant) {
-    // anearParticipant has shown activity in the event (e.g. Action)
-    const participant = this.get(anearParticipant)
-    if (participant) {
-      participant.timestamp = this.currentTimestamp
-      participant.state = ActiveState
-    } else {
-      this._participants[anearParticipant.id] = this.participantRec(anearParticipant)
-    }
+  markActive(anearParticipant, withTimestamp = this.currentTimestamp) {
+    anearParticipant.timestamp = withTimestamp
+    anearParticipant.state = ActiveState
   }
 
-  purge({id}) {
-    if (id === this.host.id) {
-      this._host = JSON.parse(JSON.stringify(DefaultSettings)).host
+  purge(participant) {
+    if (!participant) return
+
+    const {id} = participant
+
+    if (this.host && (id === this.host.id)) {
+      this.host = null
     } else {
-      if (this._participants[id]) delete this._participants[id]
+      if (this._participants[id]) {
+        delete this._participants[id]
+      }
     }
   }
 
@@ -152,12 +156,17 @@ class Participants {
     return new Date().getTime()
   }
 
-  participantRec(anearParticipant, state = ActiveState) {
-    return {
-      ...anearParticipant.identity,
-      state,
-      timestamp: this.currentTimestamp
-    }
+  load(anearParticipants) {
+    // used for tests only
+    anearParticipants.forEach(
+      p => {
+        if (p.isHost() && this.anearEvent.hosted) {
+          this.host = p
+        } else {
+          this._participants[p.id] = p
+        }
+      }
+    )
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {

package/tests/AnearEvent.test.js

@@ -1,12 +1,12 @@
 "use strict"
 const { assign } = require('xstate')
-const { AnearEvent } = require('../lib/models/AnearEvent')
+const AnearEvent = require('../lib/models/AnearEvent')
 const AnearParticipant = require('../lib/models/AnearParticipant')
 const MockMessaging = require('../lib/messaging/__mocks__/AnearMessaging')
 
 const mockParticipantEnterHandler = jest.fn()
 const mockParticipantRefreshHandler = jest.fn()
-const mockParticipantCloseHandler = jest.fn()
+const mockParticipantExitHandler = jest.fn()
 const mockParticipantActionHandler = jest.fn()
 
 const TicTacToeMachineConfig = anearEvent => ({
@@ -30,8 +30,8 @@ const TicTacToeMachineConfig = anearEvent => ({
         REFRESH: {
           actions: 'refreshHandler'
         },
-        CLOSE: {
-          actions: 'closeHandler'
+        PARTICIPANT_EXIT: {
+          actions: 'participantExitHandler'
         }
       }
     },
@@ -40,8 +40,8 @@ const TicTacToeMachineConfig = anearEvent => ({
         BULLSEYE: {
           actions: 'actionHandler'
         },
-        CLOSE: {
-          actions: 'closeHandler'
+        PARTICIPANT_EXIT: {
+          actions: 'participantExitHandler'
         },
         REFRESH: {
           actions: 'refreshHandler'
@@ -59,8 +59,8 @@ const TicTacToeMachineOptions = anearEvent => ({
     refreshHandler: (context, event) => {
       anearEvent.myParticipantRefreshHandler(event.participant)
     },
-    closeHandler: (context, event) => {
-      anearEvent.myParticipantCloseHandler(event.participant)
+    participantExitHandler: (context, event) => {
+      anearEvent.myParticipantExitHandler(event.participant)
     },
     actionHandler: assign({score: (context, event) => context.score + event.payload.points}),
   }
@@ -84,8 +84,8 @@ class TestEvent extends AnearEvent {
   async myParticipantEnterHandler(...args) {
     return mockParticipantEnterHandler(...args)
   }
-  async myParticipantCloseHandler(...args) {
-    return mockParticipantCloseHandler(...args)
+  async myParticipantExitHandler(...args) {
+    return mockParticipantExitHandler(...args)
   }
   async myParticipantRefreshHandler(...args) {
     return mockParticipantRefreshHandler(...args)
@@ -110,8 +110,8 @@ class TestEventWithDefaultXState extends AnearEvent {
     return Promise.resolve()
   }
 
-  participantCloseEventCallback(participant) {
-    mockParticipantCloseHandler(participant)
+  participantExitEventCallback(participant) {
+    mockParticipantExitHandler(participant)
     return Promise.resolve()
   }
 
@@ -142,14 +142,14 @@ afterAll(async () => await TestEvent.close())
 afterEach(() => {jest.clearAllMocks()})
 
 const newTestEvent = (hosted = false) => {
-  const t = new TestEvent(chatEvent, MessagingStub)
+  const t = new TestEvent(chatEvent, TestPlayer, MessagingStub)
   t.attributes.hosted = hosted
   t.startStateMachine()
   return t
 }
 
 const newTestEventWithDefaultXState = testEvent => {
-  const t = new TestEventWithDefaultXState(testEvent, MessagingStub)
+  const t = new TestEventWithDefaultXState(testEvent, TestPlayer, MessagingStub)
   t.startStateMachine()
   return t
 }
@@ -162,7 +162,7 @@ test('participant enter with Default Xstate Config', async () => {
   expect(t.relationships.user.data.type).toBe("users")
   expect(t.anearStateMachine.currentState.value).toBe("eventActive")
   expect(t.stateMachineContext.playerScores[0]).toBe(83)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.participantEnter(p1)
   await t.persist()
@@ -171,7 +171,7 @@ test('participant enter with Default Xstate Config', async () => {
   expect(p1.userType).toBe("participant")
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p1)
-  expect(t.participants.numActive(false)).toBe(1)
+  expect(t.participants.numActive).toBe(1)
 
   await p1.remove()
 })
@@ -179,21 +179,21 @@ test('participant enter with Default Xstate Config', async () => {
 test('participant close with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
 
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
-  await t.participantClose(p1)
+  await t.participantExit(p1)
   await t.update()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p1)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(1)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(1)
+  expect(t.participants.numActive).toBe(0)
 
   await t.remove()
 })
 
 test('participant refresh with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.refreshParticipant(p1)
   await t.update()
@@ -206,7 +206,7 @@ test('participant refresh with Default Xstate Config', async () => {
 
 test('participant action with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
   const eventName = "TEST_ACTION"
   const payload = {x: 1, y: 99}
 
@@ -230,8 +230,8 @@ test('can be persisted and removed repeatedly in storage', async () => {
 
 test('can add participants, not hosted', async () => {
   let t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
   const id = t.id
 
   await t.participantEnter(p1)
@@ -240,27 +240,47 @@ test('can add participants, not hosted', async () => {
   expect(p1.userType).toBe("participant")
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p1)
-  expect(t.participants.numActive(false)).toBe(1)
-  expect(t.participants.host).toStrictEqual({})
+  expect(t.participants.numActive).toBe(1)
+  expect(t.participants.host).toBe(null)
 
   await t.participantEnter(p2)
   await t.update()
 
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(2)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p2)
-  expect(t.participants.numActive(false)).toBe(2)
+  expect(t.participants.numActive).toBe(2)
   expect(t.participants.get(p2).name).toBe("bbondfl93")
   expect(p2.userType).toBe("participant")
 
-  await t.participantClose(p1)
-  await t.participantClose(p2)
+  await t.participantExit(p1)
+  await t.participantExit(p2)
   await t.update()
   await t.remove()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p1)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p2)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(2)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
+  expect(t.participants.numActive).toBe(0)
+})
+
+test('purge all participants', async () => {
+  let t = newTestEvent(true)
+  const host = new TestPlayer(chatHost, t)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
+  await t.participantEnter(host)
+  await t.participantEnter(p1)
+  await t.participantEnter(p2)
+  await t.update()
+
+  expect(t.participants.host).toBe(host)
+  expect(t.participants.ids).toStrictEqual([p1.id, p2.id])
+
+  await t.purgeParticipants()
+
+  expect(t.participants.all).toHaveLength(0)
+
+  await t.remove()
 })
 
 
@@ -268,10 +288,10 @@ test('can add participant, hosted', async () => {
   let t = newTestEvent(true)
 
   expect(t.hosted).toBe(true)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(t.participants.numActive).toBe(0)
 
-  const host = new TestPlayer(chatHost)
-  const p2 = new TestPlayer(chatParticipant2)
+  const host = new TestPlayer(chatHost, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
   const id = t.id
 
   await t.participantEnter(host)
@@ -281,61 +301,66 @@ test('can add participant, hosted', async () => {
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(host)
   expect(t.participants.host.name).toBe('foxhole_host')
-  expect(t.participants.numActive(false)).toBe(0) // event creator when hosted isn't active participant
+  expect(t.participants.numActive).toBe(0) // event creator when hosted isn't active participant
 
   await t.participantEnter(p2)
   await t.update()
 
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(2)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p2)
-  expect(t.participants.numActive(false)).toBe(1)
+  expect(t.participants.numActive).toBe(1)
   expect(t.participants.get(p2).name).toBe('bbondfl93')
 
-  await t.participantClose(host)
-  await t.participantClose(p2)
+  await t.participantExit(host)
+  await t.participantExit(p2)
   await t.update()
   await t.remove()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(host)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p2)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(2)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(host)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
+  expect(t.participants.numActive).toBe(0)
 })
 
 test('can be retrieved back from storage with participants, not hosted', async () => {
   const testEvent = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, testEvent)
+  const p2 = new TestPlayer(chatParticipant2, testEvent)
 
   await testEvent.participantEnter(p1)
   await testEvent.participantEnter(p2)
   await testEvent.persist()
 
   const rehydratedTestEvent = await TestEvent.getFromStorage(testEvent.id, MessagingStub)
-  const rehydratedPlayer1 = await TestPlayer.getFromStorage(p1.id)
-  const rehydratedPlayer2 = await TestPlayer.getFromStorage(p2.id)
 
   rehydratedTestEvent.startStateMachine()
 
-  expect(rehydratedTestEvent.participants.numActive(false)).toBe(2)
+  await rehydratedTestEvent.participantEnter(p1)
+  await rehydratedTestEvent.participantEnter(p2)
+
+  expect(rehydratedTestEvent.participants.numActive).toBe(2)
   expect(rehydratedTestEvent.id).toBe(testEvent.id)
   expect(rehydratedTestEvent.relationships['user'].data.type).toBe("users")
   expect(rehydratedTestEvent.relationships['zone'].data.type).toBe("zones")
   expect(rehydratedTestEvent.participantTimeout).toBe(32000)
   expect(rehydratedTestEvent.stateMachineContext.score).toBe(90)
   expect(rehydratedTestEvent.included[0].relationships.app.data.id).toBe("5b9d9838-17de-4a80-8a64-744c222ba722")
-  expect(rehydratedPlayer1.context.name).toBe('machvee')
-  expect(rehydratedPlayer2.context.name).toBe('bbondfl93')
 
-  await rehydratedTestEvent.participantClose(rehydratedPlayer1)
-  await rehydratedTestEvent.participantClose(rehydratedPlayer2)
+  const rp1 = rehydratedTestEvent.participants.getById(p1.id)
+  const rp2 = rehydratedTestEvent.participants.getById(p2.id)
+
+  expect(rehydratedTestEvent.participants.getById(rp1.id).context.name).toBe('machvee')
+  expect(rehydratedTestEvent.participants.getById(rp2.id).context.name).toBe('bbondfl93')
+
+  await rehydratedTestEvent.participantExit(rp1)
+  await rehydratedTestEvent.participantExit(rp2)
   await rehydratedTestEvent.remove()
 })
 
 test('can update state machine context via Action events', async () => {
   const t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
 
   await t.participantEnter(p1)
   await t.participantEnter(p2)
@@ -354,7 +379,8 @@ test('can update state machine context via Action events', async () => {
 
   expect(t.anearStateMachine.context.score).toBe(92)
 
-  await t.participantClose(p1)
-  await t.participantClose(p2)
+  await t.participantExit(p1)
+  await t.participantExit(p2)
+  await t.closeOutParticipants()
   await t.remove()
 })