Step 6 — List, delete, and finish the project

1touch internal/transport/web/handler_test.go Dockerfile Makefile
2
3# tests
4go test ./... -race -cover
5go test ./internal/transport/web/ -run TestCreate -v
6
7# the container
8docker build -t shortener:latest .
9docker images shortener:latest          # ~15MB
10docker run --rm -p 8080:8080 -e DATABASE_URL="$DATABASE_URL" shortener:latest
11
12# the four checks before any push
13gofmt -l .
14go vet ./...
15go test -race ./...
16go run golang.org/x/vuln/cmd/govulncheck@latest ./...

1func (s *Postgres) List(ctx context.Context, limit, offset int) ([]Link, error) {
2	rows, err := s.db.QueryContext(ctx,
3		`SELECT code, long_url, clicks, created_at
4		   FROM links ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
5		limit, offset,
6	)
7	if err != nil {
8		return nil, err
9	}
10	defer rows.Close()                  // or you leak a pooled connection
11
12	out := make([]Link, 0, limit)
13	for rows.Next() {
14		var l Link
15		if err := rows.Scan(&l.Code, &l.LongURL, &l.Clicks, &l.CreatedAt); err != nil {
16			return nil, err
17		}
18		out = append(out, l)
19	}
20	return out, rows.Err()              // iteration errors only appear here
21}

1func (h *Handler) list(w http.ResponseWriter, r *http.Request) {
2	limit := intParam(r, "limit", 20, 1, 100)     // clamped, never unbounded
3	offset := intParam(r, "offset", 0, 0, 1_000_000)
4
5	links, err := h.svc.List(r.Context(), limit, offset)
6	if err != nil {
7		Error(w, 500, "could not list links")
8		return
9	}
10	JSON(w, 200, links)
11}
12
13// intParam reads a query parameter, falling back to def and clamping the range.
14func intParam(r *http.Request, key string, def, min, max int) int {
15	v, err := strconv.Atoi(r.URL.Query().Get(key))
16	if err != nil {
17		return def
18	}
19	return Clamp(v, min, max)
20}

1func (s *Postgres) Delete(ctx context.Context, code string) error {
2	res, err := s.db.ExecContext(ctx,`DELETE FROM links WHERE code = $1`, code)
3	if err != nil {
4		return err
5	}
6	if n, _ := res.RowsAffected(); n == 0 {
7		return ErrNotFound        // deleting nothing is not success
8	}
9	return nil
10}

1errCh := make(chan error, 1)
2go func() {
3	if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
4		errCh <- err
5	}
6}()
7
8quit := make(chan os.Signal, 1)          // MUST be buffered or the signal is lost
9signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
10
11select {
12case err := <-errCh:
13	return err
14case <-quit:
15	slog.Info("shutting down")
16	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
17	defer cancel()
18	return srv.Shutdown(ctx)
19}

1func TestCreateRejectsBadURLs(t *testing.T) {
2	h := newTestHandler(t)
3
4	tests := []struct {
5		name string
6		body string
7		want int
8	}{
9		{"valid", `{"url":"https://go.dev"}`, 201},
10		{"empty", `{"url":""}`, 422},
11		{"not a url", `{"url":"hello"}`, 422},
12		{"javascript scheme", `{"url":"javascript:alert(1)"}`, 422},
13		{"malformed json", `nope`, 400},
14	}
15
16	for _, tt := range tests {
17		t.Run(tt.name, func(t *testing.T) {
18			req := httptest.NewRequest("POST", "/links", strings.NewReader(tt.body))
19			rec := httptest.NewRecorder()
20			h.ServeHTTP(rec, req)
21
22			if rec.Code != tt.want {
23				t.Errorf("status = %d, want %d — body %s", rec.Code, tt.want, rec.Body)
24			}
25		}) 
26	}
27}

1FROM golang:1.22-alpine AS build
2WORKDIR /src
3COPY go.mod go.sum ./
4RUN go mod download
5COPY . .
6RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /api ./cmd/api
7
8FROM gcr.io/distroless/static-debian12
9COPY --from=build /api /api
10USER nonroot:nonroot
11EXPOSE 8080
12ENTRYPOINT ["/api"]