Vellum/internal/engine/engine_test.go

package engine

import (
	"encoding/json"
	"strings"
	"testing"
)

// TestRegistryHasBuiltins pins the engines a client can name out of the box.
func TestRegistryHasBuiltins(t *testing.T) {
	for _, id := range []string{HTML5ID, "mpv", "vlc", "mdk"} {
		if _, ok := Get(id); !ok {
			t.Errorf("engine %q is not registered", id)
		}
	}
	if _, ok := Get("nope"); ok {
		t.Error("Get returned an unknown engine")
	}
	// Get is case/space tolerant so a client's casing never matters.
	if _, ok := Get(" HTML5 "); !ok {
		t.Error("Get should trim and lower-case the id")
	}
}

// TestHTML5BaselineIsHonest guards the measured facts: the browser baseline must
// NOT claim HEVC or mpeg4, which Chrome cannot decode, and must not claim a
// container it does not handle.
func TestHTML5BaselineIsHonest(t *testing.T) {
	html5, _ := Get(HTML5ID)
	if contains(html5.VCodecs, "hevc") || contains(html5.VCodecs, "h265") {
		t.Error("html5 baseline claims HEVC, which browsers cannot decode")
	}
	if contains(html5.VCodecs, "mpeg4") {
		t.Error("html5 baseline claims mpeg4, which browsers cannot decode")
	}
	if !contains(html5.VCodecs, "h264") || !contains(html5.VCodecs, "vp9") || !contains(html5.VCodecs, "av1") {
		t.Errorf("html5 baseline is missing a measured-playable codec: %v", html5.VCodecs)
	}
	if !contains(html5.Containers, "mkv") {
		t.Error("html5 baseline must accept mkv (h264-in-mkv plays)")
	}
	if contains(html5.Containers, "avi") {
		t.Error("html5 baseline must not claim avi")
	}
}

// TestEngineJSONMatchesContract pins the frozen wire shape (web/src/lib/api.ts).
func TestEngineJSONMatchesContract(t *testing.T) {
	e, _ := Get(HTML5ID)
	b, err := json.Marshal(e)
	if err != nil {
		t.Fatal(err)
	}
	var raw map[string]json.RawMessage
	if err := json.Unmarshal(b, &raw); err != nil {
		t.Fatal(err)
	}
	for _, key := range []string{"id", "name", "kind", "containers", "vcodecs", "acodecs"} {
		if _, ok := raw[key]; !ok {
			t.Errorf("engine JSON is missing %q", key)
		}
	}
	if len(raw) != 6 {
		t.Errorf("engine JSON has %d keys, want exactly 6: %s", len(raw), b)
	}
}

func TestResolve(t *testing.T) {
	tests := []struct {
		name      string
		facts     []string
		engines   []string
		playable  bool
		engine    string // expected engine id, or "" for nil
		reason    string
		msgSubstr string // must appear in Message when not playable
	}{
		{
			name:     "mp4 h264 aac plays in html5",
			facts:    Facts("mp4", "h264", "aac"),
			engines:  []string{"html5"},
			playable: true,
			engine:   "html5",
		},
		{
			name:     "mkv h264 plays despite the container",
			facts:    Facts("mkv", "h264", "aac"),
			engines:  []string{"html5"},
			playable: true,
			engine:   "html5",
		},
		{
			name:      "mp4 hevc aac is not playable",
			facts:     Facts("mp4", "hevc", "aac"),
			engines:   []string{"html5"},
			playable:  false,
			reason:    "vcodec:hevc",
			msgSubstr: "HEVC",
		},
		{
			name:      "avi mpeg4 is a container blocker",
			facts:     Facts("avi", "mpeg4", "mp3"),
			engines:   []string{"html5"},
			playable:  false,
			reason:    "container:avi",
			msgSubstr: "AVI",
		},
		{
			name:      "unsupported audio codec",
			facts:     Facts("mp4", "h264", "dts"),
			engines:   []string{"html5"},
			playable:  false,
			reason:    "acodec:dts",
			msgSubstr: "DTS",
		},
		{
			name:     "audio-only mp3 is playable",
			facts:    Facts("mp3", "", "mp3"),
			engines:  []string{"html5"},
			playable: true,
			engine:   "html5",
		},
		{
			name:     "audio-only flac is playable",
			facts:    Facts("flac", "", "flac"),
			engines:  []string{"html5"},
			playable: true,
			engine:   "html5",
		},
		{
			name:      "audio-only dts is not playable",
			facts:     Facts("m4a", "", "dts"),
			engines:   []string{"html5"},
			playable:  false,
			reason:    "acodec:dts",
			msgSubstr: "DTS",
		},
		{
			name:     "empty engine list falls back to html5 baseline",
			facts:    Facts("mp4", "h264", "aac"),
			engines:  nil,
			playable: true,
			engine:   "html5",
		},
		{
			name:      "empty engine list still rejects hevc",
			facts:     Facts("mp4", "hevc", "aac"),
			engines:   nil,
			playable:  false,
			reason:    "vcodec:hevc",
			msgSubstr: "mpv",
		},
		{
			name:     "native engine changes the answer for hevc",
			facts:    Facts("mp4", "hevc", "aac"),
			engines:  []string{"html5", "mpv"},
			playable: true,
			engine:   "mpv",
		},
		{
			name:     "native engine handles avi",
			facts:    Facts("avi", "mpeg4", "mp3"),
			engines:  []string{"html5", "vlc"},
			playable: true,
			engine:   "vlc",
		},
		{
			name:     "client ordering wins among capable engines",
			facts:    Facts("mkv", "h264", "aac"),
			engines:  []string{"mpv", "html5"},
			playable: true,
			engine:   "mpv",
		},
		{
			name:     "capable engine beats an earlier incapable one",
			facts:    Facts("mp4", "hevc", "aac"),
			engines:  []string{"html5", "vlc", "mpv"},
			playable: true,
			engine:   "vlc",
		},
		{
			name:      "unknown engines are skipped, reason uses fallback",
			facts:     Facts("mp4", "hevc", "aac"),
			engines:   []string{"bogus"},
			playable:  false,
			reason:    "vcodec:hevc",
			msgSubstr: "mpv",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := Resolve(tt.facts, tt.engines)
			if got.Playable != tt.playable {
				t.Fatalf("playable = %v, want %v (reason %q)", got.Playable, tt.playable, got.Reason)
			}
			if tt.playable {
				if got.Engine == nil || *got.Engine != tt.engine {
					t.Errorf("engine = %v, want %q", got.Engine, tt.engine)
				}
				if got.Reason != "" || got.Message != "" {
					t.Errorf("playable result carried reason=%q message=%q", got.Reason, got.Message)
				}
				return
			}
			if got.Engine != nil {
				t.Errorf("engine = %q, want null", *got.Engine)
			}
			if got.Reason != tt.reason {
				t.Errorf("reason = %q, want %q", got.Reason, tt.reason)
			}
			if tt.msgSubstr != "" && !strings.Contains(got.Message, tt.msgSubstr) {
				t.Errorf("message = %q, want it to mention %q", got.Message, tt.msgSubstr)
			}
			if strings.Contains(strings.ToLower(got.Message), "you ") {
				t.Errorf("message blames the user: %q", got.Message)
			}
		})
	}
}

// TestResolutionJSONEngineNull pins that a non-playable answer serialises
// engine as JSON null, exactly as PlaybackResolution declares.
func TestResolutionJSONEngineNull(t *testing.T) {
	got := Resolve(Facts("mp4", "hevc", "aac"), []string{"html5"})
	b, err := json.Marshal(got)
	if err != nil {
		t.Fatal(err)
	}
	var raw struct {
		Playable bool            `json:"playable"`
		Engine   json.RawMessage `json:"engine"`
		Reason   string          `json:"reason"`
		Message  string          `json:"message"`
	}
	if err := json.Unmarshal(b, &raw); err != nil {
		t.Fatal(err)
	}
	if string(raw.Engine) != "null" {
		t.Errorf("engine = %s, want null", raw.Engine)
	}
	if raw.Playable || raw.Reason != "vcodec:hevc" || raw.Message == "" {
		t.Errorf("unexpected resolution JSON: %s", b)
	}
}