taler-merchant-demos

app_test.go (26540B)

---

 package web
 
 import (
 	"encoding/json"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"strings"
 	"testing"
 	"time"
 
 	"git.taler.net/taler-merchant-demos/internal/backend"
 )
 
 func TestLandingRoutesAndEmbeddedStatic(t *testing.T) {
 	app, err := New(Options{Shop: "landing", Currency: "KUDOS"})
 	if err != nil {
 		t.Fatal(err)
 	}
 	request := httptest.NewRequest(http.MethodGet, "/", nil)
 	request.Header.Set("Accept-Language", "de-DE,de;q=0.9,en;q=0.5")
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || response.Header().Get("Location") != "/de/" {
 		t.Fatalf("root response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 	request = httptest.NewRequest(http.MethodGet, "/", nil)
 	request.Header.Set("Accept-Language", "fr;q=0,en;q=1")
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Header().Get("Location") != "/en/" {
 		t.Fatalf("quality-weighted location = %q", response.Header().Get("Location"))
 	}
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/en", nil))
 	if response.Code != http.StatusPermanentRedirect || response.Header().Get("Location") != "/en/" {
 		t.Fatalf("canonical language redirect = %d, %q", response.Code, response.Header().Get("Location"))
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/en/", nil))
 	body := response.Body.String()
 	if response.Code != http.StatusOK || !strings.Contains(body, "Step 1: Install the wallet") {
 		t.Fatalf("landing response = %d, %q", response.Code, response.Body.String())
 	}
 	for _, expected := range []string{
 		`class="site-header"`, `class="heading-lockup"`, `class="demo-nav"`, `class="step-list"`,
 		`taler-logo-light.svg`, `taler-logo-dark.svg`, `aria-current="page"`, `class="link-icon"`,
 	} {
 		if !strings.Contains(body, expected) {
 			t.Errorf("landing response missing branded shell marker %q", expected)
 		}
 	}
 	if strings.Contains(body, "pure.css") || strings.Contains(body, "style=") {
 		t.Errorf("landing response still includes legacy presentation markup")
 	}
 	if response.Header().Get("Cache-Control") != "private, no-store" {
 		t.Fatalf("dynamic cache policy = %q", response.Header().Get("Cache-Control"))
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/static/demo.css", nil))
 	if response.Code != http.StatusOK || response.Header().Get("Content-Type") != "text/css; charset=utf-8" {
 		t.Fatalf("static response = %d, type %q", response.Code, response.Header().Get("Content-Type"))
 	}
 	if strings.Contains(response.Body.String(), "url(/static/") {
 		t.Fatalf("static stylesheet bypasses the forwarded prefix: %q", response.Body.String())
 	}
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/static/blog.css", nil))
 	if response.Code != http.StatusOK || strings.Contains(response.Body.String(), "url(/static/") {
 		t.Fatalf("blog stylesheet response = %d, body %q", response.Code, response.Body.String())
 	}
 	for _, asset := range []string{"/static/taler-logo-light.svg", "/static/taler-logo-dark.svg"} {
 		response = httptest.NewRecorder()
 		app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, asset, nil))
 		if response.Code != http.StatusOK || response.Header().Get("Content-Type") != "image/svg+xml" {
 			t.Errorf("logo response for %s = %d, type %q", asset, response.Code, response.Header().Get("Content-Type"))
 		}
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodPost, "/en/", nil))
 	if response.Code != http.StatusMethodNotAllowed {
 		t.Fatalf("POST language index response = %d", response.Code)
 	}
 }
 
 func TestPagesUseConfiguredPublicURLs(t *testing.T) {
 	app, err := New(Options{
 		Shop: "landing", Currency: "KUDOS",
 		PublicURLs: PublicURLs{
 			Landing: "https://landing.example/", Bank: "https://bank.example/",
 			Blog: "https://blog.example/", Donations: "https://donations.example/",
 		},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/de/", nil))
 	if response.Code != http.StatusOK {
 		t.Fatalf("response status = %d", response.Code)
 	}
 	body := response.Body.String()
 	for _, expected := range []string{
 		`href="https://landing.example/de/"`,
 		`href="https://bank.example/de/"`,
 		`href="https://blog.example/de/"`,
 		`href="https://donations.example/de/"`,
 	} {
 		if !strings.Contains(body, expected) {
 			t.Errorf("response missing configured public URL %q", expected)
 		}
 	}
 }
 
 func TestDemoPagesUseDistinctBrandThemes(t *testing.T) {
 	merchant, err := backend.New("https://merchant.example/", "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	tests := []struct {
 		shop       string
 		stylesheet string
 		component  string
 	}{
 		{shop: "landing", component: `class="step-card"`},
 		{shop: "blog", stylesheet: "colors-blog.css", component: `class="article-card"`},
 		{shop: "donations", stylesheet: "colors-donations.css", component: `class="demo-form form-card"`},
 	}
 	for _, test := range tests {
 		t.Run(test.shop, func(t *testing.T) {
 			options := Options{Shop: test.shop, Currency: "KUDOS"}
 			switch test.shop {
 			case "blog":
 				options.BlogBackend = merchant
 			case "donations":
 				options.DonationBackends = map[string]*backend.Client{"gnunet": merchant, "taler": merchant, "tor": merchant}
 			}
 			app, err := New(options)
 			if err != nil {
 				t.Fatal(err)
 			}
 			response := httptest.NewRecorder()
 			app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/en/", nil))
 			body := response.Body.String()
 			if response.Code != http.StatusOK {
 				t.Fatalf("response status = %d", response.Code)
 			}
 			if !strings.Contains(body, test.component) {
 				t.Errorf("response missing themed component %q", test.component)
 			}
 			if strings.Contains(body, `>Bank<svg class="link-icon"`) {
 				t.Error("response contains external-link icon on Bank navigation item")
 			}
 			if test.stylesheet != "" && !strings.Contains(body, test.stylesheet) {
 				t.Errorf("response missing theme stylesheet %q", test.stylesheet)
 			}
 			if test.shop == "blog" {
 				for _, marker := range []string{`id="edition-info-button"`, `<dialog class="fsfs-license"`, `KUDOS:0.5`} {
 					if !strings.Contains(body, marker) {
 						t.Errorf("blog response missing %q", marker)
 					}
 				}
 				if strings.Contains(body, `<h2>Chapters</h2>`) {
 					t.Error("blog response contains redundant chapters heading")
 				}
 			}
 		})
 	}
 }
 
 func TestDonationCheckoutUsesBrandedPaymentCards(t *testing.T) {
 	merchant, err := backend.New("https://merchant.example/", "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{
 		Shop: "donations", Currency: "KUDOS",
 		DonationBackends: map[string]*backend.Client{"gnunet": merchant, "taler": merchant, "tor": merchant},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 	response := httptest.NewRecorder()
 	request := httptest.NewRequest(http.MethodGet, "/en/checkout?donation_receiver=taler&donation_amount=KUDOS%3A1&donation_donor=Alice", nil)
 	app.ServeHTTP(response, request)
 	body := response.Body.String()
 	if response.Code != http.StatusOK {
 		t.Fatalf("checkout response = %d, body %q", response.Code, body)
 	}
 	if strings.Count(body, `class="payment-option"`) != 4 || !strings.Contains(body, `class="checkout-card"`) {
 		t.Errorf("checkout response is missing branded payment cards: %q", body)
 	}
 	if !strings.Contains(body, `value="taler" checked`) {
 		t.Errorf("checkout response no longer defaults to Taler")
 	}
 
 	response = httptest.NewRecorder()
 	request = httptest.NewRequest(http.MethodGet, "/en/donate?donation_receiver=taler&donation_amount=KUDOS%3A1&donation_donor=Alice&payment_system=lisa", nil)
 	app.ServeHTTP(response, request)
 	wantLocation := "/en/provider-not-supported?donation_amount=KUDOS%3A1&donation_donor=Alice&donation_receiver=taler"
 	if response.Code != http.StatusFound || response.Header().Get("Location") != wantLocation {
 		t.Fatalf("unsupported provider response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, wantLocation, nil))
 	body = response.Body.String()
 	if response.Code != http.StatusOK || !strings.Contains(body, "Back to payment methods") || !strings.Contains(body, `href="/en/checkout?donation_amount=KUDOS%3A1&amp;donation_donor=Alice&amp;donation_receiver=taler"`) {
 		t.Fatalf("unsupported provider return action missing: status %d, body %q", response.Code, body)
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/en/provider-not-supported", nil))
 	body = response.Body.String()
 	if response.Code != http.StatusOK || !strings.Contains(body, "Back to donations") || !strings.Contains(body, `href="/en/"`) {
 		t.Fatalf("direct unsupported provider fallback missing: status %d, body %q", response.Code, body)
 	}
 }
 
 func TestUnsupportedLocalesFallBackToEnglish(t *testing.T) {
 	app, err := New(Options{Shop: "landing", Currency: "KUDOS"})
 	if err != nil {
 		t.Fatal(err)
 	}
 	request := httptest.NewRequest(http.MethodGet, "/", nil)
 	request.Header.Set("Accept-Language", "ar,zh;q=0.9")
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Header().Get("Location") != "/en/" {
 		t.Fatalf("unsupported language negotiation location = %q", response.Header().Get("Location"))
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/ar/", nil))
 	if response.Code != http.StatusTemporaryRedirect || response.Header().Get("Location") != "/en/" {
 		t.Fatalf("unsupported locale response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 }
 
 func TestLocaleRedirects(t *testing.T) {
 	merchant, err := backend.New("https://merchant.example/", "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, shop := range []string{"landing", "blog", "donations"} {
 		t.Run(shop, func(t *testing.T) {
 			app, err := New(Options{
 				Shop: shop, Currency: "KUDOS", BlogBackend: merchant,
 				DonationBackends: map[string]*backend.Client{"gnunet": merchant, "taler": merchant, "tor": merchant},
 			})
 			if err != nil {
 				t.Fatal(err)
 			}
 			for _, test := range []struct {
 				path, prefix, location string
 				status                 int
 			}{
 				{"/de_CH/", "", "/de/", 307},
 				{"/de-CH", "", "/de/", 307},
 				{"/DE-ch/", "", "/de/", 307},
 				{"/fr_CA/checkout?donor=A%2BB&x=1&x=2", "/demo", "/demo/fr/checkout?donor=A%2BB&x=1&x=2", 307},
 				{"/de_CH/essay/a%2Fb/data/c%20d?order_id=123", "", "/de/essay/a%2Fb/data/c%20d?order_id=123", 307},
 				{"/xx/", "", "/en/", 307},
 				{"/zzz_ZZ/checkout?x=1", "", "/en/checkout?x=1", 307},
 				{"/de?x=1", "", "/de/?x=1", 308},
 				{"/en/", "", "", 200},
 				{"/en/not-a-page", "", "", 404},
 				{"/favicon.ico", "", "", 404},
 				{"/not-a-locale/", "", "", 404},
 				{"/de__CH/", "", "", 404},
 				{"/static/missing.css", "", "", 404},
 				{"/de_CH/", "//evil.example", "/de/", 307},
 			} {
 				t.Run(test.path+test.prefix, func(t *testing.T) {
 					request := httptest.NewRequest(http.MethodGet, test.path, nil)
 					request.Header.Set("Accept-Language", "fr")
 					request.Header.Set("X-Forwarded-Prefix", test.prefix)
 					response := httptest.NewRecorder()
 					app.ServeHTTP(response, request)
 					if response.Code != test.status || response.Header().Get("Location") != test.location {
 						t.Fatalf("response = %d, %q; want %d, %q", response.Code, response.Header().Get("Location"), test.status, test.location)
 					}
 				})
 			}
 		})
 	}
 }
 
 func TestLocaleRedirectPreservesPostBody(t *testing.T) {
 	app, err := New(Options{Shop: "landing", Currency: "KUDOS"})
 	if err != nil {
 		t.Fatal(err)
 	}
 	app.routes.HandleFunc("POST /{lang}/echo", func(w http.ResponseWriter, r *http.Request) {
 		if r.PathValue("lang") != "de" || r.URL.RawQuery != "order_id=123" {
 			t.Errorf("redirected request = %s", r.URL)
 		}
 		_, _ = io.Copy(w, r.Body)
 	})
 	server := httptest.NewServer(app)
 	defer server.Close()
 	response, err := server.Client().Post(server.URL+"/de_CH/echo?order_id=123", "application/x-www-form-urlencoded", strings.NewReader("amount=10&reason=A%2BB"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil || response.StatusCode != 200 || string(body) != "amount=10&reason=A%2BB" {
 		t.Fatalf("POST response = %d, %q, %v", response.StatusCode, body, err)
 	}
 }
 
 func TestErrorsKeepLocalizedSummary(t *testing.T) {
 	merchant := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusInternalServerError)
 		_, _ = w.Write([]byte(`{"hint":"technical backend detail","code":42}`))
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{
 		Shop: "donations", Currency: "KUDOS",
 		DonationBackends: map[string]*backend.Client{"gnunet": client, "taler": client, "tor": client},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/de/donation/taler?order_id=order-1", nil))
 	body := response.Body.String()
 	if response.Code != http.StatusBadGateway || !strings.Contains(body, "<p>Backend-Anfrage fehlgeschlagen</p>") {
 		t.Fatalf("localized backend error response = %d, body %q", response.Code, body)
 	}
 	if strings.Contains(body, "<p>technical backend detail</p>") {
 		t.Fatalf("technical backend detail replaced localized summary: %q", body)
 	}
 	if !strings.Contains(body, "<pre>technical backend detail</pre>") {
 		t.Fatalf("technical backend detail was not rendered: %q", body)
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/de/checkout", nil))
 	if response.Code != http.StatusBadRequest || !strings.Contains(response.Body.String(), "Der Parameter donation_receiver ist erforderlich.") {
 		t.Fatalf("localized missing parameter response = %d, body %q", response.Code, response.Body.String())
 	}
 }
 
 func TestBlogStartsCookieCheckBeforeBackend(t *testing.T) {
 	merchant := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
 		t.Fatal("backend called before cookie check completed")
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{Shop: "blog", Currency: "KUDOS", BlogBackend: client})
 	if err != nil {
 		t.Fatal(err)
 	}
 	articles := sortedArticles(app.articles["en"])
 	if len(articles) == 0 {
 		t.Fatal("no English articles loaded")
 	}
 	request := httptest.NewRequest(http.MethodGet, "/en/essay/"+articles[0].Slug, nil)
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || !strings.Contains(response.Header().Get("Location"), "expect_state=yes") {
 		t.Fatalf("article response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 	if !strings.Contains(response.Header().Get("Set-Cookie"), sessionCookieName+"=") {
 		t.Fatalf("session cookie missing: %q", response.Header().Get("Set-Cookie"))
 	}
 }
 
 func TestBlogCreatesCurrentMerchantOrder(t *testing.T) {
 	var posted backend.PostOrderRequest
 	merchant := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.Method == http.MethodGet && r.URL.Path == "/private/orders":
 			_ = json.NewEncoder(w).Encode(map[string]any{"orders": []any{}})
 		case r.Method == http.MethodPost && r.URL.Path == "/private/orders":
 			_ = json.NewDecoder(r.Body).Decode(&posted)
 			_ = json.NewEncoder(w).Encode(map[string]any{"order_id": "order-1", "token": "claim-1"})
 		case r.Method == http.MethodGet && r.URL.Path == "/private/orders/order-1":
 			_ = json.NewEncoder(w).Encode(map[string]any{
 				"order_status": "paid", "refunded": false,
 				"contract_terms": map[string]any{
 					"extra":           map[string]any{"article_name": r.Header.Get("X-Test-Article")},
 					"refund_deadline": map[string]any{"t_s": time.Now().Add(time.Minute).Unix()},
 				},
 			})
 		default:
 			http.Error(w, "unexpected request", http.StatusNotFound)
 		}
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{Shop: "blog", Currency: "KUDOS", BlogBackend: client, EnableTokens: true})
 	if err != nil {
 		t.Fatal(err)
 	}
 	article := sortedArticles(app.articles["de"])[0]
 	articlePath := "/de/essay/" + article.Slug
 	request := httptest.NewRequest(http.MethodGet, articlePath, nil)
 	request.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "browser-session"})
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || !strings.Contains(response.Header().Get("Location"), "/orders/order-1?") {
 		t.Fatalf("purchase response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 	if posted.SessionID != "browser-session" || !posted.CreateToken {
 		t.Fatalf("post-order envelope = %#v", posted)
 	}
 	if posted.Order.Version != 1 {
 		t.Fatalf("order version = %d", posted.Order.Version)
 	}
 	if len(posted.Order.Choices) != 3 || posted.Order.Choices[0].Description != "Einen einzelnen Artikel kaufen" || posted.Order.Choices[1].Description != "Einen Monat unbegrenzten Zugriff kaufen" {
 		t.Fatalf("localized order choices = %#v", posted.Order.Choices)
 	}
 	if posted.RefundDelay.Microseconds != time.Hour.Microseconds() {
 		t.Fatalf("refund delay = %d microseconds", posted.RefundDelay.Microseconds)
 	}
 	if posted.Order.WireTransferDeadline.Seconds <= posted.Order.PayDeadline.Seconds+int64(time.Hour/time.Second) {
 		t.Fatalf("wire deadline does not allow the advertised refund window: %#v", posted.Order)
 	}
 }
 
 func TestDonationReceiptOrderAndFulfillment(t *testing.T) {
 	var posted backend.PostOrderRequest
 	merchant := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.Method {
 		case http.MethodPost:
 			_ = json.NewDecoder(r.Body).Decode(&posted)
 			_ = json.NewEncoder(w).Encode(map[string]any{"order_id": "donation-1"})
 		case http.MethodGet:
 			_ = json.NewEncoder(w).Encode(map[string]any{
 				"order_status": "paid",
 				"contract_terms": map[string]any{"extra": map[string]any{
 					"receiver": "taler", "amount": "KUDOS:1", "donor": "<script>alert(1)</script>",
 				}},
 			})
 		}
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{
 		Shop: "donations", Currency: "KUDOS", DonauURL: "https://donau.example/",
 		DonationBackends: map[string]*backend.Client{"gnunet": client, "taler": client, "tor": client},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 	request := httptest.NewRequest(http.MethodGet, "http://demo.example/en/donate?donation_receiver=taler&donation_amount=KUDOS%3A1&donation_donor=Alice&payment_system=taler", nil)
 	request.Header.Set("X-Forwarded-Prefix", "/merchant")
 	request.Header.Set("X-Forwarded-Proto", "https")
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || response.Header().Get("Location") != "/merchant/en/donation/taler?order_id=donation-1" {
 		t.Fatalf("donation response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 	if !strings.HasPrefix(posted.Order.FulfillmentURL, "https://demo.example/merchant/en/donation/taler?") {
 		t.Fatalf("fulfillment URL = %q", posted.Order.FulfillmentURL)
 	}
 
 	request = httptest.NewRequest(http.MethodGet, "http://demo.example/de/donate?donation_receiver=taler&donation_amount=KUDOS%3A1&donation_donor=Alice&payment_system=taler", nil)
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || posted.Order.Summary != "Spende an taler (mit Spendenquittung)" {
 		t.Fatalf("localized donation order response = %d, order = %#v", response.Code, posted.Order)
 	}
 	output := posted.Order.Choices[0].Outputs[0]
 	if output.Type != "tax-receipt" || output.TokenFamilySlug != "" || output.Amount != "" {
 		t.Fatalf("tax receipt output = %#v", output)
 	}
 
 	request = httptest.NewRequest(http.MethodGet, "http://demo.example/en/donation/taler?order_id=donation-1", nil)
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	body := response.Body.String()
 	if response.Code != http.StatusOK || strings.Contains(body, "<script>alert(1)</script>") || !strings.Contains(body, "&lt;script&gt;alert(1)&lt;/script&gt;") {
 		t.Fatalf("fulfillment response = %d, body %q", response.Code, response.Body.String())
 	}
 	for _, marker := range []string{`data-copy-value="http://demo.example/en/donation/taler?order_id=donation-1"`, "Copy receipt link", "Donate again", `role="status" hidden`} {
 		if !strings.Contains(body, marker) {
 			t.Errorf("fulfillment response missing receipt action %q", marker)
 		}
 	}
 }
 
 func TestArticleReferencesBundledSupplementalData(t *testing.T) {
 	var articleName string
 	merchant := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodGet {
 			http.Error(w, "unexpected request", http.StatusMethodNotAllowed)
 			return
 		}
 		_ = json.NewEncoder(w).Encode(backend.OrderStatusResponse{
 			OrderStatus: "paid",
 			ContractTerms: backend.ContractTerms{
 				Extra:          backend.OrderExtra{ArticleName: articleName},
 				RefundDeadline: backend.Timestamp{Seconds: time.Now().Add(time.Minute).Unix()},
 			},
 		})
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{Shop: "blog", Currency: "KUDOS", BlogBackend: client})
 	if err != nil {
 		t.Fatal(err)
 	}
 	var article Article
 	for _, candidate := range app.articles["en"] {
 		if candidate.ExtraFiles["category.png"] != "" {
 			article = candidate
 			break
 		}
 	}
 	if article.Slug == "" {
 		t.Fatal("no English article references category.png")
 	}
 	articleName = article.Slug
 	articlePath := "/en/essay/" + url.PathEscape(article.Slug)
 	request := httptest.NewRequest(http.MethodGet, articlePath, nil)
 	request.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "browser-session"})
 	request.AddCookie(&http.Cookie{Name: orderCookieName, Value: "paid-order"})
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusOK || !strings.Contains(response.Body.String(), url.PathEscape(article.Slug)+"/data/category.png") {
 		t.Fatalf("article response = %d, supplemental reference missing", response.Code)
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, articlePath+"/data/category.png", nil))
 	if response.Code != http.StatusOK || response.Header().Get("Content-Type") != "image/png" || !strings.HasPrefix(response.Body.String(), "\x89PNG") {
 		t.Fatalf("supplemental response = %d, type %q", response.Code, response.Header().Get("Content-Type"))
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, articlePath+"/data/unused.jpg", nil))
 	if response.Code != http.StatusNotFound {
 		t.Fatalf("unreferenced supplemental response = %d", response.Code)
 	}
 }
 
 func TestBlogRefundUsesMethodAwareRoute(t *testing.T) {
 	var refund backend.RefundRequest
 	choiceIndex := 0
 	merchant := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
 		case r.Method == http.MethodGet && r.URL.Path == "/private/orders/order-1":
 			_ = json.NewEncoder(w).Encode(backend.OrderStatusResponse{
 				OrderStatus:    "paid",
 				OrderStatusURL: "https://merchant.example/orders/order-1",
 				ChoiceIndex:    &choiceIndex,
 				ContractTerms: backend.ContractTerms{
 					Version:        1,
 					Choices:        []backend.OrderChoice{{Amount: "KUDOS:0.5"}, {Amount: "KUDOS:10"}, {Amount: "KUDOS:0"}},
 					RefundDeadline: backend.Timestamp{Seconds: time.Now().Add(time.Minute).Unix()},
 				},
 			})
 		case r.Method == http.MethodPost && r.URL.Path == "/private/orders/order-1/refund":
 			_ = json.NewDecoder(r.Body).Decode(&refund)
 			_ = json.NewEncoder(w).Encode(map[string]any{})
 		default:
 			http.Error(w, "unexpected request", http.StatusNotFound)
 		}
 	}))
 	defer merchant.Close()
 	client, err := backend.New(merchant.URL, "secret-token:test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	app, err := New(Options{Shop: "blog", Currency: "KUDOS", BlogBackend: client})
 	if err != nil {
 		t.Fatal(err)
 	}
 	request := httptest.NewRequest(http.MethodPost, "/de/refund/order-1", nil)
 	request.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "browser-session"})
 	response := httptest.NewRecorder()
 	app.ServeHTTP(response, request)
 	if response.Code != http.StatusFound || response.Header().Get("Location") != "https://merchant.example/orders/order-1" {
 		t.Fatalf("refund response = %d, location %q", response.Code, response.Header().Get("Location"))
 	}
 	if refund.Refund != "KUDOS:0.5" || refund.Reason != "Rückerstattung in der Demo" {
 		t.Fatalf("refund request = %#v", refund)
 	}
 
 	response = httptest.NewRecorder()
 	app.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/de/refund/order-1", nil))
 	if response.Code != http.StatusMethodNotAllowed {
 		t.Fatalf("GET refund response = %d", response.Code)
 	}
 }
 
 func TestRefundUsesSelectedOrderChoice(t *testing.T) {
 	app := &App{opts: Options{Currency: "KUDOS"}}
 	deadline := backend.Timestamp{Seconds: time.Now().Add(time.Minute).Unix()}
 	choices := []backend.OrderChoice{{Amount: "KUDOS:0.5"}, {Amount: "KUDOS:10"}, {Amount: "KUDOS:0"}}
 	for index, want := range []string{"KUDOS:0.5", "KUDOS:10", ""} {
 		choiceIndex := index
 		got, ok := app.refundAmount(backend.OrderStatusResponse{
 			ChoiceIndex: &choiceIndex,
 			ContractTerms: backend.ContractTerms{
 				Version: 1, Choices: choices, RefundDeadline: deadline,
 			},
 		})
 		if got != want || ok != (want != "") {
 			t.Errorf("choice %d refund = %q, %v; want %q", index, got, ok, want)
 		}
 	}
 	invalid := len(choices)
 	if amount, ok := app.refundAmount(backend.OrderStatusResponse{
 		ChoiceIndex: &invalid,
 		ContractTerms: backend.ContractTerms{
 			Version: 1, Choices: choices, RefundDeadline: deadline,
 		},
 	}); ok || amount != "" {
 		t.Fatalf("invalid choice refund = %q, %v", amount, ok)
 	}
 }