package modules

import "testing"

// A file only earns an inline image MIME when its extension and its magic
// bytes agree and the format is a raster one. The cases that must return ""
// are the attacker-influenced ones: content that is not an image at all, and
// SVG, which is an active document rather than a picture.
func TestImageContentType(t *testing.T) {
	png := []byte("\x89PNG\r\n\x1a\n" + "rest of the file")
	tests := []struct {
		name string
		path string
		data []byte
		want string
	}{
		{"png", "logo.png", png, "image/png"},
		{"uppercase extension", "LOGO.PNG", png, "image/png"},
		{"jpeg", "a.jpg", []byte{0xff, 0xd8, 0xff, 0xe0}, "image/jpeg"},
		{"jpeg long extension", "a.jpeg", []byte{0xff, 0xd8, 0xff, 0xe0}, "image/jpeg"},
		{"gif87", "a.gif", []byte("GIF87a...."), "image/gif"},
		{"gif89", "a.gif", []byte("GIF89a...."), "image/gif"},
		{"webp", "a.webp", []byte("RIFF\x00\x00\x00\x00WEBPVP8 "), "image/webp"},
		{"bmp", "a.bmp", []byte("BM...."), "image/bmp"},
		{"ico", "a.ico", []byte{0x00, 0x00, 0x01, 0x00}, "image/x-icon"},
		{"avif", "a.avif", []byte("\x00\x00\x00\x18ftypavif"), "image/avif"},

		// HTML wearing a .png name, and a real PNG named .txt, must both
		// fall back to the download path.
		{"html named png", "evil.png", []byte("<html><script>x</script>"), ""},
		{"png extension without magic", "evil.png", []byte("not an image"), ""},
		{"magic without extension", "evil.txt", png, ""},
		{"truncated png", "evil.png", []byte("\x89PNG"), ""},

		// SVG can carry <script> and would be stored XSS if served as a
		// document on this origin, so it is never recognised here.
		{"svg", "evil.svg", []byte(`<svg xmlns="http://www.w3.org/2000/svg"><script/></svg>`), ""},
		{"no extension", "Makefile", []byte("all:\n"), ""},
	}
	for _, tc := range tests {
		if got := imageContentType(tc.path, tc.data); got != tc.want {
			t.Errorf("%s: imageContentType(%q) = %q, want %q", tc.name, tc.path, got, tc.want)
		}
	}
}

// The blob view only renders a preview for a validated raster image, and
// only while it is under the size cap; both facts are what tell the view
// whether to show an <img>, a download notice, or numbered bytes.
func TestImageBlobPreview(t *testing.T) {
	png := append([]byte("\x89PNG\r\n\x1a\n"), make([]byte, 64)...)
	big := append([]byte("\x89PNG\r\n\x1a\n"), make([]byte, maxPreviewSize)...)
	c := blobCtx(t, map[string]string{
		"logo.png": string(png),
		"big.png":  string(big),
		"evil.png": "<html>not an image</html>",
	})

	b := blobAt(t, c, "logo.png")
	if b.Image != "image/png" || !b.Preview() || !b.Binary {
		t.Errorf("small image: Image=%q Preview=%v Binary=%v", b.Image, b.Preview(), b.Binary)
	}
	if b.PreviewLimit() != maxPreviewSize {
		t.Errorf("PreviewLimit = %d, want %d", b.PreviewLimit(), maxPreviewSize)
	}

	bigBlob := blobAt(t, c, "big.png")
	if bigBlob.Image != "image/png" {
		t.Errorf("large image: Image = %q, want image/png", bigBlob.Image)
	}
	if bigBlob.Preview() {
		t.Error("large image was previewed past the size cap")
	}

	// Not an image, so it keeps the plain binary path rather than a preview.
	evil := blobAt(t, c, "evil.png")
	if evil.Image != "" || evil.Preview() {
		t.Errorf("misnamed html: Image=%q Preview=%v, want none", evil.Image, evil.Preview())
	}
}

// /raw/ must declare the image MIME so the preview and direct navigation
// render a picture, and must expose it through the interface core checks.
func TestRawBlobInlineImage(t *testing.T) {
	png := []byte("\x89PNG\r\n\x1a\n" + "body")
	c := blobCtx(t, map[string]string{"logo.png": string(png)})
	c.Path = "logo.png"
	v, err := blobRawMod(c)
	if err != nil {
		t.Fatal(err)
	}
	r, ok := v.(RawBlob)
	if !ok {
		t.Fatalf("got %T", v)
	}
	if r.InlineContentType() != "image/png" {
		t.Errorf("InlineContentType = %q, want image/png", r.InlineContentType())
	}
}