sonda/internal/api/http/mastodon_test.go
tgiachi a7a258464b feat(mastodon): say in Settings when the instance no longer accepts the token
When the instance refuses the token on a post (it was revoked or expired), the account now remembers it: GET /me/mastodon says problem: token_refused and nothing is posted until I connect again with a new token.

- migration 0027 adds mastodon_accounts.problem (SQLite and PostgreSQL).
- Only a refused token marks the account; an instance that is down does not.
- Saving the account again clears the problem.
- Settings shows the warning and the form with the instance already filled in, next to Disconnect.
- English and Italian.
2026-11-14 10:04:07 +01:00

234 lines
8.9 KiB
Go

package httpapi
import (
"context"
"net/http"
"strings"
"sync"
"testing"
"time"
"github.com/uptrace/bun"
"go.uber.org/zap"
"codeberg.org/squidd/sonda/internal/mastodon"
"codeberg.org/squidd/sonda/internal/storage"
)
// fakeMastodon stands in for the instance: it answers like the one a test sets up and tells what was posted.
type fakeMastodon struct {
mu sync.Mutex
handle string
verify error
postErr error
posted chan [2]string // token, status
}
func (f *fakeMastodon) Verify(_ context.Context, _, _ string) (string, error) {
f.mu.Lock()
defer f.mu.Unlock()
return f.handle, f.verify
}
func (f *fakeMastodon) Post(_ context.Context, _, token, status, _ string) error {
if f.posted != nil {
f.posted <- [2]string{token, status}
}
return f.postErr
}
// mastodonEnv is the API with the Mastodon service on the given instance. The worker that posts runs for the length of the test.
func mastodonEnv(t *testing.T, remote mastodon.Remote) http.Handler {
t.Helper()
h, _ := newTestEnvDB(t, func(d *Deps, db *bun.DB) {
svc := mastodon.NewService(storage.NewMastodonRepo(db), remote, zap.NewNop())
ctx, stop := context.WithCancel(context.Background())
t.Cleanup(stop)
go svc.Run(ctx)
d.Mastodon = svc
})
return h
}
func TestMastodonNeedsASignedInUser(t *testing.T) {
h := newTestAPI(t)
for _, m := range []string{"GET", "PUT", "DELETE"} {
if r := do(t, h, m, "/api/v1/me/mastodon", "", map[string]any{}); r.Code != http.StatusUnauthorized {
t.Errorf("%s without a token: %d", m, r.Code)
}
}
}
func TestMastodonStartsDisconnected(t *testing.T) {
h := newTestAPI(t)
alice := registerAndLogin(t, h)
r := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil)
if r.Code != http.StatusOK {
t.Fatalf("%d %v", r.Code, r.Body)
}
sameKeys(t, "status", r.Body, "connected")
if r.Body["connected"] != false {
t.Errorf("status = %v", r.Body)
}
}
func TestConnectingAnAccountKeepsItAndNeverShowsTheToken(t *testing.T) {
h := mastodonEnv(t, &fakeMastodon{handle: "@squid@mastodon.social"})
alice := registerAndLogin(t, h)
r := do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "Mastodon.Social/", "token": "secret-token-value"})
if r.Code != http.StatusOK {
t.Fatalf("%d %v", r.Code, r.Body)
}
sameKeys(t, "connected", r.Body, "connected", "instance", "handle")
if r.Body["connected"] != true || r.Body["instance"] != "https://mastodon.social" || r.Body["handle"] != "@squid@mastodon.social" {
t.Errorf("body = %v", r.Body)
}
g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil)
sameKeys(t, "status", g.Body, "connected", "instance", "handle")
for _, resp := range []map[string]any{r.Body, g.Body} {
for k, v := range resp {
if s, ok := v.(string); ok && strings.Contains(s, "secret-token") {
t.Errorf("the token came back in %q: %v", k, resp)
}
}
}
}
func TestAnAccountThatCannotBeConnectedIsNotKept(t *testing.T) {
for _, c := range []struct {
name string
verify error
instance string
token string
status int
code string
}{
{"a refused token", mastodon.ErrRefused, "mastodon.social", "tok", http.StatusUnprocessableEntity, "mastodon_refused"},
{"an instance that is not there", mastodon.ErrUnreachable, "mastodon.social", "tok", http.StatusBadGateway, "mastodon_unreachable"},
{"a plain http address", nil, "http://mastodon.social", "tok", http.StatusBadRequest, "invalid_instance"},
{"a name with no dot", nil, "localhost", "tok", http.StatusBadRequest, "invalid_instance"},
{"an empty token", nil, "mastodon.social", " ", http.StatusBadRequest, "invalid_token"},
} {
h := mastodonEnv(t, &fakeMastodon{handle: "@a@b", verify: c.verify})
alice := registerAndLogin(t, h)
r := do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": c.instance, "token": c.token})
if r.Code != c.status || errCode(r) != c.code {
t.Errorf("%s: %d %v, want %d %s", c.name, r.Code, r.Body, c.status, c.code)
}
if g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil); g.Body["connected"] != false {
t.Errorf("%s: something was kept: %v", c.name, g.Body)
}
}
}
func TestAMastodonBodyThatIsNotWhatWasAskedForIsRefused(t *testing.T) {
h := newTestAPI(t)
alice := registerAndLogin(t, h)
for name, body := range map[string]any{
"a list": []any{"mastodon.social"},
"a number": map[string]any{"instance": 5, "token": "t"},
"no instance": map[string]any{"token": "t"},
"no token": map[string]any{"instance": "mastodon.social"},
"an unknown name": map[string]any{"instance": "mastodon.social", "token": "t", "visibility": "public"},
} {
if r := do(t, h, "PUT", "/api/v1/me/mastodon", alice, body); r.Code != http.StatusBadRequest {
t.Errorf("%s: %d %v, want 400", name, r.Code, r.Body)
}
}
}
func TestDisconnectingForgetsTheAccountAndCanBeRepeated(t *testing.T) {
h := mastodonEnv(t, &fakeMastodon{handle: "@a@b"})
alice := registerAndLogin(t, h)
do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "mastodon.social", "token": "tok"})
for i := 0; i < 2; i++ {
if r := do(t, h, "DELETE", "/api/v1/me/mastodon", alice, nil); r.Code != http.StatusNoContent {
t.Fatalf("delete %d: %d %v", i, r.Code, r.Body)
}
}
if g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil); g.Body["connected"] != false {
t.Errorf("still connected: %v", g.Body)
}
}
func TestEachPersonHasTheirOwnMastodonAccount(t *testing.T) {
h := mastodonEnv(t, &fakeMastodon{handle: "@a@b"})
alice := registerAndLogin(t, h)
do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "mastodon.social", "token": "tok"})
cred := map[string]any{"email": "bob@example.org", "password": "longenough"}
if c := do(t, h, "POST", "/api/v1/users", alice, cred); c.Code != http.StatusCreated {
t.Fatalf("create bob: %d %v", c.Code, c.Body)
}
bob, _ := do(t, h, "POST", "/api/v1/auth/login", "", cred).Body["access_token"].(string)
if g := do(t, h, "GET", "/api/v1/me/mastodon", bob, nil); g.Body["connected"] != false {
t.Errorf("bob sees alice's account: %v", g.Body)
}
}
func TestOnlyAListenThatCountsIsPostedAndOnlyForWhoConnected(t *testing.T) {
remote := &fakeMastodon{handle: "@squid@mastodon.social", posted: make(chan [2]string, 4)}
h := mastodonEnv(t, remote)
alice := registerAndLogin(t, h)
cred := map[string]any{"email": "bob@example.org", "password": "longenough"}
do(t, h, "POST", "/api/v1/users", alice, cred)
bob, _ := do(t, h, "POST", "/api/v1/auth/login", "", cred).Body["access_token"].(string)
do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "mastodon.social", "token": "tok"})
listen := func(token, key, kind string, ms int) {
t.Helper()
r := do(t, h, "POST", "/api/v1/listens", token, map[string]any{"track_id": 1, "event_type": kind, "duration_played_ms": ms, "idempotency_key": key})
if r.Code != http.StatusCreated {
t.Fatalf("listen %s: %d %v", key, r.Code, r.Body)
}
}
listen(bob, "b1", "complete", 30000) // counts, but bob connected nothing
listen(alice, "a1", "skip", 5000) // alice connected, but it does not count
listen(alice, "a2", "complete", 30000) // this one is posted
select {
case p := <-remote.posted:
if p[0] != "tok" || !strings.Contains(p[1], "song") || !strings.HasSuffix(p[1], "#NowPlaying") {
t.Errorf("post = %v", p)
}
case <-time.After(3 * time.Second):
t.Fatal("nothing was posted for a listen that counts")
}
select {
case p := <-remote.posted:
t.Errorf("a second post: %v", p)
case <-time.After(200 * time.Millisecond):
}
}
func TestARefusedTokenShowsAsAProblemUntilTheAccountIsConnectedAgain(t *testing.T) {
remote := &fakeMastodon{handle: "@squid@mastodon.social", postErr: mastodon.ErrRefused, posted: make(chan [2]string, 4)}
h := mastodonEnv(t, remote)
alice := registerAndLogin(t, h)
do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "mastodon.social", "token": "tok"})
if g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil); g.Body["problem"] != nil {
t.Fatalf("a fresh account has no problem: %v", g.Body)
}
r := do(t, h, "POST", "/api/v1/listens", alice, map[string]any{"track_id": 1, "event_type": "complete", "duration_played_ms": 30000, "idempotency_key": "a1"})
if r.Code != http.StatusCreated {
t.Fatalf("listen: %d %v", r.Code, r.Body)
}
<-remote.posted
deadline := time.Now().Add(3 * time.Second)
for {
g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil)
if g.Body["problem"] == "token_refused" {
sameKeys(t, "with a problem", g.Body, "connected", "instance", "handle", "problem")
break
}
if time.Now().After(deadline) {
t.Fatalf("the problem never showed: %v", g.Body)
}
time.Sleep(20 * time.Millisecond)
}
// A new token clears it.
remote.postErr = nil
do(t, h, "PUT", "/api/v1/me/mastodon", alice, map[string]any{"instance": "mastodon.social", "token": "new"})
if g := do(t, h, "GET", "/api/v1/me/mastodon", alice, nil); g.Body["problem"] != nil {
t.Errorf("connecting again left the problem: %v", g.Body)
}
}