implement native Deezer download/decrypt pipeline

Replace Deezer yt-dlp usage with native ARL session + media.get_url resolution, add BF_CBC_STRIPE decryption in downloader, and wire cipher-aware Deezer downloads through the main rip pipeline. Includes validation hardening and metadata/source-id improvements used by tagging flows.

internal/provider/deezer/client.go

@@ -8,7 +8,6 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os/exec"
 	"strconv"
 	"strings"
 	"time"
@@ -19,17 +18,24 @@ import (
 	"streamrip-go/internal/ratelimit"
 )
 
-var baseURL = "https://api.deezer.com"
-
-type commandRunner func(ctx context.Context, name string, args ...string) ([]byte, error)
+var (
+	baseURL    = "https://api.deezer.com"
+	webGWLight = "https://www.deezer.com/ajax/gw-light.php"
+	mediaURL   = "https://media.deezer.com/v1/get_url"
+	deezerUA   = "Deezer/9.0.11.4 (Android; 14; Mobile; us) Xiaomi Redmi Note 7"
+)
 
 type Client struct {
 	cfg      *config.Config
 	http     *http.Client
 	limiter  *ratelimit.Limiter
 	loggedIn bool
-	bin      string
-	run      commandRunner
+	sid      string
+	arl      string
+	jwt      string
+	refresh  string
+	license  string
+	userID   string
 }
 
 func New(cfg *config.Config) *Client {
@@ -37,8 +43,7 @@ func New(cfg *config.Config) *Client {
 		cfg:     cfg,
 		http:    netutil.NewHTTPClient(30*time.Second, cfg.Session.Downloads.VerifySSL),
 		limiter: ratelimit.New(cfg.Session.Downloads.RequestsPerMinute),
-		bin:     "yt-dlp",
-		run:     runCommand,
+		arl:     strings.TrimSpace(cfg.Session.Deezer.ARL),
 	}
 }
 
@@ -46,7 +51,13 @@ func (c *Client) Source() string {
 	return "deezer"
 }
 
-func (c *Client) Login(context.Context) error {
+func (c *Client) Login(ctx context.Context) error {
+	c.arl = strings.TrimSpace(c.cfg.Session.Deezer.ARL)
+	if c.arl != "" {
+		if err := c.refreshSessionFromARL(ctx); err != nil {
+			return err
+		}
+	}
 	c.loggedIn = true
 	return nil
 }
@@ -165,158 +176,38 @@ func (c *Client) GetMetadata(ctx context.Context, item, mediaType string) (map[s
 }
 
 func (c *Client) GetDownloadable(ctx context.Context, item string, _ int) (*provider.Downloadable, error) {
+	if strings.TrimSpace(c.arl) == "" {
+		return nil, errors.New("deezer native download requires deezer.arl in config")
+	}
+	if strings.TrimSpace(c.license) == "" {
+		if err := c.refreshSessionFromARL(ctx); err != nil {
+			return nil, err
+		}
+	}
 	meta, err := c.GetMetadata(ctx, item, "track")
 	if err != nil {
 		return nil, err
 	}
-	if c.shouldTryYtDlp() {
-		d, dlErr := c.getDownloadableViaYtDlp(ctx, item, meta)
-		if dlErr == nil {
-			return d, nil
-		}
-		if !c.cfg.Session.Deezer.LowerQualityIfNotAvailable {
-			return nil, fmt.Errorf("deezer full-quality mode failed and fallback is disabled: %w", dlErr)
+	trackToken := strings.TrimSpace(stringFromAny(meta["track_token"]))
+	if trackToken == "" {
+		trackToken, err = c.getTrackToken(ctx, item)
+		if err != nil {
+			return nil, err
 		}
 	}
-	preview := strings.TrimSpace(stringFromAny(meta["preview"]))
-	if preview == "" {
-		return nil, errors.New("deezer track missing preview url")
-	}
-	return &provider.Downloadable{URL: preview, Extension: "mp3", Source: "deezer"}, nil
-}
-
-func (c *Client) shouldTryYtDlp() bool {
-	if c.cfg == nil {
-		return false
-	}
-	if c.cfg.Session.Deezer.UseDeezloader {
-		return true
-	}
-	return strings.TrimSpace(c.cfg.Session.Deezer.ARL) != ""
-}
-
-func (c *Client) getDownloadableViaYtDlp(ctx context.Context, trackID string, meta map[string]any) (*provider.Downloadable, error) {
-	if _, err := exec.LookPath(c.bin); err != nil {
-		return nil, fmt.Errorf("yt-dlp not found for deezer full-quality mode: %w", err)
-	}
-
-	target := strings.TrimSpace(stringFromAny(meta["link"]))
-	if target == "" {
-		target = "https://www.deezer.com/track/" + trackID
-	}
-	args := []string{"-J", "--no-playlist", "--skip-download", "--no-warnings"}
-	if arl := strings.TrimSpace(c.cfg.Session.Deezer.ARL); arl != "" {
-		args = append(args, "--add-header", "Cookie: arl="+arl)
-	}
-	args = append(args, target)
-	b, err := c.run(ctx, c.bin, args...)
+	media, err := c.getMediaURL(ctx, trackToken, c.cfg.Session.Deezer.Quality, c.cfg.Session.Deezer.LowerQualityIfNotAvailable)
 	if err != nil {
 		return nil, err
 	}
-	info := map[string]any{}
-	if err = json.Unmarshal(b, &info); err != nil {
-		return nil, err
-	}
-	f := selectDeezerFormat(info, c.cfg.Session.Deezer.Quality)
-	if f.url == "" {
-		return nil, errors.New("yt-dlp output missing downloadable format url")
-	}
-	ext := f.ext
+	ext := extensionForFormat(media.Format)
 	if ext == "" {
 		ext = "mp3"
 	}
-	return &provider.Downloadable{URL: f.url, Extension: ext, Source: "deezer"}, nil
-}
-
-type deezerFormat struct {
-	url string
-	ext string
-	abr int
-}
-
-func selectDeezerFormat(info map[string]any, quality int) deezerFormat {
-	formats, _ := info["formats"].([]any)
-	selected := deezerFormat{}
-
-	pick := func(candidate deezerFormat, better func(cur, next deezerFormat) bool) {
-		if candidate.url == "" {
-			return
-		}
-		if selected.url == "" || better(selected, candidate) {
-			selected = candidate
-		}
+	trackID := strings.TrimSpace(stringFromAny(meta["id"]))
+	if trackID == "" {
+		trackID = strings.TrimSpace(item)
 	}
-
-	for _, raw := range formats {
-		m, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		if strings.TrimSpace(stringFromAny(m["vcodec"])) != "none" {
-			continue
-		}
-		cand := deezerFormat{
-			url: strings.TrimSpace(stringFromAny(m["url"])),
-			ext: strings.TrimSpace(stringFromAny(m["ext"])),
-			abr: intFromAny(m["abr"]),
-		}
-		if quality >= 2 {
-			pick(cand, func(cur, next deezerFormat) bool {
-				curFlac := strings.EqualFold(cur.ext, "flac")
-				nextFlac := strings.EqualFold(next.ext, "flac")
-				if curFlac != nextFlac {
-					return nextFlac
-				}
-				return next.abr > cur.abr
-			})
-			continue
-		}
-		if quality == 1 {
-			pick(cand, func(cur, next deezerFormat) bool {
-				curScore := abrScore(cur.abr, 320)
-				nextScore := abrScore(next.abr, 320)
-				if curScore == nextScore {
-					return next.abr > cur.abr
-				}
-				return nextScore > curScore
-			})
-			continue
-		}
-		pick(cand, func(cur, next deezerFormat) bool {
-			curScore := abrScore(cur.abr, 128)
-			nextScore := abrScore(next.abr, 128)
-			if curScore == nextScore {
-				if cur.abr == 0 {
-					return next.abr > 0
-				}
-				if next.abr == 0 {
-					return false
-				}
-				return next.abr < cur.abr
-			}
-			return nextScore > curScore
-		})
-	}
-
-	if selected.url != "" {
-		return selected
-	}
-
-	rootURL := strings.TrimSpace(stringFromAny(info["url"]))
-	if rootURL == "" {
-		return deezerFormat{}
-	}
-	return deezerFormat{url: rootURL, ext: strings.TrimSpace(stringFromAny(info["ext"])), abr: intFromAny(info["abr"])}
-}
-
-func abrScore(abr int, target int) int {
-	if abr <= 0 {
-		return -1
-	}
-	if abr > target {
-		return target - (abr-target)*2
-	}
-	return abr
+	return &provider.Downloadable{URL: media.URL, Extension: ext, Source: "deezer", Cipher: media.Cipher, TrackID: trackID}, nil
 }
 
 func (c *Client) apiGet(ctx context.Context, path string, params url.Values) (map[string]any, error) {
@@ -365,6 +256,227 @@ func (c *Client) apiGet(ctx context.Context, path string, params url.Values) (ma
 	return out, nil
 }
 
+func (c *Client) refreshSessionFromARL(ctx context.Context) error {
+	if strings.TrimSpace(c.arl) == "" {
+		return errors.New("missing deezer arl")
+	}
+	if err := c.limiter.Wait(ctx); err != nil {
+		return err
+	}
+	params := url.Values{}
+	params.Set("method", "deezer.getUserData")
+	params.Set("input", "3")
+	params.Set("api_version", "1.0")
+	params.Set("api_token", "")
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, webGWLight+"?"+params.Encode(), nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", deezerUA)
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Cookie", "arl="+strings.TrimSpace(c.arl))
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("deezer getUserData failed: status=%d body=%s", resp.StatusCode, string(raw))
+	}
+	out := map[string]any{}
+	if err = json.Unmarshal(raw, &out); err != nil {
+		return err
+	}
+	if errObj, ok := out["error"].(map[string]any); ok && len(errObj) > 0 {
+		return fmt.Errorf("deezer getUserData error: %s", stringFromAny(errObj["message"]))
+	}
+	results, _ := out["results"].(map[string]any)
+	if len(results) == 0 {
+		return errors.New("deezer getUserData returned empty results")
+	}
+	c.license = findStringByKey(results, "license_token")
+	c.userID = findStringByKey(results, "USER_ID")
+	if c.license == "" {
+		return errors.New("deezer getUserData missing license_token")
+	}
+	return nil
+}
+
+func (c *Client) getTrackToken(ctx context.Context, trackID string) (string, error) {
+	resp, err := c.apiGet(ctx, "/track/"+url.PathEscape(strings.TrimSpace(trackID)), nil)
+	if err != nil {
+		return "", err
+	}
+	token := strings.TrimSpace(stringFromAny(resp["track_token"]))
+	if token == "" {
+		return "", errors.New("deezer track metadata missing track_token")
+	}
+	return token, nil
+}
+
+type mediaResult struct {
+	URL    string
+	Format string
+	Cipher string
+}
+
+func (c *Client) getMediaURL(ctx context.Context, trackToken string, quality int, allowFallback bool) (*mediaResult, error) {
+	requestedFormats := buildFormatPriority(quality, allowFallback)
+	var lastErr error
+	for _, format := range requestedFormats {
+		result, err := c.getMediaURLForFormat(ctx, trackToken, format)
+		if err == nil {
+			return result, nil
+		}
+		lastErr = err
+		if !allowFallback {
+			break
+		}
+	}
+	if lastErr != nil {
+		return nil, lastErr
+	}
+	return nil, errors.New("deezer media response contains no playable variants")
+}
+
+func (c *Client) getMediaURLForFormat(ctx context.Context, trackToken, format string) (*mediaResult, error) {
+	if strings.TrimSpace(c.license) == "" {
+		return nil, errors.New("missing deezer license token")
+	}
+	if err := c.limiter.Wait(ctx); err != nil {
+		return nil, err
+	}
+
+	reqBody := map[string]any{
+		"license_token": c.license,
+		"track_tokens":  []string{trackToken},
+		"media": []map[string]any{{
+			"type":    "FULL",
+			"formats": []map[string]string{{"cipher": "BF_CBC_STRIPE", "format": format}, {"cipher": "NONE", "format": format}},
+		}},
+	}
+	b, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, mediaURL, strings.NewReader(string(b)))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", deezerUA)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Content-Type", "text/plain; charset=UTF-8")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("deezer media get_url failed: status=%d body=%s", resp.StatusCode, string(raw))
+	}
+	var parsed struct {
+		Data []struct {
+			Errors []struct {
+				Code    int    `json:"code"`
+				Message string `json:"message"`
+			} `json:"errors"`
+			Media []struct {
+				Cipher struct {
+					Type string `json:"type"`
+				} `json:"cipher"`
+				Format  string `json:"format"`
+				Sources []struct {
+					URL string `json:"url"`
+				} `json:"sources"`
+			} `json:"media"`
+		} `json:"data"`
+	}
+	if err = json.Unmarshal(raw, &parsed); err != nil {
+		return nil, err
+	}
+	if len(parsed.Data) == 0 {
+		return nil, errors.New("deezer media response contains no data")
+	}
+	if len(parsed.Data[0].Errors) > 0 {
+		e := parsed.Data[0].Errors[0]
+		if strings.Contains(strings.ToLower(e.Message), "drm") {
+			return nil, errors.New("deezer media is DRM protected for this format/account")
+		}
+		return nil, fmt.Errorf("deezer media error %d: %s", e.Code, e.Message)
+	}
+	for _, m := range parsed.Data[0].Media {
+		if len(m.Sources) == 0 || strings.TrimSpace(m.Sources[0].URL) == "" {
+			continue
+		}
+		return &mediaResult{URL: m.Sources[0].URL, Format: m.Format, Cipher: m.Cipher.Type}, nil
+	}
+	return nil, errors.New("deezer media response contains no sources")
+}
+
+func buildFormatPriority(quality int, allowFallback bool) []string {
+	want := "FLAC"
+	if quality <= 0 {
+		want = "MP3_128"
+	} else if quality == 1 {
+		want = "MP3_320"
+	}
+	priority := []string{want}
+	if allowFallback {
+		for _, f := range []string{"FLAC", "MP3_320", "MP3_128"} {
+			if f != want {
+				priority = append(priority, f)
+			}
+		}
+	}
+	return priority
+}
+
+func extensionForFormat(format string) string {
+	switch strings.ToUpper(strings.TrimSpace(format)) {
+	case "FLAC":
+		return "flac"
+	case "MP3_320", "MP3_128", "MP3_64", "MP3_MISC":
+		return "mp3"
+	default:
+		return "mp3"
+	}
+}
+
+func findStringByKey(v any, wantedKey string) string {
+	w := strings.ToLower(strings.TrimSpace(wantedKey))
+	switch x := v.(type) {
+	case map[string]any:
+		for k, value := range x {
+			if strings.ToLower(k) == w {
+				if s := stringFromAny(value); strings.TrimSpace(s) != "" {
+					return s
+				}
+			}
+			if nested := findStringByKey(value, wantedKey); nested != "" {
+				return nested
+			}
+		}
+	case []any:
+		for _, item := range x {
+			if nested := findStringByKey(item, wantedKey); nested != "" {
+				return nested
+			}
+		}
+	}
+	return ""
+}
+
 func enrichTrack(track map[string]any) {
 	if artist, ok := track["artist"].(map[string]any); ok {
 		track["performer"] = map[string]any{"name": stringFromAny(artist["name"]), "id": stringFromAny(artist["id"])}
@@ -452,12 +564,3 @@ func boolFromAny(v any) bool {
 	b, ok := v.(bool)
 	return ok && b
 }
-
-func runCommand(ctx context.Context, name string, args ...string) ([]byte, error) {
-	cmd := exec.CommandContext(ctx, name, args...)
-	b, err := cmd.CombinedOutput()
-	if err != nil {
-		return nil, fmt.Errorf("command %s failed: %w: %s", name, err, string(b))
-	}
-	return b, nil
-}

internal/provider/deezer/client_test.go

@@ -3,7 +3,6 @@ package deezer
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -14,12 +13,11 @@ import (
 
 func TestSearchTrack(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/search/track":
+		if r.URL.Path == "/search/track" {
 			_ = json.NewEncoder(w).Encode(map[string]any{"data": []any{map[string]any{"id": 1, "title": "Dreams", "artist": map[string]any{"name": "Fleetwood Mac"}}}})
-		default:
-			w.WriteHeader(http.StatusNotFound)
+			return
 		}
+		w.WriteHeader(http.StatusNotFound)
 	}))
 	defer ts.Close()
 
@@ -27,9 +25,9 @@ func TestSearchTrack(t *testing.T) {
 	c := New(&config.Config{File: cfgData, Session: cfgData})
 	c.loggedIn = true
 
-	orig := baseURL
+	origBase := baseURL
 	baseURL = ts.URL
-	defer func() { baseURL = orig }()
+	defer func() { baseURL = origBase }()
 
 	pages, err := c.Search(context.Background(), "track", "dreams", 5)
 	if err != nil {
@@ -40,11 +38,13 @@ func TestSearchTrack(t *testing.T) {
 	}
 }
 
-func TestGetDownloadableUsesPreview(t *testing.T) {
+func TestGetDownloadableNativeCipher(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/track/42":
-			_ = json.NewEncoder(w).Encode(map[string]any{"id": 42, "title": "X", "preview": "https://cdn.example/p.mp3"})
+			_ = json.NewEncoder(w).Encode(map[string]any{"id": 42, "title": "X", "track_token": "tt"})
+		case "/media":
+			_ = json.NewEncoder(w).Encode(map[string]any{"data": []any{map[string]any{"errors": []any{}, "media": []any{map[string]any{"cipher": map[string]any{"type": "BF_CBC_STRIPE"}, "format": "FLAC", "sources": []any{map[string]any{"url": "https://cdn.example/file"}}}}}}})
 		default:
 			w.WriteHeader(http.StatusNotFound)
 		}
@@ -52,31 +52,48 @@ func TestGetDownloadableUsesPreview(t *testing.T) {
 	defer ts.Close()
 
 	cfgData := config.DefaultConfigData()
+	cfgData.Deezer.ARL = "arl"
 	c := New(&config.Config{File: cfgData, Session: cfgData})
 	c.loggedIn = true
-	orig := baseURL
-	baseURL = ts.URL
-	defer func() { baseURL = orig }()
+	c.arl = "arl"
+	c.license = "license"
 
-	d, err := c.GetDownloadable(context.Background(), "42", 0)
+	origBase := baseURL
+	origMedia := mediaURL
+	baseURL = ts.URL
+	mediaURL = ts.URL + "/media"
+	defer func() {
+		baseURL = origBase
+		mediaURL = origMedia
+	}()
+
+	d, err := c.GetDownloadable(context.Background(), "42", 2)
 	if err != nil {
 		t.Fatalf("GetDownloadable() error = %v", err)
 	}
-	if d.URL != "https://cdn.example/p.mp3" || d.Extension != "mp3" {
+	if d.Cipher != "BF_CBC_STRIPE" || d.Extension != "flac" || d.TrackID != "42" {
 		t.Fatalf("unexpected downloadable: %+v", d)
 	}
 }
 
-func TestGetMetadataSetsExplicitFromBool(t *testing.T) {
+func TestGetDownloadableRequiresARL(t *testing.T) {
+	cfgData := config.DefaultConfigData()
+	cfgData.Deezer.ARL = ""
+	c := New(&config.Config{File: cfgData, Session: cfgData})
+	c.loggedIn = true
+	_, err := c.GetDownloadable(context.Background(), "42", 2)
+	if err == nil || !strings.Contains(strings.ToLower(err.Error()), "arl") {
+		t.Fatalf("expected arl requirement error, got %v", err)
+	}
+}
+
+func TestGetDownloadableDRMError(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
-		case "/track/9":
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"id":              9,
-				"title":           "X",
-				"explicit_lyrics": true,
-				"artist":          map[string]any{"name": "Artist"},
-			})
+		case "/track/42":
+			_ = json.NewEncoder(w).Encode(map[string]any{"id": 42, "title": "X", "track_token": "tt"})
+		case "/media":
+			_ = json.NewEncoder(w).Encode(map[string]any{"data": []any{map[string]any{"errors": []any{map[string]any{"code": 403, "message": "DRM required"}}, "media": []any{}}}})
 		default:
 			w.WriteHeader(http.StatusNotFound)
 		}
@@ -84,69 +101,23 @@ func TestGetMetadataSetsExplicitFromBool(t *testing.T) {
 	defer ts.Close()
 
 	cfgData := config.DefaultConfigData()
+	cfgData.Deezer.ARL = "arl"
 	c := New(&config.Config{File: cfgData, Session: cfgData})
 	c.loggedIn = true
-	orig := baseURL
+	c.arl = "arl"
+	c.license = "license"
+
+	origBase := baseURL
+	origMedia := mediaURL
 	baseURL = ts.URL
-	defer func() { baseURL = orig }()
-
-	meta, err := c.GetMetadata(context.Background(), "9", "track")
-	if err != nil {
-		t.Fatalf("GetMetadata() error = %v", err)
-	}
-	if explicit, _ := meta["explicit"].(bool); !explicit {
-		t.Fatalf("expected explicit=true, got %#v", meta["explicit"])
-	}
-}
-
-func TestSearchReturnsStructuredAPIError(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/search/track" {
-			_ = json.NewEncoder(w).Encode(map[string]any{"error": map[string]any{"message": "invalid query"}})
-			return
-		}
-		w.WriteHeader(http.StatusNotFound)
-	}))
-	defer ts.Close()
-
-	cfgData := config.DefaultConfigData()
-	c := New(&config.Config{File: cfgData, Session: cfgData})
-	c.loggedIn = true
-	orig := baseURL
-	baseURL = ts.URL
-	defer func() { baseURL = orig }()
-
-	_, err := c.Search(context.Background(), "track", "", 5)
-	if err == nil || !strings.Contains(err.Error(), "invalid query") {
-		t.Fatalf("expected structured deezer error, got %v", err)
-	}
-}
-
-func TestGetDownloadableErrorsWhenFullQualityFailsAndFallbackDisabled(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/track/42" {
-			_ = json.NewEncoder(w).Encode(map[string]any{"id": 42, "title": "X", "preview": "https://cdn.example/p.mp3"})
-			return
-		}
-		w.WriteHeader(http.StatusNotFound)
-	}))
-	defer ts.Close()
-
-	cfgData := config.DefaultConfigData()
-	cfgData.Deezer.UseDeezloader = true
-	cfgData.Deezer.LowerQualityIfNotAvailable = false
-	c := New(&config.Config{File: cfgData, Session: cfgData})
-	c.loggedIn = true
-	c.bin = "definitely-not-a-real-yt-dlp-bin"
-	c.run = func(context.Context, string, ...string) ([]byte, error) {
-		return nil, fmt.Errorf("unexpected run call")
-	}
-	orig := baseURL
-	baseURL = ts.URL
-	defer func() { baseURL = orig }()
+	mediaURL = ts.URL + "/media"
+	defer func() {
+		baseURL = origBase
+		mediaURL = origMedia
+	}()
 
 	_, err := c.GetDownloadable(context.Background(), "42", 2)
-	if err == nil || !strings.Contains(err.Error(), "full-quality mode failed") {
-		t.Fatalf("expected full-quality failure error, got %v", err)
+	if err == nil || !strings.Contains(strings.ToLower(err.Error()), "drm") {
+		t.Fatalf("expected drm error, got %v", err)
 	}
 }