You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
518 lines
13 KiB
Go
518 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.runcible.io/learning/pulley/internal/assert"
|
|
"git.runcible.io/learning/pulley/internal/config"
|
|
"git.runcible.io/learning/pulley/internal/data"
|
|
"git.runcible.io/learning/pulley/internal/database"
|
|
"github.com/pashagolub/pgxmock/v4"
|
|
)
|
|
|
|
func newTestApplication(pool database.PgxIface) application {
|
|
cfg := config.ServiceConfig{Env: "test"}
|
|
mockModels := data.NewModels(pool)
|
|
// Discards log output from tests
|
|
// logger := slog.New(slog.NewTextHandler(io.Discard, nil))
|
|
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug, AddSource: true}))
|
|
|
|
return application{config: cfg, logger: logger, models: mockModels}
|
|
|
|
}
|
|
|
|
func TestHealthRoute(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
mockPool, err := pgxmock.NewPool()
|
|
assert.NilError(t, err)
|
|
defer mockPool.Close()
|
|
|
|
r, err := http.NewRequest(http.MethodGet, "/v1/healthcheck", nil)
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("Got status code %q, wanted status code %q", resp.StatusCode, http.StatusOK)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
assert.NilError(t, err)
|
|
jsonContent := make(map[string]any)
|
|
|
|
json.Unmarshal(body, &jsonContent)
|
|
|
|
assert.Equal(t, jsonContent["status"], "available")
|
|
}
|
|
|
|
func TestCreateMovieHandler(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
mockPool, err := pgxmock.NewPool()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer mockPool.Close()
|
|
|
|
movie := struct {
|
|
Title string `json:"title"`
|
|
Year int32 `json:"year"`
|
|
Runtime string `json:"runtime"`
|
|
Genres []string `json:"genres"`
|
|
}{
|
|
Title: "Moana",
|
|
Year: 2019,
|
|
Runtime: "120 mins",
|
|
Genres: []string{"family", "Samoan"},
|
|
}
|
|
|
|
mockPool.ExpectQuery("INSERT INTO movies").
|
|
// must use Runtime explicitly for args
|
|
WithArgs(movie.Title, movie.Year, data.Runtime(120), movie.Genres).
|
|
WillReturnRows(
|
|
pgxmock.NewRows([]string{"id", "created_at", "version"}).
|
|
AddRow(1, time.Now(), 1), // These values will be scanned into the struct
|
|
)
|
|
|
|
rquestBody, _ := json.Marshal(movie)
|
|
|
|
r, err := http.NewRequest(http.MethodPost, "/v1/movies", bytes.NewBuffer(rquestBody))
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
|
|
assert.Equal(t, resp.StatusCode, http.StatusCreated)
|
|
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
|
|
assert.NilError(t, err)
|
|
|
|
body = bytes.TrimSpace(body)
|
|
|
|
assert.StringContains(t, string(body), "Moana")
|
|
err = mockPool.ExpectationsWereMet()
|
|
if err != nil {
|
|
t.Errorf("there were unfulfilled expectations: %s", err)
|
|
}
|
|
}
|
|
|
|
// Consider simply testing app.jsonReader
|
|
func TestCreateMovieValidatorError(t *testing.T) {
|
|
|
|
mockPool, err := pgxmock.NewPool()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer mockPool.Close()
|
|
|
|
tests := []struct {
|
|
name string
|
|
input *strings.Reader
|
|
wantBody string
|
|
wantCode int
|
|
}{
|
|
{
|
|
name: "Test XML",
|
|
input: strings.NewReader(`<?xml version="1.0" encoding="UTF-8"?><note><to>Alex</to></note>`),
|
|
wantBody: "body contains badly-formed JSON",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Test Bad JSON",
|
|
input: strings.NewReader(`{"title": "Moana", }`),
|
|
wantBody: "body contains badly-formed JSON",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send a JSON array instead of an object",
|
|
input: strings.NewReader(`["not", "good"]`),
|
|
wantBody: "body contains incorrect JSON type",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send a numeric 'title' value",
|
|
input: strings.NewReader(`{"title": 123}`),
|
|
wantBody: "body contains incorrect JSON type",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send an empty request body",
|
|
input: strings.NewReader(""),
|
|
wantBody: "body must not be empty",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send unknown field",
|
|
input: strings.NewReader(`{"title": "Moana", "year": 2019, "runtime": "120 mins", "genres": ["family", "Samoan"], "rating": "PG"}`),
|
|
wantBody: "body contains unknown key",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send garbage after JSON",
|
|
input: strings.NewReader(`{"title": "Moana"} :~()`),
|
|
wantBody: "body must only contain a single JSON value",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send too large a JSON payload",
|
|
// 1.5 MB title
|
|
input: strings.NewReader(fmt.Sprintf("{\"title\": \"%s\"}", strings.Repeat("a", int(1.5*1024*1024)))),
|
|
wantBody: "body must not be larger than 1048576 bytes",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Send invalid runtime",
|
|
input: strings.NewReader(`{"title": "Moana", "runtime": 120}`),
|
|
wantBody: "invalid runtime format",
|
|
wantCode: http.StatusBadRequest,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
r, err := http.NewRequest(http.MethodPost, "/v1/movies", test.input)
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
|
|
assert.Equal(t, resp.StatusCode, test.wantCode)
|
|
|
|
var jsonResp map[string]string
|
|
json.NewDecoder(resp.Body).Decode(&jsonResp)
|
|
|
|
assert.StringContains(t, jsonResp["error"], test.wantBody)
|
|
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestGetMovieHandler(t *testing.T) {
|
|
|
|
mockPool, err := pgxmock.NewPool()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer mockPool.Close()
|
|
|
|
// TODO since this isn't a table test anymore should be able to refactor it
|
|
testTable := []struct {
|
|
name string
|
|
id string
|
|
wantCode int
|
|
useID bool
|
|
}{
|
|
{
|
|
name: "Get Movie By ID",
|
|
id: "1337",
|
|
wantCode: 200,
|
|
},
|
|
}
|
|
|
|
mockPool.ExpectQuery("SELECT id, created_at, title, year, runtime, genres, version FROM movies").
|
|
WithArgs(int64(1337)).WillReturnRows(
|
|
pgxmock.NewRows([]string{"id", "created_at", "title", "year", "runtime", "genres", "version"}).
|
|
AddRow(int64(1337), time.Now(), "a laura is born", 1990, 36, []string{"family", "wife"}, 1), // These values will be scanned into the struct
|
|
)
|
|
|
|
for _, test := range testTable {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
|
|
r, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/v1/movies/%s", test.id), nil)
|
|
t.Logf("Path: %s, Method: %s", r.URL.Path, r.Method)
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
// want to test with httprouter since we use it to parse context
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
t.Logf("Code: %d", resp.StatusCode)
|
|
assert.Equal(t, resp.StatusCode, test.wantCode)
|
|
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetMovieHandlerErrors(t *testing.T) {
|
|
|
|
mockPool, err := pgxmock.NewPool()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer mockPool.Close()
|
|
|
|
testTable := []struct {
|
|
name string
|
|
id string
|
|
wantCode int
|
|
useID bool
|
|
}{
|
|
// will redirect to /v1/movies/
|
|
{
|
|
name: "No ID provided",
|
|
id: "",
|
|
wantCode: 301,
|
|
},
|
|
{
|
|
name: "Negative ID",
|
|
id: "-1",
|
|
wantCode: 404,
|
|
},
|
|
}
|
|
|
|
for _, test := range testTable {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
|
|
r, err := http.NewRequest(http.MethodGet, fmt.Sprintf("/v1/movies/%s", test.id), nil)
|
|
t.Logf("Path: %s, Method: %s", r.URL.Path, r.Method)
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
// want to test with httprouter since we use it to parse context
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
t.Logf("Code: %d", resp.StatusCode)
|
|
assert.Equal(t, resp.StatusCode, test.wantCode)
|
|
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestListMovieHandler(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
|
|
mockPool, err := pgxmock.NewPool()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer mockPool.Close()
|
|
|
|
movies := []data.Movie{{
|
|
ID: 1337,
|
|
CreatedAt: time.Now(),
|
|
Title: "Batteries not included",
|
|
Year: 1987,
|
|
Runtime: data.Runtime(120),
|
|
Genres: []string{"family", "comedy"},
|
|
Version: 1,
|
|
}, {
|
|
ID: 1338,
|
|
CreatedAt: time.Now(),
|
|
Title: "The Boy and the Heron",
|
|
Year: 2023,
|
|
Runtime: data.Runtime(140),
|
|
Genres: []string{"animation", "drama"},
|
|
Version: 1,
|
|
},
|
|
}
|
|
|
|
rows := pgxmock.NewRows([]string{"id", "created_at", "title", "year", "runtime", "genres", "version"})
|
|
for _, m := range movies {
|
|
rows.AddRow(m.ID, m.CreatedAt, m.Title, m.Year, m.Runtime, m.Genres, m.Version)
|
|
}
|
|
|
|
mockPool.ExpectQuery(`SELECT id, created_at, title, year, runtime, genres, version
|
|
FROM movies
|
|
ORDER BY id ASC`).WillReturnRows(rows)
|
|
|
|
r, err := http.NewRequest(http.MethodGet, "/v1/movies", nil)
|
|
assert.NilError(t, err)
|
|
|
|
app := newTestApplication(mockPool)
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("Got status code %d, wanted status code %d", resp.StatusCode, http.StatusOK)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
assert.NilError(t, err)
|
|
jsonContent := make(map[string][]data.Movie)
|
|
|
|
err = json.Unmarshal(body, &jsonContent)
|
|
assert.NilError(t, err)
|
|
|
|
assert.Equal(t, len(jsonContent["movies"]), 2)
|
|
for i := range jsonContent["movies"] {
|
|
assert.MovieEqual(t, jsonContent["movies"][i], movies[i])
|
|
}
|
|
|
|
err = mockPool.ExpectationsWereMet()
|
|
assert.NilError(t, err)
|
|
}
|
|
|
|
func TestListHandlerServerError(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
mockPool, err := pgxmock.NewPool()
|
|
assert.NilError(t, err)
|
|
getAllReturnColumns := []string{"id", "created_at", "title", "year", "runtime", "genres", "version"}
|
|
errorRows := pgxmock.NewRows(getAllReturnColumns).AddRow(1, time.Now(), "will error", 2026, 120, []string{}, 1).RowError(0, fmt.Errorf("network connection lost"))
|
|
|
|
mockPool.ExpectQuery("SELECT").WillReturnRows(errorRows)
|
|
r, err := http.NewRequest(http.MethodGet, "/v1/movies", nil)
|
|
|
|
app := newTestApplication(mockPool)
|
|
app.routes().ServeHTTP(respRec, r)
|
|
|
|
resp := respRec.Result()
|
|
assert.Equal(t, resp.StatusCode, http.StatusInternalServerError)
|
|
|
|
}
|
|
|
|
func TestListHandlerValidation(t *testing.T) {
|
|
mockPool, err := pgxmock.NewPool()
|
|
assert.NilError(t, err)
|
|
defer mockPool.Close()
|
|
|
|
getAllReturnColumns := []string{"id", "created_at", "title", "year", "runtime", "genres", "version"}
|
|
getAllQuery := `
|
|
SELECT id, created_at, title, year, runtime, genres, version
|
|
FROM movies
|
|
ORDER BY id ASC
|
|
`
|
|
|
|
testTable := []struct {
|
|
name string
|
|
query string
|
|
wantCode int
|
|
}{
|
|
// invalid requests
|
|
{
|
|
name: "bad sort key",
|
|
query: "/v1/movies?sort=dirp",
|
|
wantCode: http.StatusUnprocessableEntity,
|
|
},
|
|
{
|
|
name: "bad page value",
|
|
query: "/v1/movies?page=shouldbeint",
|
|
wantCode: http.StatusUnprocessableEntity,
|
|
},
|
|
{
|
|
name: "bad page_size value",
|
|
query: "/v1/movies?page_size=shouldbeint",
|
|
wantCode: http.StatusUnprocessableEntity,
|
|
},
|
|
{
|
|
name: "bad page too large",
|
|
query: "/v1/movies?page=1000000000",
|
|
wantCode: http.StatusUnprocessableEntity,
|
|
},
|
|
{
|
|
name: "bad page_size too large",
|
|
query: "/v1/movies?page_size=1000",
|
|
wantCode: http.StatusUnprocessableEntity,
|
|
},
|
|
// valid requests
|
|
{
|
|
name: "no query params",
|
|
query: "/v1/movies",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "valid page_size",
|
|
query: "/v1/movies?page_size=50",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "valid page",
|
|
query: "/v1/movies?page=10",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by id ascending",
|
|
query: "/v1/movies?sort=id",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by id ascending",
|
|
query: "/v1/movies?sort=-id",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by year ascending",
|
|
query: "/v1/movies?sort=year",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by year descending",
|
|
query: "/v1/movies?sort=-year",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by runtime ascending",
|
|
query: "/v1/movies?sort=runtime",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by runtime descending",
|
|
query: "/v1/movies?sort=-runtime",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by title ascending",
|
|
query: "/v1/movies?sort=title",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
{
|
|
name: "sort by title descending",
|
|
query: "/v1/movies?sort=-title",
|
|
wantCode: http.StatusOK,
|
|
},
|
|
}
|
|
|
|
app := newTestApplication(mockPool)
|
|
|
|
for _, test := range testTable {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
respRec := httptest.NewRecorder()
|
|
mockPool, err := pgxmock.NewPool()
|
|
assert.NilError(t, err)
|
|
// assert if DB is expected to be hit
|
|
if test.wantCode == http.StatusOK {
|
|
// TODO expand return values and parameterize
|
|
// empty return is fine for validator test
|
|
mockPool.ExpectQuery(getAllQuery).WillReturnRows(mockPool.NewRows(getAllReturnColumns))
|
|
}
|
|
|
|
r, err := http.NewRequest(http.MethodGet, test.query, nil)
|
|
assert.NilError(t, err)
|
|
app = newTestApplication(mockPool)
|
|
app.routes().ServeHTTP(respRec, r)
|
|
resp := respRec.Result()
|
|
|
|
assert.Equal(t, resp.StatusCode, test.wantCode)
|
|
err = mockPool.ExpectationsWereMet()
|
|
assert.NilError(t, err)
|
|
})
|
|
|
|
}
|
|
|
|
}
|