reference

This example shows how to write validation results to a file for CI integration.

package main

import (
	"encoding/json"
	"fmt"
	"os"

	"github.com/lex00/wetwire-gitlab-go/internal/reference"
)

func main() {
	// Create example result
	result := &reference.ParallelValidationResult{
		Statistics: reference.ValidationStatistics{
			Total:           20,
			Passed:          18,
			Failed:          2,
			ImportSucceeded: 19,
			BuildSucceeded:  18,
			SuccessRate:     90.0,
			Duration:        "1m30s",
		},
		Results: []reference.TestResult{
			{
				Sample:   reference.Sample{Name: "Go.gitlab-ci.yml"},
				ImportOK: true,
				BuildOK:  true,
			},
			{
				Sample:   reference.Sample{Name: "Python.gitlab-ci.yml"},
				ImportOK: true,
				BuildOK:  false,
				Errors:   []string{"build failed: missing dependencies"},
			},
		},
		Excluded: []string{"Security/*"},
	}

	// Marshal to JSON
	jsonData, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		fmt.Printf("Failed to marshal: %v\n", err)
		return
	}

	// Write to file (in real usage)
	// os.WriteFile("results.json", jsonData, 0644)

	// Print to demonstrate
	fmt.Println(string(jsonData))

	// Output would be formatted JSON with full validation results
	_ = os.Stdout
}

ExampleParallelValidator demonstrates using the parallel validator to test GitLab CI templates.

package main

import (
	"fmt"
	"path/filepath"

	"github.com/lex00/wetwire-gitlab-go/internal/reference"
)

func main() {
	// Configure validation
	config := reference.ValidationConfig{
		Workers: 4,
		Verbose: false,
		ExcludeList: []string{
			"Security/SAST.gitlab-ci.yml", // Exclude Security templates with hidden jobs
			"Security/*",                  // Exclude all Security templates
		},
	}

	// Create validator
	templatesDir := "testdata/gitlab-templates"
	validator := reference.NewParallelValidator(templatesDir, config)

	// Set project root for local development
	projectRoot, _ := filepath.Abs("../..")
	validator.SetProjectRoot(projectRoot)

	// Run validation (commented out for example - would require actual binary)
	// Build the wetwire-gitlab binary first
	// wetwireBin := "/path/to/wetwire-gitlab"
	// result, err := validator.ValidateAll(wetwireBin)
	// if err != nil {
	//     fmt.Printf("Validation failed: %v\n", err)
	//     return
	// }

	// Create example result for demonstration
	result := &reference.ParallelValidationResult{
		Statistics: reference.ValidationStatistics{
			Total:           10,
			Passed:          8,
			Failed:          2,
			ImportSucceeded: 9,
			BuildSucceeded:  8,
			SuccessRate:     80.0,
			Duration:        "45s",
		},
		Excluded: []string{"Security/SAST.gitlab-ci.yml", "Security/*"},
	}

	// Print summary
	fmt.Printf("Validation Summary:\n")
	fmt.Printf("  Total:   %d\n", result.Statistics.Total)
	fmt.Printf("  Passed:  %d (%.1f%%)\n", result.Statistics.Passed, result.Statistics.SuccessRate)
	fmt.Printf("  Failed:  %d\n", result.Statistics.Failed)
	fmt.Printf("  Duration: %s\n", result.Statistics.Duration)

}

Output:

Validation Summary:
  Total:   10
  Passed:  8 (80.0%)
  Failed:  2
  Duration: 45s

ExampleProgressReporter demonstrates real-time progress tracking.

package main

import (
	"fmt"

	"github.com/lex00/wetwire-gitlab-go/internal/reference"
)

func main() {
	// Create reporter for 5 samples
	reporter := reference.NewProgressReporter(5, false)

	// Start tracking
	reporter.Start()

	// Simulate processing samples
	samples := []reference.Sample{
		{Name: "test1.yml"},
		{Name: "test2.yml"},
		{Name: "test3.yml"},
		{Name: "test4.yml"},
		{Name: "test5.yml"},
	}

	for i, sample := range samples {
		// Simulate: first 3 pass, last 2 fail
		passed := i < 3
		reporter.Update(sample, passed)
	}

	// Finish and get statistics
	stats := reporter.Finish()

	fmt.Printf("Progress Summary:\n")
	fmt.Printf("  Total:   %d\n", stats.Total)
	fmt.Printf("  Passed:  %d\n", stats.Passed)
	fmt.Printf("  Failed:  %d\n", stats.Failed)
	fmt.Printf("  Success: %.1f%%\n", stats.SuccessRate)

}

Output:

Progress Summary:
  Total:   5
  Passed:  3
  Failed:  2
  Success: 60.0%

ExampleTester_roundTrip demonstrates full import/build/validate cycle.

package main

import (
	"fmt"
	"path/filepath"

	"github.com/lex00/wetwire-gitlab-go/internal/reference"
)

func main() {
	// Create tester
	samplesDir := "testdata/samples"
	tester := reference.NewTester(samplesDir)

	// Set project root for local development
	projectRoot := "/path/to/wetwire-gitlab-go"
	tester.SetProjectRoot(projectRoot)

	// Discover samples
	samples, err := tester.DiscoverSamples()
	if err != nil {
		fmt.Printf("Failed to discover: %v\n", err)
		return
	}

	fmt.Printf("Found %d samples\n", len(samples))

	// For demonstration, create a mock sample
	if len(samples) == 0 {
		sample := reference.Sample{
			Name:   "example.gitlab-ci.yml",
			Source: "https://example.com/example.gitlab-ci.yml",
			Path:   filepath.Join(samplesDir, "example.gitlab-ci.yml"),
		}
		samples = append(samples, sample)
	}

	// In real usage, you would test each sample:
	// for _, sample := range samples {
	//     result := tester.TestSample(sample, "/path/to/wetwire-gitlab")
	//     fmt.Printf("%s: import=%v, build=%v\n", sample.Name, result.ImportOK, result.BuildOK)
	// }

	// Output would show test results for each sample
	fmt.Printf("Sample: %s\n", samples[0].Name)
}

ExampleValidationConfig demonstrates configuration options.

package main

import (
	"fmt"

	"github.com/lex00/wetwire-gitlab-go/internal/reference"
)

func main() {
	// Basic configuration
	basicConfig := reference.ValidationConfig{
		Workers: 4,
		Verbose: false,
	}

	fmt.Printf("Basic Config:\n")
	fmt.Printf("  Workers: %d\n", basicConfig.Workers)
	fmt.Printf("  Verbose: %v\n", basicConfig.Verbose)

	// Advanced configuration with exclusions
	advancedConfig := reference.ValidationConfig{
		Workers: 8,
		Verbose: true,
		ExcludeList: []string{
			"Security/*",
			"Jobs/SAST*",
			"Complex-Rules.gitlab-ci.yml",
		},
	}

	fmt.Printf("\nAdvanced Config:\n")
	fmt.Printf("  Workers:    %d\n", advancedConfig.Workers)
	fmt.Printf("  Verbose:    %v\n", advancedConfig.Verbose)
	fmt.Printf("  Exclusions: %d patterns\n", len(advancedConfig.ExcludeList))

}

Output:

Basic Config:
  Workers: 4
  Verbose: false

Advanced Config:
  Workers:    8
  Verbose:    true
  Exclusions: 3 patterns