667 lines
28 KiB
Go
667 lines
28 KiB
Go
package result
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
|
|
)
|
|
|
|
func TestEvaluateFullTimeResult(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Home win", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"Away win", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"Draw", domain.BetOutcome{OddName: "Draw"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"Home selected, but Draw", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateFullTimeResult(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateTotalLegs(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"OverTotalLegs", domain.BetOutcome{OddName: "3", OddHeader: "Over"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"OverTotalLegs", domain.BetOutcome{OddName: "3", OddHeader: "Under"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
{"UnderTotalLegs", domain.BetOutcome{OddName: "7", OddHeader: "Under"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateTotalLegs(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateGameLines(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"GameLines - Total", domain.BetOutcome{OddName: "Total", OddHandicap: "O 5.5"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"GameLines - Total", domain.BetOutcome{OddName: "Total", OddHandicap: "O 5.5"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_LOSS},
|
|
{"GameLines - Money Line", domain.BetOutcome{OddName: "Money Line", OddHeader: "1"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_LOSS},
|
|
{"GameLines - Money Line", domain.BetOutcome{OddName: "Money Line", OddHeader: "1"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateGameLines(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateFirstTeamToScore(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
events []map[string]string
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"HomeScoreFirst", domain.BetOutcome{OddName: "1", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
|
|
{"text": "1st Goal - Team A"},
|
|
}, domain.OUTCOME_STATUS_WIN},
|
|
{"AwayScoreFirst", domain.BetOutcome{OddName: "2", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
|
|
{"text": "1st Goal - Team A"},
|
|
}, domain.OUTCOME_STATUS_LOSS},
|
|
{"AwayScoreFirst", domain.BetOutcome{OddName: "2", HomeTeamName: "Team A", AwayTeamName: "Team B"}, []map[string]string{
|
|
{"text": "1st Goal - Team B"},
|
|
}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateFirstTeamToScore(tt.outcome, tt.events)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateGoalsOverUnder(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"LosingGoalsOver", domain.BetOutcome{OddHeader: "Over", OddName: "13"}, struct{ Home, Away int }{7, 5}, domain.OUTCOME_STATUS_LOSS},
|
|
{"WinningGoalsOver", domain.BetOutcome{OddHeader: "Over", OddName: "11"}, struct{ Home, Away int }{7, 5}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningGoalsUnder", domain.BetOutcome{OddHeader: "Under", OddName: "12"}, struct{ Home, Away int }{6, 5}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateGoalsOverUnder(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateGoalsOddEven(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningOddGoals", domain.BetOutcome{OddName: "Odd"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingEvenGoals", domain.BetOutcome{OddName: "Even"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
{"WinningEvenGoals", domain.BetOutcome{OddName: "Even"}, struct{ Home, Away int }{6, 6}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateGoalsOddEven(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateCorrectScore(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"CorrectScore", domain.BetOutcome{OddName: "7-4"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"CorrectScore", domain.BetOutcome{OddName: "6-6"}, struct{ Home, Away int }{6, 6}, domain.OUTCOME_STATUS_WIN},
|
|
{"IncorrectScore", domain.BetOutcome{OddName: "2-3"}, struct{ Home, Away int }{7, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateCorrectScore(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateHighestScoringHalf(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
firstScore struct{ Home, Away int }
|
|
secondScore struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Winning1stHalf", domain.BetOutcome{OddName: "1st Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"Losing1stHalf", domain.BetOutcome{OddName: "1st Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"Losing2ndHalf", domain.BetOutcome{OddName: "2nd Half"}, struct{ Home, Away int }{0, 0}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
|
|
{"Winning2ndHalf", domain.BetOutcome{OddName: "2nd Half"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateHighestScoringHalf(tt.outcome, tt.firstScore, tt.secondScore)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestEvaluateHighestScoringQuarter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
firstScore struct{ Home, Away int }
|
|
secondScore struct{ Home, Away int }
|
|
thirdScore struct{ Home, Away int }
|
|
fourthScore struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Winning1stQuarter", domain.BetOutcome{OddName: "1st Quarter"},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
struct{ Home, Away int }{1, 0},
|
|
struct{ Home, Away int }{0, 0},
|
|
domain.OUTCOME_STATUS_WIN},
|
|
{"Losing1stQuarter", domain.BetOutcome{OddName: "1st Quarter"},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
domain.OUTCOME_STATUS_LOSS},
|
|
{"Losing2ndQuarter", domain.BetOutcome{OddName: "2nd Quarter"},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
domain.OUTCOME_STATUS_LOSS},
|
|
{"Winning3rdQuarter", domain.BetOutcome{OddName: "3rd Quarter"},
|
|
struct{ Home, Away int }{1, 0},
|
|
struct{ Home, Away int }{0, 0},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
domain.OUTCOME_STATUS_WIN},
|
|
{"Wining4thQuarter", domain.BetOutcome{OddName: "4th Quarter"},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{0, 0},
|
|
struct{ Home, Away int }{1, 1},
|
|
struct{ Home, Away int }{2, 2},
|
|
domain.OUTCOME_STATUS_WIN},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateHighestScoringQuarter(tt.outcome, tt.firstScore, tt.secondScore, tt.thirdScore, tt.fourthScore)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestEvaluateWinningMargin(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningMargin", domain.BetOutcome{OddHeader: "1", OddName: "12"}, struct{ Home, Away int }{12, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningMargin", domain.BetOutcome{OddHeader: "2", OddName: "3"}, struct{ Home, Away int }{1, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningMargin", domain.BetOutcome{OddHeader: "1", OddName: "3+"}, struct{ Home, Away int }{4, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningMargin", domain.BetOutcome{OddHeader: "2", OddName: "12+"}, struct{ Home, Away int }{0, 13}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingMargin", domain.BetOutcome{OddHeader: "2", OddName: "3"}, struct{ Home, Away int }{0, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingMargin", domain.BetOutcome{OddHeader: "2", OddName: "3+"}, struct{ Home, Away int }{1, 3}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateWinningMargin(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateDoubleResult(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
firstHalfScore struct{ Home, Away int }
|
|
fullTimeScore struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHomeAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - Team B"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayHome", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B - Team A"}, struct{ Home, Away int }{0, 1}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTie", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Tie"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTieAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Team B"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHomeAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - Team B"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{2, 0}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingTie", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Tie"}, struct{ Home, Away int }{1, 0}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingTieAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Tie - Team A"}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"BadInput", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A - "}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_PENDING},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateDoubleResult(tt.outcome, tt.firstHalfScore, tt.fullTimeScore)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateHighestScoringPeriod(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
firstScore struct{ Home, Away int }
|
|
secondScore struct{ Home, Away int }
|
|
thirdScore struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Winning1stPeriod", domain.BetOutcome{OddName: "Period 1"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{1, 1}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"Winning2ndPeriod", domain.BetOutcome{OddName: "Period 2"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"Winning3rdPeriod", domain.BetOutcome{OddName: "Period 3"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{3, 3}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTie", domain.BetOutcome{OddName: "Tie"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"Losing1stPeriod", domain.BetOutcome{OddName: "Period 1"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
|
|
{"Losing3rdPeriod", domain.BetOutcome{OddName: "Period 3"}, struct{ Home, Away int }{2, 2}, struct{ Home, Away int }{2, 3}, struct{ Home, Away int }{0, 0}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateHighestScoringPeriod(tt.outcome, tt.firstScore, tt.secondScore, tt.thirdScore)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvalauteTiedAfterRegulation(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score []struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{1, 0}, {0, 1}, {2, 2}}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{1, 1}, {0, 1}, {2, 2}, {2, 1}}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningNotTied", domain.BetOutcome{OddName: "No"}, []struct{ Home, Away int }{{0, 0}, {0, 0}, {0, 0}, {1, 0}}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingTied", domain.BetOutcome{OddName: "Yes"}, []struct{ Home, Away int }{{0, 2}, {0, 0}, {0, 0}, {0, 0}}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingNotTied", domain.BetOutcome{OddName: "No"}, []struct{ Home, Away int }{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateTiedAfterRegulation(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateTeamTotal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHomeUnder", domain.BetOutcome{OddHandicap: "Under 3", OddHeader: "1"}, struct{ Home, Away int }{2, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningHomeOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "1"}, struct{ Home, Away int }{3, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "2"}, struct{ Home, Away int }{1, 3}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHomeOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAwayOver", domain.BetOutcome{OddHandicap: "Over 2", OddHeader: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateTeamTotal(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDrawNoBet(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"Tie", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_VOID},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateDrawNoBet(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateMoneyLine(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHome", domain.BetOutcome{OddHeader: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAway", domain.BetOutcome{OddHeader: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTie", domain.BetOutcome{OddHeader: "Tie"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingTie", domain.BetOutcome{OddHeader: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAway", domain.BetOutcome{OddHeader: "2"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateMoneyLine(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateDoubleChance(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHomeOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "1 or Draw"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningHomeOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A or Draw"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Draw or Team B"}, struct{ Home, Away int }{0, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHomeorAway", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "1 or 2"}, struct{ Home, Away int }{1, 1}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAwayOrDraw", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Draw or 2"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateDoubleChance(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvalateResultAndTotal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHomeOver", domain.BetOutcome{OddHeader: "1", OddHandicap: "Over 4"}, struct{ Home, Away int }{2, 3}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningHomeUnder", domain.BetOutcome{OddHeader: "1", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayUnder", domain.BetOutcome{OddHeader: "2", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHomeOver", domain.BetOutcome{OddHeader: "1", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAwayUnder", domain.BetOutcome{OddHeader: "2", OddHandicap: "Under 4"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateResultAndTotal(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckMultiOutcome(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.OutcomeStatus
|
|
secondOutcome domain.OutcomeStatus
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Win-Win", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_WIN},
|
|
{"Win-Void", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_HALF},
|
|
{"Win-Loss", domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_PENDING},
|
|
{"Loss-Loss", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_LOSS},
|
|
{"Loss-Void", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_HALF},
|
|
{"Loss-Win", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_PENDING},
|
|
{"Void-Win", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_HALF},
|
|
{"Void-Loss", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_HALF},
|
|
{"Void-Void", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_PENDING},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := checkMultiOutcome(tt.outcome, tt.secondOutcome)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateBTTSX(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningBothScoreX", domain.BetOutcome{OddName: "3", OddHeader: "Yes"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningBothScoreLess", domain.BetOutcome{OddName: "3", OddHeader: "No"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingBothScoreX", domain.BetOutcome{OddName: "3", OddHeader: "Yes"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingBothScoreLess", domain.BetOutcome{OddName: "3", OddHeader: "No"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateBTTSX(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateResultAndBTTSX(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and Yes", OddHeader: "3"}, struct{ Home, Away int }{4, 3}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningHomeAndBothScoreLess", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and No", OddHeader: "3"}, struct{ Home, Away int }{2, 1}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAwayAndBothScoreLess", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and No", OddHeader: "3"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A and Yes", OddHeader: "3"}, struct{ Home, Away int }{3, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingHomeAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{4, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAwayAndBothScoreX", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B and Yes", OddHeader: "3"}, struct{ Home, Away int }{2, 4}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateResultAndBTTSX(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateMoneyLine3Way(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"WinningHome", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 0}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"WinningTie", domain.BetOutcome{OddName: "Tie"}, struct{ Home, Away int }{2, 2}, domain.OUTCOME_STATUS_WIN},
|
|
{"LosingTie", domain.BetOutcome{OddName: "1"}, struct{ Home, Away int }{1, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
{"LosingAway", domain.BetOutcome{OddName: "2"}, struct{ Home, Away int }{3, 2}, domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateMoneyLine3Way(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateAsianHandicap(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{
|
|
name: "Home -1 Win",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "-1"},
|
|
score: struct{ Home, Away int }{Home: 2, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_WIN,
|
|
},
|
|
{
|
|
name: "Home -0.5 Win",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5"},
|
|
score: struct{ Home, Away int }{Home: 1, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_WIN,
|
|
},
|
|
{
|
|
name: "Home -1 Void",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "-1"},
|
|
score: struct{ Home, Away int }{Home: 1, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_VOID,
|
|
},
|
|
{
|
|
name: "Away +3 Win",
|
|
outcome: domain.BetOutcome{OddHeader: "2", OddHandicap: "3"},
|
|
score: struct{ Home, Away int }{Home: 1, Away: 2},
|
|
expected: domain.OUTCOME_STATUS_WIN,
|
|
},
|
|
{
|
|
name: "Split Handicap Home -0.5,-1 Win/Win",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5,-1"},
|
|
score: struct{ Home, Away int }{Home: 2, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_WIN,
|
|
},
|
|
{
|
|
name: "Split Handicap Home -0.5,-1 Win/Void",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "-0.5,-1"},
|
|
score: struct{ Home, Away int }{Home: 1, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_WIN,
|
|
},
|
|
{
|
|
name: "Invalid Handicap",
|
|
outcome: domain.BetOutcome{OddHeader: "1", OddHandicap: "invalid"},
|
|
score: struct{ Home, Away int }{Home: 1, Away: 0},
|
|
expected: domain.OUTCOME_STATUS_PENDING,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateAsianHandicap(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEvaluateHandicapAndTotal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
outcome domain.BetOutcome
|
|
score struct{ Home, Away int }
|
|
expected domain.OutcomeStatus
|
|
}{
|
|
{"Home +2.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A +2.5 & Over 3"},
|
|
struct{ Home, Away int }{4, 0},
|
|
domain.OUTCOME_STATUS_WIN},
|
|
{"Away +2.5 Over 4", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B +2.5 & Over 4"},
|
|
struct{ Home, Away int }{1, 5},
|
|
domain.OUTCOME_STATUS_WIN},
|
|
{"Home +2.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A +2.5 & Over 3"},
|
|
struct{ Home, Away int }{2, 0},
|
|
domain.OUTCOME_STATUS_LOSS},
|
|
{"Home -3.5 Over 3", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team A -2.5 & Over 3"},
|
|
struct{ Home, Away int }{4, 3},
|
|
domain.OUTCOME_STATUS_LOSS},
|
|
{"Away -3 Over 4", domain.BetOutcome{HomeTeamName: "Team A", AwayTeamName: "Team B", OddName: "Team B -3 & Over 4"},
|
|
struct{ Home, Away int }{3, 5},
|
|
domain.OUTCOME_STATUS_LOSS},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
status, _ := evaluateHandicapAndTotal(tt.outcome, tt.score)
|
|
if status != tt.expected {
|
|
t.Errorf("expected %d, got %d", tt.expected, status)
|
|
}
|
|
})
|
|
}
|
|
}
|