package server
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
"os/exec"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func feedFixture(t *testing.T) (*Server, string, string, string, store.FeedSource) {
t.Helper()
s, token, domain, actor := taskFixture(t)
source, e := s.store.SaveFeedSource(context.Background(), domain, actor, store.FeedSource{UUID: uuid.NewString(), Provider: "local", Title: "Synthetic news", Folder: "Tech", URL: "https://example.org/feed.xml", Enabled: true, Interval: 300})
if e != nil {
t.Fatal(e)
}
sources, e := s.store.FeedSources(context.Background(), domain, actor)
if e != nil || len(sources) != 1 {
t.Fatal(e)
}
source = sources[0]
return s, token, domain, actor, source
}
func feedRequestTest(s *Server, token, method, key string, body any) *httptest.ResponseRecorder {
raw, _ := json.Marshal(body)
r := httptest.NewRequest(method, "http://localhost"+feedsAPI+key, strings.NewReader(string(raw)))
r.Header.Set("Content-Type", "application/json")
if token != "" {
r.Header.Set("Authorization", "Bearer "+token)
}
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
func TestFeedReaderStateIsolationAndFencing(t *testing.T) {
s, token, domain, actor, source := feedFixture(t)
ctx := context.Background()
claim, e := s.store.ClaimFeed(ctx, source)
if e != nil {
t.Fatal(e)
}
if _, e = s.store.ClaimFeed(ctx, source); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("double claim", e)
}
item := store.FeedItem{ID: "one", Title: "日本語 news", Body: "safe text", URL: "https://example.org/one", PublishedMS: 1}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "e1", "", "", false); e != nil {
t.Fatal(e)
}
if w := feedRequestTest(s, token, "GET", "items", nil); w.Code != 200 || !strings.Contains(w.Body.String(), "日本語") {
t.Fatal(w.Code, w.Body)
}
if w := feedRequestTest(s, "", "GET", "items", nil); w.Code == 200 {
t.Fatal("anonymous")
}
if _, e = s.store.FeedItem(ctx, domain, uuid.NewString(), source.UUID, "one"); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal(e)
}
state := map[string]any{"source": source.UUID, "id": "one", "read": true, "starred": true, "version": 0}
if w := feedRequestTest(s, token, "POST", "state", state); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
if w := feedRequestTest(s, token, "POST", "state", state); w.Code != 412 {
t.Fatal("stale state", w.Code, w.Body)
}
got, e := s.store.FeedItem(ctx, domain, actor, source.UUID, "one")
if e != nil || !got.Read || !got.Starred || got.Version != 1 {
t.Fatal(got, e)
}
if e = s.store.CompleteFeed(ctx, claim, nil, "", "", "", false); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("old completion", e)
}
// Re-fetch must preserve local read/star; config edits invalidate in-flight work.
source.Version = 1
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
sources, _ := s.store.FeedSources(ctx, domain, actor)
claim, e = s.store.ClaimFeed(ctx, sources[0])
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "", "", "", false); e != nil {
t.Fatal(e)
}
got, _ = s.store.FeedItem(ctx, domain, actor, source.UUID, "one")
if !got.Read || !got.Starred {
t.Fatal("lost state")
}
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
sources, _ = s.store.FeedSources(ctx, domain, actor)
claim, e = s.store.ClaimFeed(ctx, sources[0])
if e != nil {
t.Fatal(e)
}
source.Enabled = false
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "", "", "", false); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("disabled late commit", e)
}
if e = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); e != nil {
t.Fatal(e)
}
if _, e = s.store.FeedItems(ctx, domain, actor, "", "", "", -1, ""); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal(e)
}
if w := feedRequestTest(s, token, "GET", "items", nil); w.Code != 404 {
t.Fatal(w.Code)
}
}
func TestFeedParserSafetyAndFormats(t *testing.T) {
rss := `News- id日本語/oneHello
world]]>Fri, 06 Nov 2026 10:00:00 +0000`
items, e := parseFeed([]byte(rss), "https://example.org/feed")
if e != nil || len(items) != 1 || items[0].URL != "https://example.org/one" || strings.Contains(items[0].Body, "alert") || strings.Contains(items[0].Body, "pixel") || items[0].PublishedMS == 0 {
t.Fatal(items, e)
}
atom := `Atomurn:oneOne2026-11-01T10:00:00Z<p>Body</p>`
items, e = parseFeed([]byte(atom), "https://example.org")
if e != nil || len(items) != 1 || items[0].Body != "Body" {
t.Fatal(items, e)
}
for _, raw := range []string{`]>`, `error`, ``, `- x
- x
`, strings.Repeat("x", (4<<20)+1)} {
if _, e = parseFeed([]byte(raw), "https://example.org"); e == nil {
t.Fatal("accepted malformed feed")
}
}
if feedLink("https://example.org", "javascript:alert(1)") != "" || feedLink("https://example.org", "https://user:pass@example.org") != "" {
t.Fatal("unsafe link")
}
items, e = parseFeed([]byte(`- No ID or linkFirst body
- No ID or linkSecond body
`), "https://example.org/feed")
if e != nil || len(items) != 2 || items[0].ID == items[1].ID || items[0].URL != "" {
t.Fatal("missing IDs must not collapse to the feed URL", items, e)
}
}
func TestFreshRSSReadOnlyContract(t *testing.T) {
requests := []string{}
remote := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requests = append(requests, r.Method+" "+r.URL.Path)
switch r.URL.Path {
case "/api/greader.php/accounts/ClientLogin":
if r.Method != "POST" {
t.Error("login method")
}
r.ParseForm()
if r.Form.Get("Email") != "reader" || r.Form.Get("Passwd") != "api-secret" {
t.Error("login form")
}
fmt.Fprint(w, "SID=x\nAuth=reader/token\n")
case "/api/greader.php/reader/api/0/stream/contents/reading-list":
if r.Header.Get("Authorization") != "GoogleLogin auth=reader/token" || r.URL.Query().Get("n") != "200" {
t.Error("request contract")
}
fmt.Fprint(w, `{"items":[{"id":"tag:1","title":"Title","summary":{"content":"Text
"},"published":1793500000,"categories":["user/reader/state/com.google/read","user/reader/state/com.google/starred","user/reader/label/Tech"],"origin":{"title":"Feed"},"alternate":[{"href":"https://example.org/article"}]}]}`)
default:
t.Error("unexpected mutation", r.URL.Path)
w.WriteHeader(404)
}
}))
defer remote.Close()
items, e := fetchFreshRSS(context.Background(), remote.Client(), store.FeedSource{URL: remote.URL + "/api/greader.php"}, "reader", "api-secret")
if e != nil || len(items) != 1 || !items[0].Read || !items[0].Starred || items[0].Folder != "Tech" || items[0].Body != "Text" || items[0].BodyHTML != "Text
" || len(requests) != 2 {
t.Fatal(items, e, requests)
}
for _, bad := range []string{"http://example.org/feed", "https://127.0.0.1/feed", "https://10.0.0.1/feed", "https://example.org:8443/feed", "https://user:pass@example.org/feed"} {
if validCalendarSourceURL(bad) {
t.Fatal("SSRF URL", bad)
}
}
}
func TestFeedHTMLFormattingAndIsolation(t *testing.T) {
raw := `Title
Bold
Storybad
`
clean := feedHTML(raw, "https://example.org/news/feed.xml")
for _, want := range []string{`Title
`, `Bold`, ``, `colspan="2"`, `href="https://example.org/story"`, `target="_blank"`, `noopener`} {
if !strings.Contains(clean, want) {
t.Fatal("format lost", want, clean)
}
}
for _, bad := range []string{"", "confirm_publication": true}
w := feedRequestTest(s, token, "POST", "note", input)
if w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
original := w.Body.String()
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 201 || w.Body.String() != original {
t.Fatal("replay", w.Code, w.Body)
}
var response map[string]string
json.Unmarshal(w.Body.Bytes(), &response)
rev, e := s.store.GetLatestRevision(response["page_uuid"])
if e != nil || strings.Contains(rev.Body, "{{children}}") || strings.Contains(rev.Body, " {{children}}\n\nSource content stays inert.", Feed: "技術ニュース", URL: "https://example.org/article", PublishedMS: int64(1793500000000 + i)})
}
items[119].BodyHTML = `HTMLの記事本文
強調やリンクをそのまま読めます。
`
if e = s.store.CompleteFeed(context.Background(), claim, items, "", "", "", false); e != nil {
t.Fatal(e)
}
fresh := store.FeedSource{UUID: uuid.NewString(), Provider: "freshrss", Title: "FreshRSS fixture", URL: "https://example.org/api/greader.php", Enabled: true, Interval: 300}
fresh.Credential, e = s.store.SealFeedCredential(domain, actor, fresh.UUID, "fixture", "synthetic")
if e != nil {
t.Fatal(e)
}
fresh, e = s.store.SaveFeedSource(context.Background(), domain, actor, fresh)
if e != nil {
t.Fatal(e)
}
all, e := s.store.FeedSources(context.Background(), domain, actor)
if e != nil {
t.Fatal(e)
}
for _, v := range all {
if v.UUID == fresh.UUID {
fresh = v
}
}
claim, e = s.store.ClaimFeed(context.Background(), fresh)
if e != nil {
t.Fatal(e)
}
catalog, e := parseFreshRSSCatalog([]byte(testFeedCatalog))
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(context.Background(), claim, []store.FeedItem{{ID: "catalog-a", Title: "Catalog first", RemoteFeed: "feed/1", RemoteCategories: []string{"user/alice/label/Tech"}}, {ID: "catalog-b", Title: "Catalog second", RemoteFeed: "feed/2", RemoteCategories: []string{"user/alice/label/Other"}}}, "", "", "", false, store.FeedCatalogSnapshot{Subscriptions: catalog, Folders: []store.FeedCategory{{ID: "user/-/label/Empty/Folder", Label: "Empty/Folder"}}}); e != nil {
t.Fatal(e)
}
s.store.BackgroundJobsDisabled = true
s = New(s.store)
script, e := os.ReadFile("internal/server/testdata/feeds.js")
if e != nil {
t.Fatal(e)
}
handler := s.handler()
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == "/fixture/embedded" {
w.Header().Set("Content-Type", "text/html")
io.WriteString(w, `Isolated external article fixture
`)
return
}
if r.URL.Path == "/fixture/run-feed-actions" && r.Method == "POST" {
fake := &feedRemoteFake{id: "catalog-b"}
if e := s.syncFeedActions(r.Context(), fake.client(t)); e != nil {
http.Error(w, "test worker failed", 500)
return
}
w.WriteHeader(204)
return
}
if r.URL.Path == "/fixture/feed-history" && r.Method == "POST" {
missing, orphan := uuid.NewString(), uuid.NewString()
for _, entry := range []struct{ request, source, item string }{{missing, fresh.UUID, "history-evicted"}, {orphan, uuid.NewString(), `
`}} {
if _, e := s.store.DB.Exec(`INSERT INTO feed_actions(domain_uuid,owner_uuid,request_id,source_uuid,item_id,field,desired,source_version,status,created_ms) VALUES(?,?,?,?,?,'read',1,1,'unknown',?)`, domain, actor, entry.request, entry.source, entry.item, time.Now().UnixMilli()); e != nil {
t.Error(e)
http.Error(w, "fixture insert failed", 500)
return
}
}
writeEventJSON(w, 200, map[string]string{"missing": missing, "orphan": orphan})
return
}
if r.URL.Path == "/fixture/check-feed-history" && r.Method == "POST" {
fake := &feedRemoteFake{id: "history-evicted", read: true}
if e := s.syncFeedActions(r.Context(), fake.client(t)); e != nil || fake.edits != 0 {
t.Errorf("history read-only check: %v edits=%d", e, fake.edits)
http.Error(w, "test recheck failed", 500)
return
}
w.WriteHeader(204)
return
}
if r.URL.Path == "/fixture" {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, "")
return
}
handler.ServeHTTP(w, r)
}))
defer web.Close()
for _, width := range []string{"1440", "390"} {
if _, e = s.store.DB.Exec(`DELETE FROM feed_actions`); e != nil {
t.Fatal(e)
}
if _, e = s.store.DB.Exec(`UPDATE feed_items SET is_read=0 WHERE source_uuid=?`, fresh.UUID); e != nil {
t.Fatal(e)
}
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
args := []string{"internal/server/testdata/vim-browser-smoke.mjs", web.URL + "/fixture?width=" + url.QueryEscape(width), t.TempDir(), "/tmp/pageswiki-feeds-" + width + ".png", width, "850"}
out, e := exec.CommandContext(ctx, "node", args...).CombinedOutput()
cancel()
if e != nil {
t.Fatalf("browser %s: %v %s", width, e, out)
}
}
}