Files

124 lines
4.6 KiB
Go

package judgement
import "testing"
// TestAutonomyIsEarnedSlowlyAndLostAtOnce guards the earned-autonomy seam: a
// class earns a proposal to loosen only after N approvals in a row since it was
// last tightened, loosens only when that proposal is approved, drops to propose
// and wait at once on a denial or a failure (and never loosens by doing so),
// and a freeze holds changing actions without touching the class level.
func TestAutonomyIsEarnedSlowlyAndLostAtOnce(t *testing.T) {
const need = 3
tests := []struct {
name string
start standing
events []event
want standing
wantPropose int
frozen bool
readOnly bool
wantHeld Level
}{
{
name: "fewer than N approvals propose nothing", start: standing{level: ProposeAndWait},
events: []event{approved, approved}, want: standing{level: ProposeAndWait, count: 2},
wantHeld: ProposeAndWait,
},
{
name: "the Nth approval proposes one level up", start: standing{level: ProposeAndWait},
events: []event{approved, approved, approved},
want: standing{level: ProposeAndWait, count: 3, raiseTo: ActAndTell}, wantPropose: 1,
wantHeld: ProposeAndWait,
},
{
name: "approvals while a proposal waits propose nothing more", start: standing{level: ProposeAndWait},
events: []event{approved, approved, approved, approved, approved},
want: standing{level: ProposeAndWait, count: 5, raiseTo: ActAndTell}, wantPropose: 1,
wantHeld: ProposeAndWait,
},
{
name: "an approved proposal raises the class and restarts the count", start: standing{level: ProposeAndWait},
events: []event{approved, approved, approved, raiseApproved},
want: standing{level: ActAndTell}, wantPropose: 1,
wantHeld: ActAndTell,
},
{
name: "a refused proposal leaves the level and restarts the count", start: standing{level: ProposeAndWait},
events: []event{approved, approved, approved, raiseRefused},
want: standing{level: ProposeAndWait}, wantPropose: 1,
wantHeld: ProposeAndWait,
},
{
name: "a denial restarts the count", start: standing{level: ProposeAndWait},
events: []event{approved, approved, denied, approved, approved},
want: standing{level: ProposeAndWait, count: 2},
wantHeld: ProposeAndWait,
},
{
name: "a denial drops a raised class to propose and wait", start: standing{level: ActAndTell},
events: []event{denied}, want: standing{level: ProposeAndWait},
wantHeld: ProposeAndWait,
},
{
name: "a failure drops a raised class and withdraws the proposal", start: standing{level: ActAndTell, count: 3, raiseTo: ActQuietly},
events: []event{failed}, want: standing{level: ProposeAndWait},
wantHeld: ProposeAndWait,
},
{
name: "a failure never loosens a class that escalates", start: standing{level: Escalate},
events: []event{failed}, want: standing{level: Escalate},
wantHeld: Escalate,
},
{
name: "a proposal answered after the class dropped changes nothing", start: standing{level: ProposeAndWait, count: 3, raiseTo: ActQuietly},
events: []event{raiseApproved}, want: standing{level: ProposeAndWait, count: 3},
wantHeld: ProposeAndWait,
},
{
name: "a class that acts quietly proposes nothing", start: standing{level: ActQuietly},
events: []event{approved, approved, approved}, want: standing{level: ActQuietly, count: 3},
wantHeld: ActQuietly,
},
{
name: "a class that never runs proposes nothing", start: standing{level: Never},
events: []event{approved, approved, approved}, want: standing{level: Never, count: 3},
wantHeld: Never,
},
{
name: "a freeze holds a raised class and keeps its level", start: standing{level: ActAndTell},
want: standing{level: ActAndTell}, frozen: true,
wantHeld: ProposeAndWait,
},
{
name: "a freeze leaves reading alone", start: standing{level: ActQuietly},
want: standing{level: ActQuietly}, frozen: true, readOnly: true,
wantHeld: ActQuietly,
},
{
name: "a freeze never loosens a class that escalates", start: standing{level: Escalate},
want: standing{level: Escalate}, frozen: true,
wantHeld: Escalate,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, proposals := tt.start, 0
for _, e := range tt.events {
var propose bool
if got, propose = got.after(e, need); propose {
proposals++
}
}
if got != tt.want {
t.Fatalf("standing = %+v, want %+v", got, tt.want)
}
if proposals != tt.wantPropose {
t.Fatalf("proposals = %d, want %d", proposals, tt.wantPropose)
}
if held := lowest(got.level, freezeCeiling(tt.frozen, tt.readOnly)); held != tt.wantHeld {
t.Fatalf("held at %s, want %s", held, tt.wantHeld)
}
})
}
}