volleyballsimtypes 0.0.7 → 0.0.8

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

@@ -1,80 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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)
-  }
-}