package ci import ( "strings" "testing" ) func TestGitLabDocument(t *testing.T) { raw := []byte(` stages: [test, deploy] default: image: alpine:3.20 before_script: ["echo prep"] variables: MODE: {value: "ci"} .php: image: php:8.3 stage: test php_tests: extends: .php script: ["phpunit"] rules: - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH changes: ["**/*.php"] - when: never frontend_checks: stage: test script: ["node check"] rules: - if: $CI_COMMIT_TAG == null exists: ["package.json"] allow_failure: true cache: key: modules paths: ["node_modules"] deploy: stage: deploy when: manual resource_group: production timeout: 30m tags: [deploy] only: ["master", "tags"] script: ["echo deploy"] needs: - job: php_tests optional: true `) p, err := Parse(raw) if err != nil { t.Fatal(err) } if strings.Join(p.Stages, ",") != "test,deploy" { t.Fatalf("stages %v", p.Stages) } if p.Variables["MODE"] != "ci" { t.Fatal(p.Variables) } by := map[string]Job{} for _, j := range p.Jobs { by[j.Name] = j } if _, ok := by[".php"]; ok { t.Fatal("verborgen job hoort niet te draaien") } php := by["php_tests"] if php.Image != "php:8.3" || php.Stage != "test" || php.Before[0] != "echo prep" { t.Fatalf("extends %+v", php) } front := by["frontend_checks"] if !front.AllowFailure || front.Cache.Key != "modules" || front.Cache.Paths[0] != "node_modules" { t.Fatalf("frontend %+v", front) } dep := by["deploy"] if dep.When != "manual" || dep.ResourceGroup != "production" || dep.Timeout.Minutes() != 30 { t.Fatalf("deploy %+v", dep) } if len(dep.Needs) != 1 || dep.Optional[0] != "php_tests" { t.Fatalf("needs %+v opt %+v", dep.Needs, dep.Optional) } env := map[string]string{"CI_COMMIT_BRANCH": "master", "CI_DEFAULT_BRANCH": "master", "CI_COMMIT_REF_NAME": "master"} active, err := p.Select(Eval{Env: env, Changed: []string{"src/App.php"}, Files: []string{"package.json"}}) if err != nil { t.Fatal(err) } names := map[string]bool{} for _, j := range active { names[j.Name] = true } if !names["php_tests"] || !names["frontend_checks"] || !names["deploy"] { t.Fatalf("actief %v", names) } active, err = p.Select(Eval{Env: map[string]string{"CI_COMMIT_BRANCH": "feature", "CI_DEFAULT_BRANCH": "master", "CI_COMMIT_REF_NAME": "feature"}, Changed: []string{"README"}, Files: []string{}}) if err != nil { t.Fatal(err) } names = map[string]bool{} for _, j := range active { names[j.Name] = true if j.Name == "deploy" && j.When != "manual" { t.Fatal(j.When) } } if names["php_tests"] || names["frontend_checks"] { t.Fatalf("feature hoort die jobs over te slaan: %v", names) } if names["deploy"] { t.Fatal("only master/tags") } } func TestIncludeLocalAndWarnings(t *testing.T) { files := map[string]string{ "ci/base.yml": "jobs:\n unit:\n image: alpine\n script: ['echo unit']\n", } raw := []byte("include:\n - local: ci/base.yml\nservices: [db]\njobs:\n unit:\n script: ['echo replaced']\n") p, err := ParseIn(raw, func(path string) ([]byte, error) { return []byte(files[path]), nil }) if err != nil { t.Fatal(err) } if len(p.Jobs) != 1 || p.Jobs[0].Script[0] != "echo replaced" || p.Jobs[0].Image != "alpine" { t.Fatalf("%+v", p.Jobs) } if len(p.Warnings) != 1 || p.Warnings[0].Key != "ci.warn.ignored" { t.Fatalf("warnings %+v", p.Warnings) } _, issues := Lint([]byte("include:\n - project: other\njobs:\n a:\n image: alpine\n script: ['x']\n"), nil) found := false for _, is := range issues { if is.Key == "ci.err.includeRemote" { found = true } } if !found { t.Fatalf("issues %+v", issues) } } func TestWhenAndAllowFailure(t *testing.T) { p, err := Parse([]byte(` stages: [een, twee] jobs: a: stage: een image: alpine script: ['echo a'] allow_failure: true b: stage: twee image: alpine script: ['echo b'] c: stage: twee image: alpine when: always script: ['echo c'] d: stage: twee image: alpine when: on_failure script: ['echo d'] `)) if err != nil { t.Fatal(err) } st := map[string]string{"a": "failed", "b": "queued", "c": "queued", "d": "queued"} if Gate(p.Jobs, st, p.Jobs[1]) != "ready" { t.Fatal("allow_failure houdt de volgende stage niet tegen") } if Gate(p.Jobs, st, p.Jobs[2]) != "ready" || Gate(p.Jobs, st, p.Jobs[3]) != "ready" { t.Fatal("always en on_failure na een mislukking") } ok := map[string]string{"a": "success", "b": "queued", "c": "queued", "d": "queued"} if Gate(p.Jobs, ok, p.Jobs[3]) != "skip" { t.Fatal("on_failure slaat over na succes") } hard, err := Parse([]byte(` stages: [een, twee] jobs: a: stage: een image: alpine script: ['echo a'] b: stage: twee image: alpine script: ['echo b'] `)) if err != nil { t.Fatal(err) } if Gate(hard.Jobs, map[string]string{"a": "failed", "b": "queued"}, hard.Jobs[1]) != "skip" { t.Fatal("harde fout slaat de rest over") } } func TestMergeRequestPipelineRules(t *testing.T) { p, err := Parse([]byte(` push_job: image: alpine:3.20 script: ["echo push"] mr_job: image: alpine:3.20 script: ["echo mr"] rules: - if: $CI_PIPELINE_SOURCE == "merge_request_event" only_mr: image: alpine:3.20 script: ["echo only"] only: ["merge_requests"] `)) if err != nil { t.Fatal(err) } pushEnv := Variables(Ref{SHA: "abc", FullRef: "refs/heads/feature", Source: "push", DefaultBranch: "master", ProjectPath: "tim/app"}) push, err := p.Select(Eval{Env: pushEnv}) if err != nil { t.Fatal(err) } if len(push) != 1 || push[0].Name != "push_job" { t.Fatalf("push: %+v", namesOf(push)) } mr := &MRInfo{ID: 4, IID: 2, Title: "Titel", SourceBranch: "feature", TargetBranch: "master", ProjectPath: "tim/app", ProjectURL: "https://git.example/tim/app", TargetSHA: "def"} mrEnv := Variables(Ref{SHA: "abcdef", FullRef: "refs/heads/feature", Source: "merge_request_event", DefaultBranch: "master", ProjectPath: "tim/app", MR: mr}) if mrEnv["CI_MERGE_REQUEST_IID"] != "2" || mrEnv["CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"] != "feature" || mrEnv["CI_MERGE_REQUEST_TARGET_BRANCH_SHA"] != "def" || mrEnv["CI_MERGE_REQUEST_SOURCE_BRANCH_SHA"] != "abcdef" { t.Fatalf("%v", mrEnv) } got, err := p.Select(Eval{Env: mrEnv}) if err != nil { t.Fatal(err) } if strings.Join(namesOf(got), ",") != "mr_job,only_mr" { t.Fatalf("mr: %v", namesOf(got)) } } func namesOf(jobs []Job) []string { out := make([]string, len(jobs)) for i, j := range jobs { out[i] = j.Name } return out } func TestMaskAndVariables(t *testing.T) { if got := Mask("token=supersecret value", []string{"supersecret", "ab"}); got != "token=[MASKED] value" { t.Fatal(got) } env := Variables(Ref{SHA: "abcdef1234567890", FullRef: "refs/tags/v1.2.0", Title: "Uitgave", DefaultBranch: "master", Source: "push", ProjectPath: "tim/app", ProjectURL: "https://git.example/tim/app", APIURL: "https://git.example/api/v1", PipelineID: 9}) if env["CI_COMMIT_TAG"] != "v1.2.0" || env["CI_COMMIT_BRANCH"] != "" || env["CI_COMMIT_SHORT_SHA"] != "abcdef12" { t.Fatalf("%v", env) } if _, ok := env["CI_COMMIT_TIMESTAMP"]; ok { t.Fatal("lege committer-tijd hoort geen variabele te zetten") } stamped := Variables(Ref{SHA: "abcdef1234567890", FullRef: "refs/heads/master", Timestamp: "2026-10-22T22:32:33+00:00"}) if stamped["CI_COMMIT_TIMESTAMP"] != "2026-10-22T22:32:33+00:00" { t.Fatalf("timestamp: %q", stamped["CI_COMMIT_TIMESTAMP"]) } if env["CI_DEFAULT_BRANCH"] != "master" || env["CI_PROJECT_NAME"] != "app" || env["CI_PIPELINE_SOURCE"] != "push" { t.Fatalf("%v", env) } ok, err := evalRule(`$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH`, map[string]string{"CI_COMMIT_BRANCH": "master", "CI_DEFAULT_BRANCH": "master"}) if err != nil || !ok { t.Fatal(err, ok) } ok, err = evalRule(`$CI_COMMIT_TAG == null`, map[string]string{"CI_COMMIT_TAG": ""}) if err != nil || !ok { t.Fatal("null", err, ok) } }