@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

package/lib/testing/lib/metadata.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Test run metadata management
+ *
+ * Provides classes and utilities for generating and managing
+ * integration test metadata including unique IDs, timestamps,
+ * CI context, and system tags.
+ */
+/**
+ * CI/CD pipeline context
+ *
+ * Extracted from environment variables during test execution.
+ * Enables tracing resources back to specific pipeline runs.
+ */
+export interface CIContext {
+    /**
+     * CI platform ('github-actions', 'azure-devops', 'generic-ci', 'local')
+     */
+    readonly platform: string;
+    /**
+     * GitHub Actions workflow ID or equivalent
+     */
+    readonly pipelineId?: string;
+    /**
+     * GitHub Actions run ID or equivalent
+     */
+    readonly runId?: string;
+    /**
+     * GitHub Actions run number or equivalent
+     */
+    readonly runNumber?: string;
+    /**
+     * Git commit SHA (full)
+     */
+    readonly commitSha?: string;
+    /**
+     * Git commit SHA (short, 7 chars)
+     */
+    readonly commitShaShort?: string;
+    /**
+     * Git branch name
+     */
+    readonly branch?: string;
+    /**
+     * Git repository name
+     */
+    readonly repository?: string;
+}
+/**
+ * Integration test system tags
+ *
+ * Returns a record of tag key-value pairs for Azure resources.
+ * Uses Azure tag naming conventions with colons and hyphens.
+ */
+export type IntegrationTestTags = Record<string, string>;
+/**
+ * Test run configuration options
+ */
+export interface TestRunOptions {
+    /**
+     * Maximum age in hours before cleanup eligible (default: 4)
+     */
+    readonly maxAgeHours?: number;
+    /**
+     * Enable automated cleanup (default: true)
+     */
+    readonly autoCleanup?: boolean;
+    /**
+     * Cleanup policy (default: 'immediate')
+     */
+    readonly cleanupPolicy?: "immediate" | "delayed" | "manual";
+}
+/**
+ * Metadata for an integration test run
+ *
+ * Generated once per test execution and shared across all resources
+ * in that test. Provides unique identification, temporal tracking,
+ * and CI/CD context.
+ */
+export declare class TestRunMetadata {
+    /**
+     * Unique identifier for this test run (UUID v4)
+     */
+    readonly runId: string;
+    /**
+     * Sanitized test name from the describe block
+     */
+    readonly testName: string;
+    /**
+     * Timestamp when the test run started
+     */
+    readonly createdAt: Date;
+    /**
+     * Cleanup after timestamp (createdAt + maxAgeHours)
+     */
+    readonly cleanupAfter: Date;
+    /**
+     * Maximum age in hours before cleanup eligible
+     */
+    readonly maxAgeHours: number;
+    /**
+     * Enable automated cleanup
+     */
+    readonly autoCleanup: boolean;
+    /**
+     * Cleanup policy
+     */
+    readonly cleanupPolicy: "immediate" | "delayed" | "manual";
+    /**
+     * CI/CD context (populated from environment variables)
+     */
+    readonly ciContext?: CIContext;
+    /**
+     * Creates new test run metadata
+     *
+     * @param testName - Test name (will be sanitized)
+     * @param options - Optional configuration
+     */
+    constructor(testName: string, options?: TestRunOptions);
+    /**
+     * Generates system tags for resources
+     *
+     * @returns Integration test system tags
+     */
+    generateSystemTags(): Record<string, string>;
+    /**
+     * Checks if resources from this run are eligible for cleanup
+     *
+     * @param now - Current time (defaults to now)
+     * @returns Whether cleanup is eligible
+     */
+    isCleanupEligible(now?: Date): boolean;
+    /**
+     * Serializes metadata to JSON for logging
+     *
+     * @returns JSON-serializable object
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Sanitizes test name to be Azure-compliant
+     *
+     * @param name - Raw test name
+     * @returns Sanitized name
+     */
+    private sanitizeTestName;
+}
+/**
+ * Detects and extracts CI context from environment
+ *
+ * @returns CI context or undefined if not in CI
+ */
+export declare function detectCIContext(): CIContext | undefined;

package/lib/testing/lib/metadata.js

@@ -0,0 +1,180 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRunMetadata = void 0;
+exports.detectCIContext = detectCIContext;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Test run metadata management
+ *
+ * Provides classes and utilities for generating and managing
+ * integration test metadata including unique IDs, timestamps,
+ * CI context, and system tags.
+ */
+const uuid_1 = require("uuid");
+/**
+ * Metadata for an integration test run
+ *
+ * Generated once per test execution and shared across all resources
+ * in that test. Provides unique identification, temporal tracking,
+ * and CI/CD context.
+ */
+class TestRunMetadata {
+    /**
+     * Creates new test run metadata
+     *
+     * @param testName - Test name (will be sanitized)
+     * @param options - Optional configuration
+     */
+    constructor(testName, options) {
+        this.runId = (0, uuid_1.v4)();
+        this.testName = this.sanitizeTestName(testName);
+        this.createdAt = new Date();
+        this.maxAgeHours = options?.maxAgeHours ?? 4;
+        this.autoCleanup = options?.autoCleanup ?? true;
+        this.cleanupPolicy = options?.cleanupPolicy ?? "immediate";
+        this.cleanupAfter = new Date(this.createdAt.getTime() + this.maxAgeHours * 60 * 60 * 1000);
+        this.ciContext = detectCIContext();
+    }
+    /**
+     * Generates system tags for resources
+     *
+     * @returns Integration test system tags
+     */
+    generateSystemTags() {
+        // Build tags object with all properties
+        const tags = {
+            // Resource Identification
+            "test:run-id": this.runId,
+            "test:name": this.testName,
+            "test:resource-type": "integration-test",
+            // Temporal Tracking
+            "test:created-at": this.createdAt.toISOString(),
+            "test:cleanup-after": this.cleanupAfter.toISOString(),
+            "test:max-age-hours": this.maxAgeHours.toString(),
+            // Lifecycle Management
+            "test:managed-by": "terraform-cdk-constructs-tests",
+            "test:auto-cleanup": this.autoCleanup.toString(),
+            "test:cleanup-policy": this.cleanupPolicy,
+            // Backward Compatibility
+            environment: "integration-test",
+            purpose: "integration-test",
+        };
+        // Add CI/CD context if available
+        if (this.ciContext) {
+            if (this.ciContext.pipelineId) {
+                tags["test:ci-pipeline"] = this.ciContext.pipelineId;
+            }
+            if (this.ciContext.runId) {
+                tags["test:ci-run-id"] = this.ciContext.runId;
+            }
+            if (this.ciContext.runNumber) {
+                tags["test:ci-run-number"] = this.ciContext.runNumber;
+            }
+            if (this.ciContext.commitShaShort) {
+                tags["test:git-commit"] = this.ciContext.commitShaShort;
+            }
+            if (this.ciContext.branch) {
+                tags["test:git-branch"] = this.ciContext.branch;
+            }
+        }
+        return tags;
+    }
+    /**
+     * Checks if resources from this run are eligible for cleanup
+     *
+     * @param now - Current time (defaults to now)
+     * @returns Whether cleanup is eligible
+     */
+    isCleanupEligible(now) {
+        const currentTime = now || new Date();
+        return currentTime >= this.cleanupAfter;
+    }
+    /**
+     * Serializes metadata to JSON for logging
+     *
+     * @returns JSON-serializable object
+     */
+    toJSON() {
+        return {
+            runId: this.runId,
+            testName: this.testName,
+            createdAt: this.createdAt.toISOString(),
+            cleanupAfter: this.cleanupAfter.toISOString(),
+            maxAgeHours: this.maxAgeHours,
+            autoCleanup: this.autoCleanup,
+            cleanupPolicy: this.cleanupPolicy,
+            ciContext: this.ciContext,
+        };
+    }
+    /**
+     * Sanitizes test name to be Azure-compliant
+     *
+     * @param name - Raw test name
+     * @returns Sanitized name
+     */
+    sanitizeTestName(name) {
+        let sanitized = name
+            .toLowerCase()
+            // Replace spaces and special characters with hyphens
+            .replace(/[^a-z0-9-]/g, "-")
+            // Remove consecutive hyphens
+            .replace(/-+/g, "-")
+            // Remove leading/trailing hyphens
+            .replace(/^-+|-+$/g, "");
+        // Truncate to 63 characters (DNS label limit)
+        if (sanitized.length > 63) {
+            sanitized = sanitized.substring(0, 63).replace(/-+$/, "");
+        }
+        return sanitized;
+    }
+}
+exports.TestRunMetadata = TestRunMetadata;
+_a = JSII_RTTI_SYMBOL_1;
+TestRunMetadata[_a] = { fqn: "@microsoft/terraform-cdk-constructs.TestRunMetadata", version: "1.2.0" };
+/**
+ * Detects and extracts CI context from environment
+ *
+ * @returns CI context or undefined if not in CI
+ */
+function detectCIContext() {
+    // Detect GitHub Actions
+    if (process.env.GITHUB_ACTIONS === "true") {
+        return {
+            platform: "github-actions",
+            pipelineId: process.env.GITHUB_WORKFLOW,
+            runId: process.env.GITHUB_RUN_ID,
+            runNumber: process.env.GITHUB_RUN_NUMBER,
+            commitSha: process.env.GITHUB_SHA,
+            commitShaShort: process.env.GITHUB_SHA?.substring(0, 7),
+            branch: process.env.GITHUB_REF_NAME,
+            repository: process.env.GITHUB_REPOSITORY,
+        };
+    }
+    // Detect Azure DevOps
+    if (process.env.TF_BUILD === "True") {
+        return {
+            platform: "azure-devops",
+            pipelineId: process.env.BUILD_DEFINITIONNAME,
+            runId: process.env.BUILD_BUILDID,
+            runNumber: process.env.BUILD_BUILDNUMBER,
+            commitSha: process.env.BUILD_SOURCEVERSION,
+            commitShaShort: process.env.BUILD_SOURCEVERSION?.substring(0, 7),
+            branch: process.env.BUILD_SOURCEBRANCHNAME,
+            repository: process.env.BUILD_REPOSITORY_NAME,
+        };
+    }
+    // Detect generic CI
+    if (process.env.CI === "true") {
+        return {
+            platform: "generic-ci",
+            commitShaShort: "ci",
+        };
+    }
+    // Local execution
+    return {
+        platform: "local",
+        commitShaShort: "local",
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../../src/testing/lib/metadata.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Test run metadata management\n *\n * Provides classes and utilities for generating and managing\n * integration test metadata including unique IDs, timestamps,\n * CI context, and system tags.\n */\n\nimport { v4 as uuidv4 } from \"uuid\";\n\n/**\n * CI/CD pipeline context\n *\n * Extracted from environment variables during test execution.\n * Enables tracing resources back to specific pipeline runs.\n */\nexport interface CIContext {\n  /**\n   * CI platform ('github-actions', 'azure-devops', 'generic-ci', 'local')\n   */\n  readonly platform: string;\n\n  /**\n   * GitHub Actions workflow ID or equivalent\n   */\n  readonly pipelineId?: string;\n\n  /**\n   * GitHub Actions run ID or equivalent\n   */\n  readonly runId?: string;\n\n  /**\n   * GitHub Actions run number or equivalent\n   */\n  readonly runNumber?: string;\n\n  /**\n   * Git commit SHA (full)\n   */\n  readonly commitSha?: string;\n\n  /**\n   * Git commit SHA (short, 7 chars)\n   */\n  readonly commitShaShort?: string;\n\n  /**\n   * Git branch name\n   */\n  readonly branch?: string;\n\n  /**\n   * Git repository name\n   */\n  readonly repository?: string;\n}\n\n/**\n * Integration test system tags\n *\n * Returns a record of tag key-value pairs for Azure resources.\n * Uses Azure tag naming conventions with colons and hyphens.\n */\nexport type IntegrationTestTags = Record<string, string>;\n\n/**\n * Test run configuration options\n */\nexport interface TestRunOptions {\n  /**\n   * Maximum age in hours before cleanup eligible (default: 4)\n   */\n  readonly maxAgeHours?: number;\n\n  /**\n   * Enable automated cleanup (default: true)\n   */\n  readonly autoCleanup?: boolean;\n\n  /**\n   * Cleanup policy (default: 'immediate')\n   */\n  readonly cleanupPolicy?: \"immediate\" | \"delayed\" | \"manual\";\n}\n\n/**\n * Metadata for an integration test run\n *\n * Generated once per test execution and shared across all resources\n * in that test. Provides unique identification, temporal tracking,\n * and CI/CD context.\n */\nexport class TestRunMetadata {\n  /**\n   * Unique identifier for this test run (UUID v4)\n   */\n  public readonly runId: string;\n\n  /**\n   * Sanitized test name from the describe block\n   */\n  public readonly testName: string;\n\n  /**\n   * Timestamp when the test run started\n   */\n  public readonly createdAt: Date;\n\n  /**\n   * Cleanup after timestamp (createdAt + maxAgeHours)\n   */\n  public readonly cleanupAfter: Date;\n\n  /**\n   * Maximum age in hours before cleanup eligible\n   */\n  public readonly maxAgeHours: number;\n\n  /**\n   * Enable automated cleanup\n   */\n  public readonly autoCleanup: boolean;\n\n  /**\n   * Cleanup policy\n   */\n  public readonly cleanupPolicy: \"immediate\" | \"delayed\" | \"manual\";\n\n  /**\n   * CI/CD context (populated from environment variables)\n   */\n  public readonly ciContext?: CIContext;\n\n  /**\n   * Creates new test run metadata\n   *\n   * @param testName - Test name (will be sanitized)\n   * @param options - Optional configuration\n   */\n  constructor(testName: string, options?: TestRunOptions) {\n    this.runId = uuidv4();\n    this.testName = this.sanitizeTestName(testName);\n    this.createdAt = new Date();\n    this.maxAgeHours = options?.maxAgeHours ?? 4;\n    this.autoCleanup = options?.autoCleanup ?? true;\n    this.cleanupPolicy = options?.cleanupPolicy ?? \"immediate\";\n    this.cleanupAfter = new Date(\n      this.createdAt.getTime() + this.maxAgeHours * 60 * 60 * 1000,\n    );\n    this.ciContext = detectCIContext();\n  }\n\n  /**\n   * Generates system tags for resources\n   *\n   * @returns Integration test system tags\n   */\n  public generateSystemTags(): Record<string, string> {\n    // Build tags object with all properties\n    const tags: Record<string, string> = {\n      // Resource Identification\n      \"test:run-id\": this.runId,\n      \"test:name\": this.testName,\n      \"test:resource-type\": \"integration-test\",\n\n      // Temporal Tracking\n      \"test:created-at\": this.createdAt.toISOString(),\n      \"test:cleanup-after\": this.cleanupAfter.toISOString(),\n      \"test:max-age-hours\": this.maxAgeHours.toString(),\n\n      // Lifecycle Management\n      \"test:managed-by\": \"terraform-cdk-constructs-tests\",\n      \"test:auto-cleanup\": this.autoCleanup.toString(),\n      \"test:cleanup-policy\": this.cleanupPolicy,\n\n      // Backward Compatibility\n      environment: \"integration-test\",\n      purpose: \"integration-test\",\n    };\n\n    // Add CI/CD context if available\n    if (this.ciContext) {\n      if (this.ciContext.pipelineId) {\n        tags[\"test:ci-pipeline\"] = this.ciContext.pipelineId;\n      }\n      if (this.ciContext.runId) {\n        tags[\"test:ci-run-id\"] = this.ciContext.runId;\n      }\n      if (this.ciContext.runNumber) {\n        tags[\"test:ci-run-number\"] = this.ciContext.runNumber;\n      }\n      if (this.ciContext.commitShaShort) {\n        tags[\"test:git-commit\"] = this.ciContext.commitShaShort;\n      }\n      if (this.ciContext.branch) {\n        tags[\"test:git-branch\"] = this.ciContext.branch;\n      }\n    }\n\n    return tags as IntegrationTestTags;\n  }\n\n  /**\n   * Checks if resources from this run are eligible for cleanup\n   *\n   * @param now - Current time (defaults to now)\n   * @returns Whether cleanup is eligible\n   */\n  public isCleanupEligible(now?: Date): boolean {\n    const currentTime = now || new Date();\n    return currentTime >= this.cleanupAfter;\n  }\n\n  /**\n   * Serializes metadata to JSON for logging\n   *\n   * @returns JSON-serializable object\n   */\n  public toJSON(): Record<string, any> {\n    return {\n      runId: this.runId,\n      testName: this.testName,\n      createdAt: this.createdAt.toISOString(),\n      cleanupAfter: this.cleanupAfter.toISOString(),\n      maxAgeHours: this.maxAgeHours,\n      autoCleanup: this.autoCleanup,\n      cleanupPolicy: this.cleanupPolicy,\n      ciContext: this.ciContext,\n    };\n  }\n\n  /**\n   * Sanitizes test name to be Azure-compliant\n   *\n   * @param name - Raw test name\n   * @returns Sanitized name\n   */\n  private sanitizeTestName(name: string): string {\n    let sanitized = name\n      .toLowerCase()\n      // Replace spaces and special characters with hyphens\n      .replace(/[^a-z0-9-]/g, \"-\")\n      // Remove consecutive hyphens\n      .replace(/-+/g, \"-\")\n      // Remove leading/trailing hyphens\n      .replace(/^-+|-+$/g, \"\");\n\n    // Truncate to 63 characters (DNS label limit)\n    if (sanitized.length > 63) {\n      sanitized = sanitized.substring(0, 63).replace(/-+$/, \"\");\n    }\n\n    return sanitized;\n  }\n}\n\n/**\n * Detects and extracts CI context from environment\n *\n * @returns CI context or undefined if not in CI\n */\nexport function detectCIContext(): CIContext | undefined {\n  // Detect GitHub Actions\n  if (process.env.GITHUB_ACTIONS === \"true\") {\n    return {\n      platform: \"github-actions\",\n      pipelineId: process.env.GITHUB_WORKFLOW,\n      runId: process.env.GITHUB_RUN_ID,\n      runNumber: process.env.GITHUB_RUN_NUMBER,\n      commitSha: process.env.GITHUB_SHA,\n      commitShaShort: process.env.GITHUB_SHA?.substring(0, 7),\n      branch: process.env.GITHUB_REF_NAME,\n      repository: process.env.GITHUB_REPOSITORY,\n    };\n  }\n\n  // Detect Azure DevOps\n  if (process.env.TF_BUILD === \"True\") {\n    return {\n      platform: \"azure-devops\",\n      pipelineId: process.env.BUILD_DEFINITIONNAME,\n      runId: process.env.BUILD_BUILDID,\n      runNumber: process.env.BUILD_BUILDNUMBER,\n      commitSha: process.env.BUILD_SOURCEVERSION,\n      commitShaShort: process.env.BUILD_SOURCEVERSION?.substring(0, 7),\n      branch: process.env.BUILD_SOURCEBRANCHNAME,\n      repository: process.env.BUILD_REPOSITORY_NAME,\n    };\n  }\n\n  // Detect generic CI\n  if (process.env.CI === \"true\") {\n    return {\n      platform: \"generic-ci\",\n      commitShaShort: \"ci\",\n    };\n  }\n\n  // Local execution\n  return {\n    platform: \"local\",\n    commitShaShort: \"local\",\n  };\n}\n"]}

package/lib/testing/lib/naming.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Resource naming utilities for integration tests
+ *
+ * Provides functions for generating unique, Azure-compliant
+ * resource names with proper length constraints and character restrictions.
+ */
+/**
+ * Azure resource naming constraints
+ */
+interface ResourceConstraints {
+    maxLength: number;
+    allowHyphens: boolean;
+    allowUnderscores: boolean;
+    allowPeriods: boolean;
+    casePolicy: "lower" | "upper" | "any";
+    allowedPattern?: RegExp;
+}
+/**
+ * Options for generating resource names
+ */
+export interface NameGenerationOptions {
+    /**
+     * Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')
+     */
+    resourceType: string;
+    /**
+     * Test name or identifier
+     */
+    testName: string;
+    /**
+     * Test run UUID
+     */
+    runId: string;
+    /**
+     * Optional custom identifier to include in name
+     */
+    customIdentifier?: string;
+}
+/**
+ * Generates a unique, Azure-compliant resource name
+ *
+ * Creates names in format: {prefix}-{identifier}-{suffix} or
+ * {prefix}{identifier}{suffix} depending on resource constraints.
+ *
+ * @param options - Name generation options
+ * @returns Azure-compliant resource name
+ *
+ * @example
+ * generateResourceName({
+ *   resourceType: 'Microsoft.Resources/resourceGroups',
+ *   testName: 'storage-test',
+ *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'
+ * });
+ * // Returns: 'rg-storage-test-a1b2c3'
+ *
+ * generateResourceName({
+ *   resourceType: 'Microsoft.Storage/storageAccounts',
+ *   testName: 'basic-test',
+ *   runId: 'a1b2c3d4-e5f6-4789-b012-3456789abcde'
+ * });
+ * // Returns: 'stbasictesta1b2c3'
+ */
+export declare function generateResourceName(options: NameGenerationOptions): string;
+/**
+ * Gets the resource type prefix
+ *
+ * @param resourceType - Azure resource type
+ * @returns Short prefix for the resource type
+ */
+export declare function getResourcePrefix(resourceType: string): string;
+/**
+ * Sanitizes a test identifier to be Azure-compliant
+ *
+ * @param identifier - Raw identifier
+ * @param constraints - Resource naming constraints
+ * @returns Sanitized identifier
+ */
+export declare function sanitizeIdentifier(identifier: string, constraints: ResourceConstraints): string;
+/**
+ * Generates a short unique ID from a UUID
+ *
+ * Takes the first 6 characters of the UUID (without hyphens)
+ * to create a short, unique suffix.
+ *
+ * @param runId - UUID v4 run ID
+ * @returns Short ID (6 characters)
+ */
+export declare function generateShortId(runId: string): string;
+/**
+ * Gets resource naming constraints for a resource type
+ *
+ * @param resourceType - Azure resource type
+ * @returns Naming constraints for the resource type
+ */
+export declare function getResourceConstraints(resourceType: string): ResourceConstraints;
+export {};