feat: add feature flags functionality + tests

Author: WasinWatt

Makefile

@@ -4,7 +4,7 @@
 GO_VERSION := 1.22
 GO_SYSTEM_VERSION := $(shell go version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f1-2)
 REQUIRE_GO_VERSION := $(GO_VERSION)
-ENABLED_FLAGS :=
+ENABLED_FLAGS := minitia_launch
 
 # Project version
 WEAVE_VERSION := v0.0.1

cmd/root.go

@@ -6,6 +6,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
+	"github.com/initia-labs/weave/flags"
 	"github.com/initia-labs/weave/utils"
 )
 
@@ -28,7 +29,9 @@ func Execute() error {
 
 	rootCmd.AddCommand(InitCommand())
 	rootCmd.AddCommand(InitiaCommand())
-	rootCmd.AddCommand(MinitiaCommand())
+	if flags.IsEnabled(flags.MinitiaLaunch) {
+		rootCmd.AddCommand(MinitiaCommand())
+	}
 
 	return rootCmd.ExecuteContext(context.Background())
 }

flags/flag.go

@@ -7,9 +7,9 @@ var EnabledFlags string
 type FeatureFlag string
 
 const (
-	MinitiaLaunch      FeatureFlag = "minitia_launch"
-	OPInitBotsExecutor FeatureFlag = "opinit-bots-executor"
-	Relayer            FeatureFlag = "relayer"
+	MinitiaLaunch FeatureFlag = "minitia_launch"
+	OPInitBots    FeatureFlag = "opinit_bots"
+	Relayer       FeatureFlag = "relayer"
 )
 
 func IsEnabled(flag FeatureFlag) bool {

flags/flag_test.go

@@ -0,0 +1,49 @@
+package flags
+
+import (
+	"testing"
+
+	"github.com/test-go/testify/assert"
+)
+
+func TestIsEnabled(t *testing.T) {
+	testCases := []struct {
+		name          string
+		enabledFlags  string
+		flag          FeatureFlag
+		expectedValue bool
+	}{
+		{
+			name:          "Single flag enabled",
+			enabledFlags:  "minitia_launch",
+			flag:          MinitiaLaunch,
+			expectedValue: true,
+		},
+		{
+			name:          "Multiple flags enabled, target flag present",
+			enabledFlags:  "minitia_launch,opinit_bots,relayer",
+			flag:          OPInitBots,
+			expectedValue: true,
+		},
+		{
+			name:          "Multiple flags enabled, target flag not present",
+			enabledFlags:  "minitia_launch,opinit_bots",
+			flag:          Relayer,
+			expectedValue: false,
+		},
+		{
+			name:          "No flags enabled",
+			enabledFlags:  "",
+			flag:          MinitiaLaunch,
+			expectedValue: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			EnabledFlags = tc.enabledFlags
+			result := IsEnabled(tc.flag)
+			assert.Equal(t, tc.expectedValue, result)
+		})
+	}
+}

models/weaveinit/weaveinit.go

@@ -3,6 +3,7 @@ package weaveinit
 import (
 	tea "github.com/charmbracelet/bubbletea"
 
+	"github.com/initia-labs/weave/flags"
 	"github.com/initia-labs/weave/models/initia"
 	"github.com/initia-labs/weave/models/minitia"
 	"github.com/initia-labs/weave/styles"
@@ -22,16 +23,31 @@ const (
 	StartRelayerOption     WeaveInitOption = "Start a Relayer"
 )
 
+func GetWeaveInitOptions() []WeaveInitOption {
+	options := []WeaveInitOption{
+		RunL1NodeOption,
+	}
+
+	if flags.IsEnabled(flags.MinitiaLaunch) {
+		options = append(options, LaunchNewMinitiaOption)
+	}
+
+	if flags.IsEnabled(flags.OPInitBots) {
+		options = append(options, InitializeOPBotsOption)
+	}
+
+	if flags.IsEnabled(flags.Relayer) {
+		options = append(options, StartRelayerOption)
+	}
+
+	return options
+}
+
 func NewWeaveInit() *WeaveInit {
 	return &WeaveInit{
 		Selector: utils.Selector[WeaveInitOption]{
-			Options: []WeaveInitOption{
-				RunL1NodeOption,
-				LaunchNewMinitiaOption,
-				InitializeOPBotsOption,
-				StartRelayerOption,
-			},
-			Cursor: 0,
+			Options: GetWeaveInitOptions(),
+			Cursor:  0,
 		},
 	}
 }

models/weaveinit/weaveinit_test.go

@@ -0,0 +1,35 @@
+package weaveinit
+
+import (
+	"testing"
+
+	"github.com/initia-labs/weave/flags"
+)
+
+func TestGetWeaveInitOptions(t *testing.T) {
+	// Test with different flag combinations
+	testCases := []struct {
+		flags    string
+		expected []WeaveInitOption
+	}{
+		{"", []WeaveInitOption{RunL1NodeOption}},
+		{"minitia_launch", []WeaveInitOption{RunL1NodeOption, LaunchNewMinitiaOption}},
+		{"minitia_launch,opinit_bots", []WeaveInitOption{RunL1NodeOption, LaunchNewMinitiaOption, InitializeOPBotsOption}},
+		{"minitia_launch,opinit_bots,relayer", []WeaveInitOption{RunL1NodeOption, LaunchNewMinitiaOption, InitializeOPBotsOption, StartRelayerOption}},
+	}
+
+	for _, tc := range testCases {
+		flags.EnabledFlags = tc.flags
+		options := GetWeaveInitOptions()
+
+		if len(options) != len(tc.expected) {
+			t.Errorf("For flags '%s': Expected %d options, but got %d", tc.flags, len(tc.expected), len(options))
+		}
+
+		for i, option := range options {
+			if option != tc.expected[i] {
+				t.Errorf("For flags '%s': Expected option %d to be %s, but got %s", tc.flags, i, tc.expected[i], option)
+			}
+		}
+	}
+}