QWQLwToo
255 lines
7.4 KiB
Go
255 lines
7.4 KiB
Go
package sources
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"ymhut-box/server/unified-management/internal/config"
|
|
"ymhut-box/server/unified-management/internal/db"
|
|
)
|
|
|
|
func TestCheckOneTreatsRedirectToOKAsRedirected(t *testing.T) {
|
|
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, _ = w.Write([]byte("ok"))
|
|
}))
|
|
defer target.Close()
|
|
redirector := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
http.Redirect(w, r, target.URL, http.StatusFound)
|
|
}))
|
|
defer redirector.Close()
|
|
|
|
cfg, store := testStore(t)
|
|
service := NewService(cfg, store)
|
|
item, err := store.UpsertSource(db.Source{
|
|
CategoryID: "test",
|
|
CategoryName: "Test",
|
|
SourceID: "redirect",
|
|
Name: "Redirect",
|
|
Method: "GET",
|
|
APIURL: redirector.URL,
|
|
TimeoutMS: 3000,
|
|
CheckIntervalSec: 300,
|
|
Enabled: true,
|
|
ClientVisible: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := service.CheckOne(context.Background(), item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
checked, err := store.GetSourceBySourceID("redirect")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if checked.LastStatus != "redirected" {
|
|
t.Fatalf("LastStatus = %q, want redirected", checked.LastStatus)
|
|
}
|
|
if !strings.Contains(checked.LastError, `"redirected":true`) {
|
|
t.Fatalf("LastError does not contain redirect metadata: %s", checked.LastError)
|
|
}
|
|
if checked.ConsecutiveFailure != 0 {
|
|
t.Fatalf("ConsecutiveFailure = %d, want 0", checked.ConsecutiveFailure)
|
|
}
|
|
}
|
|
|
|
func TestQueueCheckAllUsesBackgroundContext(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, _ = w.Write([]byte("ok"))
|
|
}))
|
|
defer server.Close()
|
|
cfg, store := testStore(t)
|
|
service := NewService(cfg, store)
|
|
if _, err := store.UpsertSource(db.Source{
|
|
CategoryID: "test",
|
|
CategoryName: "Test",
|
|
SourceID: "slow-ok",
|
|
Name: "Slow OK",
|
|
Method: "GET",
|
|
APIURL: server.URL,
|
|
TimeoutMS: 1000,
|
|
CheckIntervalSec: 300,
|
|
Enabled: true,
|
|
ClientVisible: true,
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
job := service.QueueCheckAll()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
current, ok := service.CheckJob(job.ID)
|
|
if ok && current.Status == "completed" {
|
|
if current.Stats["ok"] != 1 {
|
|
t.Fatalf("stats = %#v, want one ok", current.Stats)
|
|
}
|
|
return
|
|
}
|
|
time.Sleep(20 * time.Millisecond)
|
|
}
|
|
t.Fatalf("job did not complete: %#v", job)
|
|
}
|
|
|
|
func TestSubscribeEventsBroadcastsToAllSubscribers(t *testing.T) {
|
|
cfg, store := testStore(t)
|
|
service := NewService(cfg, store)
|
|
eventsA, unsubscribeA := service.SubscribeEvents()
|
|
defer unsubscribeA()
|
|
eventsB, unsubscribeB := service.SubscribeEvents()
|
|
defer unsubscribeB()
|
|
|
|
service.emit("source_check.completed", map[string]any{"jobId": "demo"})
|
|
|
|
assertEvent := func(name string, events <-chan Event) {
|
|
t.Helper()
|
|
select {
|
|
case event := <-events:
|
|
if event.Type != "source_check.completed" || event.Data["jobId"] != "demo" {
|
|
t.Fatalf("%s received unexpected event: %#v", name, event)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Fatalf("%s did not receive broadcast event", name)
|
|
}
|
|
}
|
|
assertEvent("subscriber A", eventsA)
|
|
assertEvent("subscriber B", eventsB)
|
|
}
|
|
|
|
func TestCheckOneResolvesNestedJSONMediaURL(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(map[string]any{
|
|
"ok": true,
|
|
"data": map[string]any{
|
|
"ignored": "https://example.test/readme.txt",
|
|
"items": []map[string]any{
|
|
{"name": "first"},
|
|
{"cover": "/media/poster.webp"},
|
|
},
|
|
},
|
|
})
|
|
}))
|
|
defer server.Close()
|
|
cfg, store := testStore(t)
|
|
service := NewService(cfg, store)
|
|
item, err := store.UpsertSource(db.Source{
|
|
CategoryID: "image",
|
|
CategoryName: "Image",
|
|
SourceID: "json-cover",
|
|
Name: "JSON Cover",
|
|
Method: "GET",
|
|
APIURL: server.URL + "/api/random",
|
|
TimeoutMS: 3000,
|
|
CheckIntervalSec: 300,
|
|
Enabled: true,
|
|
ClientVisible: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := service.CheckOne(context.Background(), item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
checked, err := store.GetSourceBySourceID("json-cover")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
meta := parseHealthMeta(checked.LastError)
|
|
if meta["resolvedUrl"] != server.URL+"/media/poster.webp" {
|
|
t.Fatalf("resolvedUrl = %#v, want relative media URL", meta["resolvedUrl"])
|
|
}
|
|
if meta["resolvedKey"] != "data.items.cover" {
|
|
t.Fatalf("resolvedKey = %#v", meta["resolvedKey"])
|
|
}
|
|
if meta["mediaType"] != "image" {
|
|
t.Fatalf("mediaType = %#v, want image", meta["mediaType"])
|
|
}
|
|
catalog, err := service.Catalog(false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
categories := catalog["categories"].([]map[string]any)
|
|
sub := categories[0]["subcategories"].([]map[string]any)[0]
|
|
if sub["resolvedUrl"] != server.URL+"/media/poster.webp" {
|
|
t.Fatalf("catalog resolvedUrl = %#v", sub["resolvedUrl"])
|
|
}
|
|
endpoints, err := service.Endpoints(false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if endpoints[0]["resolvedUrl"] != server.URL+"/media/poster.webp" {
|
|
t.Fatalf("endpoint resolvedUrl = %#v", endpoints[0]["resolvedUrl"])
|
|
}
|
|
if endpoints[0]["urlTemplate"] != server.URL+"/api/random" {
|
|
t.Fatalf("urlTemplate changed: %#v", endpoints[0]["urlTemplate"])
|
|
}
|
|
}
|
|
|
|
func TestCheckOneResolvesTextMediaURL(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
_, _ = w.Write([]byte(`play: https://cdn.example.test/video/sample.mp4`))
|
|
}))
|
|
defer server.Close()
|
|
cfg, store := testStore(t)
|
|
service := NewService(cfg, store)
|
|
item, err := store.UpsertSource(db.Source{
|
|
CategoryID: "video",
|
|
CategoryName: "Video",
|
|
SourceID: "text-video",
|
|
Name: "Text Video",
|
|
Method: "GET",
|
|
APIURL: server.URL,
|
|
TimeoutMS: 3000,
|
|
CheckIntervalSec: 300,
|
|
Enabled: true,
|
|
ClientVisible: true,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := service.CheckOne(context.Background(), item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
checked, err := store.GetSourceBySourceID("text-video")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
meta := parseHealthMeta(checked.LastError)
|
|
if meta["resolvedUrl"] != "https://cdn.example.test/video/sample.mp4" {
|
|
t.Fatalf("resolvedUrl = %#v", meta["resolvedUrl"])
|
|
}
|
|
if meta["mediaType"] != "video" {
|
|
t.Fatalf("mediaType = %#v, want video", meta["mediaType"])
|
|
}
|
|
}
|
|
|
|
func testStore(t *testing.T) (*config.Config, *db.Store) {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
cfg := &config.Config{
|
|
BaseDir: dir,
|
|
StorageDir: filepath.Join(dir, "storage"),
|
|
DataDir: filepath.Join(dir, "data"),
|
|
UpdatePublicDir: filepath.Join(dir, "data", "update", "public"),
|
|
DownloadsDir: filepath.Join(dir, "data", "update", "public", "downloads"),
|
|
BaseURL: "https://update.ymhut.cn",
|
|
Database: config.DatabaseConfig{
|
|
Provider: "sqlite",
|
|
SQLitePath: filepath.Join(dir, "storage", "unified.sqlite"),
|
|
HealthIntervalSec: 30,
|
|
},
|
|
}
|
|
store, err := db.Open(cfg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { store.Close() })
|
|
return cfg, store
|
|
}
|