@intentius/chant-lexicon-gitlab 0.0.16 → 0.0.18

package/src/testdata/pipelines/multi-stage.gitlab-ci.yml

@@ -0,0 +1,56 @@
+stages:
+  - build
+  - test
+  - deploy
+
+build-app:
+  stage: build
+  image: node:22-alpine
+  script:
+    - npm ci
+    - npm run build
+  artifacts:
+    paths:
+      - dist/
+    expire_in: 1 hour
+  cache:
+    key:
+      files:
+        - package-lock.json
+    paths:
+      - .npm/
+
+lint:
+  stage: test
+  image: node:22-alpine
+  needs:
+    - build-app
+  script:
+    - npm ci
+    - npm run lint
+
+unit-tests:
+  stage: test
+  image: node:22-alpine
+  needs:
+    - build-app
+  script:
+    - npm ci
+    - npm test -- --coverage
+  artifacts:
+    reports:
+      junit: junit.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml
+
+deploy-staging:
+  stage: deploy
+  needs:
+    - lint
+    - unit-tests
+  script:
+    - deploy.sh staging
+  environment:
+    name: staging
+    url: https://staging.example.com

package/src/testdata/pipelines/simple.gitlab-ci.yml

@@ -0,0 +1,9 @@
+stages:
+  - test
+
+unit-test:
+  stage: test
+  image: node:22-alpine
+  script:
+    - npm ci
+    - npm test

package/src/validate.test.ts

@@ -1,31 +1,37 @@
 import { describe, test, expect } from "bun:test";
-import { validate } from "./validate";
-import { dirname } from "path";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 
 const basePath = dirname(dirname(fileURLToPath(import.meta.url)));
+const lexiconPath = join(basePath, "src", "generated", "lexicon-gitlab.json");
+const hasGenerated = existsSync(lexiconPath);
 
 describe("validate", () => {
-  test("runs validation checks on current generated artifacts", async () => {
+  test.skipIf(!hasGenerated)("runs validation checks on current generated artifacts", async () => {
+    const { validate } = await import("./validate");
     const result = await validate({ basePath });
     expect(result.checks.length).toBeGreaterThan(0);
   });
 
-  test("checks lexicon JSON exists and parses", async () => {
+  test.skipIf(!hasGenerated)("checks lexicon JSON exists and parses", async () => {
+    const { validate } = await import("./validate");
     const result = await validate({ basePath });
     const jsonCheck = result.checks.find((c) => c.name === "lexicon-json-exists");
     expect(jsonCheck).toBeDefined();
     expect(jsonCheck?.ok).toBe(true);
   });
 
-  test("checks types exist", async () => {
+  test.skipIf(!hasGenerated)("checks types exist", async () => {
+    const { validate } = await import("./validate");
     const result = await validate({ basePath });
     const typesCheck = result.checks.find((c) => c.name === "types-exist");
     expect(typesCheck).toBeDefined();
     expect(typesCheck?.ok).toBe(true);
   });
 
-  test("checks required names are present", async () => {
+  test.skipIf(!hasGenerated)("checks required names are present", async () => {
+    const { validate } = await import("./validate");
     const result = await validate({ basePath });
     const requiredCheck = result.checks.find((c) => c.name === "required-names");
     expect(requiredCheck).toBeDefined();

package/src/variables.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect } from "bun:test";
+import { CI } from "./variables";
+
+describe("CI variables", () => {
+  test("all values start with $CI_", () => {
+    for (const [key, value] of Object.entries(CI)) {
+      expect(value).toMatch(/^\$CI_/);
+    }
+  });
+
+  test("all values are non-empty strings", () => {
+    for (const [key, value] of Object.entries(CI)) {
+      expect(typeof value).toBe("string");
+      expect(value.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("contains expected commit variables", () => {
+    expect(CI.CommitBranch).toBe("$CI_COMMIT_BRANCH");
+    expect(CI.CommitRef).toBe("$CI_COMMIT_REF_NAME");
+    expect(CI.CommitRefSlug).toBe("$CI_COMMIT_REF_SLUG");
+    expect(CI.CommitSha).toBe("$CI_COMMIT_SHA");
+    expect(CI.CommitTag).toBe("$CI_COMMIT_TAG");
+  });
+
+  test("contains expected project variables", () => {
+    expect(CI.ProjectDir).toBe("$CI_PROJECT_DIR");
+    expect(CI.ProjectId).toBe("$CI_PROJECT_ID");
+    expect(CI.ProjectName).toBe("$CI_PROJECT_NAME");
+    expect(CI.ProjectPath).toBe("$CI_PROJECT_PATH");
+  });
+
+  test("contains expected pipeline variables", () => {
+    expect(CI.PipelineId).toBe("$CI_PIPELINE_ID");
+    expect(CI.PipelineSource).toBe("$CI_PIPELINE_SOURCE");
+    expect(CI.JobId).toBe("$CI_JOB_ID");
+    expect(CI.JobName).toBe("$CI_JOB_NAME");
+    expect(CI.JobStage).toBe("$CI_JOB_STAGE");
+  });
+
+  test("contains expected registry variables", () => {
+    expect(CI.Registry).toBe("$CI_REGISTRY");
+    expect(CI.RegistryImage).toBe("$CI_REGISTRY_IMAGE");
+    expect(CI.RegistryUser).toBe("$CI_REGISTRY_USER");
+    expect(CI.RegistryPassword).toBe("$CI_REGISTRY_PASSWORD");
+  });
+
+  test("contains environment variables", () => {
+    expect(CI.Environment).toBe("$CI_ENVIRONMENT_NAME");
+    expect(CI.EnvironmentSlug).toBe("$CI_ENVIRONMENT_SLUG");
+    expect(CI.DefaultBranch).toBe("$CI_DEFAULT_BRANCH");
+    expect(CI.MergeRequestIid).toBe("$CI_MERGE_REQUEST_IID");
+  });
+
+  test("exports at least 20 variables", () => {
+    expect(Object.keys(CI).length).toBeGreaterThanOrEqual(20);
+  });
+});