qmk-rgb/cmd/qmk-rgb-tool/effect_test.go

package main

import (
	"bytes"
	"path/filepath"
	"reflect"
	"strings"
	"testing"

	intrgb "netdome.biz/paul/qmk-rgb/internal/rgb"
	"netdome.biz/paul/qmk-rgb/internal/via"
)

// impact80Catalog is the catalog of the board these cases describe, which comes
// from the vendored definition file: that file is where every effect name now
// comes from.
func impact80Catalog(t *testing.T) *intrgb.Catalog {
	t.Helper()
	def, err := intrgb.LoadDefinition(filepath.Join("..", "..", "definitions", "impact80.json"))
	if err != nil {
		t.Fatalf("LoadDefinition(definitions/impact80.json) error = %v", err)
	}
	return def.Catalog
}

func TestResolveEffectTargetsBacklightOnly(t *testing.T) {
	targets, skipped, err := resolveEffectTargets(impact80Catalog(t), "rainbow_moving_chevron", impact80Channels())
	if err != nil {
		t.Fatalf("resolveEffectTargets() unexpected error: %v", err)
	}
	wantTargets := []intrgb.EffectTarget{{Channel: via.ChannelRgbMatrix, ID: 17}}
	if !reflect.DeepEqual(targets, wantTargets) {
		t.Errorf("resolveEffectTargets() targets = %v, want %v", targets, wantTargets)
	}
	wantSkipped := []string{"rgblight", "audio"}
	if !reflect.DeepEqual(skipped, wantSkipped) {
		t.Errorf("resolveEffectTargets() skipped = %v, want %v", skipped, wantSkipped)
	}
}

func TestResolveEffectTargetsBreathing(t *testing.T) {
	targets, skipped, err := resolveEffectTargets(impact80Catalog(t), "breathing", impact80Channels())
	if err != nil {
		t.Fatalf("resolveEffectTargets() unexpected error: %v", err)
	}
	wantTargets := []intrgb.EffectTarget{
		{Channel: via.ChannelRgblight, ID: 4},
		{Channel: via.ChannelRgbMatrix, ID: 5},
		{Channel: via.ChannelAudio, ID: 4},
	}
	if !reflect.DeepEqual(targets, wantTargets) {
		t.Errorf("resolveEffectTargets() targets = %v, want %v", targets, wantTargets)
	}
	if len(skipped) != 0 {
		t.Errorf("resolveEffectTargets() skipped = %v, want none", skipped)
	}
}

func TestResolveEffectTargetsExplicitUnsupported(t *testing.T) {
	cases := []struct {
		name  string
		zones []via.Channel
	}{
		{"rainbow_moving_chevron", []via.Channel{via.ChannelRgblight}},
		{"rainbow_wave", []via.Channel{via.ChannelRgbMatrix}},
		{"splash", []via.Channel{via.ChannelAudio}},
	}
	for _, tc := range cases {
		t.Run(tc.name+string(tc.zones[0]), func(t *testing.T) {
			// A name the board has but the named channel does not is refused,
			// so this only means anything when a zone was actually named.
			originalZone := targetZone
			t.Cleanup(func() { targetZone = originalZone })
			targetZone = tc.zones[0].Subsystem()

			targets, skipped, err := resolveEffectTargets(impact80Catalog(t), tc.name, tc.zones)
			if err == nil {
				t.Fatal("resolveEffectTargets() expected error, got nil")
			}
			if len(targets) != 0 {
				t.Errorf("resolveEffectTargets() targets = %v, want none", targets)
			}
			if len(skipped) != 0 {
				t.Errorf("resolveEffectTargets() skipped = %v, want none", skipped)
			}
		})
	}
}

func TestResolveEffectTargetsUnknownName(t *testing.T) {
	targets, skipped, err := resolveEffectTargets(impact80Catalog(t), "not_an_effect", impact80Channels())
	if err == nil {
		t.Fatal("resolveEffectTargets() expected error, got nil")
	}
	if len(targets) != 0 {
		t.Errorf("resolveEffectTargets() targets = %v, want none", targets)
	}
	if len(skipped) != 0 {
		t.Errorf("resolveEffectTargets() skipped = %v, want none", skipped)
	}
}

func TestResolveEffectTargetsStaticCompatibility(t *testing.T) {
	targets, skipped, err := resolveEffectTargets(impact80Catalog(t), "static", impact80Channels())
	if err != nil {
		t.Fatalf("resolveEffectTargets() unexpected error: %v", err)
	}
	wantTargets := []intrgb.EffectTarget{
		{Channel: via.ChannelRgblight, ID: 5},
		{Channel: via.ChannelRgbMatrix, ID: 1},
		{Channel: via.ChannelAudio, ID: 5},
	}
	if !reflect.DeepEqual(targets, wantTargets) {
		t.Errorf("resolveEffectTargets() targets = %v, want %v", targets, wantTargets)
	}
	if len(skipped) != 0 {
		t.Errorf("resolveEffectTargets() skipped = %v, want none", skipped)
	}
}

func executeEffectCommand(t *testing.T, protocol rgbProtocol, target string, args ...string) (string, string, error) {
	t.Helper()
	originalZone := targetZone
	t.Cleanup(func() { targetZone = originalZone })
	targetZone = target
	t.Cleanup(stubOpenTarget(t, protocol, impact80Display(), impact80Channels(), 0x36B0, 0x309F))

	var stdout bytes.Buffer
	var stderr bytes.Buffer
	cmd := NewEffectCmd()
	cmd.SetOut(&stdout)
	cmd.SetErr(&stderr)
	cmd.SilenceErrors = true
	cmd.SilenceUsage = true
	cmd.SetArgs(args)
	err := cmd.Execute()
	return stdout.String(), stderr.String(), err
}

func TestEffectCommandWarnsForSkippedZones(t *testing.T) {
	t.Cleanup(vendoredDefinitions(t))
	protocol := &fakeZoneProtocol{failAt: -1}
	stdout, stderr, err := executeEffectCommand(t, protocol, "", "rainbow_moving_chevron")
	if err != nil {
		t.Fatalf("Execute() unexpected error: %v", err)
	}
	if !strings.Contains(stderr, "effect not supported on channel(s): rgblight, audio") {
		t.Errorf("stderr = %q, want skipped-zone warning", stderr)
	}
	if !strings.Contains(stdout, `Effect set to "rainbow_moving_chevron"`) {
		t.Errorf("stdout = %q, want success output", stdout)
	}
	if len(protocol.reports) != 1 {
		t.Fatalf("reports = %v, want one Backlight report", protocol.reports)
	}
	if protocol.reports[0].channel != 3 || protocol.reports[0].param != 2 || protocol.reports[0].value != 17 {
		t.Errorf("report = %+v, want Backlight Effect 17", protocol.reports[0])
	}
}

func TestEffectCommandWritesNothingForAnUnsupportedEffect(t *testing.T) {
	protocol := &fakeZoneProtocol{failAt: -1}
	stdout, _, err := executeEffectCommand(t, protocol, "logo", "rainbow_moving_chevron")
	if err == nil {
		t.Fatal("Execute() expected error, got nil")
	}
	if len(protocol.reports) != 0 {
		t.Errorf("reports = %v, want no writes before rejection", protocol.reports)
	}
	if stdout != "" {
		t.Errorf("stdout = %q, want no success output", stdout)
	}
}

func TestEffectCommandSuppressesSuccessAfterLaterWriteFailure(t *testing.T) {
	t.Cleanup(vendoredDefinitions(t))
	protocol := &fakeZoneProtocol{failAt: 1}
	stdout, _, err := executeEffectCommand(t, protocol, "", "breathing")
	if err == nil {
		t.Fatal("Execute() expected write error, got nil")
	}
	if len(protocol.reports) != 1 {
		t.Fatalf("reports = %v, want one report before failure", protocol.reports)
	}
	if strings.Contains(stdout, "Effect set") {
		t.Errorf("stdout = %q, want success output suppressed", stdout)
	}
}