chore: Introduce unified experimental handling (#386)

Author: PeterSchafer

pkg/local_workflows/code_workflow.go

@@ -37,7 +37,6 @@ func GetCodeFlagSet() *pflag.FlagSet {
 	flagSet.String(code_workflow.ConfigurationTargetName, "", "The name of the target to test.")
 	flagSet.String(code_workflow.ConfigurationTargetReference, "", "The reference that differentiates this project, e.g. a branch name or version.")
 	flagSet.String("target-file", "", "The path to the target file to test.")
-	flagSet.Bool(configuration.FLAG_EXPERIMENTAL, false, "Enable experimental code test command")
 
 	return flagSet
 }

pkg/local_workflows/config_utils/experimental.go

@@ -0,0 +1,38 @@
+package config_utils
+
+import (
+	"strings"
+
+	"github.com/spf13/pflag"
+
+	"github.com/snyk/go-application-framework/pkg/configuration"
+)
+
+func IsExperimental(flags *pflag.FlagSet) bool {
+	result := false
+
+	// if the experimental flag exists, it's an experimental command
+	if tmp := flags.Lookup(configuration.FLAG_EXPERIMENTAL); tmp != nil {
+		result = true
+
+		// if the experimental flag is deprecated, it'll be ignored
+		if strings.Contains(strings.ToLower(tmp.Usage), "deprecated") ||
+			len(tmp.Deprecated) > 0 {
+			result = false
+		}
+	}
+
+	return result
+}
+
+func MarkAsExperimental(flags *pflag.FlagSet) *pflag.FlagSet {
+	if flags == nil {
+		return nil
+	}
+
+	result := *flags
+	if result.Lookup(configuration.FLAG_EXPERIMENTAL) == nil {
+		result.Bool(configuration.FLAG_EXPERIMENTAL, false, "enable experimental command")
+	}
+	return &result
+}

pkg/local_workflows/config_utils/experimental_test.go

@@ -0,0 +1,125 @@
+package config_utils
+
+import (
+	"testing"
+
+	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/snyk/go-application-framework/pkg/configuration"
+)
+
+func TestIsExperimental(t *testing.T) {
+	tests := []struct {
+		name           string
+		setupFlags     func(t *testing.T) *pflag.FlagSet
+		expectedResult bool
+	}{
+		{
+			name: "returns false when experimental flag does not exist",
+			setupFlags: func(_ *testing.T) *pflag.FlagSet {
+				flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
+				flags.String("other-flag", "", "some other flag")
+				return flags
+			},
+			expectedResult: false,
+		},
+		{
+			name: "returns true when experimental flag exists and is not deprecated",
+			setupFlags: func(_ *testing.T) *pflag.FlagSet {
+				flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
+				return MarkAsExperimental(flags)
+			},
+			expectedResult: true,
+		},
+		{
+			name: "returns false when experimental flag usage contains 'deprecated' (case insensitive)",
+			setupFlags: func(_ *testing.T) *pflag.FlagSet {
+				flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
+				flags.Bool(configuration.FLAG_EXPERIMENTAL, false, "This is DEPRECATED and should not be used")
+				return flags
+			},
+			expectedResult: false,
+		},
+		{
+			name: "returns false when experimental flag deprecated field is set",
+			setupFlags: func(t *testing.T) *pflag.FlagSet {
+				t.Helper()
+				flags := MarkAsExperimental(pflag.NewFlagSet("test", pflag.ContinueOnError))
+				err := flags.MarkDeprecated(configuration.FLAG_EXPERIMENTAL, "use new-flag instead")
+				assert.NoError(t, err)
+				return flags
+			},
+			expectedResult: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			flags := tt.setupFlags(t)
+			result := IsExperimental(flags)
+			assert.Equal(t, tt.expectedResult, result)
+		})
+	}
+}
+
+func TestMarkAsExperimental(t *testing.T) {
+	t.Run("makes non-experimental flagset experimental", func(t *testing.T) {
+		original := pflag.NewFlagSet("test", pflag.ContinueOnError)
+		original.String("existing-flag", "", "existing flag")
+
+		result := MarkAsExperimental(original)
+
+		// Should make the flagset experimental
+		assert.True(t, IsExperimental(result), "flagset should be experimental after marking")
+	})
+
+	t.Run("returns different flagset instance", func(t *testing.T) {
+		original := pflag.NewFlagSet("test", pflag.ContinueOnError)
+
+		result := MarkAsExperimental(original)
+
+		// Should return a different instance
+		assert.NotSame(t, original, result, "should return a new flagset instance")
+
+		// Original should not be experimental, result should be
+		assert.False(t, IsExperimental(original), "original flagset should not be experimental")
+		assert.True(t, IsExperimental(result), "result flagset should be experimental")
+	})
+
+	t.Run("makes empty flagset experimental", func(t *testing.T) {
+		original := pflag.NewFlagSet("empty", pflag.ContinueOnError)
+
+		result := MarkAsExperimental(original)
+
+		// Should make empty flagset experimental
+		assert.True(t, IsExperimental(result), "empty flagset should be experimental after marking")
+	})
+
+	t.Run("preserves existing experimental flag", func(t *testing.T) {
+		original := pflag.NewFlagSet("test", pflag.ContinueOnError)
+		original.Bool(configuration.FLAG_EXPERIMENTAL, true, "old usage")
+
+		result := MarkAsExperimental(original)
+
+		// Should remain experimental
+		assert.True(t, IsExperimental(result), "should remain experimental")
+	})
+
+	t.Run("works with both new and existing experimental flags", func(t *testing.T) {
+		// Test with flagset that doesn't have experimental flag
+		original1 := pflag.NewFlagSet("test1", pflag.ContinueOnError)
+		original1.String("other-flag", "", "some other flag")
+
+		result1 := MarkAsExperimental(original1)
+
+		// Should be experimental after adding flag
+		assert.True(t, IsExperimental(result1), "should be experimental after adding flag")
+
+		// Test with flagset that already has experimental flag (reuse result1)
+		result2 := MarkAsExperimental(result1)
+
+		// Should remain experimental
+		assert.True(t, IsExperimental(result2), "should remain experimental")
+	})
+}

pkg/local_workflows/connectivity_check_extension/connectivity_check_workflow.go

@@ -7,11 +7,11 @@ import (
 	"os"
 
 	"github.com/rs/zerolog"
-	"github.com/snyk/error-catalog-golang-public/cli"
 	"github.com/spf13/pflag"
 	"golang.org/x/term"
 
 	"github.com/snyk/go-application-framework/pkg/configuration"
+	"github.com/snyk/go-application-framework/pkg/local_workflows/config_utils"
 	"github.com/snyk/go-application-framework/pkg/local_workflows/connectivity_check_extension/connectivity"
 	"github.com/snyk/go-application-framework/pkg/workflow"
 )
@@ -35,9 +35,8 @@ func InitConnectivityCheckWorkflow(engine workflow.Engine) error {
 	config.Bool(noColorFlag, false, "Disable colored output")
 	config.Int(timeoutFlag, 10, "Timeout in seconds for each connection test")
 	config.Int(maxOrgCountFlag, 100, "Maximum number of organizations to retrieve")
-	config.Bool(configuration.FLAG_EXPERIMENTAL, false, "This feature is experimental")
 
-	_, err := engine.Register(WORKFLOWID_CONNECTIVITY_CHECK, workflow.ConfigurationOptionsFromFlagset(config), connectivityCheckEntryPoint)
+	_, err := engine.Register(WORKFLOWID_CONNECTIVITY_CHECK, workflow.ConfigurationOptionsFromFlagset(config_utils.MarkAsExperimental(config)), connectivityCheckEntryPoint)
 	return err
 }
 
@@ -48,10 +47,6 @@ func connectivityCheckEntryPoint(invocationCtx workflow.InvocationContext, input
 	networkAccess := invocationCtx.GetNetworkAccess()
 	ui := invocationCtx.GetUserInterface()
 
-	if !config.GetBool(configuration.FLAG_EXPERIMENTAL) {
-		return nil, cli.NewCommandIsExperimentalError("")
-	}
-
 	checker := connectivity.NewChecker(networkAccess, logger, config, ui)
 
 	logger.Info().Msg("Starting Snyk connectivity check")

pkg/local_workflows/whoami_workflow.go

@@ -10,6 +10,7 @@ import (
 	"github.com/snyk/go-application-framework/internal/api"
 	"github.com/snyk/go-application-framework/internal/api/contract"
 	"github.com/snyk/go-application-framework/pkg/configuration"
+	"github.com/snyk/go-application-framework/pkg/local_workflows/config_utils"
 	"github.com/snyk/go-application-framework/pkg/workflow"
 )
 
@@ -26,13 +27,11 @@ var WORKFLOWID_WHOAMI workflow.Identifier = workflow.NewWorkflowIdentifier(whoAm
 func InitWhoAmIWorkflow(engine workflow.Engine) error {
 	// initialize workflow configuration
 	whoAmIConfig := pflag.NewFlagSet(whoAmIworkflowName, pflag.ExitOnError)
-	// add experimental flag to configuration
-	whoAmIConfig.Bool(experimentalFlag, false, "enable experimental whoAmI command")
 	// add json flag to configuration
 	whoAmIConfig.Bool(jsonFlag, false, "output in json format")
 
 	// register workflow with engine
-	_, err := engine.Register(WORKFLOWID_WHOAMI, workflow.ConfigurationOptionsFromFlagset(whoAmIConfig), whoAmIWorkflowEntryPoint)
+	_, err := engine.Register(WORKFLOWID_WHOAMI, workflow.ConfigurationOptionsFromFlagset(config_utils.MarkAsExperimental(whoAmIConfig)), whoAmIWorkflowEntryPoint)
 	return err
 }