吴璨
244 lines
8.7 KiB
Go
244 lines
8.7 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func waitSortMetadataQueue(t *testing.T, app *UIApp) {
|
|
t.Helper()
|
|
app.mu.Lock()
|
|
done := app.metadataDone
|
|
app.mu.Unlock()
|
|
if done != nil {
|
|
select {
|
|
case <-done:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatal("metadata queue did not finish")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPrimaryCatalogReturnsBeforeOptionalMetadata(t *testing.T) {
|
|
for _, source := range []string{sourceHongguo} {
|
|
t.Run(source, func(t *testing.T) {
|
|
id := "7615465407347952664"
|
|
started, release := make(chan struct{}), make(chan struct{})
|
|
var once sync.Once
|
|
var calls atomic.Int32
|
|
d := rankingTestDownloader(t, func(request *http.Request) (*http.Response, error) {
|
|
calls.Add(1)
|
|
if request.Context().Value(backgroundCatalogKey{}) != true {
|
|
t.Error("optional detail did not use background priority")
|
|
}
|
|
once.Do(func() { close(started) })
|
|
select {
|
|
case <-release:
|
|
case <-request.Context().Done():
|
|
return nil, request.Context().Err()
|
|
}
|
|
switch request.URL.Path {
|
|
case "/detail":
|
|
if request.URL.Query().Get("series_id") != id {
|
|
t.Error("historical entry was automatically fetched")
|
|
}
|
|
return rankingHTTPResponse(request, 200, sortDetailFixture(id, "1773662280")), nil
|
|
case "/novel/player/video_detail/v1/":
|
|
return rankingHTTPResponse(request, 200, fmt.Sprintf(`{"data":{"video_data":{"series_id_str":%q,"series_title":"详情标题","hot_score":20019,"series_play_cnt":10019}}}`, id)), nil
|
|
default:
|
|
t.Errorf("unexpected metadata request: %s", request.URL.Path)
|
|
return rankingHTTPResponse(request, 404, ""), nil
|
|
}
|
|
})
|
|
old := Drama{ID: providerDramaID(source, "7498612570866076734"), Source: source, Title: "历史条目"}
|
|
fresh := Drama{ID: providerDramaID(source, id), Source: source, Title: "列表标题", Heat: "20019", Views: "0", Cover: coverAddressFixture}
|
|
app := &UIApp{downloader: d, cfg: d.cfg, dramas: []Drama{old}, librarySources: map[string]librarySourceState{}, libraryLoading: make(chan struct{})}
|
|
t.Cleanup(app.stopSortMetadata)
|
|
app.acceptLibraryProgress(source, []Drama{old, fresh}, nil, false)
|
|
app.mu.Lock()
|
|
if calls.Load() != 0 || len(app.dramas) != 2 || app.dramas[1].Heat != fresh.Heat || app.dramas[1].Views != "0" {
|
|
t.Error("primary fields did not return before optional requests")
|
|
}
|
|
close(app.libraryLoading)
|
|
app.libraryLoading = nil
|
|
app.mu.Unlock()
|
|
select {
|
|
case <-started:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("new entry was not scheduled automatically")
|
|
}
|
|
|
|
app.acceptLibraryProgress(source, []Drama{fresh, old}, nil, true)
|
|
writer := httptest.NewRecorder()
|
|
app.handleDramas(writer, httptest.NewRequest("GET", "/api/ui/dramas", nil))
|
|
var snapshot struct {
|
|
Loading bool `json:"loading"`
|
|
Metadata libraryMetadataProgress `json:"metadata"`
|
|
}
|
|
if json.Unmarshal(writer.Body.Bytes(), &snapshot) != nil || snapshot.Loading || !snapshot.Metadata.Running || snapshot.Metadata.Total != 1 {
|
|
t.Fatal("optional metadata blocked the library or duplicated work")
|
|
}
|
|
close(release)
|
|
waitSortMetadataQueue(t, app)
|
|
cache, err := readLibraryCache(d.cfg.dataDirectory())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, row := range cache.Dramas {
|
|
if row.ID == old.ID && row.SortMetadata != nil {
|
|
t.Error("ordinary catalog refresh enrolled historical data")
|
|
}
|
|
wantViews := "10019次播放"
|
|
if source == sourceHongguo {
|
|
wantViews = "0"
|
|
}
|
|
if row.ID == fresh.ID && (row.OnlineDate != "2026-03-16" || row.Views != wantViews || row.Heat != fresh.Heat || row.Title != "列表标题" || row.SortMetadata == nil || row.SortMetadata.Version != sortMetadataVersion || row.SortMetadata.Pending) {
|
|
t.Errorf("asynchronous metadata was not merged correctly: %+v", row)
|
|
}
|
|
}
|
|
if calls.Load() != 1 {
|
|
t.Fatalf("duplicate detail requests: %d", calls.Load())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResumeOnlyPreviouslyQueuedMetadata(t *testing.T) {
|
|
var calls atomic.Int32
|
|
d := rankingTestDownloader(t, func(request *http.Request) (*http.Response, error) {
|
|
calls.Add(1)
|
|
if request.URL.Path != "/detail" || request.URL.Query().Get("series_id") != "7000000000000000002" {
|
|
t.Errorf("unexpected resource: %s", request.URL.Path)
|
|
}
|
|
return rankingHTTPResponse(request, 200, sortDetailFixture("7000000000000000002", "0")), nil
|
|
})
|
|
cache := libraryCache{Dramas: []Drama{
|
|
{ID: "hongguo:7000000000000000001", Source: sourceHongguo, Title: "历史条目"},
|
|
{ID: "hongguo:7000000000000000002", Source: sourceHongguo, Title: "新条目", Heat: "0", Views: "0", Cover: coverAddressFixture, SortMetadata: &sortMetadataState{Pending: true}},
|
|
}}
|
|
if err := writeLibraryCache(d.cfg.dataDirectory(), cache); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
app := &UIApp{downloader: d, cfg: d.cfg}
|
|
t.Cleanup(app.stopSortMetadata)
|
|
app.loadLibrary()
|
|
waitSortMetadataQueue(t, app)
|
|
if calls.Load() != 1 {
|
|
t.Fatalf("resume requested %d resources, want one pending detail", calls.Load())
|
|
}
|
|
app.mu.Lock()
|
|
defer app.mu.Unlock()
|
|
if app.dramas[0].SortMetadata != nil || app.dramas[1].OnlineDate != "" || app.dramas[1].Views != "0" || app.dramas[1].SortMetadata.Version != sortMetadataVersion {
|
|
t.Fatal("resume changed history, lost zero, or invented an empty source date")
|
|
}
|
|
}
|
|
|
|
func TestPrimarySortFieldsNeedNoAdditionalInterfacesWhenComplete(t *testing.T) {
|
|
hongguo := hongguoDramaFromAny(map[string]any{"series_id": "7615465407347952664", "series_title": "列表剧", "series_cover": coverAddressFixture, "first_visible_time": "1773662280", "hot_score": "20019", "series_play_cnt": "0"}, "测试")
|
|
d := rankingTestDownloader(t, func(request *http.Request) (*http.Response, error) {
|
|
t.Errorf("complete primary data triggered an optional request: %s", request.URL.Path)
|
|
return rankingHTTPResponse(request, 404, ""), nil
|
|
})
|
|
for _, drama := range []Drama{hongguo} {
|
|
if drama.OnlineDate != "2026-03-16" || drama.Views != "0" || !hasCompleteSortMetadata(drama) {
|
|
t.Errorf("primary sort fields were lost: %+v", drama)
|
|
}
|
|
if _, err := d.fetchDramaSortMetadata(context.Background(), drama); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if hasSortMetric("未知") || hasSortMetric("-1") {
|
|
t.Fatal("unknown metrics were misclassified as available sorting data")
|
|
}
|
|
}
|
|
|
|
func TestBackgroundRequestsYieldToForeground(t *testing.T) {
|
|
limiter := newRequestLimiter(1, time.Nanosecond)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
request := httptest.NewRequest("GET", "https://hongguoduanju.com/search/test", nil)
|
|
release, err := limiter.acquire(ctx, request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
background := make(chan func(), 1)
|
|
foreground := make(chan func(), 1)
|
|
go func() {
|
|
unlock, _ := limiter.acquire(context.WithValue(ctx, backgroundCatalogKey{}, true), request)
|
|
background <- unlock
|
|
}()
|
|
go func() {
|
|
unlock, _ := limiter.acquire(ctx, request)
|
|
foreground <- unlock
|
|
}()
|
|
|
|
for {
|
|
limiter.mu.Lock()
|
|
waiting := limiter.foregroundWaiting
|
|
limiter.mu.Unlock()
|
|
if waiting > 0 {
|
|
break
|
|
}
|
|
if ctx.Err() != nil {
|
|
t.Fatal("foreground waiter did not register")
|
|
}
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
release()
|
|
select {
|
|
case unlock := <-foreground:
|
|
if unlock == nil {
|
|
t.Fatal("foreground timed out")
|
|
}
|
|
select {
|
|
case <-background:
|
|
t.Fatal("background ran alongside a waiting foreground request")
|
|
default:
|
|
}
|
|
unlock()
|
|
case <-background:
|
|
t.Fatal("optional metadata overtook foreground work")
|
|
case <-ctx.Done():
|
|
t.Fatal(ctx.Err())
|
|
}
|
|
select {
|
|
case unlock := <-background:
|
|
if unlock == nil {
|
|
t.Fatal("background did not resume")
|
|
}
|
|
unlock()
|
|
case <-ctx.Done():
|
|
t.Fatal(ctx.Err())
|
|
}
|
|
}
|
|
|
|
func TestOptionalDetailPermissionFailureDoesNotBlockForeground(t *testing.T) {
|
|
limiter := newRequestLimiter(1, time.Nanosecond)
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
foreground := httptest.NewRequest("GET", "https://hongguoduanju.com/search/test", nil).WithContext(ctx)
|
|
background := foreground.WithContext(context.WithValue(ctx, backgroundCatalogKey{}, true))
|
|
limiter.observe(background, &http.Response{StatusCode: http.StatusForbidden, Header: http.Header{}})
|
|
if release, err := limiter.acquire(background.Context(), background); err == nil {
|
|
release()
|
|
t.Fatal("repeated forbidden details must cool down")
|
|
}
|
|
release, err := limiter.acquire(ctx, foreground)
|
|
if err != nil {
|
|
t.Fatal("an optional detail's permissions blocked public search", err)
|
|
}
|
|
release()
|
|
limiter.observe(background, &http.Response{StatusCode: http.StatusTooManyRequests, Header: http.Header{"Retry-After": {"60"}}})
|
|
if release, err := limiter.acquire(ctx, foreground); err == nil {
|
|
release()
|
|
t.Fatal("site rate limits must still be respected")
|
|
}
|
|
}
|