sonda/internal/api/http/stream_test.go
tgiachi a880b87a9e chore: move the module path to git.kmalloc.org/squid/sonda
Migrating hosting from Codeberg to git.kmalloc.org. Renames the
module path in go.mod, every internal import, and the OCI image
source label in the Dockerfile. Build and full test suite verified
green after the rename.
2026-11-15 17:30:29 +01:00

256 lines
8.4 KiB
Go

package httpapi
import (
"bytes"
"context"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"testing"
"time"
"git.kmalloc.org/squid/sonda/internal/streaming"
)
type mapSource map[int64]streaming.File
func (m mapSource) PlayableFile(_ context.Context, id int64) (streaming.File, error) {
f, ok := m[id]
if !ok {
return streaming.File{}, streaming.ErrNotFound
}
return f, nil
}
// streamFixture serves track 1 (a 1000-byte mp3), track 2 (file gone from
// disk) and track 3 (a path that escapes the root).
type streamFixture struct {
h http.Handler
token string
data []byte
}
func newStreamFixture(t *testing.T) streamFixture {
t.Helper()
root := t.TempDir()
data := make([]byte, 1000)
for i := range data {
data[i] = byte(i % 251)
}
if err := os.WriteFile(filepath.Join(root, "song.mp3"), data, 0o644); err != nil {
t.Fatal(err)
}
src := mapSource{
1: {Root: root, RelPath: "song.mp3"},
2: {Root: root, RelPath: "gone.mp3"},
3: {Root: root, RelPath: "../escape.mp3"},
}
h := newTestAPIWith(t, func(d *Deps) { d.Streams = streaming.NewService(src) })
return streamFixture{h: h, token: registerAndLogin(t, h), data: data}
}
func (f streamFixture) get(t *testing.T, method, path string, headers map[string]string) *httptest.ResponseRecorder {
t.Helper()
req := httptest.NewRequest(method, path, nil)
for k, v := range headers {
req.Header.Set(k, v)
}
rec := httptest.NewRecorder()
f.h.ServeHTTP(rec, req)
return rec
}
func (f streamFixture) auth() map[string]string {
return map[string]string{"Authorization": "Bearer " + f.token}
}
func TestStreamRequiresAuth(t *testing.T) {
f := newStreamFixture(t)
for _, method := range []string{"GET", "HEAD"} {
if rec := f.get(t, method, "/api/v1/tracks/1/stream", nil); rec.Code != http.StatusUnauthorized {
t.Errorf("%s without token: %d", method, rec.Code)
}
}
if rec := f.get(t, "GET", "/api/v1/tracks/1/stream?access_token=garbage", nil); rec.Code != http.StatusUnauthorized {
t.Errorf("garbage query token: %d", rec.Code)
}
// The header wins: a bad header is not rescued by a good query token.
rec := f.get(t, "GET", "/api/v1/tracks/1/stream?access_token="+f.token, map[string]string{"Authorization": "Bearer garbage"})
if rec.Code != http.StatusUnauthorized {
t.Errorf("bad header with good query token: %d", rec.Code)
}
}
// A header that is present but not a Bearer token is not rescued by the query.
func TestStreamIgnoresQueryTokenWhenAnyAuthorizationHeaderIsPresent(t *testing.T) {
f := newStreamFixture(t)
for _, header := range []string{f.token, "Basic " + f.token, "Token x"} {
rec := f.get(t, "GET", "/api/v1/tracks/1/stream?access_token="+f.token, map[string]string{"Authorization": header})
if rec.Code != http.StatusUnauthorized {
t.Errorf("Authorization %.12q... with a valid query token: %d, want 401", header, rec.Code)
}
}
}
func TestStreamAcceptsHeaderAndQueryToken(t *testing.T) {
f := newStreamFixture(t)
if rec := f.get(t, "GET", "/api/v1/tracks/1/stream", f.auth()); rec.Code != http.StatusOK {
t.Errorf("header token: %d", rec.Code)
}
if rec := f.get(t, "GET", "/api/v1/tracks/1/stream?access_token="+f.token, nil); rec.Code != http.StatusOK {
t.Errorf("query token: %d", rec.Code)
}
}
func TestQueryTokenIsAcceptedOnlyForStreaming(t *testing.T) {
f := newStreamFixture(t)
for _, path := range []string{"/api/v1/auth/me", "/api/v1/users", "/api/v1/library/scan"} {
if rec := f.get(t, "GET", path+"?access_token="+f.token, nil); rec.Code != http.StatusUnauthorized {
t.Errorf("%s accepted a token in the URL: %d", path, rec.Code)
}
}
}
func TestStreamFullFile(t *testing.T) {
f := newStreamFixture(t)
rec := f.get(t, "GET", "/api/v1/tracks/1/stream", f.auth())
if rec.Code != http.StatusOK || !bytes.Equal(rec.Body.Bytes(), f.data) {
t.Fatalf("status %d, %d bytes", rec.Code, rec.Body.Len())
}
want := map[string]string{
"Content-Type": "audio/mpeg",
"Content-Length": "1000",
"Accept-Ranges": "bytes",
"X-Content-Type-Options": "nosniff",
"Referrer-Policy": "no-referrer",
"Cache-Control": "private, no-cache",
}
for k, v := range want {
if got := rec.Header().Get(k); got != v {
t.Errorf("%s = %q, want %q", k, got, v)
}
}
if rec.Header().Get("Last-Modified") == "" {
t.Error("Last-Modified missing")
}
}
func TestStreamHead(t *testing.T) {
f := newStreamFixture(t)
rec := f.get(t, "HEAD", "/api/v1/tracks/1/stream", f.auth())
if rec.Code != http.StatusOK || rec.Body.Len() != 0 {
t.Fatalf("HEAD: %d with a %d byte body", rec.Code, rec.Body.Len())
}
if rec.Header().Get("Content-Length") != "1000" || rec.Header().Get("Content-Type") != "audio/mpeg" ||
rec.Header().Get("Accept-Ranges") != "bytes" {
t.Errorf("HEAD headers = %v", rec.Header())
}
}
func TestStreamRanges(t *testing.T) {
f := newStreamFixture(t)
tests := []struct {
name, header string
first, last int
}{
{"first bytes", "bytes=0-99", 0, 99},
{"middle", "bytes=100-199", 100, 199},
{"open ended", "bytes=900-", 900, 999},
{"suffix", "bytes=-50", 950, 999},
{"single byte", "bytes=5-5", 5, 5},
{"end beyond the file is clamped", "bytes=990-5000", 990, 999},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
h := f.auth()
h["Range"] = tt.header
rec := f.get(t, "GET", "/api/v1/tracks/1/stream", h)
if rec.Code != http.StatusPartialContent {
t.Fatalf("status = %d, want 206", rec.Code)
}
wantRange := "bytes " + strconv.Itoa(tt.first) + "-" + strconv.Itoa(tt.last) + "/1000"
if got := rec.Header().Get("Content-Range"); got != wantRange {
t.Errorf("Content-Range = %q, want %q", got, wantRange)
}
if got := rec.Header().Get("Content-Length"); got != strconv.Itoa(tt.last-tt.first+1) {
t.Errorf("Content-Length = %q", got)
}
if !bytes.Equal(rec.Body.Bytes(), f.data[tt.first:tt.last+1]) {
t.Error("body does not match the requested bytes")
}
})
}
}
func TestStreamRangeOnHeadHasNoBody(t *testing.T) {
f := newStreamFixture(t)
h := f.auth()
h["Range"] = "bytes=0-9"
rec := f.get(t, "HEAD", "/api/v1/tracks/1/stream", h)
if rec.Code != http.StatusPartialContent || rec.Body.Len() != 0 || rec.Header().Get("Content-Length") != "10" {
t.Fatalf("HEAD with Range: %d, body %d, length %q", rec.Code, rec.Body.Len(), rec.Header().Get("Content-Length"))
}
}
func TestStreamUnsatisfiableRange(t *testing.T) {
f := newStreamFixture(t)
// Well-formed but outside the file: 416 and the real size in Content-Range.
for _, rng := range []string{"bytes=2000-3000", "bytes=1000-"} {
h := f.auth()
h["Range"] = rng
rec := f.get(t, "GET", "/api/v1/tracks/1/stream", h)
if rec.Code != http.StatusRequestedRangeNotSatisfiable {
t.Errorf("Range %q: status %d, want 416", rng, rec.Code)
continue
}
if got := rec.Header().Get("Content-Range"); got != "bytes */1000" {
t.Errorf("Range %q: Content-Range = %q, want %q", rng, got, "bytes */1000")
}
}
// Malformed: also refused with 416, and no audio is sent.
for _, rng := range []string{"bytes=abc", "bytes=9-1"} {
h := f.auth()
h["Range"] = rng
rec := f.get(t, "GET", "/api/v1/tracks/1/stream", h)
if rec.Code != http.StatusRequestedRangeNotSatisfiable || bytes.Contains(rec.Body.Bytes(), f.data[:50]) {
t.Errorf("Range %q: status %d", rng, rec.Code)
}
}
}
func TestStreamConditionalRequest(t *testing.T) {
f := newStreamFixture(t)
h := f.auth()
h["If-Modified-Since"] = time.Now().Add(time.Hour).UTC().Format(http.TimeFormat)
rec := f.get(t, "GET", "/api/v1/tracks/1/stream", h)
if rec.Code != http.StatusNotModified || rec.Body.Len() != 0 {
t.Fatalf("If-Modified-Since in the future: %d with %d bytes", rec.Code, rec.Body.Len())
}
}
func TestStreamErrors(t *testing.T) {
f := newStreamFixture(t)
tests := []struct {
name, path string
status int
code string
}{
{"unknown track", "/api/v1/tracks/99/stream", http.StatusNotFound, "track_not_found"},
{"file gone from disk", "/api/v1/tracks/2/stream", http.StatusNotFound, "file_missing"},
{"path escaping the root", "/api/v1/tracks/3/stream", http.StatusNotFound, "file_missing"},
{"id is not a number", "/api/v1/tracks/abc/stream", http.StatusBadRequest, "invalid_input"},
{"id is zero", "/api/v1/tracks/0/stream", http.StatusBadRequest, "invalid_input"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := do(t, f.h, "GET", tt.path, f.token, nil)
if r.Code != tt.status || errCode(r) != tt.code {
t.Fatalf("%d %v, want %d %s", r.Code, r.Body, tt.status, tt.code)
}
})
}
}