Yimaru/Yimaru-BackEnd
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f6348576a2
Yimaru-BackEnd/internal/services/result/sports_eval_test.go

981 lines
47 KiB
Go
Raw Blame History

package result
// import (
// "fmt"
// "testing"
// "time"
// "github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
// "github.com/stretchr/testify/assert"
// )
// // TestNFLMarkets covers all American Football (NFL) market types defined in the domain.
// // For each market (Money Line, Spread, Total Points), it tests home/away win, draw, void, and invalid input scenarios.
// func TestNFLMarkets(t *testing.T) {
// t.Log("Testing NFL (American Football) Markets")
// markets := []struct {
// marketID int64
// name string
// }{
// {int64(domain.AMERICAN_FOOTBALL_MONEY_LINE), "MONEY_LINE"},
// {int64(domain.AMERICAN_FOOTBALL_SPREAD), "SPREAD"},
// {int64(domain.AMERICAN_FOOTBALL_TOTAL_POINTS), "TOTAL_POINTS"},
// }
// for _, m := range markets {
// t.Run(m.name, func(t *testing.T) {
// // Each subtest below covers a key scenario for the given NFL market.
// switch m.marketID {
// case int64(domain.AMERICAN_FOOTBALL_MONEY_LINE):
// // Home win, away win, draw, and invalid OddHeader for Money Line
// t.Run("Home Win", func(t *testing.T) {
// status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 21, Away: 14})
// t.Logf("Market: %s, Scenario: Home Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win", func(t *testing.T) {
// status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 14, Away: 21})
// t.Logf("Market: %s, Scenario: Away Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Draw", func(t *testing.T) {
// status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 17, Away: 17})
// t.Logf("Market: %s, Scenario: Draw", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// })
// t.Run("Invalid OddHeader", func(t *testing.T) {
// status, err := EvaluateNFLMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.AMERICAN_FOOTBALL_SPREAD):
// t.Run("Home Win with Handicap", func(t *testing.T) {
// status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-3.5"}, struct{ Home, Away int }{Home: 24, Away: 20})
// t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win with Handicap", func(t *testing.T) {
// status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+3.5"}, struct{ Home, Away int }{Home: 20, Away: 24})
// t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 21, Away: 21})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric Handicap", func(t *testing.T) {
// status, err := EvaluateNFLSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 21, Away: 14})
// t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.AMERICAN_FOOTBALL_TOTAL_POINTS):
// t.Run("Over Win", func(t *testing.T) {
// status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "44.5"}, struct{ Home, Away int }{Home: 30, Away: 20})
// t.Logf("Market: %s, Scenario: Over Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Under Win", func(t *testing.T) {
// status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "44.5"}, struct{ Home, Away int }{Home: 20, Away: 17})
// t.Logf("Market: %s, Scenario: Under Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "37"}, struct{ Home, Away int }{Home: 20, Away: 17})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric OddName", func(t *testing.T) {
// status, err := EvaluateNFLTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 20, Away: 17})
// t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// }
// })
// }
// }
// // TestRugbyMarkets covers all Rugby (Union & League) market types defined in the domain.
// // For each market (Money Line, Spread, Handicap, Total Points), it tests home/away win, draw, void, and invalid input scenarios.
// func TestRugbyMarkets(t *testing.T) {
// t.Log("Testing Rugby Markets (Union & League)")
// markets := []struct {
// marketID int64
// name string
// }{
// {int64(domain.RUGBY_MONEY_LINE), "MONEY_LINE"},
// {int64(domain.RUGBY_SPREAD), "SPREAD"},
// {int64(domain.RUGBY_TOTAL_POINTS), "TOTAL_POINTS"},
// {int64(domain.RUGBY_HANDICAP), "HANDICAP"},
// }
// for _, m := range markets {
// t.Run(m.name, func(t *testing.T) {
// // Each subtest below covers a key scenario for the given Rugby market.
// switch m.marketID {
// case int64(domain.RUGBY_MONEY_LINE):
// // Home win, away win, draw, and invalid OddHeader for Money Line
// t.Run("Home Win", func(t *testing.T) {
// status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 30, Away: 20})
// t.Logf("Market: %s, Scenario: Home Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win", func(t *testing.T) {
// status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 20, Away: 30})
// t.Logf("Market: %s, Scenario: Away Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Draw", func(t *testing.T) {
// status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 25, Away: 25})
// t.Logf("Market: %s, Scenario: Draw", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// })
// t.Run("Invalid OddHeader", func(t *testing.T) {
// status, err := EvaluateRugbyMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.RUGBY_SPREAD), int64(domain.RUGBY_HANDICAP):
// t.Run("Home Win with Handicap", func(t *testing.T) {
// status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-6.5"}, struct{ Home, Away int }{Home: 28, Away: 20})
// t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win with Handicap", func(t *testing.T) {
// status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+6.5"}, struct{ Home, Away int }{Home: 20, Away: 28})
// t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 21, Away: 21})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric Handicap", func(t *testing.T) {
// status, err := EvaluateRugbySpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 21, Away: 14})
// t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.RUGBY_TOTAL_POINTS):
// t.Run("Over Win", func(t *testing.T) {
// status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "40.5"}, struct{ Home, Away int }{Home: 25, Away: 20})
// t.Logf("Market: %s, Scenario: Over Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Under Win", func(t *testing.T) {
// status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "40.5"}, struct{ Home, Away int }{Home: 15, Away: 20})
// t.Logf("Market: %s, Scenario: Under Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "35"}, struct{ Home, Away int }{Home: 20, Away: 15})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric OddName", func(t *testing.T) {
// status, err := EvaluateRugbyTotalPoints(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 20, Away: 15})
// t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// }
// })
// }
// }
// // TestBaseballMarkets covers all Baseball market types defined in the domain.
// // For each market (Money Line, Spread, Total Runs), it tests home/away win, draw, void, and invalid input scenarios.
// func TestBaseballMarkets(t *testing.T) {
// t.Log("Testing Baseball Markets")
// markets := []struct {
// marketID int64
// name string
// }{
// {int64(domain.BASEBALL_MONEY_LINE), "MONEY_LINE"},
// {int64(domain.BASEBALL_SPREAD), "SPREAD"},
// {int64(domain.BASEBALL_TOTAL_RUNS), "TOTAL_RUNS"},
// }
// for _, m := range markets {
// t.Run(m.name, func(t *testing.T) {
// // Each subtest below covers a key scenario for the given Baseball market.
// switch m.marketID {
// case int64(domain.BASEBALL_MONEY_LINE):
// // Home win, away win, draw, and invalid OddHeader for Money Line
// t.Run("Home Win", func(t *testing.T) {
// status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 6, Away: 3})
// t.Logf("Market: %s, Scenario: Home Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win", func(t *testing.T) {
// status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2"}, struct{ Home, Away int }{Home: 2, Away: 5})
// t.Logf("Market: %s, Scenario: Away Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Draw", func(t *testing.T) {
// status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1"}, struct{ Home, Away int }{Home: 4, Away: 4})
// t.Logf("Market: %s, Scenario: Draw", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_LOSS, status)
// })
// t.Run("Invalid OddHeader", func(t *testing.T) {
// status, err := EvaluateBaseballMoneyLine(domain.BetOutcome{MarketID: m.marketID, OddHeader: "X"}, struct{ Home, Away int }{Home: 10, Away: 7})
// t.Logf("Market: %s, Scenario: Invalid OddHeader", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.BASEBALL_SPREAD):
// t.Run("Home Win with Handicap", func(t *testing.T) {
// status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "-1.5"}, struct{ Home, Away int }{Home: 5, Away: 3})
// t.Logf("Market: %s, Scenario: Home Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Away Win with Handicap", func(t *testing.T) {
// status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "2", OddHandicap: "+1.5"}, struct{ Home, Away int }{Home: 3, Away: 5})
// t.Logf("Market: %s, Scenario: Away Win with Handicap", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "0"}, struct{ Home, Away int }{Home: 4, Away: 4})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric Handicap", func(t *testing.T) {
// status, err := EvaluateBaseballSpread(domain.BetOutcome{MarketID: m.marketID, OddHeader: "1", OddHandicap: "notanumber"}, struct{ Home, Away int }{Home: 5, Away: 3})
// t.Logf("Market: %s, Scenario: Non-numeric Handicap", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// case int64(domain.BASEBALL_TOTAL_RUNS):
// t.Run("Over Win", func(t *testing.T) {
// status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "7.5"}, struct{ Home, Away int }{Home: 5, Away: 4})
// t.Logf("Market: %s, Scenario: Over Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Under Win", func(t *testing.T) {
// status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Under", OddName: "7.5"}, struct{ Home, Away int }{Home: 2, Away: 3})
// t.Logf("Market: %s, Scenario: Under Win", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_WIN, status)
// })
// t.Run("Push (Void)", func(t *testing.T) {
// status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "7"}, struct{ Home, Away int }{Home: 4, Away: 3})
// t.Logf("Market: %s, Scenario: Push (Void)", m.name)
// assert.NoError(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_VOID, status)
// })
// t.Run("Non-numeric OddName", func(t *testing.T) {
// status, err := EvaluateBaseballTotalRuns(domain.BetOutcome{MarketID: m.marketID, OddHeader: "Over", OddName: "notanumber"}, struct{ Home, Away int }{Home: 4, Away: 3})
// t.Logf("Market: %s, Scenario: Non-numeric OddName", m.name)
// assert.Error(t, err)
// assert.Equal(t, domain.OUTCOME_STATUS_PENDING, status)
// })
// }
// })
// }
// }
// func TestEvaluateFootballOutcome(t *testing.T) {
// service := &Service{} // or your real logger
// // Mock outcome
// outcome := domain.BetOutcome{
// ID: 1,
// BetID: 1,
// EventID: 1001,
// OddID: 2001,
// SportID: 1, // Assuming 1 = Football
// HomeTeamName: "Manchester",
// AwayTeamName: "Liverpool",
// MarketID: int64(domain.FOOTBALL_FULL_TIME_RESULT),
// MarketName: "Full Time Result",
// Odd: 1.75,
// OddName: "2", // Home win
// OddHeader: "1",
// OddHandicap: "",
// Status: domain.OUTCOME_STATUS_PENDING, // Initial status
// Expires: time.Now().Add(24 * time.Hour),
// }
// // Parsed result (simulate Bet365 JSON)
// finalScore := struct{ Home, Away int }{Home: 2, Away: 1}
// firstHalfScore := struct{ Home, Away int }{Home: 1, Away: 1}
// secondHalfScore := struct{ Home, Away int }{Home: 1, Away: 0}
// corners := struct{ Home, Away int }{Home: 5, Away: 3}
// halfTimeCorners := struct{ Home, Away int }{Home: 2, Away: 2}
// events := []map[string]string{
// {"type": "goal", "team": "home", "minute": "23"},
// {"type": "goal", "team": "away", "minute": "34"},
// }
// // Act
// status, _ := service.EvaluateFootballOutcome(outcome, finalScore, firstHalfScore, secondHalfScore, corners, halfTimeCorners, events)
// fmt.Printf("\n\nBet Outcome: %v\n\n", &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 TestEvaluateResultAndTotal(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 }{3, 2}, 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 }{1, 2}, domain.OUTCOME_STATUS_WIN},
// {"LosingHomeOver", domain.BetOutcome{OddHeader: "1", OddHandicap: "Under 4"}, struct{ Home, Away int }{3, 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_LOSS},
// {"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_VOID},
// {"Loss-Win", domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_LOSS},
// {"Void-Win", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_WIN, domain.OUTCOME_STATUS_VOID},
// {"Void-Loss", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_LOSS, domain.OUTCOME_STATUS_VOID},
// {"Void-Void", domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID, domain.OUTCOME_STATUS_VOID},
// }
// 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_ERROR,
// },
// }
// 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)
// }
// })
// }
// }
Reference in New Issue View Git Blame Copy Permalink