From 35f8a166c68b3dfff74042627a29dff0f35d3b46 Mon Sep 17 00:00:00 2001 From: ShukeBta <272197458+ShukeBta@users.noreply.github.com> Date: Wed, 24 Jun 2026 19:36:08 +0800 Subject: [PATCH] refactor: split image proxy tests --- internal/service/image_proxy_cloud_test.go | 165 ++++++++ internal/service/image_proxy_remote_test.go | 301 ++++++++++++++ internal/service/image_proxy_test.go | 435 -------------------- 3 files changed, 466 insertions(+), 435 deletions(-) create mode 100644 internal/service/image_proxy_cloud_test.go create mode 100644 internal/service/image_proxy_remote_test.go diff --git a/internal/service/image_proxy_cloud_test.go b/internal/service/image_proxy_cloud_test.go new file mode 100644 index 0000000..59c545b --- /dev/null +++ b/internal/service/image_proxy_cloud_test.go @@ -0,0 +1,165 @@ +package service + +import ( + "bytes" + "errors" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "sync/atomic" + "testing" + + "go.uber.org/zap" + + "github.com/ShukeBta/MediaStationGo/internal/config" + "github.com/ShukeBta/MediaStationGo/internal/service/cloud" +) + +func TestImageProxyCachesCloudResolvedImage(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/png"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/poster.png"} + if proxy.ServeCloudCached(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png") { + t.Fatal("ServeCloudCached returned true before the cloud image was cached") + } + for i := 0; i < 2; i++ { + rec := httptest.NewRecorder() + if err := proxy.ServeCloudResolved(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png", link); err != nil { + t.Fatal(err) + } + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + if got := rec.Header().Get("Cache-Control"); got != imageBrowserCacheControl { + t.Fatalf("Cache-Control = %q, want %q", got, imageBrowserCacheControl) + } + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1 due to cloud image cache", got) + } + + rec := httptest.NewRecorder() + if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png") { + t.Fatal("ServeCloudCached returned false after the cloud image was cached") + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls after ServeCloudCached = %d, want 1", got) + } + if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { + t.Fatalf("cached body = %x, want cached cloud image", got) + } +} + +func TestImageProxyPrefetchCloudResolvedImage(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/png"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/folder.png"} + if err := proxy.PrefetchCloudResolved(t.Context(), "openlist:folder.png", link); err != nil { + t.Fatal(err) + } + if err := proxy.PrefetchCloudResolved(t.Context(), "openlist:folder.png", link); err != nil { + t.Fatal(err) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1 after prefetch cache hit", got) + } + rec := httptest.NewRecorder() + if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=folder.png", nil), "openlist:folder.png") { + t.Fatal("prefetched cloud image was not served from cache") + } + if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { + t.Fatalf("cached body = %x, want prefetched cloud image", got) + } +} + +func TestImageProxyPrefetchCloudResolvedRefetchesInvalidCache(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/jpeg"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + stableKey := "openlist:bad-cache-poster.jpg" + _, cachePath, failPath := proxy.cloudImageCachePaths(stableKey) + if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(cachePath, []byte("old bad cache"), 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { + t.Fatal(err) + } + + link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/bad-cache-poster.jpg"} + if err := proxy.PrefetchCloudResolved(t.Context(), stableKey, link); err != nil { + t.Fatal(err) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1 after invalid cache cleanup", got) + } + rec := httptest.NewRecorder() + if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=bad-cache-poster.jpg", nil), stableKey) { + t.Fatal("refetched cloud image was not served from cache") + } + if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { + t.Fatalf("cached body = %x, want refetched cloud image", got) + } +} + +func TestImageProxyServeCloudCachedSkipsInvalidCache(t *testing.T) { + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + stableKey := "openlist:invalid-cached-poster.jpg" + _, cachePath, failPath := proxy.cloudImageCachePaths(stableKey) + if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(cachePath, transparent1x1PNG, 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { + t.Fatal(err) + } + + rec := httptest.NewRecorder() + if proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=invalid-cached-poster.jpg", nil), stableKey) { + t.Fatal("ServeCloudCached should skip invalid cached cloud artwork") + } + if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("invalid cache should be removed, stat err=%v", err) + } + if _, err := os.Stat(failPath); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("stale fail marker should be removed with invalid cache, stat err=%v", err) + } +} diff --git a/internal/service/image_proxy_remote_test.go b/internal/service/image_proxy_remote_test.go new file mode 100644 index 0000000..ab94bd6 --- /dev/null +++ b/internal/service/image_proxy_remote_test.go @@ -0,0 +1,301 @@ +package service + +import ( + "bytes" + "errors" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync/atomic" + "testing" + + "go.uber.org/zap" + + "github.com/ShukeBta/MediaStationGo/internal/config" +) + +func TestImageProxyCachesFailedRemoteImageFetch(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusBadGateway, + Status: "502 Bad Gateway", + Header: make(http.Header), + Body: io.NopCloser(strings.NewReader("upstream unavailable")), + Request: req, + }, nil + })} + raw := "https://image.tmdb.org/t/p/w500/poster.jpg" + for i := 0; i < 2; i++ { + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { + t.Fatal(err) + } + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + if rec.Body.Len() != len(transparent1x1PNG) { + t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) + } + if got := rec.Header().Get("Cache-Control"); got != imagePlaceholderCacheControl { + t.Fatalf("Cache-Control = %q, want %q", got, imagePlaceholderCacheControl) + } + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1 due to negative cache", got) + } +} + +func TestImageProxyRemoveFailedAllowsRetry(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + call := atomic.AddInt32(&calls, 1) + if call == 1 { + return &http.Response{ + StatusCode: http.StatusBadGateway, + Status: "502 Bad Gateway", + Header: make(http.Header), + Body: io.NopCloser(strings.NewReader("upstream unavailable")), + Request: req, + }, nil + } + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/jpeg"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + raw := "https://image.tmdb.org/t/p/w500/retry-poster.jpg" + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { + t.Fatal(err) + } + if rec.Body.Len() != len(transparent1x1PNG) { + t.Fatalf("first body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) + } + if err := proxy.RemoveFailed(raw); err != nil { + t.Fatal(err) + } + rec = httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?v=retry", nil), raw); err != nil { + t.Fatal(err) + } + if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { + t.Fatalf("retried body = %x, want poster bytes", got) + } + if got := atomic.LoadInt32(&calls); got != 2 { + t.Fatalf("upstream calls = %d, want 2 after retry", got) + } +} + +func TestImageProxyPrefetchRemoteUsesProviderHeaders(t *testing.T) { + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + if got := req.Header.Get("Referer"); got != "https://movie.douban.com/" { + t.Fatalf("Referer = %q, want Douban movie referer", got) + } + if got := req.Header.Get("User-Agent"); !strings.Contains(got, "Mozilla/5.0") { + t.Fatalf("User-Agent = %q, want browser-like UA", got) + } + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/jpeg"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + raw := "https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2933012346.jpg" + if err := proxy.PrefetchRemote(t.Context(), raw); err != nil { + t.Fatal(err) + } +} + +func TestImageProxyRemoveCachedAllowsRefresh(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/png"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + raw := "https://image.tmdb.org/t/p/w500/refresh-poster.jpg" + if err := proxy.PrefetchRemote(t.Context(), raw); err != nil { + t.Fatal(err) + } + if err := proxy.RemoveCached(raw); err != nil { + t.Fatal(err) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls before refresh = %d, want 1", got) + } + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?refresh=1", nil), raw); err != nil { + t.Fatal(err) + } + if got := atomic.LoadInt32(&calls); got != 2 { + t.Fatalf("upstream calls after refresh = %d, want 2", got) + } + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } +} + +func TestImageProxyRefreshKeepsCachedImageOnUpstreamFailure(t *testing.T) { + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + return &http.Response{ + StatusCode: http.StatusBadGateway, + Status: "502 Bad Gateway", + Header: make(http.Header), + Body: io.NopCloser(strings.NewReader("upstream unavailable")), + Request: req, + }, nil + })} + + raw := "https://image.tmdb.org/t/p/w500/cached-poster.jpg" + _, cachePath, _, err := proxy.remoteImageCachePaths(raw) + if err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { + t.Fatal(err) + } + cachedPoster := testJPEG + if err := os.WriteFile(cachePath, cachedPoster, 0o600); err != nil { + t.Fatal(err) + } + + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?refresh=1", nil), raw); err != nil { + t.Fatal(err) + } + if got := rec.Body.Bytes(); !bytes.Equal(got, cachedPoster) { + t.Fatalf("body = %x, want cached poster after failed refresh", got) + } +} + +func TestImageProxyRefetchesTransparentPlaceholderCache(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/jpeg"}}, + Body: io.NopCloser(bytes.NewReader(testJPEG)), + Request: req, + }, nil + })} + + raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p2925358079.jpg" + _, cachePath, failPath, err := proxy.remoteImageCachePaths(raw) + if err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(cachePath, transparent1x1PNG, 0o600); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { + t.Fatal(err) + } + + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?retry=1", nil), raw); err != nil { + t.Fatal(err) + } + if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { + t.Fatalf("body = %x, want refetched poster bytes", got) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1", got) + } +} + +func TestImageProxyDoesNotCacheNonImageRemoteResponse(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"text/html"}}, + Body: io.NopCloser(strings.NewReader("not image")), + Request: req, + }, nil + })} + + raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p-bad.jpg" + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { + t.Fatal(err) + } + if rec.Body.Len() != len(transparent1x1PNG) { + t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) + } + _, cachePath, _, err := proxy.remoteImageCachePaths(raw) + if err != nil { + t.Fatal(err) + } + if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("non-image response should not be cached, stat err=%v", err) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1", got) + } +} + +func TestImageProxyDoesNotCacheMislabeledRemoteResponse(t *testing.T) { + var calls int32 + proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) + proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { + atomic.AddInt32(&calls, 1) + return &http.Response{ + StatusCode: http.StatusOK, + Status: "200 OK", + Header: http.Header{"Content-Type": []string{"image/jpeg"}}, + Body: io.NopCloser(strings.NewReader("not a poster")), + Request: req, + }, nil + })} + + raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p-mislabeled.jpg" + rec := httptest.NewRecorder() + if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { + t.Fatal(err) + } + if rec.Body.Len() != len(transparent1x1PNG) { + t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) + } + _, cachePath, _, err := proxy.remoteImageCachePaths(raw) + if err != nil { + t.Fatal(err) + } + if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("mislabeled non-image response should not be cached, stat err=%v", err) + } + if got := atomic.LoadInt32(&calls); got != 1 { + t.Fatalf("upstream calls = %d, want 1", got) + } +} diff --git a/internal/service/image_proxy_test.go b/internal/service/image_proxy_test.go index e7ec17b..d591d2e 100644 --- a/internal/service/image_proxy_test.go +++ b/internal/service/image_proxy_test.go @@ -2,20 +2,15 @@ package service import ( "bytes" - "errors" - "io" "net/http" "net/http/httptest" "os" "path/filepath" - "strings" - "sync/atomic" "testing" "go.uber.org/zap" "github.com/ShukeBta/MediaStationGo/internal/config" - "github.com/ShukeBta/MediaStationGo/internal/service/cloud" ) var testJPEG = []byte{ @@ -106,436 +101,6 @@ func TestImageProxyServesPosterUnderLibraryRoot(t *testing.T) { } } -func TestImageProxyCachesFailedRemoteImageFetch(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusBadGateway, - Status: "502 Bad Gateway", - Header: make(http.Header), - Body: io.NopCloser(strings.NewReader("upstream unavailable")), - Request: req, - }, nil - })} - raw := "https://image.tmdb.org/t/p/w500/poster.jpg" - for i := 0; i < 2; i++ { - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { - t.Fatal(err) - } - if rec.Code != http.StatusOK { - t.Fatalf("status = %d, want 200", rec.Code) - } - if rec.Body.Len() != len(transparent1x1PNG) { - t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) - } - if got := rec.Header().Get("Cache-Control"); got != imagePlaceholderCacheControl { - t.Fatalf("Cache-Control = %q, want %q", got, imagePlaceholderCacheControl) - } - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1 due to negative cache", got) - } -} - -func TestImageProxyRemoveFailedAllowsRetry(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - call := atomic.AddInt32(&calls, 1) - if call == 1 { - return &http.Response{ - StatusCode: http.StatusBadGateway, - Status: "502 Bad Gateway", - Header: make(http.Header), - Body: io.NopCloser(strings.NewReader("upstream unavailable")), - Request: req, - }, nil - } - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/jpeg"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - raw := "https://image.tmdb.org/t/p/w500/retry-poster.jpg" - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { - t.Fatal(err) - } - if rec.Body.Len() != len(transparent1x1PNG) { - t.Fatalf("first body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) - } - if err := proxy.RemoveFailed(raw); err != nil { - t.Fatal(err) - } - rec = httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?v=retry", nil), raw); err != nil { - t.Fatal(err) - } - if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { - t.Fatalf("retried body = %x, want poster bytes", got) - } - if got := atomic.LoadInt32(&calls); got != 2 { - t.Fatalf("upstream calls = %d, want 2 after retry", got) - } -} - -func TestImageProxyPrefetchRemoteUsesProviderHeaders(t *testing.T) { - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - if got := req.Header.Get("Referer"); got != "https://movie.douban.com/" { - t.Fatalf("Referer = %q, want Douban movie referer", got) - } - if got := req.Header.Get("User-Agent"); !strings.Contains(got, "Mozilla/5.0") { - t.Fatalf("User-Agent = %q, want browser-like UA", got) - } - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/jpeg"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - raw := "https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2933012346.jpg" - if err := proxy.PrefetchRemote(t.Context(), raw); err != nil { - t.Fatal(err) - } -} - -func TestImageProxyRemoveCachedAllowsRefresh(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/png"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - raw := "https://image.tmdb.org/t/p/w500/refresh-poster.jpg" - if err := proxy.PrefetchRemote(t.Context(), raw); err != nil { - t.Fatal(err) - } - if err := proxy.RemoveCached(raw); err != nil { - t.Fatal(err) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls before refresh = %d, want 1", got) - } - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?refresh=1", nil), raw); err != nil { - t.Fatal(err) - } - if got := atomic.LoadInt32(&calls); got != 2 { - t.Fatalf("upstream calls after refresh = %d, want 2", got) - } - if rec.Code != http.StatusOK { - t.Fatalf("status = %d, want 200", rec.Code) - } -} - -func TestImageProxyRefreshKeepsCachedImageOnUpstreamFailure(t *testing.T) { - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - return &http.Response{ - StatusCode: http.StatusBadGateway, - Status: "502 Bad Gateway", - Header: make(http.Header), - Body: io.NopCloser(strings.NewReader("upstream unavailable")), - Request: req, - }, nil - })} - - raw := "https://image.tmdb.org/t/p/w500/cached-poster.jpg" - _, cachePath, _, err := proxy.remoteImageCachePaths(raw) - if err != nil { - t.Fatal(err) - } - if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { - t.Fatal(err) - } - cachedPoster := testJPEG - if err := os.WriteFile(cachePath, cachedPoster, 0o600); err != nil { - t.Fatal(err) - } - - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?refresh=1", nil), raw); err != nil { - t.Fatal(err) - } - if got := rec.Body.Bytes(); !bytes.Equal(got, cachedPoster) { - t.Fatalf("body = %x, want cached poster after failed refresh", got) - } -} - -func TestImageProxyRefetchesTransparentPlaceholderCache(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/jpeg"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p2925358079.jpg" - _, cachePath, failPath, err := proxy.remoteImageCachePaths(raw) - if err != nil { - t.Fatal(err) - } - if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(cachePath, transparent1x1PNG, 0o600); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { - t.Fatal(err) - } - - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img?retry=1", nil), raw); err != nil { - t.Fatal(err) - } - if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { - t.Fatalf("body = %x, want refetched poster bytes", got) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1", got) - } -} - -func TestImageProxyDoesNotCacheNonImageRemoteResponse(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"text/html"}}, - Body: io.NopCloser(strings.NewReader("not image")), - Request: req, - }, nil - })} - - raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p-bad.jpg" - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { - t.Fatal(err) - } - if rec.Body.Len() != len(transparent1x1PNG) { - t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) - } - _, cachePath, _, err := proxy.remoteImageCachePaths(raw) - if err != nil { - t.Fatal(err) - } - if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { - t.Fatalf("non-image response should not be cached, stat err=%v", err) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1", got) - } -} - -func TestImageProxyDoesNotCacheMislabeledRemoteResponse(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/jpeg"}}, - Body: io.NopCloser(strings.NewReader("not a poster")), - Request: req, - }, nil - })} - - raw := "https://img1.doubanio.com/view/photo/s_ratio_poster/public/p-mislabeled.jpg" - rec := httptest.NewRecorder() - if err := proxy.Serve(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/img", nil), raw); err != nil { - t.Fatal(err) - } - if rec.Body.Len() != len(transparent1x1PNG) { - t.Fatalf("body length = %d, want placeholder %d", rec.Body.Len(), len(transparent1x1PNG)) - } - _, cachePath, _, err := proxy.remoteImageCachePaths(raw) - if err != nil { - t.Fatal(err) - } - if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { - t.Fatalf("mislabeled non-image response should not be cached, stat err=%v", err) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1", got) - } -} - -func TestImageProxyCachesCloudResolvedImage(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/png"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/poster.png"} - if proxy.ServeCloudCached(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png") { - t.Fatal("ServeCloudCached returned true before the cloud image was cached") - } - for i := 0; i < 2; i++ { - rec := httptest.NewRecorder() - if err := proxy.ServeCloudResolved(t.Context(), rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png", link); err != nil { - t.Fatal(err) - } - if rec.Code != http.StatusOK { - t.Fatalf("status = %d, want 200", rec.Code) - } - if got := rec.Header().Get("Cache-Control"); got != imageBrowserCacheControl { - t.Fatalf("Cache-Control = %q, want %q", got, imageBrowserCacheControl) - } - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1 due to cloud image cache", got) - } - - rec := httptest.NewRecorder() - if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=poster.png", nil), "openlist:poster.png") { - t.Fatal("ServeCloudCached returned false after the cloud image was cached") - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls after ServeCloudCached = %d, want 1", got) - } - if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { - t.Fatalf("cached body = %x, want cached cloud image", got) - } -} - -func TestImageProxyPrefetchCloudResolvedImage(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/png"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/folder.png"} - if err := proxy.PrefetchCloudResolved(t.Context(), "openlist:folder.png", link); err != nil { - t.Fatal(err) - } - if err := proxy.PrefetchCloudResolved(t.Context(), "openlist:folder.png", link); err != nil { - t.Fatal(err) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1 after prefetch cache hit", got) - } - rec := httptest.NewRecorder() - if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=folder.png", nil), "openlist:folder.png") { - t.Fatal("prefetched cloud image was not served from cache") - } - if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { - t.Fatalf("cached body = %x, want prefetched cloud image", got) - } -} - -func TestImageProxyPrefetchCloudResolvedRefetchesInvalidCache(t *testing.T) { - var calls int32 - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - proxy.client = &http.Client{Transport: imageRoundTripFunc(func(req *http.Request) (*http.Response, error) { - atomic.AddInt32(&calls, 1) - return &http.Response{ - StatusCode: http.StatusOK, - Status: "200 OK", - Header: http.Header{"Content-Type": []string{"image/jpeg"}}, - Body: io.NopCloser(bytes.NewReader(testJPEG)), - Request: req, - }, nil - })} - - stableKey := "openlist:bad-cache-poster.jpg" - _, cachePath, failPath := proxy.cloudImageCachePaths(stableKey) - if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(cachePath, []byte("old bad cache"), 0o600); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { - t.Fatal(err) - } - - link := &cloud.DirectLink{URL: "http://cloud-provider.invalid/bad-cache-poster.jpg"} - if err := proxy.PrefetchCloudResolved(t.Context(), stableKey, link); err != nil { - t.Fatal(err) - } - if got := atomic.LoadInt32(&calls); got != 1 { - t.Fatalf("upstream calls = %d, want 1 after invalid cache cleanup", got) - } - rec := httptest.NewRecorder() - if !proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=bad-cache-poster.jpg", nil), stableKey) { - t.Fatal("refetched cloud image was not served from cache") - } - if got := rec.Body.Bytes(); !bytes.Equal(got, testJPEG) { - t.Fatalf("cached body = %x, want refetched cloud image", got) - } -} - -func TestImageProxyServeCloudCachedSkipsInvalidCache(t *testing.T) { - proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop()) - stableKey := "openlist:invalid-cached-poster.jpg" - _, cachePath, failPath := proxy.cloudImageCachePaths(stableKey) - if err := os.MkdirAll(filepath.Dir(cachePath), 0o750); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(cachePath, transparent1x1PNG, 0o600); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(failPath, []byte("failed"), 0o600); err != nil { - t.Fatal(err) - } - - rec := httptest.NewRecorder() - if proxy.ServeCloudCached(rec, httptest.NewRequest(http.MethodGet, "/api/cloud/play/openlist?ref=invalid-cached-poster.jpg", nil), stableKey) { - t.Fatal("ServeCloudCached should skip invalid cached cloud artwork") - } - if _, err := os.Stat(cachePath); !errors.Is(err, os.ErrNotExist) { - t.Fatalf("invalid cache should be removed, stat err=%v", err) - } - if _, err := os.Stat(failPath); !errors.Is(err, os.ErrNotExist) { - t.Fatalf("stale fail marker should be removed with invalid cache, stat err=%v", err) - } -} - type imageRoundTripFunc func(*http.Request) (*http.Response, error) func (f imageRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {