From 70839155f247c74935d2ee900790a3a8fc4099d2 Mon Sep 17 00:00:00 2001
From: Michael Eischer <michael.eischer@fau.de>
Date: Mon, 12 Feb 2024 21:34:37 +0100
Subject: [PATCH] features: add tests

---
 internal/feature/features_test.go | 139 ++++++++++++++++++++++++++++++
 internal/feature/testing_test.go  |  19 ++++
 2 files changed, 158 insertions(+)
 create mode 100644 internal/feature/features_test.go
 create mode 100644 internal/feature/testing_test.go

diff --git a/internal/feature/features_test.go b/internal/feature/features_test.go
new file mode 100644
index 000000000..3611ac998
--- /dev/null
+++ b/internal/feature/features_test.go
@@ -0,0 +1,139 @@
+package feature_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/restic/restic/internal/feature"
+	rtest "github.com/restic/restic/internal/test"
+)
+
+var (
+	alpha      = feature.FlagName("alpha-feature")
+	beta       = feature.FlagName("beta-feature")
+	stable     = feature.FlagName("stable-feature")
+	deprecated = feature.FlagName("deprecated-feature")
+)
+
+var testFlags = map[feature.FlagName]feature.FlagDesc{
+	alpha: {
+		Type:        feature.Alpha,
+		Description: "alpha",
+	},
+	beta: {
+		Type:        feature.Beta,
+		Description: "beta",
+	},
+	stable: {
+		Type:        feature.Stable,
+		Description: "stable",
+	},
+	deprecated: {
+		Type:        feature.Deprecated,
+		Description: "deprecated",
+	},
+}
+
+func buildTestFlagSet() *feature.FlagSet {
+	flags := feature.New()
+	flags.SetFlags(testFlags)
+	return flags
+}
+
+func TestFeatureDefaults(t *testing.T) {
+	flags := buildTestFlagSet()
+	for _, exp := range []struct {
+		flag  feature.FlagName
+		value bool
+	}{
+		{alpha, false},
+		{beta, true},
+		{stable, true},
+		{deprecated, false},
+	} {
+		rtest.Assert(t, flags.Enabled(exp.flag) == exp.value, "expected flag %v to have value %v got %v", exp.flag, exp.value, flags.Enabled(exp.flag))
+	}
+}
+
+func TestEmptyApply(t *testing.T) {
+	flags := buildTestFlagSet()
+	rtest.OK(t, flags.Apply(""))
+
+	rtest.Assert(t, !flags.Enabled(alpha), "expected alpha feature to be disabled")
+	rtest.Assert(t, flags.Enabled(beta), "expected beta feature to be enabled")
+}
+
+func TestFeatureApply(t *testing.T) {
+	flags := buildTestFlagSet()
+	rtest.OK(t, flags.Apply(string(alpha)))
+	rtest.Assert(t, flags.Enabled(alpha), "expected alpha feature to be enabled")
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=false", alpha)))
+	rtest.Assert(t, !flags.Enabled(alpha), "expected alpha feature to be disabled")
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=true", alpha)))
+	rtest.Assert(t, flags.Enabled(alpha), "expected alpha feature to be enabled again")
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=false", beta)))
+	rtest.Assert(t, !flags.Enabled(beta), "expected beta feature to be disabled")
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=false", stable)))
+	rtest.Assert(t, flags.Enabled(stable), "expected stable feature to remain enabled")
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=true", deprecated)))
+	rtest.Assert(t, !flags.Enabled(deprecated), "expected deprecated feature to remain disabled")
+}
+
+func TestFeatureMultipleApply(t *testing.T) {
+	flags := buildTestFlagSet()
+
+	rtest.OK(t, flags.Apply(fmt.Sprintf("%s=true,%s=false", alpha, beta)))
+	rtest.Assert(t, flags.Enabled(alpha), "expected alpha feature to be enabled")
+	rtest.Assert(t, !flags.Enabled(beta), "expected beta feature to be disabled")
+}
+
+func TestFeatureApplyInvalid(t *testing.T) {
+	flags := buildTestFlagSet()
+
+	err := flags.Apply("invalid-flag")
+	rtest.Assert(t, err != nil && strings.Contains(err.Error(), "unknown feature flag"), "expected unknown feature flag error, got: %v", err)
+
+	err = flags.Apply(fmt.Sprintf("%v=invalid", alpha))
+	rtest.Assert(t, err != nil && strings.Contains(err.Error(), "failed to parse value"), "expected parsing error, got: %v", err)
+}
+
+func assertPanic(t *testing.T) {
+	if r := recover(); r == nil {
+		t.Fatal("should have panicked")
+	}
+}
+
+func TestFeatureQueryInvalid(t *testing.T) {
+	defer assertPanic(t)
+
+	flags := buildTestFlagSet()
+	flags.Enabled("invalid-flag")
+}
+
+func TestFeatureSetInvalidPhase(t *testing.T) {
+	defer assertPanic(t)
+
+	flags := feature.New()
+	flags.SetFlags(map[feature.FlagName]feature.FlagDesc{
+		"invalid": {
+			Type: "invalid",
+		},
+	})
+}
+
+func TestFeatureList(t *testing.T) {
+	flags := buildTestFlagSet()
+
+	rtest.Equals(t, []feature.Help{
+		{string(alpha), string(feature.Alpha), false, "alpha"},
+		{string(beta), string(feature.Beta), true, "beta"},
+		{string(deprecated), string(feature.Deprecated), false, "deprecated"},
+		{string(stable), string(feature.Stable), true, "stable"},
+	}, flags.List())
+}
diff --git a/internal/feature/testing_test.go b/internal/feature/testing_test.go
new file mode 100644
index 000000000..f11b4bae4
--- /dev/null
+++ b/internal/feature/testing_test.go
@@ -0,0 +1,19 @@
+package feature_test
+
+import (
+	"testing"
+
+	"github.com/restic/restic/internal/feature"
+	rtest "github.com/restic/restic/internal/test"
+)
+
+func TestSetFeatureFlag(t *testing.T) {
+	flags := buildTestFlagSet()
+	rtest.Assert(t, !flags.Enabled(alpha), "expected alpha feature to be disabled")
+
+	restore := feature.TestSetFlag(t, flags, alpha, true)
+	rtest.Assert(t, flags.Enabled(alpha), "expected alpha feature to be enabled")
+
+	restore()
+	rtest.Assert(t, !flags.Enabled(alpha), "expected alpha feature to be disabled again")
+}