sonda/internal/federation/service_test.go
tgiachi 7f38ae038e feat(federation): play a friend's music and show its covers through this server
A listener can now play the music of a friend from the web app.

- GET /friends/{friend}/tracks/{id}/stream and /friends/{friend}/albums/{id}/cover,
  in the group that accepts the access token in the query, like the local ones.
  This server asks the friend with a signed request and passes the bytes on,
  forwarding Range and the conditional headers, so a player can seek. The
  friend sees this server and never the listener.
- Only audio (for a stream) and a JPEG (for a cover) are passed on, with a
  fixed set of headers: Content-Type, Content-Length, Content-Range,
  Accept-Ranges, Last-Modified and ETag. Anything else a friend sends, or
  what a listener's request carries (cookies, authorization), is not passed
  either way, so a friend cannot make this server serve anything else.
- The client of friends can open a streaming answer: no limit on its whole
  length, one only on its beginning, no redirect followed, and it ends when
  the listener leaves.
- The player holds a friend's track next to the local ones. It streams
  through this server, shows the friend's cover, links to the music of the
  friend and not to a local page, is told apart from a local track with the
  same id, and is never reported as a listen: it does not feed taste.
- The songs of a friend have play buttons, the albums their covers.
- OpenAPI paths, contract test, and two real servers checked end to end: the
  bytes of the file arrive unchanged, with ranges, and a song plays in a
  browser from the friend's server through the other one.
2026-11-13 16:11:59 +01:00

585 lines
18 KiB
Go

package federation
import (
"context"
"crypto/ed25519"
"errors"
"net/http"
"strings"
"testing"
"time"
)
// memStore is a Store in memory.
type memStore struct {
settings *Settings
invites map[string]memInvite
friends []Friend
requests []FriendRequest
nextID int64
}
type memInvite struct {
expires time.Time
used bool
}
func newMemStore() *memStore { return &memStore{invites: map[string]memInvite{}} }
func (m *memStore) Settings(context.Context) (Settings, bool, error) {
if m.settings == nil {
return Settings{}, false, nil
}
return *m.settings, true, nil
}
func (m *memStore) SaveSettings(_ context.Context, s Settings) error { m.settings = &s; return nil }
func (m *memStore) AddInvite(_ context.Context, hash string, _, expires time.Time) error {
m.invites[hash] = memInvite{expires: expires}
return nil
}
func (m *memStore) UseInvite(_ context.Context, hash string, now time.Time) (bool, error) {
inv, ok := m.invites[hash]
if !ok || inv.used || !now.Before(inv.expires) {
return false, nil
}
inv.used = true
m.invites[hash] = inv
return true, nil
}
func (m *memStore) Friends(context.Context) ([]Friend, error) {
return append([]Friend(nil), m.friends...), nil
}
func (m *memStore) Friend(_ context.Context, id int64) (Friend, error) {
for _, f := range m.friends {
if f.ID == id {
return f, nil
}
}
return Friend{}, ErrFriendMissing
}
func (m *memStore) FriendByKey(_ context.Context, key ed25519.PublicKey) (Friend, bool, error) {
for _, f := range m.friends {
if f.PublicKey.Equal(key) {
return f, true, nil
}
}
return Friend{}, false, nil
}
func (m *memStore) AddFriend(ctx context.Context, f Friend) (Friend, error) {
if _, found, _ := m.FriendByKey(ctx, f.PublicKey); found {
return Friend{}, ErrAlreadyFriend
}
m.nextID++
f.ID = m.nextID
m.friends = append(m.friends, f)
return f, nil
}
func (m *memStore) Approve(_ context.Context, id int64, now time.Time) error {
for i, f := range m.friends {
if f.ID != id {
continue
}
if f.State != Incoming {
return ErrWrongState
}
m.friends[i].State, m.friends[i].ApprovedAt = Active, now
return nil
}
return ErrFriendMissing
}
func (m *memStore) Activate(_ context.Context, id int64, now time.Time) error {
for i, f := range m.friends {
if f.ID != id {
continue
}
if f.State != Outgoing {
return ErrWrongState
}
m.friends[i].State, m.friends[i].ApprovedAt = Active, now
return nil
}
return ErrFriendMissing
}
func (m *memStore) LogRequest(_ context.Context, r FriendRequest) error {
m.requests = append(m.requests, r)
return nil
}
func (m *memStore) Requests(_ context.Context, limit int) ([]FriendRequest, error) {
var out []FriendRequest
for i := len(m.requests) - 1; i >= 0 && len(out) < limit; i-- {
r := m.requests[i]
for _, f := range m.friends {
if f.ID == r.FriendID {
r.FriendName = f.Name
}
}
out = append(out, r)
}
return out, nil
}
func (m *memStore) PruneRequests(_ context.Context, before time.Time) error {
kept := m.requests[:0]
for _, r := range m.requests {
if !r.At.Before(before) {
kept = append(kept, r)
}
}
m.requests = kept
return nil
}
func (m *memStore) DeleteFriend(_ context.Context, id int64) error {
for i, f := range m.friends {
if f.ID == id {
m.friends = append(m.friends[:i], m.friends[i+1:]...)
return nil
}
}
return ErrFriendMissing
}
// direct is a Remote that reaches another Service in the same process, answering as the HTTP layer would.
type direct struct {
to *Service
calls int
}
func (d *direct) Pair(ctx context.Context, _ string, req PairRequest) (PairReply, error) {
d.calls++
reply, err := d.to.Pair(ctx, req)
switch {
case errors.Is(err, ErrInvalidInvite), errors.Is(err, ErrOff):
return PairReply{}, ErrRefused
case err != nil:
return PairReply{}, err
}
return reply, nil
}
func (d *direct) Info(context.Context, string, Auth) (Info, error) {
return Info{}, errors.New("not used")
}
func (d *direct) Get(context.Context, string, string, Auth) (int, []byte, error) {
return 0, nil, errors.New("not used")
}
func (d *direct) Open(context.Context, string, string, Auth, http.Header) (*http.Response, error) {
return nil, errors.New("not used")
}
type clock struct{ t time.Time }
func (c *clock) now() time.Time { return c.t }
func newServer(t *testing.T, name, address string, remote Remote) (*Service, *memStore, *clock) {
t.Helper()
st := newMemStore()
ck := &clock{t: time.Unix(1_700_000_000, 0)}
s := NewService(st, remote)
s.now = ck.now
s.host = func() string { return "host-" + name }
on, n, a := true, name, address
if _, err := s.Update(context.Background(), Patch{Enabled: &on, Name: &n, Address: &a}); err != nil {
t.Fatal(err)
}
return s, st, ck
}
func TestFederationStartsOffAndAsksNothing(t *testing.T) {
ctx := context.Background()
s := NewService(newMemStore(), nil)
s.host = func() string { return "nas" }
st, err := s.Status(ctx)
if err != nil {
t.Fatal(err)
}
if st.Enabled || st.KeyID != "" || len(st.Friends) != 0 || st.Address != "" || st.Name != "nas" {
t.Errorf("Status = %+v: federation must start off, with no key and no friend, named after the host", st)
}
if !strings.Contains(st.Sends, "never learns who listens") {
t.Errorf("Sends = %q, it must say what a friend is sent", st.Sends)
}
if _, err := s.CreateInvite(ctx); !errors.Is(err, ErrOff) {
t.Errorf("CreateInvite = %v, want ErrOff", err)
}
if _, err := s.Redeem(ctx, "sonda1.x"); !errors.Is(err, ErrOff) {
t.Errorf("Redeem = %v, want ErrOff", err)
}
if _, err := s.Pair(ctx, PairRequest{}); !errors.Is(err, ErrOff) {
t.Errorf("Pair = %v, want ErrOff", err)
}
}
func TestTheKeyIsMadeOnceOnFirstUse(t *testing.T) {
ctx := context.Background()
st := newMemStore()
s := NewService(st, nil)
on, off := true, false
got, err := s.Update(ctx, Patch{Enabled: &on})
if err != nil {
t.Fatal(err)
}
if !got.Enabled || len(got.KeyID) != 16 {
t.Fatalf("Status = %+v", got)
}
if len(st.settings.PrivateKey) != ed25519.PrivateKeySize || KeyID(st.settings.PublicKey) != got.KeyID {
t.Errorf("the stored pair does not match the key id")
}
if _, err := s.Update(ctx, Patch{Enabled: &off}); err != nil {
t.Fatal(err)
}
again, _ := s.Update(ctx, Patch{Enabled: &on})
if again.KeyID != got.KeyID {
t.Errorf("key id changed from %s to %s: turning it off and on must keep the key", got.KeyID, again.KeyID)
}
}
func TestUpdateChecksTheNameAndTheAddress(t *testing.T) {
ctx := context.Background()
s := NewService(newMemStore(), nil)
set := func(name, addr string) error {
_, err := s.Update(ctx, Patch{Name: &name, Address: &addr})
return err
}
for _, addr := range []string{
"ftp://music.example.org", "music.example.org", "https://", "https://user:pw@music.example.org",
"https://music.example.org/?a=b", "https://music.example.org/#x", "http://music.example.org",
"http://8.8.8.8", "http://" + strings.Repeat("a", 300) + ".example.org", "https://exa mple.org",
} {
if err := set("Home", addr); !errors.Is(err, ErrInvalidInput) {
t.Errorf("address %q: err = %v, want ErrInvalidInput", addr, err)
}
}
for _, name := range []string{strings.Repeat("n", 61), "line\nbreak", "tab\there"} {
if err := set(name, ""); !errors.Is(err, ErrInvalidInput) {
t.Errorf("name %q: err = %v, want ErrInvalidInput", name, err)
}
}
// https is fine anywhere. Plain http only on a network of one's own: a private or loopback address, or a local name.
for addr, want := range map[string]string{
"https://Music.Example.org/": "https://music.example.org",
"https://music.example.org/sonda/": "https://music.example.org/sonda",
"http://192.168.1.20:8080": "http://192.168.1.20:8080",
"http://10.0.0.5": "http://10.0.0.5",
"http://127.0.0.1:8081": "http://127.0.0.1:8081",
"http://[::1]:8081": "http://[::1]:8081",
"http://nas": "http://nas",
"http://nas.local:8080": "http://nas.local:8080",
"http://music.lan": "http://music.lan",
"http://router.home.arpa": "http://router.home.arpa",
"https://8.8.8.8": "https://8.8.8.8",
} {
if err := set("Home", addr); err != nil {
t.Errorf("address %q: %v", addr, err)
continue
}
if st, _ := s.Status(ctx); st.Address != want {
t.Errorf("address %q saved as %q, want %q", addr, st.Address, want)
}
}
// An empty address clears it.
if err := set(" Home ", ""); err != nil {
t.Fatal(err)
}
if st, _ := s.Status(ctx); st.Address != "" || st.Name != "Home" {
t.Errorf("Status = %+v", st)
}
}
func TestAnInviteNeedsAnAddressAndKeepsOnlyAHash(t *testing.T) {
ctx := context.Background()
st := newMemStore()
s := NewService(st, nil)
s.now = (&clock{t: time.Unix(1_700_000_000, 0)}).now
on := true
if _, err := s.Update(ctx, Patch{Enabled: &on}); err != nil {
t.Fatal(err)
}
if _, err := s.CreateInvite(ctx); !errors.Is(err, ErrNoAddress) {
t.Fatalf("CreateInvite without an address = %v, want ErrNoAddress", err)
}
addr := "https://a.example.org"
if _, err := s.Update(ctx, Patch{Address: &addr}); err != nil {
t.Fatal(err)
}
inv, err := s.CreateInvite(ctx)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(inv.Text, "sonda1.") || inv.ExpiresAt.Sub(s.now()) != 24*time.Hour {
t.Errorf("invite = %+v", inv)
}
if len(st.invites) != 1 {
t.Fatalf("stored invites = %d", len(st.invites))
}
for hash := range st.invites {
if len(hash) != 64 || strings.Contains(inv.Text, hash) {
t.Errorf("stored %q: want only the SHA-256 of the code", hash)
}
}
}
func TestTwoServersBecomeFriendsWithTwoConfirmations(t *testing.T) {
ctx := context.Background()
a, aStore, _ := newServer(t, "Anna", "https://anna.example.org", nil)
toA := &direct{to: a}
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", toA)
inv, err := a.CreateInvite(ctx)
if err != nil {
t.Fatal(err)
}
friend, err := b.Redeem(ctx, inv.Text)
if err != nil {
t.Fatal(err)
}
// B pasted the invite: that is its confirmation. It waits for Anna.
if friend.Name != "Anna" || friend.Address != "https://anna.example.org" || friend.State != Outgoing {
t.Errorf("B's friend = %+v", friend)
}
// A now has a request to approve, and has not agreed to anything yet.
list, _ := aStore.Friends(ctx)
if len(list) != 1 || list[0].State != Incoming || list[0].Name != "Bruno" || list[0].Address != "https://bruno.example.org" {
t.Fatalf("A's friends = %+v", list)
}
if got, _ := bStore.Friends(ctx); len(got) != 1 || got[0].State != Outgoing {
t.Errorf("B's friends = %+v", got)
}
approved, err := a.Approve(ctx, list[0].ID)
if err != nil {
t.Fatal(err)
}
if approved.State != Active || approved.ApprovedAt.IsZero() {
t.Errorf("approved = %+v", approved)
}
st, _ := a.Status(ctx)
if len(st.Friends) != 1 || st.Friends[0].State != Active {
t.Errorf("Status.Friends = %+v", st.Friends)
}
// The invite was good once.
c, _, _ := newServer(t, "Carla", "https://carla.example.org", toA)
if _, err := c.Redeem(ctx, inv.Text); !errors.Is(err, ErrRefused) {
t.Errorf("second use of the invite = %v, want ErrRefused", err)
}
}
func TestAnExpiredInviteIsRefused(t *testing.T) {
ctx := context.Background()
a, _, ack := newServer(t, "Anna", "https://anna.example.org", nil)
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
ack.t = ack.t.Add(24*time.Hour + time.Second)
if _, err := b.Redeem(ctx, inv.Text); !errors.Is(err, ErrRefused) {
t.Fatalf("Redeem = %v, want ErrRefused", err)
}
if got, _ := bStore.Friends(ctx); len(got) != 0 {
t.Errorf("B kept %+v after a refusal", got)
}
}
// A server that answers with another key than the one in the invite is not the one the invite came from.
type swapKey struct{ real Remote }
func (s swapKey) Info(ctx context.Context, addr string, a Auth) (Info, error) {
return s.real.Info(ctx, addr, a)
}
func (s swapKey) Get(ctx context.Context, addr, uri string, a Auth) (int, []byte, error) {
return s.real.Get(ctx, addr, uri, a)
}
func (s swapKey) Open(ctx context.Context, addr, uri string, a Auth, h http.Header) (*http.Response, error) {
return s.real.Open(ctx, addr, uri, a, h)
}
func (s swapKey) Pair(ctx context.Context, addr string, req PairRequest) (PairReply, error) {
r, err := s.real.Pair(ctx, addr, req)
if err != nil {
return r, err
}
pub, _, _ := ed25519.GenerateKey(nil)
r.PublicKey = pub
return r, nil
}
func TestAKeyThatIsNotTheOneInTheInviteIsNotAFriend(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", swapKey{&direct{to: a}})
inv, _ := a.CreateInvite(ctx)
if _, err := b.Redeem(ctx, inv.Text); !errors.Is(err, ErrKeyMismatch) {
t.Fatalf("Redeem = %v, want ErrKeyMismatch", err)
}
if got, _ := bStore.Friends(ctx); len(got) != 0 {
t.Errorf("B kept %+v", got)
}
}
func TestPairingChecksWhatItIsSent(t *testing.T) {
ctx := context.Background()
a, aStore, _ := newServer(t, "Anna", "https://anna.example.org", nil)
pub, _, _ := ed25519.GenerateKey(nil)
ownPub := aStore.settings.PublicKey
for name, req := range map[string]PairRequest{
"no name": {Code: "c", Name: "", Address: "https://b.example.org", PublicKey: pub},
"bad address": {Code: "c", Name: "B", Address: "ftp://b", PublicKey: pub},
"short key": {Code: "c", Name: "B", Address: "https://b.example.org", PublicKey: pub[:10]},
"its own key": {Code: "c", Name: "B", Address: "https://b.example.org", PublicKey: ownPub},
"no code at all": {Code: "", Name: "B", Address: "https://b.example.org", PublicKey: pub},
} {
_, err := a.Pair(ctx, req)
want := ErrInvalidInput
if name == "no code at all" {
want = ErrInvalidInvite
}
if !errors.Is(err, want) {
t.Errorf("%s: err = %v, want %v", name, err, want)
}
}
if got, _ := aStore.Friends(ctx); len(got) != 0 {
t.Errorf("A kept %+v", got)
}
}
func TestAKnownServerDoesNotBurnAnInvite(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
b, _, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
first, _ := a.CreateInvite(ctx)
friend, err := b.Redeem(ctx, first.Text)
if err != nil {
t.Fatal(err)
}
second, _ := a.CreateInvite(ctx)
if _, err := b.Redeem(ctx, second.Text); !errors.Is(err, ErrAlreadyFriend) {
t.Fatalf("second Redeem = %v, want ErrAlreadyFriend", err)
}
// The second invite was not used up by that attempt: once B's friend is removed on A's side it works.
list, _ := a.Status(ctx)
if err := a.Remove(ctx, list.Friends[0].ID); err != nil {
t.Fatal(err)
}
if err := b.Remove(ctx, friend.ID); err != nil {
t.Fatal(err)
}
if _, err := b.Redeem(ctx, second.Text); err != nil {
t.Errorf("Redeem after removal = %v, the invite must still be good", err)
}
}
func TestTooManyAttemptsAreSlowedDown(t *testing.T) {
ctx := context.Background()
a, _, ack := newServer(t, "Anna", "https://anna.example.org", nil)
pub, _, _ := ed25519.GenerateKey(nil)
req := PairRequest{Code: "guess", Name: "B", Address: "https://b.example.org", PublicKey: pub}
for i := 0; i < 10; i++ {
if _, err := a.Pair(ctx, req); !errors.Is(err, ErrInvalidInvite) {
t.Fatalf("attempt %d = %v, want ErrInvalidInvite", i, err)
}
}
if _, err := a.Pair(ctx, req); !errors.Is(err, ErrTooMany) {
t.Fatalf("attempt 11 = %v, want ErrTooMany", err)
}
ack.t = ack.t.Add(61 * time.Second)
if _, err := a.Pair(ctx, req); !errors.Is(err, ErrInvalidInvite) {
t.Errorf("after a minute = %v, want ErrInvalidInvite", err)
}
}
func TestPairingStopsWhenFederationIsTurnedOff(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
b, _, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
off := false
if _, err := a.Update(ctx, Patch{Enabled: &off}); err != nil {
t.Fatal(err)
}
if _, err := b.Redeem(ctx, inv.Text); !errors.Is(err, ErrRefused) {
t.Errorf("Redeem = %v, want ErrRefused while the other side is off", err)
}
}
func TestRedeemRefusesWhatIsNotAnInvite(t *testing.T) {
ctx := context.Background()
remote := &direct{}
b, _, _ := newServer(t, "Bruno", "https://bruno.example.org", remote)
for _, text := range []string{
"", "hello", "sonda1.", "sonda1.!!!", "sonda1.e30", // {}
"sonda2.e30",
} {
if _, err := b.Redeem(ctx, text); !errors.Is(err, ErrInvalidInvite) {
t.Errorf("Redeem(%q) = %v, want ErrInvalidInvite", text, err)
}
}
// Its own invite is no use to it.
own, _ := b.CreateInvite(ctx)
if _, err := b.Redeem(ctx, own.Text); !errors.Is(err, ErrInvalidInput) {
t.Errorf("Redeem(own invite) = %v, want ErrInvalidInput", err)
}
if remote.calls != 0 {
t.Errorf("the other server was called %d times for invites that could not be used", remote.calls)
}
}
func TestRedeemNeedsAnAddressOfItsOwn(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
inv, _ := a.CreateInvite(ctx)
b := NewService(newMemStore(), &direct{to: a})
on := true
if _, err := b.Update(ctx, Patch{Enabled: &on}); err != nil {
t.Fatal(err)
}
if _, err := b.Redeem(ctx, inv.Text); !errors.Is(err, ErrNoAddress) {
t.Errorf("Redeem = %v, want ErrNoAddress: the friend must know where to reach it", err)
}
}
func TestApproveAndRemove(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
b, _, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
mine, err := b.Redeem(ctx, inv.Text)
if err != nil {
t.Fatal(err)
}
// B waits for A: it has nothing to approve.
if _, err := b.Approve(ctx, mine.ID); !errors.Is(err, ErrWrongState) {
t.Errorf("approve an outgoing friend = %v, want ErrWrongState", err)
}
if _, err := a.Approve(ctx, 999); !errors.Is(err, ErrFriendMissing) {
t.Errorf("approve a missing friend = %v, want ErrFriendMissing", err)
}
if err := a.Remove(ctx, 999); !errors.Is(err, ErrFriendMissing) {
t.Errorf("remove a missing friend = %v, want ErrFriendMissing", err)
}
if err := b.Remove(ctx, mine.ID); err != nil {
t.Errorf("a request one made can be withdrawn: %v", err)
}
}