405 lines
12 KiB
Go
405 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
"pageswiki/internal/store"
|
|
)
|
|
|
|
func feedActionFixture(t *testing.T) (*Server, string, string, string, store.FeedSource) {
|
|
t.Helper()
|
|
s, token, domain, actor, _ := feedFixture(t)
|
|
ctx := context.Background()
|
|
v := store.FeedSource{UUID: uuid.NewString(), Provider: "freshrss", Title: "Remote", URL: "https://example.org/api/greader.php", Enabled: true, WriteEnabled: true, Interval: 300}
|
|
v.Credential, _ = s.store.SealFeedCredential(domain, actor, v.UUID, "reader", "secret")
|
|
if _, e := s.store.SaveFeedSource(ctx, domain, actor, v); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
all, e := s.store.FeedSources(ctx, domain, actor)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
for _, x := range all {
|
|
if x.UUID == v.UUID {
|
|
v = x
|
|
}
|
|
}
|
|
c, e := s.store.ClaimFeed(ctx, v)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.store.CompleteFeed(ctx, c, []store.FeedItem{{ID: "one", Title: "Article", Starred: true}}, "", "", "", false); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
return s, token, domain, actor, v
|
|
}
|
|
func newFeedAction(v store.FeedSource) store.FeedAction {
|
|
return store.FeedAction{RequestID: uuid.NewString(), Source: v.UUID, ID: "one", Field: "read", Desired: true, SourceVersion: v.Version}
|
|
}
|
|
|
|
type feedRemoteFake struct {
|
|
id string
|
|
read, star, timeout bool
|
|
edits, lookups, requests int
|
|
beforeEdit func()
|
|
afterEdit func()
|
|
}
|
|
|
|
func (f *feedRemoteFake) client(t *testing.T) *http.Client {
|
|
return &http.Client{Transport: feedTransportFunc(func(r *http.Request) (*http.Response, error) {
|
|
id := f.id
|
|
if id == "" {
|
|
id = "one"
|
|
}
|
|
f.requests++
|
|
body := ""
|
|
switch {
|
|
case strings.HasSuffix(r.URL.Path, "/ClientLogin"):
|
|
body = "Auth=test-auth"
|
|
case strings.HasSuffix(r.URL.Path, "/stream/items/contents"):
|
|
if r.Method != "POST" {
|
|
t.Fatal("read lookup requires POST")
|
|
}
|
|
r.ParseForm()
|
|
if r.Form.Get("i") != id {
|
|
t.Fatal("wrong item")
|
|
}
|
|
f.lookups++
|
|
cats := []string{}
|
|
if f.read {
|
|
cats = append(cats, "user/reader/state/com.google/read")
|
|
}
|
|
if f.star {
|
|
cats = append(cats, "user/reader/state/com.google/starred")
|
|
}
|
|
raw, _ := json.Marshal(map[string]any{"items": []map[string]any{{"id": id, "title": "Article", "categories": cats}}})
|
|
body = string(raw)
|
|
case strings.HasSuffix(r.URL.Path, "/token"):
|
|
body = "write-token"
|
|
if f.beforeEdit != nil {
|
|
f.beforeEdit()
|
|
}
|
|
case strings.HasSuffix(r.URL.Path, "/edit-tag"):
|
|
if r.Method != "POST" {
|
|
t.Fatal("mutation method")
|
|
}
|
|
r.ParseForm()
|
|
if len(r.Form) != 3 || r.Form.Get("T") != "write-token" || r.Form.Get("i") != id {
|
|
t.Fatal("unexpected mutation fields", r.Form)
|
|
}
|
|
if tag := r.Form.Get("a"); tag != "" {
|
|
switch tag {
|
|
case "user/-/state/com.google/read":
|
|
f.read = true
|
|
case "user/-/state/com.google/starred":
|
|
f.star = true
|
|
default:
|
|
t.Fatal("wrong tag", tag)
|
|
}
|
|
} else {
|
|
switch r.Form.Get("r") {
|
|
case "user/-/state/com.google/read":
|
|
f.read = false
|
|
case "user/-/state/com.google/starred":
|
|
f.star = false
|
|
default:
|
|
t.Fatal("wrong tag")
|
|
}
|
|
}
|
|
f.edits++
|
|
if f.afterEdit != nil {
|
|
f.afterEdit()
|
|
}
|
|
if f.timeout {
|
|
return nil, errors.New("synthetic response lost after apply")
|
|
}
|
|
body = "OK"
|
|
default:
|
|
t.Fatal("unexpected path", r.URL.Path)
|
|
}
|
|
return &http.Response{StatusCode: 200, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(body))}, nil
|
|
})}
|
|
}
|
|
func TestFeedActionWritebackReceiptAndIsolation(t *testing.T) {
|
|
s, token, domain, actor, v := feedActionFixture(t)
|
|
ctx := context.Background()
|
|
a := newFeedAction(v)
|
|
w := feedRequestTest(s, token, "POST", "remote-state", a)
|
|
if w.Code != 202 {
|
|
t.Fatal(w.Code, w.Body)
|
|
}
|
|
if w = feedRequestTest(s, token, "POST", "remote-state", a); w.Code != 202 {
|
|
t.Fatal("replay", w.Code, w.Body)
|
|
}
|
|
changed := a
|
|
changed.Desired = false
|
|
if w = feedRequestTest(s, token, "POST", "remote-state", changed); w.Code != 412 {
|
|
t.Fatal("changed replay", w.Code)
|
|
}
|
|
changed.RequestID = uuid.NewString()
|
|
if w = feedRequestTest(s, token, "POST", "remote-state", changed); w.Code != 412 {
|
|
t.Fatal("parallel intent", w.Code)
|
|
}
|
|
item, _ := s.store.FeedItem(ctx, domain, actor, v.UUID, "one")
|
|
if item.Read {
|
|
t.Fatal("optimistic cache mutation")
|
|
}
|
|
f := &feedRemoteFake{star: true}
|
|
if e := s.syncFeedActions(ctx, f.client(t)); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
got, e := s.store.FeedAction(ctx, domain, actor, v.UUID, "one")
|
|
if e != nil || got.Status != "confirmed" || f.edits != 1 {
|
|
t.Fatal(got, e, f.edits)
|
|
}
|
|
item, _ = s.store.FeedItem(ctx, domain, actor, v.UUID, "one")
|
|
if !item.Read || !item.Starred {
|
|
t.Fatal("unrelated star overwritten", item)
|
|
}
|
|
if w = feedRequestTest(s, token, "POST", "remote-state", a); w.Code != 202 {
|
|
t.Fatal("receipt replay", w.Code)
|
|
}
|
|
if e = s.syncFeedActions(ctx, f.client(t)); e != nil || f.edits != 1 {
|
|
t.Fatal("replayed write", e, f.edits)
|
|
}
|
|
// A second explicit intent already satisfied remotely causes no edit-tag.
|
|
a.RequestID = uuid.NewString()
|
|
if _, e = s.store.QueueFeedAction(ctx, domain, actor, a); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.syncFeedActions(ctx, f.client(t)); e != nil || f.edits != 1 {
|
|
t.Fatal("redundant write", e)
|
|
}
|
|
other, e := s.store.CreatePasswordAccount(domain, "actionother", "long test password", "Other", "")
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if got, e = s.store.FeedAction(ctx, domain, other.UUID, v.UUID, "one"); e != nil || got != nil {
|
|
t.Fatal("other owner receipt", got, e)
|
|
}
|
|
a.RequestID = uuid.NewString()
|
|
if _, e = s.store.QueueFeedAction(ctx, domain, other.UUID, a); e == nil {
|
|
t.Fatal("other owner mutation")
|
|
}
|
|
v.Credential = ""
|
|
v.WriteEnabled = false
|
|
if _, e = s.store.SaveFeedSource(ctx, domain, actor, v); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
a.SourceVersion++
|
|
if _, e = s.store.QueueFeedAction(ctx, domain, actor, a); e == nil {
|
|
t.Fatal("opt-out ignored")
|
|
}
|
|
}
|
|
func TestFeedActionUnknownNeverResendsAndReadOnlyRecheck(t *testing.T) {
|
|
s, _, domain, actor, v := feedActionFixture(t)
|
|
ctx := context.Background()
|
|
a := newFeedAction(v)
|
|
if _, e := s.store.QueueFeedAction(ctx, domain, actor, a); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
f := &feedRemoteFake{star: true, timeout: true}
|
|
client := f.client(t)
|
|
if e := s.syncFeedActions(ctx, client); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
got, e := s.store.FeedAction(ctx, domain, actor, v.UUID, "one")
|
|
if e != nil || got.Status != "unknown" {
|
|
t.Fatal(got, e)
|
|
}
|
|
item, _ := s.store.FeedItem(ctx, domain, actor, v.UUID, "one")
|
|
if item.Read {
|
|
t.Fatal("unconfirmed cache")
|
|
}
|
|
requests := f.requests
|
|
if e = s.syncFeedActions(ctx, client); e != nil || f.requests != requests {
|
|
t.Fatal("automatic retry", e)
|
|
}
|
|
if e = s.store.RecheckFeedAction(ctx, domain, actor, a.RequestID); e == nil {
|
|
t.Fatal("must wait for claim expiry")
|
|
}
|
|
// Simulate the uncertainty cooldown without sleeping.
|
|
v.Credential = ""
|
|
v.WriteEnabled = false
|
|
if _, e = s.store.SaveFeedSource(ctx, domain, actor, v); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
s.store.DB.Exec(`UPDATE feed_actions SET until_ms=0 WHERE request_id=?`, a.RequestID)
|
|
if e = s.store.RecheckFeedAction(ctx, domain, actor, a.RequestID); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.syncFeedActions(ctx, client); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
got, e = s.store.FeedAction(ctx, domain, actor, v.UUID, "one")
|
|
if e != nil || got.Status != "confirmed" || f.edits != 1 {
|
|
t.Fatal("recheck sent a write", got, e, f.edits)
|
|
}
|
|
}
|
|
func TestFeedActionConflictAndPostSendFence(t *testing.T) {
|
|
for _, changed := range []bool{false, true} {
|
|
t.Run(map[bool]string{false: "remote_conflict", true: "source_changed"}[changed], func(t *testing.T) {
|
|
s, _, domain, actor, v := feedActionFixture(t)
|
|
ctx := context.Background()
|
|
a := newFeedAction(v)
|
|
if _, e := s.store.QueueFeedAction(ctx, domain, actor, a); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
f := &feedRemoteFake{star: true}
|
|
f.afterEdit = func() {
|
|
if changed {
|
|
v.Credential = ""
|
|
v.WriteEnabled = false
|
|
if _, e := s.store.SaveFeedSource(ctx, domain, actor, v); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
} else {
|
|
f.read = false
|
|
}
|
|
}
|
|
if e := s.syncFeedActions(ctx, f.client(t)); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
got, e := s.store.FeedAction(ctx, domain, actor, v.UUID, "one")
|
|
want := "conflict"
|
|
if changed {
|
|
want = "unknown"
|
|
}
|
|
if e != nil || got.Status != want || f.edits != 1 {
|
|
t.Fatal(got, e)
|
|
}
|
|
item, e := s.store.FeedItem(ctx, domain, actor, v.UUID, "one")
|
|
if e != nil || item.Read {
|
|
t.Fatal("unconfirmed/fenced value stored", item, e)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFeedActionFencesAndRecovery(t *testing.T) {
|
|
for _, scenario := range []string{"config", "delete", "readonly", "extension", "crash"} {
|
|
t.Run(scenario, func(t *testing.T) {
|
|
s, _, domain, actor, v := feedActionFixture(t)
|
|
ctx := context.Background()
|
|
a := newFeedAction(v)
|
|
if _, e := s.store.QueueFeedAction(ctx, domain, actor, a); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if scenario == "crash" {
|
|
due, e := s.store.DueFeedActions(ctx)
|
|
if e != nil || len(due) != 1 {
|
|
t.Fatal(e)
|
|
}
|
|
a, source, e := s.store.ClaimFeedAction(ctx, due[0])
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, e = s.store.ClaimFeed(ctx, v); !errors.Is(e, store.ErrTaskConflict) {
|
|
t.Fatal("fetch overlapped mutation", e)
|
|
}
|
|
if e = s.store.MarkFeedActionSending(ctx, a, source); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
s.store.DB.Exec(`UPDATE feed_actions SET until_ms=0 WHERE request_id=?`, a.RequestID)
|
|
due, e = s.store.DueFeedActions(ctx)
|
|
if e != nil || len(due) != 0 {
|
|
t.Fatal("crash requeued", due, e)
|
|
}
|
|
got, _ := s.store.FeedAction(ctx, domain, actor, v.UUID, "one")
|
|
if got.Status != "unknown" {
|
|
t.Fatal(got)
|
|
}
|
|
return
|
|
}
|
|
f := &feedRemoteFake{star: true}
|
|
f.beforeEdit = func() {
|
|
var e error
|
|
switch scenario {
|
|
case "config":
|
|
v.Credential = ""
|
|
v.WriteEnabled = false
|
|
_, e = s.store.SaveFeedSource(ctx, domain, actor, v)
|
|
case "delete":
|
|
e = s.store.FeedSourceAction(ctx, domain, actor, v.UUID, "delete", v.Version)
|
|
case "readonly":
|
|
e = s.store.SetPrincipalState(domain, actor, "readonly")
|
|
case "extension":
|
|
e = s.setSystemExtensionEnabled(domain, "organizer.feeds", false)
|
|
}
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
}
|
|
if e := s.syncFeedActions(ctx, f.client(t)); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if f.edits != 0 {
|
|
t.Fatal("sent after revocation")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFeedActionSingleFieldAndConcurrentIntent(t *testing.T) {
|
|
for _, field := range []string{"read", "starred"} {
|
|
for _, desired := range []bool{false, true} {
|
|
t.Run(field+map[bool]string{false: "_remove", true: "_add"}[desired], func(t *testing.T) {
|
|
s, _, domain, actor, v := feedActionFixture(t)
|
|
ctx := context.Background()
|
|
a := newFeedAction(v)
|
|
a.Field = field
|
|
a.Desired = desired
|
|
results := make(chan error, 2)
|
|
for range 2 {
|
|
go func() {
|
|
copy := a
|
|
copy.RequestID = uuid.NewString()
|
|
_, e := s.store.QueueFeedAction(ctx, domain, actor, copy)
|
|
results <- e
|
|
}()
|
|
}
|
|
success := 0
|
|
for range 2 {
|
|
e := <-results
|
|
if e == nil {
|
|
success++
|
|
} else if !errors.Is(e, store.ErrTaskConflict) {
|
|
t.Fatal(e)
|
|
}
|
|
}
|
|
if success != 1 {
|
|
t.Fatal("concurrent intents accepted", success)
|
|
}
|
|
f := &feedRemoteFake{read: true, star: true}
|
|
if field == "read" {
|
|
f.read = !desired
|
|
} else {
|
|
f.star = !desired
|
|
}
|
|
if e := s.syncFeedActions(ctx, f.client(t)); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if f.edits != 1 {
|
|
t.Fatal("wrong edit count", f.edits)
|
|
}
|
|
if field == "read" {
|
|
if f.read != desired || !f.star {
|
|
t.Fatal("wrong field changed")
|
|
}
|
|
} else {
|
|
if f.star != desired || !f.read {
|
|
t.Fatal("wrong field changed")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|