package scripts_test import ( "fmt" "os" "path/filepath" "strings" "testing" "gopkg.in/yaml.v3" ) func TestCIWorkflowArtifactOwnership(t *testing.T) { for _, workflowName := range []string{"pr.yml", "main.yml"} { t.Run(workflowName, func(t *testing.T) { workflow := readCIWorkflow(t, workflowName) for _, forbidden := range []string{ "golangci-lint", "make ci-pr-policy", "make ci-pr-lint", } { for _, step := range workflow.job(t, "build-artifacts").Steps { if strings.Contains(step.Run, forbidden) { t.Errorf("build-artifacts runs %q in step %q", forbidden, step.Name) } } } assertJobRunsExactly(t, workflow.job(t, "pr-policy-wrapper"), "make ci-pr-policy") assertJobRunsExactly(t, workflow.job(t, "pr-lint-wrapper"), "make ci-pr-lint") }) } } func TestPRCIGateRequiresPolicyAndLintWrappers(t *testing.T) { gate := readCIWorkflow(t, "pr.yml").job(t, "ci-gate") gateEnv := gate.step(t, "Evaluate CI gate").Env for _, job := range []string{"pr-policy-wrapper", "pr-lint-wrapper"} { if !contains(gate.Needs, job) { t.Errorf("ci-gate needs %q: %v", job, gate.Needs) } } for key, want := range map[string]string{ "PR_POLICY_WRAPPER": "${{ needs.pr-policy-wrapper.result }}", "PR_LINT_WRAPPER": "${{ needs.pr-lint-wrapper.result }}", } { if got := gateEnv[key]; got != want { t.Errorf("ci-gate env %s = %q, want %q", key, got, want) } } for _, required := range []string{"PR_POLICY_WRAPPER", "PR_LINT_WRAPPER"} { if !strings.Contains(gateEnv["CI_GATE_REQUIRED"], required) { t.Errorf("ci-gate CI_GATE_REQUIRED does not include %q", required) } } } type ciWorkflow struct { Jobs map[string]ciWorkflowJob `yaml:"jobs"` } type ciWorkflowJob struct { Needs ciWorkflowStringList `yaml:"needs"` Steps []ciWorkflowStep `yaml:"steps"` } type ciWorkflowStep struct { Name string `yaml:"name"` Run string `yaml:"run"` Env map[string]string `yaml:"env"` } type ciWorkflowStringList []string func (items *ciWorkflowStringList) UnmarshalYAML(node *yaml.Node) error { switch node.Kind { case yaml.ScalarNode: *items = []string{node.Value} return nil case yaml.SequenceNode: values := make([]string, 0, len(node.Content)) for _, item := range node.Content { if item.Kind != yaml.ScalarNode { return fmt.Errorf("needs item must be scalar, got YAML kind %d", item.Kind) } values = append(values, item.Value) } *items = values return nil default: return fmt.Errorf("needs must be scalar or sequence, got YAML kind %d", node.Kind) } } func readCIWorkflow(t *testing.T, name string) ciWorkflow { t.Helper() path := filepath.Join(sourceRepoRoot(t), ".github", "workflows", name) data, err := os.ReadFile(path) if err != nil { t.Fatal(err) } var workflow ciWorkflow if err := yaml.Unmarshal(data, &workflow); err != nil { t.Fatalf("parse %s: %v", path, err) } return workflow } func (workflow ciWorkflow) job(t *testing.T, name string) ciWorkflowJob { t.Helper() job, ok := workflow.Jobs[name] if !ok { t.Fatalf("workflow has no %q job", name) } return job } func (job ciWorkflowJob) step(t *testing.T, name string) ciWorkflowStep { t.Helper() for _, step := range job.Steps { if step.Name == name { return step } } t.Fatalf("job has no %q step", name) return ciWorkflowStep{} } func assertJobRunsExactly(t *testing.T, job ciWorkflowJob, want string) { t.Helper() for _, step := range job.Steps { if strings.TrimSpace(step.Run) == want { return } } t.Errorf("job has no step that runs exactly %q", want) } func contains(items []string, want string) bool { for _, item := range items { if item == want { return true } } return false }