refactor: add workflow writer interface

Introduced WorkflowWriter interface to decouple workflow generation
from filesystem operations. Previously, githubWorkflow.Persist()
directly wrote files, making unit tests require filesystem I/O.
Now, Export() accepts a WorkflowWriter, enabling tests to verify
YAML generation in-memory using BufferWriter while production code
uses fileWriter for actual file operations.

Moved feature flag check from runtime to command registration,
preventing the subcommand from appearing when feature is disabled
rather than failing during execution.

Reorganized tests into unit tests (mocked I/O) and integration
tests (real filesystem).

Additional changes:
- Made workflow types private (githubWorkflow, job, step, etc)
- Renamed *Option constants to *Flag for consistency
- Corrected GitHub capitalization throughout codebase
- Added MockLoaderSaver to common package for test reuse

Issue SRVOCF-744

Signed-off-by: Stanislav Jakuschevskij <sjakusch@redhat.com>

Author: twoGiants

cmd/ci/config.go

@@ -9,43 +9,42 @@ import (
 const (
 	ConfigCIFeatureFlag = "FUNC_ENABLE_CI_CONFIG"
 
-	// TODO(twoGiants): *Option -> *Flag
-	PathOption = "path"
+	PathFlag = "path"
 
-	DefaultGithubWorkflowDir      = ".github/workflows"
-	DefaultGithubWorkflowFilename = "func-deploy.yaml"
+	DefaultGitHubWorkflowDir      = ".github/workflows"
+	DefaultGitHubWorkflowFilename = "func-deploy.yaml"
 
-	BranchOption  = "branch"
+	BranchFlag    = "branch"
 	DefaultBranch = "main"
 
-	WorkflowNameOption  = "workflow-name"
+	WorkflowNameFlag    = "workflow-name"
 	DefaultWorkflowName = "Func Deploy"
 
-	KubeconfigSecretNameOption  = "kubeconfig-secret-name"
+	KubeconfigSecretNameFlag    = "kubeconfig-secret-name"
 	DefaultKubeconfigSecretName = "KUBECONFIG"
 
-	RegistryLoginUrlVariableNameOption  = "registry-login-url-variable-name"
+	RegistryLoginUrlVariableNameFlag    = "registry-login-url-variable-name"
 	DefaultRegistryLoginUrlVariableName = "REGISTRY_LOGIN_URL"
 
-	RegistryUserVariableNameOption  = "registry-user-variable-name"
+	RegistryUserVariableNameFlag    = "registry-user-variable-name"
 	DefaultRegistryUserVariableName = "REGISTRY_USERNAME"
 
-	RegistryPassSecretNameOption  = "registry-pass-secret-name"
+	RegistryPassSecretNameFlag    = "registry-pass-secret-name"
 	DefaultRegistryPassSecretName = "REGISTRY_PASSWORD"
 
-	RegistryUrlVariableNameOption  = "registry-url-variable-name"
+	RegistryUrlVariableNameFlag    = "registry-url-variable-name"
 	DefaultRegistryUrlVariableName = "REGISTRY_URL"
 
-	UseRegistryLoginOption  = "use-registry-login"
+	UseRegistryLoginFlag    = "use-registry-login"
 	DefaultUseRegistryLogin = true
 
-	UseDebugOption  = "debug"
+	UseDebugFlag    = "debug"
 	DefaultUseDebug = false
 
-	UseRemoteBuild        = "remote"
+	UseRemoteBuildFlag    = "remote"
 	DefaultUseRemoteBuild = false
 
-	UseSelfHostedRunner        = "self-hosted-runner"
+	UseSelfHostedRunnerFlag    = "self-hosted-runner"
 	DefaultUseSelfHostedRunner = false
 )
 
@@ -67,31 +66,31 @@ type CIConfig struct {
 	debug bool
 }
 
-func NewCiGithubConfig() CIConfig {
+func NewCIGitHubConfig() CIConfig {
 	return CIConfig{
-		githubWorkflowDir:      DefaultGithubWorkflowDir,
-		githubWorkflowFilename: DefaultGithubWorkflowFilename,
-		path:                   viper.GetString(PathOption),
-		branch:                 viper.GetString(BranchOption),
-		workflowName:           viper.GetString(WorkflowNameOption),
-		kubeconfigSecret:       viper.GetString(KubeconfigSecretNameOption),
-		registryLoginUrlVar:    viper.GetString(RegistryLoginUrlVariableNameOption),
-		registryUserVar:        viper.GetString(RegistryUserVariableNameOption),
-		registryPassSecret:     viper.GetString(RegistryPassSecretNameOption),
-		registryUrlVar:         viper.GetString(RegistryUrlVariableNameOption),
-		useRegistryLogin:       viper.GetBool(UseRegistryLoginOption),
-		useRemoteBuild:         viper.GetBool(UseRemoteBuild),
-		useSelfHostedRunner:    viper.GetBool(UseSelfHostedRunner),
-		debug:                  viper.GetBool(UseDebugOption),
+		githubWorkflowDir:      DefaultGitHubWorkflowDir,
+		githubWorkflowFilename: DefaultGitHubWorkflowFilename,
+		path:                   viper.GetString(PathFlag),
+		branch:                 viper.GetString(BranchFlag),
+		workflowName:           viper.GetString(WorkflowNameFlag),
+		kubeconfigSecret:       viper.GetString(KubeconfigSecretNameFlag),
+		registryLoginUrlVar:    viper.GetString(RegistryLoginUrlVariableNameFlag),
+		registryUserVar:        viper.GetString(RegistryUserVariableNameFlag),
+		registryPassSecret:     viper.GetString(RegistryPassSecretNameFlag),
+		registryUrlVar:         viper.GetString(RegistryUrlVariableNameFlag),
+		useRegistryLogin:       viper.GetBool(UseRegistryLoginFlag),
+		useRemoteBuild:         viper.GetBool(UseRemoteBuildFlag),
+		useSelfHostedRunner:    viper.GetBool(UseSelfHostedRunnerFlag),
+		debug:                  viper.GetBool(UseDebugFlag),
 	}
 }
 
-func (cc *CIConfig) FnGithubWorkflowDir(fnRoot string) string {
+func (cc *CIConfig) FnGitHubWorkflowDir(fnRoot string) string {
 	return filepath.Join(fnRoot, cc.githubWorkflowDir)
 }
 
-func (cc *CIConfig) FnGithubWorkflowFilepath(fnRoot string) string {
-	return filepath.Join(cc.FnGithubWorkflowDir(fnRoot), cc.githubWorkflowFilename)
+func (cc *CIConfig) FnGitHubWorkflowFilepath(fnRoot string) string {
+	return filepath.Join(cc.FnGitHubWorkflowDir(fnRoot), cc.githubWorkflowFilename)
 }
 
 func (cc *CIConfig) Path() string {

cmd/ci/workflow.go

@@ -3,54 +3,31 @@ package ci
 import (
 	"bytes"
 	"fmt"
-	"os"
-	"path/filepath"
 
 	"gopkg.in/yaml.v3"
 )
 
-const (
-	dirPerm  = 0755 // o: rwx, g|u: r-x
-	filePerm = 0644 // o: rw,  g|u: r
-)
-
-// TODO(twoGiants)
-//   - encapsulate => create Interface and defaultGithubWorkflow struct
-//   - provide printers for configurable properties
-//   - provide toYamlString for checks in tests
-type GithubWorkflow struct {
+type githubWorkflow struct {
 	Name string           `yaml:"name"`
-	On   WorkflowTriggers `yaml:"on"`
-	Jobs map[string]Job   `yaml:"jobs"`
+	On   workflowTriggers `yaml:"on"`
+	Jobs map[string]job   `yaml:"jobs"`
 }
 
-type WorkflowTriggers struct {
-	Push             *PushTrigger `yaml:"push,omitempty"`
+type workflowTriggers struct {
+	Push             *pushTrigger `yaml:"push,omitempty"`
 	WorkflowDispatch *struct{}    `yaml:"workflow_dispatch,omitempty"`
 }
 
-func newPushTrigger(branch string, debug bool) WorkflowTriggers {
-	result := WorkflowTriggers{
-		Push: &PushTrigger{Branches: []string{branch}},
-	}
-
-	if debug {
-		result.WorkflowDispatch = &struct{}{}
-	}
-
-	return result
-}
-
-type PushTrigger struct {
+type pushTrigger struct {
 	Branches []string `yaml:"branches,omitempty"`
 }
 
-type Job struct {
+type job struct {
 	RunsOn string `yaml:"runs-on"`
-	Steps  []Step `yaml:"steps"`
+	Steps  []step `yaml:"steps"`
 }
 
-type Step struct {
+type step struct {
 	Name string            `yaml:"name,omitempty"`
 	ID   string            `yaml:"id,omitempty"`
 	If   string            `yaml:"if,omitempty"`
@@ -59,50 +36,17 @@ type Step struct {
 	With map[string]string `yaml:"with,omitempty"`
 }
 
-func newStep(name string) *Step {
-	return &Step{Name: name}
-}
-
-func (s *Step) withID(id string) *Step {
-	s.ID = id
-	return s
-}
-
-func (s *Step) withIf(ifCond string) *Step {
-	s.If = ifCond
-	return s
-}
-
-func (s *Step) withUses(u string) *Step {
-	s.Uses = u
-	return s
-}
-
-func (s *Step) withRun(r string) *Step {
-	s.Run = r
-	return s
-}
-
-func (s *Step) withActionConfig(key, value string) *Step {
-	if s.With == nil {
-		s.With = make(map[string]string)
-	}
-
-	s.With[key] = value
-
-	return s
-}
-
 // TODO(twoGiants): add validation => no empty values, etc.
-func NewGithubWorkflow(conf CIConfig) *GithubWorkflow {
+func NewGitHubWorkflow(conf CIConfig) *githubWorkflow {
+	// TODO(twoGiants): add more runner labels => for GitHub enterprise clients
 	runsOn := "ubuntu-latest"
 	if conf.UseSelfHostedRunner() {
 		runsOn = "self-hosted"
 	}
 
 	pushTrigger := newPushTrigger(conf.Branch(), conf.UseDebug())
 
-	var steps []Step
+	var steps []step
 	checkoutCode := newStep("Checkout code").
 		withUses("actions/checkout@v4")
 	steps = append(steps, *checkoutCode)
@@ -160,10 +104,10 @@ func NewGithubWorkflow(conf CIConfig) *GithubWorkflow {
 		withRun(runFuncDeploy + " --registry=" + registryUrl + " -v")
 	steps = append(steps, *deployFunc)
 
-	return &GithubWorkflow{
+	return &githubWorkflow{
 		Name: name,
 		On:   pushTrigger,
-		Jobs: map[string]Job{
+		Jobs: map[string]job{
 			"deploy": {
 				RunsOn: runsOn,
 				Steps:  steps,
@@ -172,47 +116,70 @@ func NewGithubWorkflow(conf CIConfig) *GithubWorkflow {
 	}
 }
 
-func NewGithubWorkflowFromPath(path string) (*GithubWorkflow, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
+func newPushTrigger(branch string, debug bool) workflowTriggers {
+	result := workflowTriggers{
+		Push: &pushTrigger{Branches: []string{branch}},
 	}
 
-	var result GithubWorkflow
-	if err = yaml.Unmarshal(raw, &result); err != nil {
-		return nil, err
+	if debug {
+		result.WorkflowDispatch = &struct{}{}
 	}
 
-	return &result, nil
+	return result
 }
 
-func (gw *GithubWorkflow) Persist(path string) error {
-	raw, err := gw.toYaml()
-	if err != nil {
-		return err
-	}
+func newStep(name string) *step {
+	return &step{Name: name}
+}
 
-	if err := os.MkdirAll(filepath.Dir(path), dirPerm); err != nil {
-		return err
-	}
+func (s *step) withID(id string) *step {
+	s.ID = id
+	return s
+}
 
-	if err := os.WriteFile(path, raw, filePerm); err != nil {
-		return err
+func (s *step) withIf(ifCond string) *step {
+	s.If = ifCond
+	return s
+}
+
+func (s *step) withUses(u string) *step {
+	s.Uses = u
+	return s
+}
+
+func (s *step) withRun(r string) *step {
+	s.Run = r
+	return s
+}
+
+func (s *step) withActionConfig(key, value string) *step {
+	if s.With == nil {
+		s.With = make(map[string]string)
 	}
 
-	return nil
+	s.With[key] = value
+
+	return s
+}
+
+func newSecret(key string) string {
+	return fmt.Sprintf("${{ secrets.%s }}", key)
+}
+
+func newVariable(key string) string {
+	return fmt.Sprintf("${{ vars.%s }}", key)
 }
 
-func (gw *GithubWorkflow) YamlString() (string, error) {
+func (gw *githubWorkflow) Export(path string, w WorkflowWriter) error {
 	raw, err := gw.toYaml()
 	if err != nil {
-		return "", err
+		return err
 	}
 
-	return string(raw), nil
+	return w.Write(path, raw)
 }
 
-func (gw *GithubWorkflow) toYaml() ([]byte, error) {
+func (gw *githubWorkflow) toYaml() ([]byte, error) {
 	var buf bytes.Buffer
 	encoder := yaml.NewEncoder(&buf)
 	encoder.SetIndent(2)
@@ -224,11 +191,3 @@ func (gw *GithubWorkflow) toYaml() ([]byte, error) {
 
 	return buf.Bytes(), nil
 }
-
-func newSecret(key string) string {
-	return fmt.Sprintf("${{ secrets.%s }}", key)
-}
-
-func newVariable(key string) string {
-	return fmt.Sprintf("${{ vars.%s }}", key)
-}

cmd/ci/workflow_test.go

@@ -1,23 +1,22 @@
 package ci_test
 
 import (
+	"strings"
 	"testing"
 
 	"gotest.tools/v3/assert"
 	"knative.dev/func/cmd/ci"
 )
 
-func TestGithubWorkflow_PersistAndLoad(t *testing.T) {
+func TestGitHubWorkflow_Export(t *testing.T) {
 	// GIVEN
-	gw := ci.NewGithubWorkflow(ci.NewCiGithubConfig())
-	targetPath := t.TempDir() + "/" + gw.Name + ".yaml"
+	gw := ci.NewGitHubWorkflow(ci.NewCIGitHubConfig())
+	bufferWriter := ci.NewBufferWriter()
 
 	// WHEN
-	persistErr := gw.Persist(targetPath)
-	actualGw, loadErr := ci.NewGithubWorkflowFromPath(targetPath)
+	exportErr := gw.Export("path", bufferWriter)
 
 	// THEN
-	assert.NilError(t, persistErr, "unexpected error when persisting Github Workflow")
-	assert.NilError(t, loadErr, "unexpected error when loading Github Workflow")
-	assert.Equal(t, actualGw.Name, gw.Name, "expected names to be equal")
+	assert.NilError(t, exportErr, "unexpected error when exporting GitHub Workflow")
+	assert.Assert(t, strings.Contains(bufferWriter.Buffer.String(), gw.Name))
 }