grail/gralias
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix: unittests

Browse Source
This commit is contained in:
Grail Finder
2025-07-02 19:00:39 +03:00
parent a438d5b665
commit 130ed3763b
15 changed files with 227 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
repos/actions.go
View File

@ -4,6 +4,8 @@ import (
"context"
"gralias/models"
"time"
"github.com/jmoiron/sqlx"
)
type ActionsRepo interface {
@ -15,7 +17,7 @@ type ActionsRepo interface {
func (p *RepoProvider) ListActions(ctx context.Context, roomID string) ([]models.Action, error) {
actions := []models.Action{}
err := p.DB.SelectContext(ctx, &actions, `SELECT actor, actor_color, action_type, word, word_color, number_associated, created_at FROM actions WHERE room_id = ? ORDER BY created_at ASC`, roomID)
err := sqlx.SelectContext(ctx, p.DB, &actions, `SELECT actor, actor_color, action_type, word, word_color, number_associated, created_at FROM actions WHERE room_id = ? ORDER BY created_at ASC`, roomID)
if err != nil {
return nil, err
}
@ -26,13 +28,14 @@ func (p *RepoProvider) ListActions(ctx context.Context, roomID string) ([]models
}
func (p *RepoProvider) CreateAction(ctx context.Context, roomID string, a *models.Action) error {
_, err := p.DB.ExecContext(ctx, `INSERT INTO actions (room_id, actor, actor_color, action_type, word, word_color, number_associated, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, roomID, a.Actor, a.ActorColor, a.Action, a.Word, a.WordColor, a.Number, a.CreatedAt.UnixNano())
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `INSERT INTO actions (room_id, actor, actor_color, action_type, word, word_color, number_associated, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, roomID, a.Actor, a.ActorColor, a.Action, a.Word, a.WordColor, a.Number, a.CreatedAt.UnixNano())
return err
}
func (p *RepoProvider) GetLastClue(ctx context.Context, roomID string) (*models.Action, error) {
action := &models.Action{}
err := p.DB.GetContext(ctx, action, `SELECT actor, actor_color, action_type, word, word_color, number_associated, created_at FROM actions WHERE room_id = ? AND action_type = 'gave_clue' ORDER BY created_at DESC LIMIT 1`, roomID)
err := sqlx.GetContext(ctx, p.DB, action, `SELECT actor, actor_color, action_type, word, word_color, number_associated, created_at FROM actions WHERE room_id = ? AND action_type = 'gave_clue' ORDER BY created_at DESC LIMIT 1`, roomID)
if err != nil {
return nil, err
}
@ -41,6 +44,7 @@ func (p *RepoProvider) GetLastClue(ctx context.Context, roomID string) (*models.
}
func (p *RepoProvider) DeleteActionsByRoomID(ctx context.Context, roomID string) error {
_, err := p.DB.ExecContext(ctx, `DELETE FROM actions WHERE room_id = ?`, roomID)
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `DELETE FROM actions WHERE room_id = ?`, roomID)
return err
}
}

13
repos/main.go
View File

@ -1,6 +1,7 @@
package repos
import (
"context"
"log/slog"
"os"
@ -12,11 +13,11 @@ type AllRepos interface {
RoomsRepo
ActionsRepo
PlayersRepo
SessionsRepo
}
type RepoProvider struct {
DB *sqlx.DB
Ext sqlx.Ext
DB *sqlx.DB
}
func NewRepoProvider(pathToDB string) *RepoProvider {
@ -30,3 +31,11 @@ func NewRepoProvider(pathToDB string) *RepoProvider {
DB: db,
}
}
func getDB(ctx context.Context, db *sqlx.DB) sqlx.ExtContext {
if tx, ok := ctx.Value("tx").(*sqlx.Tx);
ok {
return tx
}
return db
}

55
repos/players.go
View File

@ -3,65 +3,72 @@ package repos
import (
"context"
"gralias/models"
"github.com/jmoiron/sqlx"
)
type PlayersRepo interface {
PlayerGetByName(username string) (*models.Player, error)
PlayerAdd(player *models.Player) error
PlayerUpdate(player *models.Player) error
PlayerDelete(roomID, username string) error
PlayerSetRoomID(username, roomID string) error
PlayerExitRoom(username string) error
PlayerListNames() ([]string, error)
PlayerList(isBot bool) ([]models.Player, error)
PlayerGetByName(ctx context.Context, username string) (*models.Player, error)
PlayerAdd(ctx context.Context, player *models.Player) error
PlayerUpdate(ctx context.Context, player *models.Player) error
PlayerDelete(ctx context.Context, roomID, username string) error
PlayerSetRoomID(ctx context.Context, username, roomID string) error
PlayerExitRoom(ctx context.Context, username string) error
PlayerListNames(ctx context.Context) ([]string, error)
PlayerList(ctx context.Context, isBot bool) ([]models.Player, error)
}
func (p *RepoProvider) PlayerListNames() ([]string, error) {
func (p *RepoProvider) PlayerListNames(ctx context.Context) ([]string, error) {
var names []string
err := p.DB.SelectContext(context.Background(), &names, "SELECT username FROM players;")
err := sqlx.SelectContext(ctx, p.DB, &names, "SELECT username FROM players;")
if err != nil {
return nil, err
}
return names, nil
}
func (p *RepoProvider) PlayerGetByName(username string) (*models.Player, error) {
func (p *RepoProvider) PlayerGetByName(ctx context.Context, username string) (*models.Player, error) {
var player models.Player
err := p.DB.GetContext(context.Background(), &player, "SELECT id, room_id, username, team, role, is_bot FROM players WHERE username = ?", username)
err := sqlx.GetContext(ctx, p.DB, &player, "SELECT id, room_id, username, team, role, is_bot FROM players WHERE username = ?", username)
if err != nil {
return nil, err
}
return &player, nil
}
func (p *RepoProvider) PlayerAdd(player *models.Player) error {
_, err := p.DB.ExecContext(context.Background(), "INSERT INTO players (room_id, username, team, role, is_bot) VALUES (?, ?, ?, ?, ?)",
func (p *RepoProvider) PlayerAdd(ctx context.Context, player *models.Player) error {
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, "INSERT INTO players (room_id, username, team, role, is_bot) VALUES (?, ?, ?, ?, ?)",
player.RoomID, player.Username, player.Team, player.Role, player.IsBot)
return err
}
func (p *RepoProvider) PlayerUpdate(player *models.Player) error {
_, err := p.DB.ExecContext(context.Background(), "UPDATE players SET room_id = ?, username = ?, team = ?, role = ?, is_bot = ? WHERE id = ?",
func (p *RepoProvider) PlayerUpdate(ctx context.Context, player *models.Player) error {
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, "UPDATE players SET room_id = ?, username = ?, team = ?, role = ?, is_bot = ? WHERE id = ?",
player.RoomID, player.Username, player.Team, player.Role, player.IsBot, player.ID)
return err
}
func (p *RepoProvider) PlayerDelete(roomID, username string) error {
_, err := p.DB.ExecContext(context.Background(), "DELETE FROM players WHERE room_id = ? AND username = ?", roomID, username)
func (p *RepoProvider) PlayerDelete(ctx context.Context, roomID, username string) error {
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, "DELETE FROM players WHERE room_id = ? AND username = ?", roomID, username)
return err
}
func (p *RepoProvider) PlayerSetRoomID(username, roomID string) error {
_, err := p.DB.ExecContext(context.Background(), "UPDATE players SET room_id = ? WHERE username = ?", roomID, username)
func (p *RepoProvider) PlayerSetRoomID(ctx context.Context, username, roomID string) error {
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, "UPDATE players SET room_id = ? WHERE username = ?", roomID, username)
return err
}
func (p *RepoProvider) PlayerExitRoom(username string) error {
_, err := p.DB.ExecContext(context.Background(), "UPDATE players SET room_id = null WHERE username = ?", username)
func (p *RepoProvider) PlayerExitRoom(ctx context.Context, username string) error {
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, "UPDATE players SET room_id = null WHERE username = ?", username)
return err
}
func (p *RepoProvider) PlayerList(isBot bool) ([]models.Player, error) {
func (p *RepoProvider) PlayerList(ctx context.Context, isBot bool) ([]models.Player, error) {
var players []models.Player
var query string
if isBot {
@ -69,7 +76,7 @@ func (p *RepoProvider) PlayerList(isBot bool) ([]models.Player, error) {
} else {
query = "SELECT id, room_id, username, team, role, is_bot FROM players WHERE is_bot = false;"
}
err := p.DB.SelectContext(context.Background(), &players, query)
err := sqlx.SelectContext(ctx, p.DB, &players, query)
if err != nil {
return nil, err
}

7
repos/players_test.go
View File

@ -1,6 +1,7 @@
package repos
import (
"context"
"gralias/models"
"testing"
@ -45,7 +46,7 @@ func TestPlayersRepo_AddPlayer(t *testing.T) {
IsBot: false,
}
err := repo.AddPlayer(player)
err := repo.PlayerAdd(context.Background(), player)
assert.NoError(t, err)
var retrievedPlayer models.Player
@ -71,7 +72,7 @@ func TestPlayersRepo_GetPlayer(t *testing.T) {
_, err := db.Exec(`INSERT INTO players (room_id, username, team, role, is_bot) VALUES (?, ?, ?, ?, ?)`, player.RoomID, player.Username, player.Team, player.Role, player.IsBot)
assert.NoError(t, err)
retrievedPlayer, err := repo.GetPlayer(player.RoomID, player.Username)
retrievedPlayer, err := repo.PlayerGetByName(context.Background(), player.Username)
assert.NoError(t, err)
assert.NotNil(t, retrievedPlayer)
assert.Equal(t, player.Username, retrievedPlayer.Username)
@ -94,7 +95,7 @@ func TestPlayersRepo_DeletePlayer(t *testing.T) {
_, err := db.Exec(`INSERT INTO players (room_id, username, team, role, is_bot) VALUES (?, ?, ?, ?, ?)`, player.RoomID, player.Username, player.Team, player.Role, player.IsBot)
assert.NoError(t, err)
err = repo.DeletePlayer(player.RoomID, player.Username)
err = repo.PlayerDelete(context.Background(), player.RoomID, player.Username)
assert.NoError(t, err)
var count int

43
repos/rooms.go
View File

@ -3,6 +3,8 @@ package repos
import (
"context"
"gralias/models"
"github.com/jmoiron/sqlx"
)
type RoomsRepo interface {
@ -16,7 +18,7 @@ type RoomsRepo interface {
func (p *RepoProvider) RoomList(ctx context.Context) ([]*models.Room, error) {
rooms := []*models.Room{}
err := p.DB.SelectContext(ctx, &rooms, `SELECT * FROM rooms`)
err := sqlx.SelectContext(ctx, p.DB, &rooms, `SELECT * FROM rooms`)
if err != nil {
return nil, err
}
@ -25,37 +27,58 @@ func (p *RepoProvider) RoomList(ctx context.Context) ([]*models.Room, error) {
func (p *RepoProvider) RoomGetByID(ctx context.Context, id string) (*models.Room, error) {
room := &models.Room{}
err := p.DB.GetContext(ctx, room, `SELECT * FROM rooms WHERE id = ?`, id)
err := sqlx.GetContext(ctx, p.DB, room, `SELECT * FROM rooms WHERE id = ?`, id)
if err != nil {
return nil, err
}
settings := &models.GameSettings{}
err = sqlx.GetContext(ctx, p.DB, settings, `SELECT * FROM settings WHERE room_id = ?`, id)
if err != nil {
return nil, err
}
room.Settings = *settings
return room, nil
}
func (p *RepoProvider) RoomCreate(ctx context.Context, r *models.Room) error {
_, err := p.DB.ExecContext(ctx, `INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, , is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, r.ID, r.CreatedAt, r.CreatorName, r.TeamTurn, r.ThisTurnLimit, r.OpenedThisTurn, r.BlueCounter, r.RedCounter, r.RedTurn, r.MimeDone, r.IsRunning, r.IsOver, r.TeamWon, r.RoomLink)
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, r.ID, r.CreatedAt, r.CreatorName, r.TeamTurn, r.ThisTurnLimit, r.OpenedThisTurn, r.BlueCounter, r.RedCounter, r.RedTurn, r.MimeDone, r.IsRunning, r.IsOver, r.TeamWon, r.RoomLink)
if err != nil {
return err
}
_, err = db.ExecContext(ctx, `INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, r.ID, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime)
return err
}
func (p *RepoProvider) RoomDeleteByID(ctx context.Context, id string) error {
_, err := p.DB.ExecContext(ctx, `DELETE FROM rooms WHERE id = ?`, id)
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `DELETE FROM rooms WHERE id = ?`, id)
if err != nil {
return err
}
_, err = db.ExecContext(ctx, `DELETE FROM settings WHERE room_id = ?`, id)
return err
}
func (p *RepoProvider) RoomUpdate(ctx context.Context, r *models.Room) error {
_, err := p.DB.ExecContext(ctx, `UPDATE rooms SET team_turn = ?, this_turn_limit = ?, opened_this_turn = ?, blue_counter = ?, red_counter = ?, red_turn = ?, mime_done = ?, = ?, is_running = ?, is_over = ?, team_won = ?, room_link = ? WHERE id = ?`, r.TeamTurn, r.ThisTurnLimit, r.OpenedThisTurn, r.BlueCounter, r.RedCounter, r.RedTurn, r.MimeDone, r.IsRunning, r.IsOver, r.TeamWon, r.RoomLink, r.ID)
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `UPDATE rooms SET team_turn = ?, this_turn_limit = ?, opened_this_turn = ?, blue_counter = ?, red_counter = ?, red_turn = ?, mime_done = ?, is_running = ?, is_over = ?, team_won = ?, room_link = ? WHERE id = ?`, r.TeamTurn, r.ThisTurnLimit, r.OpenedThisTurn, r.BlueCounter, r.RedCounter, r.RedTurn, r.MimeDone, r.IsRunning, r.IsOver, r.TeamWon, r.RoomLink, r.ID)
if err != nil {
return err
}
_, err = db.ExecContext(ctx, `UPDATE settings SET language = ?, room_pass = ?, turn_time = ? WHERE room_id = ?`, r.Settings.Language, r.Settings.RoomPass, r.Settings.RoundTime, r.ID)
return err
}
func (p *RepoProvider) RoomGetExtended(ctx context.Context, id string) (*models.Room, error) {
room := &models.Room{}
err := p.DB.GetContext(ctx, room, `SELECT * FROM rooms WHERE id = ?`, id)
err := sqlx.GetContext(ctx, p.DB, room, `SELECT * FROM rooms WHERE id = ?`, id)
if err != nil {
return nil, err
}
// Get players
players := []*models.Player{}
err = p.DB.SelectContext(ctx, &players, `SELECT * FROM players WHERE room_id = ?`, id)
err = sqlx.SelectContext(ctx, p.DB, &players, `SELECT * FROM players WHERE room_id = ?`, id)
if err != nil {
return nil, err
}
@ -87,21 +110,21 @@ func (p *RepoProvider) RoomGetExtended(ctx context.Context, id string) (*models.
}
// Get word cards
wordCards := []models.WordCard{}
err = p.DB.SelectContext(ctx, &wordCards, `SELECT * FROM word_cards WHERE room_id = ?`, id)
err = sqlx.SelectContext(ctx, p.DB, &wordCards, `SELECT * FROM word_cards WHERE room_id = ?`, id)
if err != nil {
return nil, err
}
room.Cards = wordCards
// Get actions
actions := []models.Action{}
err = p.DB.SelectContext(ctx, &actions, `SELECT * FROM actions WHERE room_id = ? ORDER BY created_at ASC`, id)
err = sqlx.SelectContext(ctx, p.DB, &actions, `SELECT * FROM actions WHERE room_id = ? ORDER BY created_at ASC`, id)
if err != nil {
return nil, err
}
room.ActionHistory = actions
// Get settings
settings := &models.GameSettings{}
err = p.DB.GetContext(ctx, settings, `SELECT * FROM settings WHERE room_id = ?`, id)
err = sqlx.GetContext(ctx, p.DB, settings, `SELECT * FROM settings WHERE room_id = ?`, id)
if err != nil {
return nil, err
}

150
repos/rooms_test.go
View File

@ -18,22 +18,29 @@ func setupTestDB(t *testing.T) (*sqlx.DB, func()) {
schema := `
CREATE TABLE IF NOT EXISTS rooms (
id TEXT PRIMARY KEY,
created_at DATETIME,
creator_name TEXT,
team_turn TEXT,
this_turn_limit INTEGER,
opened_this_turn INTEGER,
blue_counter INTEGER,
red_counter INTEGER,
red_turn BOOLEAN,
mime_done BOOLEAN,
is_public BOOLEAN,
is_running BOOLEAN,
language TEXT,
round_time INTEGER,
is_over BOOLEAN,
team_won TEXT,
room_pass TEXT
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
creator_name TEXT NOT NULL,
team_turn TEXT NOT NULL DEFAULT '',
this_turn_limit INTEGER NOT NULL DEFAULT 0,
opened_this_turn INTEGER NOT NULL DEFAULT 0,
blue_counter INTEGER NOT NULL DEFAULT 0,
red_counter INTEGER NOT NULL DEFAULT 0,
red_turn BOOLEAN NOT NULL DEFAULT FALSE,
mime_done BOOLEAN NOT NULL DEFAULT FALSE,
is_running BOOLEAN NOT NULL DEFAULT FALSE,
is_over BOOLEAN NOT NULL DEFAULT FALSE,
team_won TEXT NOT NULL DEFAULT '',
room_link TEXT NOT NULL DEFAULT ''
);
CREATE TABLE IF NOT EXISTS settings (
id INTEGER PRIMARY KEY AUTOINCREMENT,
room_id TEXT NOT NULL,
language TEXT NOT NULL DEFAULT 'en',
room_pass TEXT NOT NULL DEFAULT '',
turn_time INTEGER NOT NULL DEFAULT 60,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (room_id) REFERENCES rooms(id)
);
`
_, err = db.Exec(schema)
@ -61,16 +68,18 @@ func TestRoomsRepo_CreateRoom(t *testing.T) {
RedCounter: 0,
RedTurn: false,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
err := repo.CreateRoom(context.Background(), room)
err := repo.RoomCreate(context.Background(), room)
assert.NoError(t, err)
// Verify the room was created
@ -79,6 +88,13 @@ func TestRoomsRepo_CreateRoom(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, room.ID, retrievedRoom.ID)
assert.Equal(t, room.CreatorName, retrievedRoom.CreatorName)
var retrievedSettings models.GameSettings
err = db.Get(&retrievedSettings, "SELECT id, language, room_pass, turn_time FROM settings WHERE room_id = ?", room.ID)
assert.NoError(t, err)
assert.Equal(t, room.Settings.Language, retrievedSettings.Language)
assert.Equal(t, room.Settings.RoundTime, retrievedSettings.RoundTime)
assert.Equal(t, room.Settings.RoomPass, retrievedSettings.RoomPass)
}
func TestRoomsRepo_GetRoomByID(t *testing.T) {
@ -98,24 +114,29 @@ func TestRoomsRepo_GetRoomByID(t *testing.T) {
RedCounter: 0,
RedTurn: true,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
// Insert a room directly into the database for testing GetRoomByID
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
assert.NoError(t, err)
_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
assert.NoError(t, err)
retrievedRoom, err := repo.GetRoomByID(context.Background(), room.ID)
retrievedRoom, err := repo.RoomGetByID(context.Background(), room.ID)
assert.NoError(t, err)
assert.NotNil(t, retrievedRoom)
assert.Equal(t, room.ID, retrievedRoom.ID)
assert.Equal(t, room.CreatorName, retrievedRoom.CreatorName)
assert.Equal(t, room.Settings.Language, retrievedRoom.Settings.Language)
}
func TestRoomsRepo_ListRooms(t *testing.T) {
@ -135,13 +156,15 @@ func TestRoomsRepo_ListRooms(t *testing.T) {
RedCounter: 0,
RedTurn: false,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
room2 := &models.Room{
ID: "list_room_2",
@ -154,21 +177,28 @@ func TestRoomsRepo_ListRooms(t *testing.T) {
RedCounter: 0,
RedTurn: true,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room1.ID, room1.CreatedAt, room1.CreatorName, room1.TeamTurn, room1.ThisTurnLimit, room1.OpenedThisTurn, room1.BlueCounter, room1.RedCounter, room1.RedTurn, room1.MimeDone, room1.IsPublic, room1.IsRunning, room1.Language, room1.RoundTime, room1.IsOver, room1.TeamWon, room1.RoomPass)
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room1.ID, room1.CreatedAt, room1.CreatorName, room1.TeamTurn, room1.ThisTurnLimit, room1.OpenedThisTurn, room1.BlueCounter, room1.RedCounter, room1.RedTurn, room1.MimeDone, room1.IsRunning, room1.IsOver, room1.TeamWon, room1.RoomLink)
assert.NoError(t, err)
_, err = db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room2.ID, room2.CreatedAt, room2.CreatorName, room2.TeamTurn, room2.ThisTurnLimit, room2.OpenedThisTurn, room2.BlueCounter, room2.RedCounter, room2.RedTurn, room2.MimeDone, room2.IsPublic, room2.IsRunning, room2.Language, room2.RoundTime, room2.IsOver, room2.TeamWon, room2.RoomPass)
_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room1.ID, room1.Settings.Language, room1.Settings.RoomPass, room1.Settings.RoundTime)
assert.NoError(t, err)
rooms, err := repo.ListRooms(context.Background())
_, err = db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room2.ID, room2.CreatedAt, room2.CreatorName, room2.TeamTurn, room2.ThisTurnLimit, room2.OpenedThisTurn, room2.BlueCounter, room2.RedCounter, room2.RedTurn, room2.MimeDone, room2.IsRunning, room2.IsOver, room2.TeamWon, room2.RoomLink)
assert.NoError(t, err)
_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room2.ID, room2.Settings.Language, room2.Settings.RoomPass, room2.Settings.RoundTime)
assert.NoError(t, err)
rooms, err := repo.RoomList(context.Background())
assert.NoError(t, err)
assert.Len(t, rooms, 2)
}
@ -190,25 +220,33 @@ func TestRoomsRepo_DeleteRoomByID(t *testing.T) {
RedCounter: 0,
RedTurn: false,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
assert.NoError(t, err)
_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
assert.NoError(t, err)
err = repo.DeleteRoomByID(context.Background(), room.ID)
err = repo.RoomDeleteByID(context.Background(), room.ID)
assert.NoError(t, err)
var count int
err = db.Get(&count, "SELECT COUNT(*) FROM rooms WHERE id = ?", room.ID)
assert.NoError(t, err)
assert.Equal(t, 0, count)
err = db.Get(&count, "SELECT COUNT(*) FROM settings WHERE room_id = ?", room.ID)
assert.NoError(t, err)
assert.Equal(t, 0, count)
}
func TestRoomsRepo_UpdateRoom(t *testing.T) {
@ -228,27 +266,37 @@ func TestRoomsRepo_UpdateRoom(t *testing.T) {
RedCounter: 0,
RedTurn: false,
MimeDone: false,
IsPublic: true,
IsRunning: false,
Language: "en",
RoundTime: 60,
IsOver: false,
TeamWon: "",
RoomPass: "",
RoomLink: "",
Settings: models.GameSettings{
Language: "en",
RoundTime: 60,
RoomPass: "",
},
}
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_public, is_running, language, round_time, is_over, team_won, room_pass) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsPublic, room.IsRunning, room.Language, room.RoundTime, room.IsOver, room.TeamWon, room.RoomPass)
_, err := db.Exec(`INSERT INTO rooms (id, created_at, creator_name, team_turn, this_turn_limit, opened_this_turn, blue_counter, red_counter, red_turn, mime_done, is_running, is_over, team_won, room_link) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, room.ID, room.CreatedAt, room.CreatorName, room.TeamTurn, room.ThisTurnLimit, room.OpenedThisTurn, room.BlueCounter, room.RedCounter, room.RedTurn, room.MimeDone, room.IsRunning, room.IsOver, room.TeamWon, room.RoomLink)
assert.NoError(t, err)
_, err = db.Exec(`INSERT INTO settings (room_id, language, room_pass, turn_time) VALUES (?, ?, ?, ?)`, room.ID, room.Settings.Language, room.Settings.RoomPass, room.Settings.RoundTime)
assert.NoError(t, err)
room.TeamTurn = "red"
room.BlueCounter = 10
room.Settings.RoundTime = 120
err = repo.UpdateRoom(context.Background(), room)
err = repo.RoomUpdate(context.Background(), room)
assert.NoError(t, err)
var updatedRoom models.Room
err = db.Get(&updatedRoom, "SELECT * FROM rooms WHERE id = ?", room.ID)
assert.NoError(t, err)
assert.Equal(t, models.UserTeam("red"), updatedRoom.TeamTurn)
assert.Equal(t, models.UserTeam("red"), updatedRoom.TeamTurn)
assert.Equal(t, uint8(10), updatedRoom.BlueCounter)
var updatedSettings models.GameSettings
err = db.Get(&updatedSettings, "SELECT * FROM settings WHERE room_id = ?", room.ID)
assert.NoError(t, err)
assert.Equal(t, uint32(120), updatedSettings.RoundTime)
}

28
repos/session.go
View File

@ -16,9 +16,10 @@ type SessionsRepo interface {
}
func (p *RepoProvider) SessionByToken(ctx context.Context, token string) (*models.Session, error) {
db := getDB(ctx, p.DB)
session := &models.Session{}
// The lifetime in the DB is in seconds, but in the model it is in minutes.
err := p.DB.GetContext(ctx, session, `SELECT id, updated_at, lifetime / 60 as lifetime, cookie_token, username FROM sessions WHERE cookie_token = ?`, token)
err := sqlx.GetContext(ctx, db, session, `SELECT id, updated_at, lifetime / 60 as lifetime, cookie_token, username FROM sessions WHERE cookie_token = ?`, token)
if err != nil {
return nil, err
}
@ -26,36 +27,23 @@ func (p *RepoProvider) SessionByToken(ctx context.Context, token string) (*model
}
func (p *RepoProvider) SessionCreate(ctx context.Context, session *models.Session) error {
p.Ext = p.DB
tx, ok := ctx.Value("sqltx").(*sqlx.Tx)
if ok && tx != nil {
// how to know if it is a final exec in chain?
// or is it better to commit outside?
tocommit, ok := ctx.Value("tocommit").(bool)
if ok && tocommit {
defer func() {
if err := tx.Commit(); err != nil {
// log
// return err
}
}()
}
p.Ext = tx
}
db := getDB(ctx, p.DB)
// The lifetime in the model is in minutes, but in the DB it is in seconds.
_, err := p.Ext.Exec(`INSERT INTO sessions (updated_at, lifetime, cookie_token, username) VALUES (?, ?, ?, ?)`,
_, err := db.ExecContext(ctx, `INSERT INTO sessions (updated_at, lifetime, cookie_token, username) VALUES (?, ?, ?, ?)`,
time.Now(), session.Lifetime*60, session.CookieToken, session.Username)
return err
}
func (p *RepoProvider) SessionUpdate(ctx context.Context, session *models.Session) error {
db := getDB(ctx, p.DB)
// The lifetime in the model is in minutes, but in the DB it is in seconds.
_, err := p.DB.ExecContext(ctx, `UPDATE sessions SET updated_at = ?, lifetime = ? WHERE cookie_token = ?`,
_, err := db.ExecContext(ctx, `UPDATE sessions SET updated_at = ?, lifetime = ? WHERE cookie_token = ?`,
time.Now(), session.Lifetime*60, session.CookieToken)
return err
}
func (p *RepoProvider) SessionDelete(ctx context.Context, token string) error {
_, err := p.DB.ExecContext(ctx, `DELETE FROM sessions WHERE cookie_token = ?`, token)
db := getDB(ctx, p.DB)
_, err := db.ExecContext(ctx, `DELETE FROM sessions WHERE cookie_token = ?`, token)
return err
}