273 lines
6.5 KiB
Go
273 lines
6.5 KiB
Go
package repo
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"watch-party-backend/internal/core/episode"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
)
|
|
|
|
func TestPGXEpisodeRepo_Delete(t *testing.T) {
|
|
t.Run("not found", func(t *testing.T) {
|
|
fp := &fakePool{
|
|
execFn: func(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) {
|
|
if sql != `DELETE FROM current_archive WHERE id = $1` {
|
|
t.Fatalf("unexpected sql: %s", sql)
|
|
}
|
|
return pgconn.NewCommandTag("DELETE 0"), nil
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
if err := repo.Delete(context.Background(), 10); !errors.Is(err, episode.ErrNotFound) {
|
|
t.Fatalf("expected ErrNotFound, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("ok", func(t *testing.T) {
|
|
var (
|
|
gotSQL string
|
|
gotID int64
|
|
)
|
|
fp := &fakePool{
|
|
execFn: func(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) {
|
|
gotSQL = sql
|
|
gotID = args[0].(int64)
|
|
return pgconn.NewCommandTag("DELETE 1"), nil
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
if err := repo.Delete(context.Background(), 22); err != nil {
|
|
t.Fatalf("unexpected err: %v", err)
|
|
}
|
|
if gotSQL != `DELETE FROM current_archive WHERE id = $1` {
|
|
t.Fatalf("expected archive delete sql, got %s", gotSQL)
|
|
}
|
|
if gotID != 22 {
|
|
t.Fatalf("expected id 22, got %d", gotID)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestPGXEpisodeRepo_GetCurrent(t *testing.T) {
|
|
t.Run("not found", func(t *testing.T) {
|
|
fp := &fakePool{
|
|
queryRowFn: func(ctx context.Context, sql string, args ...any) pgx.Row {
|
|
return fakeRow{err: pgx.ErrNoRows}
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
_, err := repo.GetCurrent(context.Background())
|
|
if !errors.Is(err, episode.ErrNotFound) {
|
|
t.Fatalf("expected ErrNotFound, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("ok", func(t *testing.T) {
|
|
now := time.Now().UTC()
|
|
fp := &fakePool{
|
|
queryRowFn: func(ctx context.Context, sql string, args ...any) pgx.Row {
|
|
return fakeRow{values: []any{
|
|
3,
|
|
5,
|
|
"Title",
|
|
"S1",
|
|
"12:00:00",
|
|
"00:24:00",
|
|
true,
|
|
now,
|
|
}}
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
row, err := repo.GetCurrent(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("unexpected err: %v", err)
|
|
}
|
|
if row.Id != 3 || row.EpTitle != "Title" {
|
|
t.Fatalf("bad row: %+v", row)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestPGXEpisodeRepo_ListAll(t *testing.T) {
|
|
now := time.Now().UTC()
|
|
fp := &fakePool{
|
|
queryFn: func(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
|
|
return &fakeRows{
|
|
rows: [][]any{
|
|
{1, 1, "Pilot", "S1", "10:00:00", "00:24:00", true, now},
|
|
{2, 2, "Next", "S1", "10:30:00", "00:24:00", false, now},
|
|
},
|
|
}, nil
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
items, err := repo.ListAll(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("unexpected err: %v", err)
|
|
}
|
|
if len(items) != 2 || items[1].EpNum != 2 {
|
|
t.Fatalf("bad items: %+v", items)
|
|
}
|
|
}
|
|
|
|
func TestPGXEpisodeRepo_Create(t *testing.T) {
|
|
now := time.Now().UTC()
|
|
var gotSQL string
|
|
var gotArgs []any
|
|
fp := &fakePool{
|
|
queryRowFn: func(ctx context.Context, sql string, args ...any) pgx.Row {
|
|
gotSQL = sql
|
|
gotArgs = append([]any(nil), args...)
|
|
return fakeRow{values: []any{
|
|
5,
|
|
10,
|
|
"Title",
|
|
"S1",
|
|
"12:00:00",
|
|
"00:24:00",
|
|
false,
|
|
now,
|
|
}}
|
|
},
|
|
}
|
|
repo := &pgxEpisodeRepo{pool: fp}
|
|
row, err := repo.Create(context.Background(), episode.NewShowInput{
|
|
EpNum: 10,
|
|
EpTitle: "Title",
|
|
SeasonName: "S1",
|
|
StartTime: "12:00:00",
|
|
PlaybackLength: "00:24:00",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected err: %v", err)
|
|
}
|
|
if row.Id != 5 || !strings.Contains(gotSQL, "INSERT INTO current") {
|
|
t.Fatalf("bad insert: id=%d sql=%s", row.Id, gotSQL)
|
|
}
|
|
if len(gotArgs) != 5 || gotArgs[0] != 10 || gotArgs[4] != "00:24:00" {
|
|
t.Fatalf("bad args: %+v", gotArgs)
|
|
}
|
|
if row.CurrentEp {
|
|
t.Fatalf("expected current_ep false")
|
|
}
|
|
}
|
|
|
|
// --- fakes ---
|
|
|
|
type fakePool struct {
|
|
queryFn func(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
|
|
queryRowFn func(ctx context.Context, sql string, args ...any) pgx.Row
|
|
execFn func(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error)
|
|
}
|
|
|
|
func (f *fakePool) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
|
|
if f.queryFn == nil {
|
|
return nil, fmt.Errorf("unexpected Query call")
|
|
}
|
|
return f.queryFn(ctx, sql, args...)
|
|
}
|
|
|
|
func (f *fakePool) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
|
|
if f.queryRowFn == nil {
|
|
return fakeRow{err: fmt.Errorf("unexpected QueryRow call")}
|
|
}
|
|
return f.queryRowFn(ctx, sql, args...)
|
|
}
|
|
|
|
func (f *fakePool) Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) {
|
|
if f.execFn == nil {
|
|
return pgconn.CommandTag{}, fmt.Errorf("unexpected Exec call")
|
|
}
|
|
return f.execFn(ctx, sql, args...)
|
|
}
|
|
|
|
func (f *fakePool) Begin(ctx context.Context) (pgx.Tx, error) {
|
|
return nil, fmt.Errorf("Begin not implemented")
|
|
}
|
|
|
|
type fakeRow struct {
|
|
values []any
|
|
err error
|
|
}
|
|
|
|
func (r fakeRow) Scan(dest ...any) error {
|
|
if r.err != nil {
|
|
return r.err
|
|
}
|
|
return assignValues(dest, r.values)
|
|
}
|
|
|
|
type fakeRows struct {
|
|
rows [][]any
|
|
idx int
|
|
err error
|
|
}
|
|
|
|
func (r *fakeRows) Close() {}
|
|
|
|
func (r *fakeRows) Err() error { return r.err }
|
|
|
|
func (r *fakeRows) CommandTag() pgconn.CommandTag { return pgconn.CommandTag{} }
|
|
|
|
func (r *fakeRows) FieldDescriptions() []pgconn.FieldDescription { return nil }
|
|
|
|
func (r *fakeRows) Next() bool {
|
|
if r.err != nil {
|
|
return false
|
|
}
|
|
if r.idx >= len(r.rows) {
|
|
return false
|
|
}
|
|
r.idx++
|
|
return true
|
|
}
|
|
|
|
func (r *fakeRows) Scan(dest ...any) error {
|
|
if r.idx == 0 {
|
|
return fmt.Errorf("Scan without Next")
|
|
}
|
|
return assignValues(dest, r.rows[r.idx-1])
|
|
}
|
|
|
|
func (r *fakeRows) Values() ([]any, error) {
|
|
if r.idx == 0 || r.idx > len(r.rows) {
|
|
return nil, fmt.Errorf("no row")
|
|
}
|
|
return append([]any(nil), r.rows[r.idx-1]...), nil
|
|
}
|
|
|
|
func (r *fakeRows) RawValues() [][]byte { return nil }
|
|
|
|
func (r *fakeRows) Conn() *pgx.Conn { return nil }
|
|
|
|
func assignValues(dest []any, values []any) error {
|
|
if len(dest) != len(values) {
|
|
return fmt.Errorf("dest len %d != values len %d", len(dest), len(values))
|
|
}
|
|
for i := range dest {
|
|
if dest[i] == nil {
|
|
continue
|
|
}
|
|
rv := reflect.ValueOf(dest[i])
|
|
if rv.Kind() != reflect.Pointer {
|
|
return fmt.Errorf("dest %d not pointer", i)
|
|
}
|
|
rv = rv.Elem()
|
|
val := reflect.ValueOf(values[i])
|
|
if !val.Type().AssignableTo(rv.Type()) {
|
|
return fmt.Errorf("value %d type %s not assignable to %s", i, val.Type(), rv.Type())
|
|
}
|
|
rv.Set(val)
|
|
}
|
|
return nil
|
|
}
|