227 lines
8.5 KiB
Go
227 lines
8.5 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/alicebob/miniredis/v2"
|
|
"github.com/metazla/meta-core/internal/storage"
|
|
)
|
|
|
|
// newUDLTestServer returns a Server wired to an in-memory Redis.
|
|
//
|
|
// The struct is built directly rather than through NewServer: NewServer boots
|
|
// the file watcher, mounts manager, watchers poller and WebDAV handler, none of
|
|
// which the UDL handlers touch — they use s.storage and nothing else.
|
|
func newUDLTestServer(t *testing.T) *Server {
|
|
t.Helper()
|
|
|
|
mr := miniredis.RunT(t)
|
|
c := storage.NewClient("")
|
|
if err := c.Connect("redis://" + mr.Addr()); err != nil {
|
|
t.Fatalf("connect to miniredis: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = c.Close() })
|
|
return &Server{storage: c}
|
|
}
|
|
|
|
// getRecord drives handleUDLRecordGet and decodes the body into raw JSON
|
|
// fields, so a test can assert on the *encoding* of `value` (is it a quoted
|
|
// string? is the key there at all?) rather than on what a typed struct would
|
|
// have coerced it into.
|
|
func getRecord(t *testing.T, s *Server, uid, cid, key string) (int, map[string]json.RawMessage) {
|
|
t.Helper()
|
|
|
|
req := httptest.NewRequest(http.MethodGet, "/api/udl/record?uid="+uid+"&cid="+cid+"&key="+key, nil)
|
|
rr := httptest.NewRecorder()
|
|
s.handleUDLRecordGet(rr, req)
|
|
|
|
var body map[string]json.RawMessage
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil {
|
|
t.Fatalf("decode response %q: %v", rr.Body.String(), err)
|
|
}
|
|
return rr.Code, body
|
|
}
|
|
|
|
// The plaintext value of a PUBLIC-tier cell must come back over the wire, and
|
|
// come back *as it was written* — a JSON string stays a quoted string, a bool
|
|
// stays a bool.
|
|
//
|
|
// Both halves matter. Without the value at all, the meta-core dashboard can
|
|
// only ever show 44-character base58 uids: display names live in the User Data
|
|
// Layer as the public cell (uid, "self", "profile:name"), and the plaintext
|
|
// sits in Redis where the storage layer has always read it — the handler just
|
|
// used to drop it. And the type has to stay json.RawMessage: this endpoint is
|
|
// generic over keys, so a `*string` would mangle `like` (bool) and `rating`
|
|
// (number) while looking correct for names.
|
|
func TestUDLRecordGet_ReturnsPublicValue(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
const uid = "zAlice"
|
|
if ok, err := s.storage.UDLUpsertIfNewer(uid, "self", "profile:name", 1, 100, "cmVj", `"Ada Lovelace"`, true, false); err != nil || !ok {
|
|
t.Fatalf("seed name: ok=%v err=%v", ok, err)
|
|
}
|
|
if ok, err := s.storage.UDLUpsertIfNewer(uid, "bagcsaaa", "like", 1, 100, "cmVj", `true`, true, false); err != nil || !ok {
|
|
t.Fatalf("seed like: ok=%v err=%v", ok, err)
|
|
}
|
|
|
|
code, body := getRecord(t, s, uid, "self", "profile:name")
|
|
if code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", code)
|
|
}
|
|
if got := string(body["value"]); got != `"Ada Lovelace"` {
|
|
t.Fatalf("value = %s, want a quoted JSON string", got)
|
|
}
|
|
var name string
|
|
if err := json.Unmarshal(body["value"], &name); err != nil || name != "Ada Lovelace" {
|
|
t.Fatalf("value should unmarshal to the plain name, got %q err=%v", name, err)
|
|
}
|
|
|
|
// A boolean key survives unquoted — the assertion a *string field fails.
|
|
if _, body = getRecord(t, s, uid, "bagcsaaa", "like"); string(body["value"]) != "true" {
|
|
t.Fatalf("like value = %s, want the bare JSON literal true", body["value"])
|
|
}
|
|
}
|
|
|
|
// A cell with no plaintext must omit `value` entirely rather than send null.
|
|
//
|
|
// That is the shape of every private-tier key (seek, watched, card, localpath —
|
|
// their real value rides encrypted inside the opaque record) and of every
|
|
// tombstone. A reader keys off presence: "there is no plaintext here" and "the
|
|
// plaintext is null" are different facts, and a name cleared by its owner
|
|
// leaves the cell existing with no value, which must not read as a name.
|
|
func TestUDLRecordGet_OmitsValueForPrivateCell(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
const uid = "zBob"
|
|
if ok, err := s.storage.UDLUpsertIfNewer(uid, "bagcsaaa", "seek", 1, 100, "ZW5jcnlwdGVk", "", false, false); err != nil || !ok {
|
|
t.Fatalf("seed private cell: ok=%v err=%v", ok, err)
|
|
}
|
|
|
|
code, body := getRecord(t, s, uid, "bagcsaaa", "seek")
|
|
if code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", code)
|
|
}
|
|
if _, ok := body["value"]; ok {
|
|
t.Fatalf("private cell must omit `value`, got %s", body["value"])
|
|
}
|
|
if string(body["exists"]) != "true" {
|
|
t.Fatalf("exists = %s, want true", body["exists"])
|
|
}
|
|
}
|
|
|
|
// A cell that was never written answers 200 with exists:false and no value —
|
|
// not a 404, and not an empty-string value that would render as a blank name.
|
|
func TestUDLRecordGet_MissingCellHasNoValue(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
code, body := getRecord(t, s, "zNobody", "self", "profile:name")
|
|
if code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", code)
|
|
}
|
|
if string(body["exists"]) != "false" {
|
|
t.Fatalf("exists = %s, want false", body["exists"])
|
|
}
|
|
if _, ok := body["value"]; ok {
|
|
t.Fatalf("missing cell must omit `value`, got %s", body["value"])
|
|
}
|
|
}
|
|
|
|
// putRecords drives handleUDLRecordsPut with a raw JSON body and decodes the
|
|
// per-record results.
|
|
func putRecords(t *testing.T, s *Server, body string) (int, UDLPutBatchResponse) {
|
|
t.Helper()
|
|
|
|
req := httptest.NewRequest(http.MethodPut, "/api/udl/records", strings.NewReader(body))
|
|
rr := httptest.NewRecorder()
|
|
s.handleUDLRecordsPut(rr, req)
|
|
|
|
var out UDLPutBatchResponse
|
|
if rr.Code == http.StatusOK {
|
|
if err := json.Unmarshal(rr.Body.Bytes(), &out); err != nil {
|
|
t.Fatalf("decode response %q: %v", rr.Body.String(), err)
|
|
}
|
|
}
|
|
return rr.Code, out
|
|
}
|
|
|
|
// **The load-bearing property of the batch endpoint: one stale cell does not
|
|
// fail the batch.**
|
|
//
|
|
// The single-record PUT answers a stale version with 409, which is right when
|
|
// the caller wrote one thing. In a batch it would be wrong: bulk verbs ("mark
|
|
// this whole series seen") routinely include episodes another device already
|
|
// marked, and 409-ing there would abandon every cell after it. So staleness is
|
|
// reported per record as accepted:false, with 200 on the request itself.
|
|
func TestUDLRecordsPut_StaleCellDoesNotFailTheBatch(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
const uid = "zCarol"
|
|
const cid = "bagdsaaaseries"
|
|
// Seed s01e01 at version 4 — the batch below tries to write it at 2.
|
|
if ok, err := s.storage.UDLUpsertIfNewer(uid, cid, "seen:s01e01", 4, 100, "b2xk", "", false, false); err != nil || !ok {
|
|
t.Fatalf("seed: ok=%v err=%v", ok, err)
|
|
}
|
|
|
|
code, out := putRecords(t, s, `{"records":[
|
|
{"uid":"`+uid+`","cid":"`+cid+`","key":"seen:s01e01","version":2,"ts":200,"record":"c3RhbGU"},
|
|
{"uid":"`+uid+`","cid":"`+cid+`","key":"seen:s01e02","version":1,"ts":200,"record":"ZnJlc2g"}
|
|
]}`)
|
|
|
|
if code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200 — a stale cell is an outcome, not an error", code)
|
|
}
|
|
if len(out.Results) != 2 {
|
|
t.Fatalf("results = %d, want 2 (one per record, in order)", len(out.Results))
|
|
}
|
|
if out.Results[0].Accepted || out.Results[0].Error != "" {
|
|
t.Fatalf("stale cell = %+v, want accepted:false with no error", out.Results[0])
|
|
}
|
|
if !out.Results[1].Accepted {
|
|
t.Fatalf("fresh cell = %+v, want accepted:true", out.Results[1])
|
|
}
|
|
|
|
// The fresh cell really landed, and the stale one did not overwrite.
|
|
if _, body := getRecord(t, s, uid, cid, "seen:s01e02"); string(body["exists"]) != "true" {
|
|
t.Fatalf("s01e02 was not written")
|
|
}
|
|
if _, body := getRecord(t, s, uid, cid, "seen:s01e01"); string(body["version"]) != "4" {
|
|
t.Fatalf("s01e01 version = %s, want 4 (the stale write must not apply)", body["version"])
|
|
}
|
|
}
|
|
|
|
// A malformed record is reported in its own slot rather than rejecting the
|
|
// request, for the same reason: the caller retries that cell, not the batch.
|
|
func TestUDLRecordsPut_ReportsBadRecordPerSlot(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
code, out := putRecords(t, s, `{"records":[
|
|
{"uid":"zDan","cid":"bagdsaaa","key":"","version":1,"ts":1,"record":"eA"},
|
|
{"uid":"zDan","cid":"bagdsaaa","key":"seen:s01e01","version":1,"ts":1,"record":"eA"}
|
|
]}`)
|
|
|
|
if code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200", code)
|
|
}
|
|
if out.Results[0].Error == "" {
|
|
t.Fatalf("record with no key must report an error, got %+v", out.Results[0])
|
|
}
|
|
if !out.Results[1].Accepted {
|
|
t.Fatalf("the valid record beside it must still land, got %+v", out.Results[1])
|
|
}
|
|
}
|
|
|
|
// An empty batch is a client bug, not a no-op: it almost always means the
|
|
// caller built its record list wrong, and answering 200 with an empty array
|
|
// would hide that.
|
|
func TestUDLRecordsPut_RejectsEmptyBatch(t *testing.T) {
|
|
s := newUDLTestServer(t)
|
|
|
|
if code, _ := putRecords(t, s, `{"records":[]}`); code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want 400", code)
|
|
}
|
|
}
|