hakurei/internal/uevent/uevent_test.go

package uevent_test

import (
	"encoding"
	"fmt"
	"reflect"
	"testing"

	"hakurei.app/internal/uevent"
)

// adeT sets up a parallel subtest for a textual appender/decoder/encoder.
func adeT[V any, S interface {
	encoding.TextAppender
	encoding.TextMarshaler
	encoding.TextUnmarshaler
	fmt.Stringer

	*V
}](t *testing.T, name string, v V, want string, wantErr, wantErrE error) {
	t.Helper()
	t.Run(name, func(t *testing.T) {
		t.Parallel()
		t.Helper()

		t.Run("decode", func(t *testing.T) {
			t.Parallel()
			t.Helper()

			var got V
			if err := S(&got).UnmarshalText([]byte(want)); !reflect.DeepEqual(err, wantErr) {
				t.Fatalf("UnmarshalText: error = %v, want %v", err, wantErr)
			}
			if wantErr != nil {
				return
			}

			if !reflect.DeepEqual(&got, &v) {
				t.Errorf("UnmarshalText: %#v, want %#v", got, v)
			}
		})

		t.Run("encode", func(t *testing.T) {
			t.Parallel()
			t.Helper()

			if got, err := S(&v).MarshalText(); !reflect.DeepEqual(err, wantErrE) {
				t.Fatalf("MarshalText: error = %v, want %v", err, wantErrE)
			} else if err == nil && string(got) != want {
				t.Errorf("MarshalText: %q, want %q", string(got), want)
			}
			if wantErrE != nil {
				return
			}

			if got := S(&v).String(); got != want {
				t.Errorf("String: %q, want %q", got, want)
			}
		})
	})
}

func TestErrors(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		name string
		err  error
		want string
	}{
		{"UnsupportedActionError", uevent.UnsupportedActionError("explode"),
			`unsupported kobject_action "explode"`},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			if got := tc.err.Error(); got != tc.want {
				t.Errorf("Error: %q, want %q", got, tc.want)
			}
		})
	}
}