feat: Add CFT test lint subcommand, implement blueprint connection source version lint rule for POC

cli/bptest/blueprint_connection_source_version_rule.go

@@ -0,0 +1,46 @@
+package bptest
+
+import (
+	"fmt"
+	"github.com/hashicorp/go-version"
+)
+
+type BlueprintConnectionSourceVersionRule struct{}
+
+func (r *BlueprintConnectionSourceVersionRule) name() string {
+	return "blueprint_connection_source_version_rule"
+}
+
+func (r *BlueprintConnectionSourceVersionRule) enabled() bool {
+	return true
+}
+
+func (r *BlueprintConnectionSourceVersionRule) check(ctx lintContext) error {
+	// Check if Spec or Interfaces is nil to avoid null pointer dereference
+	if ctx.metadata == nil || ctx.metadata.Spec == nil || ctx.metadata.Spec.Interfaces == nil {
+		fmt.Println("metadata, spec, or interfaces are nil")
+		return nil
+	}
+
+	for _, variable := range ctx.metadata.Spec.Interfaces.Variables {
+		if variable == nil {
+			continue // Skip if variable is nil
+		}
+
+		for _, conn := range variable.Connections {
+			if conn == nil || conn.Source == nil {
+				continue // Skip if connection or source is nil
+			}
+
+			if conn.Source.Version != "" {
+				_, err := version.NewConstraint(conn.Source.Version)
+				if err != nil {
+					return fmt.Errorf("invalid version: %w", err)
+				}
+				return nil
+			}
+		}
+	}
+
+	return nil
+}

cli/bptest/blueprint_connection_source_version_rule_test.go

@@ -0,0 +1,86 @@
+package bptest
+
+import (
+	"testing"
+
+	"github.com/GoogleCloudPlatform/cloud-foundation-toolkit/cli/bpmetadata"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBlueprintConnectionSourceVersionRule(t *testing.T) {
+	tests := []struct {
+		name         string
+		version      string
+		expectErr    bool
+		errorMessage string
+	}{
+		{
+			name:      "Valid version - no equal sign expect version",
+			version:   "1.2.3",
+			expectErr: false,
+		},
+		{
+			name:      "Valid version - expect version",
+			version:   "=1.2.3",
+			expectErr: false,
+		},
+		{
+			name:      "Valid version - pessimistic constraint",
+			version:   "~> 6.0",
+			expectErr: false,
+		},
+		{
+			name:      "Valid version - minimal version",
+			version:   ">= 0.13.7",
+			expectErr: false,
+		},
+		{
+			name:      "Valid version - range interval",
+			version:   ">= 0.13.7, < 2.0.0",
+			expectErr: false,
+		},
+		{
+			name:         "Invalid version - random string",
+			version:      "invalid_version",
+			expectErr:    true,
+			errorMessage: "invalid_version",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			metadata := &bpmetadata.BlueprintMetadata{
+				Spec: &bpmetadata.BlueprintMetadataSpec{
+					Interfaces: &bpmetadata.BlueprintInterface{
+						Variables: []*bpmetadata.BlueprintVariable{
+							{
+								Connections: []*bpmetadata.BlueprintConnection{
+									{
+										Source: &bpmetadata.ConnectionSource{
+											Source:  "example/source",
+											Version: tt.version,
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			}
+
+			ctx := lintContext{
+				metadata: metadata,
+			}
+
+			rule := &BlueprintConnectionSourceVersionRule{}
+			err := rule.check(ctx)
+
+			if tt.expectErr {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tt.errorMessage)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

cli/bptest/cmd.go

@@ -23,6 +23,7 @@ func init() {
 	Cmd.AddCommand(runCmd)
 	Cmd.AddCommand(convertCmd)
 	Cmd.AddCommand(initCmd)
+	Cmd.AddCommand(lintCmd)
 
 	Cmd.PersistentFlags().StringVar(&flags.testDir, "test-dir", "", "Path to directory containing integration tests (default is computed by scanning current working directory)")
 	runCmd.Flags().StringVar(&flags.testStage, "stage", "", "Test stage to execute (default is running all stages in order - init, plan, apply, verify, teardown)")
@@ -145,3 +146,14 @@ var initCmd = &cobra.Command{
 		return initTest(initTestName)
 	},
 }
+
+var lintCmd = &cobra.Command{
+	Use:   "lint",
+	Short: "Lints blueprint",
+	Long:  "Lints TF blueprint",
+	Args:  cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		RunLintCommand()
+		return nil
+	},
+}

cli/bptest/lint.go

@@ -0,0 +1,47 @@
+package bptest
+
+import (
+	"fmt"
+	"github.com/GoogleCloudPlatform/cloud-foundation-toolkit/cli/bpmetadata"
+	"os"
+)
+
+const metadataFile = "metadata.yaml"
+
+// RunLintCommand is the entry function that will run the metadata.yml lint checks.
+func RunLintCommand() {
+	dir, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Error getting current directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Parse medata.yaml to proto
+	metadata, err := bpmetadata.UnmarshalMetadata(dir, "/"+metadataFile)
+	metadataFile := dir + "/" + metadataFile
+
+	if err != nil {
+		fmt.Printf("Error parsing metadata file: %v\n", err)
+		os.Exit(1)
+	}
+
+	ctx := lintContext{
+		metadata: metadata,
+		filePath: metadataFile,
+	}
+
+	runner := &lintRunner{}
+	runner.RegisterRule(&BlueprintConnectionSourceVersionRule{})
+
+	// Run lint checks
+	errs := runner.Run(ctx)
+	if len(errs) > 0 {
+		fmt.Println("Linting failed with the following errors:")
+		for _, err := range errs {
+			fmt.Println("- ", err)
+		}
+		os.Exit(1)
+	} else {
+		fmt.Println("All lint checks passed!")
+	}
+}

cli/bptest/lint_interface.go

@@ -0,0 +1,42 @@
+package bptest
+
+import (
+	"github.com/GoogleCloudPlatform/cloud-foundation-toolkit/cli/bpmetadata"
+)
+
+// lintRule defines the common interface for all metadata lint rules.
+type lintRule interface {
+	name() string            // Unique name of the rule
+	enabled() bool           // Indicates if the rule is enabled by default
+	check(lintContext) error // Main entrypoint for rule validation
+}
+
+// LintContext holds the metadata and other contextual information for a rule.
+type lintContext struct {
+	metadata *bpmetadata.BlueprintMetadata // Parsed metadata for the blueprint
+	filePath string                        // Path of the metadata file being checked
+}
+
+// LintRunner is responsible for running all registered lint rules.
+type lintRunner struct {
+	rules []lintRule
+}
+
+// RegisterRule adds a new rule to the runner.
+func (r *lintRunner) RegisterRule(rule lintRule) {
+	r.rules = append(r.rules, rule)
+}
+
+// Run runs all the registered rules on the provided context.
+func (r *lintRunner) Run(ctx lintContext) []error {
+	var errs []error
+	for _, rule := range r.rules {
+		if rule.enabled() {
+			err := rule.check(ctx)
+			if err != nil {
+				errs = append(errs, err)
+			}
+		}
+	}
+	return errs
+}