dkforest

commit 9f81888e7a59be6f8be250e81bf2c51ae2574ec8
parent e41bd45bfcd71a7a50272681407e286cda8fe01c
Author: n0tr1v <n0tr1v@protonmail.com>
Date:   Thu,  7 Dec 2023 17:28:11 -0500

cleanup

Diffstat:
M
pkg/web/handlers/poker/poker.go
 | 
21
++++++++++++++-------
M
pkg/web/handlers/poker/poker_test.go
 | 
59
+++++++++++++----------------------------------------------

2 files changed, 27 insertions(+), 53 deletions(-)
diff --git a/pkg/web/handlers/poker/poker.go b/pkg/web/handlers/poker/poker.go
@@ -169,19 +169,26 @@ func (g *Ongoing) computeWinners() (winner []GameResult) {
 
 	arr := make([]GameResult, 0)
 	for k, v := range m {
-		sort.Slice(v, func(i, j int) bool {
-			if v[i].Cash == v[j].Cash {
-				return v[i].RoundTotalBet < v[j].RoundTotalBet
-			}
-			return v[i].Cash < v[j].Cash
-		})
 		arr = append(arr, GameResult{HandScore: k, Players: v})
 	}
-	sort.Slice(arr, func(i, j int) bool { return arr[i].HandScore < arr[j].HandScore })
+	sortGameResults(arr)
 
 	return arr
 }
 
+// Sort players by cash remaining (to have all-ins first), then by RoundTotalBet.
+func sortGameResults(arr []GameResult) {
+	for idx := range arr {
+		sort.Slice(arr[idx].Players, func(i, j int) bool {
+			if arr[idx].Players[i].Cash == arr[idx].Players[j].Cash {
+				return arr[idx].Players[i].RoundTotalBet < arr[idx].Players[j].RoundTotalBet
+			}
+			return arr[idx].Players[i].Cash < arr[idx].Players[j].Cash
+		})
+	}
+	sort.Slice(arr, func(i, j int) bool { return arr[i].HandScore < arr[j].HandScore })
+}
+
 func (g *Ongoing) AddEvent(evts ...PokerEvent) {
 	g.EventsMtx.Lock()
 	defer g.EventsMtx.Unlock()
diff --git a/pkg/web/handlers/poker/poker_test.go b/pkg/web/handlers/poker/poker_test.go
@@ -1,8 +1,8 @@
 package poker
 
 import (
+	"github.com/stretchr/testify/assert"
 	"reflect"
-	"sync"
 	"testing"
 )
 
@@ -30,50 +30,17 @@ func Test_reorderPlayers(t *testing.T) {
 	}
 }
 
-func TestOngoing_computeWinners(t *testing.T) {
-	type fields struct {
-		Deck             []string
-		Players          []*PokerPlayer
-		Events           []PokerEvent
-		EventsMtx        sync.RWMutex
-		LogEvents        []LogEvent
-		LogEventsMtx     sync.RWMutex
-		CommunityCards   []string
-		WaitTurnEvent    PokerWaitTurnEvent
-		WaitTurnEventMtx sync.RWMutex
-		MainPot          int
-		MainPotMtx       sync.RWMutex
-	}
-	tests := []struct {
-		name           string
-		fields         fields
-		wantWinner     *PokerPlayer
-		wantWinnerHand string
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			g := &Ongoing{
-				Deck:             tt.fields.Deck,
-				Players:          tt.fields.Players,
-				Events:           tt.fields.Events,
-				EventsMtx:        tt.fields.EventsMtx,
-				LogEvents:        tt.fields.LogEvents,
-				LogEventsMtx:     tt.fields.LogEventsMtx,
-				CommunityCards:   tt.fields.CommunityCards,
-				WaitTurnEvent:    tt.fields.WaitTurnEvent,
-				WaitTurnEventMtx: tt.fields.WaitTurnEventMtx,
-				MainPot:          tt.fields.MainPot,
-				MainPotMtx:       tt.fields.MainPotMtx,
-			}
-			gotWinner, gotWinnerHand := g.computeWinners()
-			if !reflect.DeepEqual(gotWinner, tt.wantWinner) {
-				t.Errorf("computeWinners() gotWinner = %v, want %v", gotWinner, tt.wantWinner)
-			}
-			if gotWinnerHand != tt.wantWinnerHand {
-				t.Errorf("computeWinners() gotWinnerHand = %v, want %v", gotWinnerHand, tt.wantWinnerHand)
-			}
-		})
+func Test_sortGameResults(t *testing.T) {
+	p1 := &PokerPlayer{Cash: 0, RoundTotalBet: 10, Username: "p1"}
+	p2 := &PokerPlayer{Cash: 0, RoundTotalBet: 20, Username: "p2"}
+	p3 := &PokerPlayer{Cash: 0, RoundTotalBet: 30, Username: "p3"}
+	p4 := &PokerPlayer{Cash: 1, RoundTotalBet: 100, Username: "p4"}
+	arr := []GameResult{
+		{1, []*PokerPlayer{p2, p4, p1, p3}},
 	}
+	sortGameResults(arr)
+	assert.Equal(t, "p1", arr[0].Players[0].Username)
+	assert.Equal(t, "p2", arr[0].Players[1].Username)
+	assert.Equal(t, "p3", arr[0].Players[2].Username)
+	assert.Equal(t, "p4", arr[0].Players[3].Username)
 }