📦 sleepyfran / duets

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79module Duets.Simulation.Tests.Bands.HireMember

open Test.Common
open NUnit.Framework
open FsUnit

open Duets.Entities
open Duets.Simulation
open Duets.Simulation.Bands.Members

let instrument = Instrument.createInstrument Guitar

let skillLevel = 50

let state =
    dummyState
    |> addSkillTo
        dummyCharacter
        (Skill.createWithLevel SkillId.Composition skillLevel)
    |> addSkillTo
        dummyCharacter
        (Skill.createWithLevel (SkillId.Genre dummyBand.Genre) skillLevel)

let assertOnMembers assertion =
    membersForHire state dummyBand instrument.Type
    |> Seq.take 20
    |> Seq.iter assertion

let memberForHire =
    membersForHire state dummyBand instrument.Type |> Seq.take 1 |> Seq.head

let hiredMember = Band.Member.fromMemberForHire dummyToday memberForHire

[<Test>]
let MembersForHireShouldExposeMembersOfGivenInstrument () =
    assertOnMembers (fun m -> m.Role |> should equal Guitar)

[<Test>]
let MembersForHireShouldExposeMembersWithAtLeastThreeSkills () =
    assertOnMembers (fun m -> m.Skills |> should haveLength 3)

[<Test>]
let MembersForHireShouldExposeMembersWithSkillLevelAroundBandsAverage () =
    let assertLevelRange =
        fun (_, level) ->
            level |> should be (lessThanOrEqualTo (skillLevel + 5))

            level |> should be (greaterThanOrEqualTo (skillLevel - 5))

    assertOnMembers (fun m -> List.iter assertLevelRange m.Skills)

[<Test>]
let MembersForHireShouldExposeMembersWithAgeAroundBandsAverage () =
    let characterAge = Queries.Characters.ageOf state dummyCharacter

    let assertAgeRange =
        fun age ->
            age |> should be (lessThanOrEqualTo (characterAge + 5<years>))

            age |> should be (greaterThanOrEqualTo (characterAge - 5<years>))

    assertOnMembers (fun m ->
        Queries.Characters.ageOf state m.Character |> assertAgeRange)

[<Test>]
let HireMemberShouldGeneratedHiredMemberEffect () =
    hireMember state dummyBand memberForHire
    |> should
        be
        (ofCase
            <@
                MemberHired(
                    dummyBand,
                    memberForHire.Character,
                    hiredMember,
                    memberForHire.Skills
                )
            @>)