volleyballsimtypes 0.0.1

package/src/service/match/match.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from '@jest/globals'
+import { Match } from './match'
+import { noLiberoTeam, team } from '../team/__stubs__'
+import { Team } from '../team'
+import { finishedSet, inProgressSet, newSet } from './__stubs__'
+import { MatchTeam } from './match-team'
+
+describe('Match Test Module', () => {
+  let match: Match
+
+  beforeEach(() => {
+    match = new Match({
+      id: '1f7f63bc-6bfd-4f3d-bc46-b8c6d210664e',
+      sets: [],
+      homeTeam: team,
+      awayTeam: noLiberoTeam,
+      scheduledDate: new Date('2020-01-01')
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(match.id).toBe('1f7f63bc-6bfd-4f3d-bc46-b8c6d210664e')
+    expect(match.homeTeam.id).toBe(team.id)
+    expect(match.awayTeam.id).toBe(noLiberoTeam.id)
+    expect(match.sets.length).toBe(0)
+    expect(match.scheduledDate.toUTCString()).toBe('Wed, 01 Jan 2020 00:00:00 GMT')
+  })
+  // addSet Tests
+  test('Should add a set to sets array', () => {
+    expect(match.sets.length).toBe(0)
+    match.addSet(newSet)
+    expect(match.sets.length).toBe(1)
+  })
+  test('Should throw an Error when trying to add a set after limit was reached', () => {
+    match.addSet(newSet)
+    match.addSet(newSet)
+    match.addSet(newSet)
+
+    function add (): void { match.addSet(newSet) }
+
+    expect(add).toThrow(/^SET_AMOUNT_EXCEEDED$/)
+  })
+  // getTeamSets Tests
+  test('Should return proper amount of sets per team', () => {
+    expect(match.getTeamSets(MatchTeam.HOME)).toBe(0)
+    match.addSet(finishedSet)
+    expect(match.getTeamSets(MatchTeam.HOME)).toBe(1)
+    expect(match.getTeamSets(MatchTeam.AWAY)).toBe(0)
+    match.addSet(inProgressSet)
+    expect(match.getTeamSets(MatchTeam.AWAY)).toBe(0)
+  })
+  // isOver Tests
+  test('Should return false when match is not over', () => {
+    expect(match.isOver()).toBe(false)
+    match.addSet(finishedSet)
+    expect(match.isOver()).toBe(false)
+  })
+  test('Should return true when match is over', () => {
+    match.addSet(finishedSet)
+    match.addSet(finishedSet)
+    match.addSet(finishedSet)
+
+    expect(match.isOver()).toBe(true)
+  })
+  // getWinner Tests
+  test('Should throw an Error when getting winner of unfinished match', () => {
+    function win (): void { match.getWinner() }
+
+    expect(win).toThrow(/^UNFINISHED_MATCH$/)
+  })
+  test('Should return winning team', () => {
+    match.addSet(finishedSet)
+    match.addSet(finishedSet)
+    match.addSet(finishedSet)
+
+    const winner: Team = match.getWinner()
+
+    expect(winner.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd')
+  })
+})

package/src/service/match/match.ts

@@ -0,0 +1,63 @@
+import { MatchSet } from './match-set'
+import { Team } from '../team'
+import { validateUUID } from '../utils'
+import { MatchTeam } from './match-team'
+
+interface MatchOpts {
+  readonly id: string
+  readonly homeTeam: Team
+  readonly awayTeam: Team
+  readonly scheduledDate: Date
+  readonly sets: MatchSet[]
+}
+
+export class Match {
+  static readonly BEST_OF = 5
+  readonly id: string
+  readonly homeTeam: Team
+  readonly awayTeam: Team
+  readonly sets: MatchSet[]
+  readonly scheduledDate: Date
+
+  constructor ({ id, homeTeam, awayTeam, scheduledDate, sets }: MatchOpts) {
+    validateUUID(id)
+
+    this.id = id
+    this.homeTeam = homeTeam
+    this.awayTeam = awayTeam
+    this.scheduledDate = scheduledDate
+    this.sets = sets
+  }
+
+  public addSet (set: MatchSet): void {
+    if (this.sets.length >= Match.BEST_OF) throw new Error('SET_AMOUNT_EXCEEDED')
+
+    this.sets.push(set)
+  }
+
+  public getTeamSets (team: MatchTeam): number {
+    return this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0)
+  }
+
+  public isOver (): boolean {
+    const gamesRequired: number = Math.ceil(Match.BEST_OF / 2)
+    const lastSet: MatchSet | undefined = this.sets.at(-1)
+
+    if (lastSet == null || !lastSet.isOver() || this.sets.length < gamesRequired) return false
+
+    const homeSets: number = this.getTeamSets(MatchTeam.HOME)
+    const awaySets: number = this.getTeamSets(MatchTeam.AWAY)
+
+    // Check if any of the teams has enough sets to win.
+    return !(homeSets < gamesRequired && awaySets < gamesRequired)
+  }
+
+  public getWinner (): Team {
+    if (!this.isOver()) throw new Error('UNFINISHED_MATCH')
+
+    const homeSets: number = this.getTeamSets(MatchTeam.HOME)
+    const awaySets: number = this.getTeamSets(MatchTeam.AWAY)
+
+    return homeSets > awaySets ? this.homeTeam : this.awayTeam
+  }
+}

package/src/service/match/rally.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from '@jest/globals'
+import { Rally, RallyState } from './rally'
+import { score, serve } from '../event/__stubs__'
+import { EventType } from '../event/rally-event'
+import { team } from '../team/__stubs__'
+
+describe('Rally Test Module', () => {
+  let rally: Rally
+
+  beforeEach(() => {
+    rally = new Rally({
+      events: [],
+      order: 0,
+      servingTeam: team,
+      id: '0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9',
+      homePlayerPosition: [],
+      awayPlayerPosition: []
+    })
+  })
+
+  test('Should instantiate the object properly', () => {
+    expect(rally.id).toBe('0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9')
+    expect(rally.servingTeam.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd')
+    expect(rally.events.length).toBe(0)
+    expect(rally.state).toBe(0)
+  })
+  // nextState Tests
+  test('Should cycle through states correctly', () => {
+    expect(rally.state).toBe(0)
+    rally.nextState()
+    expect(rally.state).toBe(1)
+    rally.nextState()
+    expect(rally.state).toBe(2)
+    rally.nextState()
+    expect(rally.state).toBe(3)
+  })
+  test('Should throw Error when trying to get next state after FINISHED', () => {
+    function state (): void {
+      rally.nextState()
+      rally.nextState()
+      rally.nextState()
+      rally.nextState()
+    }
+
+    expect(state).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/)
+  })
+  // addEvent Tests
+  test('Should add event to event array', () => {
+    expect(rally.events.length).toBe(0)
+    rally.addEvent(serve)
+    expect(rally.events.at(-1)?.eventType).toBe(EventType.SERVE)
+  })
+  // isOver Tests
+  test('Should return false if rally state is not FINISHED', () => {
+    expect(rally.state).toBe(0)
+    expect(rally.isOver()).toBe(false)
+  })
+  test('Should return true if rally state is FINISHED', () => {
+    rally.nextState()
+    rally.nextState()
+    rally.nextState()
+
+    expect(rally.state).toBe(3)
+    expect(rally.isOver()).toBe(true)
+  })
+  // getScore Tests
+  test('Should return undefined if events array does not contain a Score', () => {
+    rally.addEvent(serve)
+    expect(rally.score).toBeUndefined()
+  })
+  test('Should return Score if events array contains a Score', () => {
+    rally.addEvent(score)
+    expect(rally.score).not.toBeUndefined()
+    expect(rally.score?.eventType).toBe(EventType.SCORE)
+  })
+  // RallyState Tests
+  test('Should get next state', () => {
+    expect(RallyState.nextState(0)).toBe(1)
+    expect(RallyState.nextState(1)).toBe(2)
+  })
+  test('Should throw Error for state outside range', () => {
+    function fn1 (): void { RallyState.nextState(-1) }
+
+    function fn2 (): void { RallyState.nextState(4) }
+
+    expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/)
+    expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/)
+  })
+  test('Should throw Error for last state', () => {
+    function fn (): void { RallyState.nextState(3) }
+
+    expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/)
+  })
+})

package/src/service/match/rally.ts

@@ -0,0 +1,79 @@
+import { validateUUID } from '../utils'
+import { Team } from '../team'
+import { CourtPosition } from './court-position'
+import { EventType, RallyEvent } from '../event/rally-event'
+import { Score } from '../event/score'
+
+interface RallyOpts {
+  readonly id: string
+  readonly order: number
+  readonly servingTeam: Team
+  readonly events: RallyEvent[]
+  readonly homePlayerPosition: PlayerPosition[]
+  readonly awayPlayerPosition: PlayerPosition[]
+}
+
+export interface PlayerPosition {
+  position: CourtPosition
+  playerId: string
+}
+
+export enum RallyState {
+  NEW = 0,
+  MANAGEMENT = 1,
+  IN_PLAY = 2,
+  FINISHED = 3
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace RallyState {
+  export function nextState (state: number): RallyState {
+    if (state < 0 || state > 3) throw new Error('STATE_INDEX_OUT_OF_BOUNDS')
+    if (state === 3) throw new Error(`CANT_GET_STATE_AFTER: ${RallyState[state]}`)
+
+    return state + 1
+  }
+}
+
+export class Rally {
+  readonly id: string
+  readonly servingTeam: Team
+  readonly events: RallyEvent[]
+  readonly homePlayerPosition: PlayerPosition[]
+  readonly awayPlayerPosition: PlayerPosition[]
+  readonly order: number
+
+  constructor ({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts) {
+    validateUUID(id)
+
+    this.id = id
+    this.order = order
+    this.servingTeam = servingTeam
+    this.homePlayerPosition = homePlayerPosition
+    this.awayPlayerPosition = awayPlayerPosition
+    this.events = events
+    this._state = RallyState.NEW
+  }
+
+  private _state: RallyState
+
+  get state (): RallyState {
+    return this._state
+  }
+
+  public get score (): Score | undefined {
+    return this.events.find(e => e.eventType === EventType.SCORE) as Score
+  }
+
+  public isOver (): boolean {
+    return this._state === RallyState.FINISHED
+  }
+
+  public addEvent (event: RallyEvent): void {
+    this.events.push(event)
+  }
+
+  public nextState (): void {
+    this._state = RallyState.nextState(this._state)
+  }
+}