some-automoderation/rooms/room_release_hand_test.go

package rooms

import (
	"testing"

	"github.com/kr/pretty"
)

type releaseHandTest struct {
	testName               string
	room, expected         Room
	releasingParticipantId PersonId
}

var releaseHandTests = []releaseHandTest{
	singleHandActive,
	raisingLevelFromExpandToMetaQ,
	selectNextHigherLevel,
	usingMarkToLoverLevel,
	releasingNonSpeakerHand,
	releaseToPersonWithHandAndMark,
	raisingLevelSetMarksWithoutOverridingExisting,
	releaseAllMarksWhenNoSpeaker,
}

func TestRoomReleaseHand(t *testing.T) {
	for _, test := range releaseHandTests {
		t.Run(test.testName, func(t *testing.T) {
			test.room.InitMaps()
			test.expected.InitMaps()
			if test.room.ReleaseHand(test.releasingParticipantId); !test.room.Equal(&test.expected) {
				t.Logf("room state is %+v", test.room)
				t.Logf("expected state is %+v", test.expected)
				t.Errorf("Test release hand diff: (-want +got)\n%s", pretty.Diff(test.room, test.expected))
			}
		})
	}
}

var person1 = Person{
	Id:   PersonId(100),
	Name: "test person 1",
}
var person2 = Person{
	Id:   PersonId(200),
	Name: "test person 2",
}
var person3 = Person{
	Id:   PersonId(300),
	Name: "test person 3",
}
var person4 = Person{
	Id:   PersonId(400),
	Name: "test person 4",
}

// 2 persons, 1 hand active, releasing it makes 'nobody' active
var singleHandActive releaseHandTest = releaseHandTest{
	testName: "singleHandActive",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person1.Id,
		AllKnownPeople: map[PersonId]Person{
			person1.Id: person1,
			person2.Id: person2,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person1.Id: Expand,
		},
	},
	releasingParticipantId: person1.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: PersonId(0),
		AllKnownPeople: map[PersonId]Person{
			person1.Id: person1,
			person2.Id: person2,
		},
		ParticipantHands: map[PersonId]HandGesture{},
	},
}

// 3 person in room, active does expand, next is probingQ,
// this sets mark for all levels between levels
// so going down by many levels - starts from marked person due to 'count from' logic
// that uses marks from higher level if current level doesn't have a mark
// but also going down by 1 step keeps the marks until we return to initially diverged
// conversation layer
var raisingLevelFromExpandToMetaQ releaseHandTest = releaseHandTest{
	testName: "raisingLevelFromExpandToMetaQ",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person1.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person1.Id: Expand,
			person3.Id: Meta,
		},
	},
	releasingParticipantId: person1.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{
			Expand: person1.Id,
			ClarifyingQ: person1.Id,
		},
	},
}

// 3 person in room, active does expand, next is meta,
// this sets mark between level of current speaker and next speaker
var raisingLevelSetMarksWithoutOverridingExisting releaseHandTest = releaseHandTest{
	testName: "raisingLevelSetMarksWithoutOverridingExisting",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person1.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person1.Id: Expand,
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{
			ChangeTopic: person2.Id,
		},
	},
	releasingParticipantId: person1.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{
			ChangeTopic: person2.Id,
			Expand: person1.Id,
			ClarifyingQ: person1.Id,
		},
	},
}

// 3 person in room, active does expand, next is probingQ, this sets mark for expand
var selectNextHigherLevel releaseHandTest = releaseHandTest{
	testName: "selectNextHigherLevel",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person1.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person1.Id: Meta,
			person2.Id: Expand,
			person3.Id: Meta,
		},
	},
	releasingParticipantId: person1.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{},
	},
}

// 4 person in room, returning to lover level, start not from cur speaker, but from mark
var usingMarkToLoverLevel releaseHandTest = releaseHandTest{
	testName: "usingMarkToLoverLevel",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person3.Id: Meta,
			person4.Id: Expand,
		},
		Marks: map[HandGesture]PersonId{
			ClarifyingQ: person3.Id,
			Expand:      person1.Id,
		},
	},
	releasingParticipantId: person3.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person2.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person4.Id: Expand,
		},
		Marks: map[HandGesture]PersonId{},
	},
}

// 4 person in room, releasing hand for non-speaker changes nothing else
var releasingNonSpeakerHand releaseHandTest = releaseHandTest{
	testName: "releasingNonSpeakerHand",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person3.Id: Meta,
			person4.Id: Expand,
		},
		Marks: map[HandGesture]PersonId{
			ClarifyingQ: person3.Id,
			Expand:      person1.Id,
		},
	},
	releasingParticipantId: person4.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{
			ClarifyingQ: person3.Id,
			Expand:      person1.Id,
		},
	},
}

// there is a mark for Expand on person 2, and raised hand with Expand on person 2
// speaker is person 3 with Meta
// after hand release person 2 should be speaking, with mark removed
var releaseToPersonWithHandAndMark releaseHandTest = releaseHandTest{
	testName: "releaseToPersonWithHandAndMark",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person3.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
			person3.Id: Meta,
		},
		Marks: map[HandGesture]PersonId{
			Expand: person2.Id,
		},
	},
	releasingParticipantId: person3.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: person2.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person2.Id: Expand,
		},
		Marks: map[HandGesture]PersonId{},
	},
}

// there is a mark for Expand on person 2, mark for Change Topic on person 3
// speaker is person 1 with Expand
// after hand release person nobody should be speaking, with all marks removed
var releaseAllMarksWhenNoSpeaker releaseHandTest = releaseHandTest{
	testName: "releaseAllMarksWhenNoSpeaker",
	room: Room{
		Name:           "test",
		CurrentSpeaker: person1.Id,
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{
			person1.Id: Expand,
		},
		Marks: map[HandGesture]PersonId{
			Expand: person2.Id,
			ChangeTopic: person3.Id,
		},
	},
	releasingParticipantId: person1.Id,
	expected: Room{
		Name:           "test",
		CurrentSpeaker: PersonId(0),
		Paricipants: []PersonId{
			person1.Id,
			person2.Id,
			person3.Id,
			person4.Id,
		},
		ParticipantHands: map[PersonId]HandGesture{},
		Marks: map[HandGesture]PersonId{},
	},
}