sonda/internal/api/http/peer_test.go
tgiachi a92326c1b4 feat(player): play every song at a similar volume with ReplayGain
I want songs from different albums to play at about the same loudness without touching the volume.

- The scan reads REPLAYGAIN_TRACK_GAIN, REPLAYGAIN_ALBUM_GAIN and the two peaks from each file, offline, and keeps them on the file (migration 0029, SQLite and PostgreSQL). A tag that makes no sense (not a number, more than 60 dB) is left out. Files indexed before have none until a full rescan.
- A track in the API carries them as replay_gain (null when its first playable file says nothing).
- The web player levels each song with them: the sound passes through a gain node, so a quiet song can be raised too, but never so much that its peak would clip (and never more than 12 dB when there is no peak). Without Web Audio the element is turned down instead.
- A new Playback section in Settings chooses song by song (default), album by album or off; the choice stays on the device.
- README: the ReplayGain entry, and the old line that said the year was not in the index is removed.
- English and Italian.
2026-11-14 16:02:23 +01:00

548 lines
20 KiB
Go

package httpapi
import (
"bytes"
"crypto/ed25519"
"crypto/rand"
"encoding/base64"
"encoding/json"
"image"
"image/png"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/uptrace/bun"
"codeberg.org/squidd/sonda/internal/federation"
"codeberg.org/squidd/sonda/internal/library"
"codeberg.org/squidd/sonda/internal/storage"
)
// peerFixture is a server with two libraries, one that can be shared and one that cannot, and a friend that holds
// a key of its own.
type peerFixture struct {
h http.Handler
db *bun.DB
admin string
fed *federation.Service
pub ed25519.PublicKey
priv ed25519.PrivateKey
shared int64 // library ids
private int64
track map[string]int64
friendID string
bytes map[string][]byte // what each file holds
root string // the folder of the libraries: one folder for each, with song.mp3 in it
nonce atomic.Int64
}
func peerParsed(rel, title, album, artist string) library.ParsedFile {
return library.ParsedFile{
FileInfo: library.FileInfo{RelPath: rel, Size: 400, MTimeUnix: 1_700_000_000},
Metadata: library.Metadata{
Tags: library.Tags{Title: title, Album: album, AlbumArtist: artist, Artists: []string{artist}, TrackNo: 1, DiscNo: 1},
Properties: library.Properties{Format: "mpeg", DurationMs: 60000, SampleRate: 44100},
},
}
}
func newPeerFixture(t *testing.T) *peerFixture {
t.Helper()
f := &peerFixture{track: map[string]int64{}, bytes: map[string][]byte{}}
h, db := newTestEnvDB(t, func(d *Deps, db *bun.DB) {
f.fed = federation.NewService(storage.NewFederationRepo(db), federation.NewClient())
d.Federation = f.fed
})
f.h, f.db = h, db
f.admin = registerAndLogin(t, h)
root := t.TempDir()
f.root = root
repo := storage.NewLibraryRepo(db)
for _, l := range []struct {
name, title, album, artist string
fill byte
id *int64
}{
{"shared", "Shared Song", "Shared Album", "Shared Band", 0xA1, &f.shared},
{"private", "Private Song", "Private Album", "Private Band", 0xB2, &f.private},
} {
dir := filepath.Join(root, l.name)
if err := os.MkdirAll(dir, 0o755); err != nil {
t.Fatal(err)
}
data := bytes.Repeat([]byte{l.fill}, 400)
for i := range data {
data[i] ^= byte(i)
}
f.bytes[l.title] = data
if err := os.WriteFile(filepath.Join(dir, "song.mp3"), data, 0o644); err != nil {
t.Fatal(err)
}
// A picture next to the audio: the cover of the album, once somebody asks for it.
var pic bytes.Buffer
if err := png.Encode(&pic, image.NewRGBA(image.Rect(0, 0, 40, 30))); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "cover.png"), pic.Bytes(), 0o644); err != nil {
t.Fatal(err)
}
lib, err := repo.CreateLibrary(t.Context(), l.name, dir)
if err != nil {
t.Fatal(err)
}
*l.id = lib.ID
if _, err := repo.SaveFile(t.Context(), lib.ID, peerParsed("song.mp3", l.title, l.album, l.artist), 0); err != nil {
t.Fatal(err)
}
}
rows, err := db.Query("SELECT id, title FROM tracks WHERE title <> 'song'")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
var title string
_ = rows.Scan(&id, &title)
f.track[title] = id
}
_ = rows.Close()
return f
}
func (f *peerFixture) admin1(t *testing.T, method, path string, body any) resp {
t.Helper()
return do(t, f.h, method, "/api/v1"+path, f.admin, body)
}
// befriend turns federation on and makes the friend (its key is in f.priv) an active friend, the way a real one
// would: with an invite, and then the admin's approval.
func (f *peerFixture) befriend(t *testing.T) {
t.Helper()
if r := f.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "name": "Anna", "address": "https://anna.example.org"}); r.Code != 200 {
t.Fatalf("turn on: %d %v", r.Code, r.Body)
}
inv := f.admin1(t, "POST", "/federation/invites", nil)
f.pub, f.priv, _ = ed25519.GenerateKey(rand.Reader)
body := map[string]any{
"code": inviteCode(t, str(inv.Body, "invite")), "name": "Bruno", "address": "https://bruno.example.org",
"public_key": base64.RawURLEncoding.EncodeToString(f.pub),
}
if r := do(t, f.h, "POST", "/api/v1/peer/pair", "", body); r.Code != 200 {
t.Fatalf("pair: %d %v", r.Code, r.Body)
}
list := f.admin1(t, "GET", "/federation", nil).Body["friends"].([]any)
f.friendID = strconv.Itoa(int(list[0].(map[string]any)["id"].(float64)))
if r := f.admin1(t, "POST", "/federation/friends/"+f.friendID+"/approve", nil); r.Code != 200 {
t.Fatalf("approve: %d %v", r.Code, r.Body)
}
}
func (f *peerFixture) share(t *testing.T, id int64, on bool) {
t.Helper()
r := f.admin1(t, "PATCH", "/libraries/"+strconv.FormatInt(id, 10), map[string]any{"shared": on})
if r.Code != 200 || r.Body["shared"] != on {
t.Fatalf("share %d: %d %v", id, r.Code, r.Body)
}
}
// signed makes a request a friend would make, signed with its key.
func (f *peerFixture) signed(method, path string, mutate ...func(*http.Request)) *http.Request {
uri := "/api/v1/peer" + path
n := f.nonce.Add(1)
h := federation.Sign(f.priv, method, uri, time.Now(), "nonce-"+strconv.FormatInt(n, 10)+"-0123456789abcdef")
req := httptest.NewRequest(method, uri, nil)
req.Header.Set(federation.HeaderKeyID, federation.KeyID(f.pub))
req.Header.Set(federation.HeaderDate, h.Date)
req.Header.Set(federation.HeaderNonce, h.Nonce)
req.Header.Set(federation.HeaderSignature, h.Signature)
for _, m := range mutate {
m(req)
}
return req
}
func (f *peerFixture) serve(req *http.Request) *httptest.ResponseRecorder {
rec := httptest.NewRecorder()
f.h.ServeHTTP(rec, req)
return rec
}
func (f *peerFixture) get(t *testing.T, path string) resp {
t.Helper()
rec := f.serve(f.signed("GET", path))
out := resp{Code: rec.Code, Body: map[string]any{}}
_ = json.Unmarshal(rec.Body.Bytes(), &out.Body)
return out
}
func titlesIn(r resp) []string {
var out []string
for _, it := range r.Body["items"].([]any) {
m := it.(map[string]any)
if v, ok := m["title"].(string); ok {
out = append(out, v)
} else {
out = append(out, m["name"].(string))
}
}
return out
}
func TestAFriendMustSignItsRequests(t *testing.T) {
f := newPeerFixture(t)
f.share(t, f.shared, true)
// Federation is off: the routes are as good as missing, whoever asks.
if rec := f.serve(httptest.NewRequest("GET", "/api/v1/peer/info", nil)); rec.Code != 404 {
t.Errorf("while off: %d", rec.Code)
}
f.befriend(t)
for name, req := range map[string]*http.Request{
"no signature": httptest.NewRequest("GET", "/api/v1/peer/info", nil),
"another path": f.signed("GET", "/info", func(r *http.Request) { r.URL.Path = "/api/v1/peer/artists" }),
"a bad signature": f.signed("GET", "/info", func(r *http.Request) { r.Header.Set(federation.HeaderSignature, "AAAA") }),
"an old date": f.signed("GET", "/info", func(r *http.Request) {
r.Header.Set(federation.HeaderDate, strconv.FormatInt(time.Now().Add(-time.Hour).Unix(), 10))
}),
"another key": f.signed("GET", "/info", func(r *http.Request) { r.Header.Set(federation.HeaderKeyID, "0123456789abcdef") }),
} {
rec := f.serve(req)
var body struct{ Error struct{ Code string } }
_ = json.Unmarshal(rec.Body.Bytes(), &body)
if rec.Code != 401 || body.Error.Code != "unauthorized" {
t.Errorf("%s: %d %s", name, rec.Code, rec.Body.String())
}
}
// A request is good once.
req := f.signed("GET", "/info")
if rec := f.serve(req); rec.Code != 200 {
t.Fatalf("the good request: %d %s", rec.Code, rec.Body.String())
}
if rec := f.serve(req.Clone(req.Context())); rec.Code != 401 {
t.Errorf("the same request again: %d, want 401", rec.Code)
}
// Removing the friend ends it at once.
f.admin1(t, "DELETE", "/federation/friends/"+f.friendID, nil)
if rec := f.serve(f.signed("GET", "/info")); rec.Code != 401 {
t.Errorf("after removal: %d, want 401", rec.Code)
}
}
func TestAFriendWaitingForApprovalIsToldSo(t *testing.T) {
f := newPeerFixture(t)
f.admin1(t, "PUT", "/federation", map[string]any{"enabled": true, "address": "https://anna.example.org"})
inv := f.admin1(t, "POST", "/federation/invites", nil)
f.pub, f.priv, _ = ed25519.GenerateKey(rand.Reader)
do(t, f.h, "POST", "/api/v1/peer/pair", "", map[string]any{
"code": inviteCode(t, str(inv.Body, "invite")), "name": "Bruno", "address": "https://bruno.example.org",
"public_key": base64.RawURLEncoding.EncodeToString(f.pub),
})
rec := f.serve(f.signed("GET", "/info"))
if rec.Code != 403 || !strings.Contains(rec.Body.String(), `"not_approved"`) {
t.Errorf("unapproved friend: %d %s", rec.Code, rec.Body.String())
}
}
func TestAFriendSeesWhoWeAreAndHowManyLibrariesAreShared(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
r := f.get(t, "/info")
sameKeys(t, "info", r.Body, "name", "shared_libraries")
if r.Code != 200 || r.Body["name"] != "Anna" || r.Body["shared_libraries"] != float64(0) {
t.Errorf("info = %d %v", r.Code, r.Body)
}
f.share(t, f.shared, true)
if r := f.get(t, "/info"); r.Body["shared_libraries"] != float64(1) {
t.Errorf("info = %v", r.Body)
}
}
func TestAFriendReadsOnlyTheSharedLibraries(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
// Nothing is shared: nothing is there, by list, by id or by search.
for _, p := range []string{"/artists", "/albums", "/tracks"} {
if r := f.get(t, p); r.Code != 200 || r.Body["total"] != float64(0) {
t.Errorf("%s with nothing shared = %d %v", p, r.Code, r.Body)
}
}
for _, p := range []string{"/tracks/" + strconv.FormatInt(f.track["Shared Song"], 10), "/tracks/" + strconv.FormatInt(f.track["Private Song"], 10)} {
if r := f.get(t, p); r.Code != 404 {
t.Errorf("%s with nothing shared = %d", p, r.Code)
}
}
f.share(t, f.shared, true)
if got := titlesIn(f.get(t, "/tracks")); len(got) != 1 || got[0] != "Shared Song" {
t.Errorf("tracks = %v", got)
}
if got := titlesIn(f.get(t, "/albums")); len(got) != 1 || got[0] != "Shared Album" {
t.Errorf("albums = %v", got)
}
if got := titlesIn(f.get(t, "/artists")); len(got) != 1 || got[0] != "Shared Band" {
t.Errorf("artists = %v", got)
}
if got := titlesIn(f.get(t, "/tracks?q=private")); len(got) != 0 {
t.Errorf("a search found %v in the library that is not shared", got)
}
if got := titlesIn(f.get(t, "/tracks?library_id="+strconv.FormatInt(f.private, 10))); len(got) != 0 {
t.Errorf("asking for the other library found %v", got)
}
one := f.get(t, "/tracks/"+strconv.FormatInt(f.track["Shared Song"], 10))
sameKeys(t, "track", one.Body, "id", "title", "duration_ms", "track_no", "disc_no", "album", "artists", "format", "replay_gain")
if one.Code != 200 || one.Body["title"] != "Shared Song" {
t.Errorf("track = %d %v", one.Code, one.Body)
}
if r := f.get(t, "/tracks/"+strconv.FormatInt(f.track["Private Song"], 10)); r.Code != 404 || errCode(r) != "track_not_found" {
t.Errorf("the track of the other library: %d %v", r.Code, r.Body)
}
for _, p := range []string{"/artists/", "/albums/"} {
if r := f.get(t, p+"999999"); r.Code != 404 {
t.Errorf("%s999999 = %d", p, r.Code)
}
}
// Whatever the answer says, it is never a path.
rec := f.serve(f.signed("GET", "/tracks"))
if strings.Contains(rec.Body.String(), "song.mp3") || strings.Contains(rec.Body.String(), "/shared") {
t.Errorf("the answer names a path: %s", rec.Body.String())
}
// Unsharing takes it away at once.
f.share(t, f.shared, false)
if r := f.get(t, "/tracks"); r.Body["total"] != float64(0) {
t.Errorf("after unsharing: %v", r.Body)
}
}
func TestAFriendStreamsSharedMusicWithRanges(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
f.share(t, f.shared, true)
want := f.bytes["Shared Song"]
id := strconv.FormatInt(f.track["Shared Song"], 10)
rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream"))
if rec.Code != 200 || !bytes.Equal(rec.Body.Bytes(), want) {
t.Fatalf("stream: %d, %d bytes", rec.Code, rec.Body.Len())
}
if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "audio/") {
t.Errorf("Content-Type = %q", ct)
}
rec = f.serve(f.signed("GET", "/tracks/"+id+"/stream", func(r *http.Request) { r.Header.Set("Range", "bytes=100-199") }))
if rec.Code != 206 || !bytes.Equal(rec.Body.Bytes(), want[100:200]) || rec.Header().Get("Content-Range") != "bytes 100-199/400" {
t.Errorf("range: %d %q %d bytes", rec.Code, rec.Header().Get("Content-Range"), rec.Body.Len())
}
// The other library is out of reach, by its id too.
other := strconv.FormatInt(f.track["Private Song"], 10)
if rec := f.serve(f.signed("GET", "/tracks/"+other+"/stream")); rec.Code != 404 {
t.Errorf("stream of a track that is not shared: %d", rec.Code)
}
if rec := f.serve(f.signed("GET", "/tracks/999999/stream")); rec.Code != 404 {
t.Errorf("stream of no track: %d", rec.Code)
}
}
func TestAFriendCannotHaveMoreStreamsThanAllowed(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
f.share(t, f.shared, true)
one := 1
if _, err := f.fed.Update(t.Context(), federation.Patch{MaxStreams: &one}); err != nil {
t.Fatal(err)
}
fid, _ := strconv.ParseInt(f.friendID, 10, 64)
open, err := f.fed.StartStream(t.Context(), fid)
if err != nil {
t.Fatal(err)
}
id := strconv.FormatInt(f.track["Shared Song"], 10)
rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream"))
if rec.Code != 429 || !strings.Contains(rec.Body.String(), `"too_many_streams"`) || rec.Header().Get("Retry-After") == "" {
t.Errorf("one stream too many: %d %s (Retry-After %q)", rec.Code, rec.Body.String(), rec.Header().Get("Retry-After"))
}
open.Close()
if rec := f.serve(f.signed("GET", "/tracks/"+id+"/stream")); rec.Code != 200 {
t.Errorf("after the first ended: %d", rec.Code)
}
}
func TestACoverIsOnlyServedOnceBuiltAndOnlyForSharedAlbums(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
f.share(t, f.shared, true)
var shared, private int64
_ = f.db.QueryRow("SELECT id FROM albums WHERE title = 'Shared Album'").Scan(&shared)
_ = f.db.QueryRow("SELECT id FROM albums WHERE title = 'Private Album'").Scan(&private)
sid, pid := strconv.FormatInt(shared, 10), strconv.FormatInt(private, 10)
r := f.get(t, "/albums/"+sid+"/cover")
if r.Code != 404 || errCode(r) != "cover_not_found" {
t.Errorf("a cover that was not built: %d %v: a friend must not make this server build one", r.Code, r.Body)
}
if r := f.get(t, "/albums/"+pid+"/cover"); r.Code != 404 || errCode(r) != "album_not_found" {
t.Errorf("the cover of an album that is not shared: %d %v", r.Code, r.Body)
}
if r := f.get(t, "/albums/"+sid+"/cover?size=huge"); r.Code != 400 {
t.Errorf("a bad size: %d", r.Code)
}
}
func TestSharingALibraryIsAnAdminsChoice(t *testing.T) {
f := newPeerFixture(t)
id := strconv.FormatInt(f.shared, 10)
list := f.admin1(t, "GET", "/libraries", nil).Body["libraries"].([]any)
for _, l := range list {
if l.(map[string]any)["shared"] != false {
t.Errorf("library %v starts shared", l)
}
}
_, bob := addUser(t, f.h, f.admin, "bob", false)
if r := do(t, f.h, "PATCH", "/api/v1/libraries/"+id, bob, map[string]any{"shared": true}); r.Code != 403 {
t.Errorf("a user who is not an admin shares a library: %d", r.Code)
}
r := f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"shared": true})
if r.Code != 200 || r.Body["shared"] != true {
t.Fatalf("share: %d %v", r.Code, r.Body)
}
// Name and sharing can be changed together or apart.
r = f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"name": "renamed"})
if r.Code != 200 || r.Body["shared"] != true || r.Body["name"] != "renamed" {
t.Errorf("rename keeps sharing: %d %v", r.Code, r.Body)
}
r = f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{"name": "again", "shared": false})
if r.Code != 200 || r.Body["shared"] != false || r.Body["name"] != "again" {
t.Errorf("both at once: %d %v", r.Code, r.Body)
}
if r := f.admin1(t, "PATCH", "/libraries/"+id, map[string]any{}); r.Code != 400 {
t.Errorf("nothing to change: %d", r.Code)
}
if r := f.admin1(t, "PATCH", "/libraries/99999", map[string]any{"shared": true}); r.Code != 404 {
t.Errorf("unknown library: %d", r.Code)
}
}
func TestTheAdminSeesWhatFriendsAsked(t *testing.T) {
f := newPeerFixture(t)
f.befriend(t)
f.share(t, f.shared, true)
f.get(t, "/info")
f.get(t, "/tracks?q=secret+words&limit=5")
f.serve(f.signed("GET", "/tracks/"+strconv.FormatInt(f.track["Shared Song"], 10)+"/stream"))
r := f.admin1(t, "GET", "/federation/requests", nil)
if r.Code != 200 {
t.Fatalf("requests: %d %v", r.Code, r.Body)
}
list := r.Body["requests"].([]any)
if len(list) != 3 {
t.Fatalf("requests = %v", list)
}
newest := list[0].(map[string]any)
sameKeys(t, "request", newest, "at", "friend_id", "friend", "route", "status", "bytes")
if newest["route"] != "/api/v1/peer/tracks/:id/stream" || newest["status"] != float64(200) || newest["bytes"] != float64(400) || newest["friend"] != "Bruno" {
t.Errorf("newest = %v", newest)
}
if body := strings.ToLower(jsonOf(t, r.Body)); strings.Contains(body, "secret") {
t.Errorf("the log keeps what was searched for: %s", body)
}
_, bob := addUser(t, f.h, f.admin, "bob", false)
if r := do(t, f.h, "GET", "/api/v1/federation/requests", bob, nil); r.Code != 403 {
t.Errorf("a user who is not an admin reads the log: %d", r.Code)
}
}
func jsonOf(t *testing.T, v any) string {
t.Helper()
b, err := json.Marshal(v)
if err != nil {
t.Fatal(err)
}
return string(b)
}
func TestTheLimitsAreSetWithTheOtherSettings(t *testing.T) {
f := newPeerFixture(t)
r := f.admin1(t, "GET", "/federation", nil)
if r.Body["max_streams"] != float64(3) || r.Body["max_kib_per_sec"] != float64(4096) {
t.Errorf("defaults = %v %v", r.Body["max_streams"], r.Body["max_kib_per_sec"])
}
r = f.admin1(t, "PUT", "/federation", map[string]any{"max_streams": 2, "max_kib_per_sec": 0})
if r.Code != 200 || r.Body["max_streams"] != float64(2) || r.Body["max_kib_per_sec"] != float64(0) {
t.Errorf("update = %d %v", r.Code, r.Body)
}
for _, body := range []map[string]any{{"max_streams": 0}, {"max_streams": 99}, {"max_kib_per_sec": 5}} {
if r := f.admin1(t, "PUT", "/federation", body); r.Code != 400 || errCode(r) != "invalid_input" {
t.Errorf("%v: %d %v", body, r.Code, r.Body)
}
}
}
func TestAServerChecksWhetherTheOtherApproved(t *testing.T) {
a := newFriendServer(t, true)
b := newFriendServer(t, false)
a.setUp(t, "Anna", a.ts.URL)
b.setUp(t, "Bruno", "https://bruno.example.org")
inv := a.call(t, "POST", "/federation/invites", nil)
mine := b.call(t, "POST", "/federation/friends", map[string]any{"invite": inv.Body["invite"]})
bID := strconv.Itoa(int(mine.Body["id"].(float64)))
// Anna has not approved yet.
r := b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
if r.Code != http.StatusConflict || errCode(r) != "not_approved" {
t.Fatalf("before approval: %d %v", r.Code, r.Body)
}
if got := b.call(t, "GET", "/federation", nil).Body["friends"].([]any)[0].(map[string]any)["state"]; got != "outgoing" {
t.Errorf("state = %v", got)
}
list := a.call(t, "GET", "/federation", nil).Body["friends"].([]any)
aID := strconv.Itoa(int(list[0].(map[string]any)["id"].(float64)))
a.call(t, "POST", "/federation/friends/"+aID+"/approve", nil)
r = b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
if r.Code != 200 || r.Body["state"] != "active" || r.Body["approved_at"] == nil {
t.Fatalf("after approval: %d %v", r.Code, r.Body)
}
// Anna logged that call.
if reqs := a.call(t, "GET", "/federation/requests", nil).Body["requests"].([]any); len(reqs) != 1 || reqs[0].(map[string]any)["route"] != "/api/v1/peer/info" {
t.Errorf("Anna's log = %v", reqs)
}
// Anna removes Bruno: Bruno is told it is no friend any more, and stays as it was.
a.call(t, "DELETE", "/federation/friends/"+aID, nil)
r = b.call(t, "POST", "/federation/friends/"+bID+"/check", nil)
if r.Code != http.StatusConflict || errCode(r) != "friend_gone" {
t.Errorf("after removal: %d %v", r.Code, r.Body)
}
// And a server that is gone is "unreachable", not a verdict.
a.ts.Close()
if r := b.call(t, "POST", "/federation/friends/"+bID+"/check", nil); r.Code != http.StatusBadGateway || errCode(r) != "friend_unreachable" {
t.Errorf("server gone: %d %v", r.Code, r.Body)
}
if r := b.call(t, "POST", "/federation/friends/99999/check", nil); r.Code != 404 {
t.Errorf("unknown friend: %d", r.Code)
}
}
// serveAs asks the server as its admin and returns the whole answer.
func (f *peerFixture) serveAs(t *testing.T, method, path string) *httptest.ResponseRecorder {
t.Helper()
req := httptest.NewRequest(method, path, nil)
req.Header.Set("Authorization", "Bearer "+f.admin)
rec := httptest.NewRecorder()
f.h.ServeHTTP(rec, req)
return rec
}