diff --git a/.github/workflows/Action-Test.yml b/.github/workflows/Action-Test.yml index b2a7d72..d3a3000 100644 --- a/.github/workflows/Action-Test.yml +++ b/.github/workflows/Action-Test.yml @@ -5,6 +5,12 @@ run-name: "Action-Test - [${{ github.event.pull_request.title }} #${{ github.eve on: workflow_dispatch: pull_request: + types: + - opened + - reopened + - synchronize + - labeled + - unlabeled schedule: - cron: '0 0 * * *' @@ -12,14 +18,35 @@ concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true -permissions: - contents: read - pull-requests: read +permissions: {} jobs: + UnitTest: + name: Pester 6.1 + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - name: Checkout repo + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Test release decisions + uses: PSModule/Invoke-Pester@4ff33199141fdf22568990b6107fe3148ae93a1c # v5.1.0 + with: + Path: tests + Version: 6.1.0 + Prescript: | + Install-PSResource -Name powershell-yaml -Version '[0.4.12]' -TrustRepository -Repository PSGallery + Install-PSResource -Name PSSemVer -Version '[1.1.10]' -TrustRepository -Repository PSGallery + ActionTestDefault: name: Action-Test - [Default] runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: read steps: - name: Checkout repo uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 @@ -30,3 +57,60 @@ jobs: uses: ./ with: WhatIf: true + + - name: Prepare caller settings + id: caller-settings + shell: pwsh + run: | + $ErrorActionPreference = 'Stop' + $settingsFilePath = Join-Path -Path $env:RUNNER_TEMP -ChildPath 'release-caller.settings.yml' + @' + DefaultBump: major + AutoCleanup: true + CreateMajorTag: false + DatePrereleaseFormat: yyyyMMdd + VersionPrefix: v + WhatIf: false + Debug: true + Verbose: true + WorkingDirectory: .github + Version: '[0.43.1]' + Prerelease: true + '@ | Set-Content -LiteralPath $settingsFilePath + "path=$settingsFilePath" | Add-Content -LiteralPath $env:GITHUB_OUTPUT + + - name: Action-Test - Repository policy + uses: ./ + with: + SettingsFilePath: ${{ steps.caller-settings.outputs.path }} + AutoCleanup: false + DatePrereleaseFormat: '' + VersionPrefix: '' + Debug: '' + Verbose: '' + WorkingDirectory: '' + Version: '' + Prerelease: '' + WhatIf: true + + - name: Action-Test - Explicit standard-value override + uses: ./ + with: + SettingsFilePath: ${{ steps.caller-settings.outputs.path }} + DefaultBump: patch + AutoCleanup: false + DatePrereleaseFormat: '' + VersionPrefix: '' + Debug: false + Verbose: false + WorkingDirectory: ${{ github.workspace }} + Version: '[0.43.1]' + Prerelease: false + WhatIf: true + + - name: Remove caller settings + if: ${{ always() && steps.caller-settings.outputs.path != '' }} + shell: pwsh + env: + CALLER_SETTINGS_PATH: ${{ steps.caller-settings.outputs.path }} + run: Remove-Item -LiteralPath $env:CALLER_SETTINGS_PATH -ErrorAction Stop diff --git a/.github/workflows/Release.yml b/.github/workflows/Release.yml index fd81eb0..9ce46f0 100644 --- a/.github/workflows/Release.yml +++ b/.github/workflows/Release.yml @@ -3,7 +3,7 @@ name: Release run-name: "Release - [${{ github.event.pull_request.title }} #${{ github.event.pull_request.number }}] by @${{ github.actor }}" on: - pull_request: + pull_request_target: # zizmor: ignore[dangerous-triggers] trusted base checkout; writes labels and releases branches: - main types: @@ -12,16 +12,15 @@ on: - reopened - synchronize - labeled - paths: - - 'action.yml' - - 'src/**' + - unlabeled concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true + group: ${{ github.workflow }}-${{ github.event.pull_request.merged && github.event.pull_request.base.ref || github.event.pull_request.number || github.ref }} + cancel-in-progress: false permissions: contents: write # Required to create releases + issues: write # Required to provision release labels pull-requests: write # Required to create comments on the PRs jobs: diff --git a/README.md b/README.md index 9bcd513..be00b65 100644 --- a/README.md +++ b/README.md @@ -1,83 +1,46 @@ # Release-GHRepository -Automatically creates releases based on pull requests and labels. +Create GitHub releases from owned pull-request labels and a configurable default bump. +This action is for repository and workflow maintainers who publish GitHub releases through the `action.yml` input interface and version-controlled release settings. -## Specifications and practices +## Release decision -Release-GHRepository follows: +Release-GHRepository owns and provisions five labels: -- [SemVer 2.0.0 specifications](https://semver.org) -- [GitHub Flow specifications](https://docs.github.com/en/get-started/using-github/github-flow) -- [Continuous Delivery practices](https://en.wikipedia.org/wiki/Continuous_delivery) +| Label | Instruction | Valid combination | +| --- | --- | --- | +| `release:patch` | Increment the patch version. | Exactly one bump label. | +| `release:minor` | Increment the minor version. | Exactly one bump label. | +| `release:major` | Increment the major version. | Exactly one bump label. | +| `release:prerelease` | Publish from an open pull request as a prerelease. | Alone or with exactly one bump label. | +| `release:skip` | Validate without publishing a release. | Without another owned release label. | -## How it works +When no owned bump or skip label exists, `DefaultBump` selects `patch`, `minor`, or `major`. Its default is `patch`, preserving the automatic patch behavior from v2. An explicit `release:patch`, `release:minor`, or `release:major` label overrides `DefaultBump`. -The workflow will trigger on pull requests to the main branch. +`release:prerelease` is a mode. It uses the explicit bump when one is present and otherwise uses `DefaultBump`. `release:skip` suppresses publication instead of applying the default. -The following labels will inform the action what kind of release to create: -- For a major release, and increasing the first number in the version use: - - `major` - - `breaking` -- For a minor release, and increasing the second number in the version. - - `minor` - - `feature` -- For a patch release, and increases the third number in the version. - - `patch` - - `fix` +The action rejects: -When a pull request is closed, the action will create a release based on the labels and clean up any previous prereleases that were created. +- a `DefaultBump` value other than exactly `patch`, `minor`, or `major`; +- multiple bump labels; +- `release:skip` with another owned release label. -> [!NOTE] -> The labels can be configured using the `MajorLabels`, `MinorLabels` and `PatchLabels` parameters/settings in the configuration file to trigger -> on other labels. +Labels outside this set do not affect releases. Bare and legacy labels such as `Major`, `Minor`, `Patch`, `Prerelease`, `NoRelease`, `major`, `minor`, `patch`, and the retired `release:pre-release` are ignored, so a pull request carrying only those labels uses `DefaultBump`. -This action is built on [GitHub-Script](https://github.com/PSModule/GitHub-Script) which by default uses the `GITHUB_TOKEN`. -## Usage +## How it works -The action can be configured using the following settings: +On every non-WhatIf run, the action creates missing canonical labels and reconciles their colors and descriptions. It leaves all other repository labels unchanged. -| Name | Description | Default | Required | -| --- | --- | --- | --- | -| `AutoCleanup` | Control whether to automatically cleanup prereleases. If disabled, the action will not remove any prereleases. | `true` | false | -| `AutoPatching` | Control whether to automatically handle patches. If disabled, the action will only create a patch release if the pull request has a 'patch' label. | `true` | false | -| `ConfigurationFile` | The path to the configuration file. Settings in the configuration file take precedence over the action inputs. | `.github\auto-release.yml` | false | -| `CreateMajorTag` | Control whether to create a tag for major releases. | `true` | false | -| `CreateMinorTag` | Control whether to create a tag for minor releases. | `true` | false | -| `DatePrereleaseFormat` | The format to use for the prerelease number using [.NET DateTime format strings](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings). | `''` | false | -| `IgnoreLabels` | A comma separated list of labels that do not trigger a release. | `NoRelease` | false | -| `IncrementalPrerelease` | Control whether to automatically increment the prerelease number. If disabled, the action will ensure only one prerelease exists for a given branch. | `true` | false | -| `MajorLabels` | A comma separated list of labels that trigger a major release. | `major, breaking` | false | -| `MinorLabels` | A comma separated list of labels that trigger a minor release. | `minor, feature` | false | -| `PatchLabels` | A comma separated list of labels that trigger a patch release. | `patch, fix` | false | -| `UsePRTitleAsReleaseName` | When enabled, uses the pull request title as the name for the GitHub release. | `false` | false | -| `UsePRBodyAsReleaseNotes` | When enabled, uses the pull request body as the release notes for the GitHub release. | `true` | false | -| `UsePRTitleAsNotesHeading` | When enabled, the release notes will begin with the pull request title as a H1 heading followed by the pull request body. The title will include a reference to the PR number. | `true` | false | -| `VersionPrefix` | The prefix to use for the version number. | `v` | false | -| `WhatIf` | Control whether to simulate the action. If enabled, the action will not create any releases. Used for testing. | `false` | false | -| `Debug` | Enable debug output. | `'false'` | false | -| `Verbose` | Enable verbose output. | `'false'` | false | -| `Version` | Specifies the version of the GitHub module to install. Accepts an exact version or a NuGet version range (for example `[1.2.0, 2.0.0)`). | | false | -| `Prerelease` | Allow prerelease versions if available. | `'false'` | false | -| `WorkingDirectory` | The working directory where the script runs. | `${{ github.workspace }}` | false | - -### Configuration file - -The configuration file is a YAML file that can be used to configure the action. -By default, the configuration file is expected at `.github\auto-release.yml`, which can be changed using the `ConfigurationFile` setting. -The action's configuration can be changed by altering the settings in the configuration file. +An open pull request with `release:prerelease` publishes a prerelease from its explicit bump or `DefaultBump`. The prerelease name uses the head branch, while its tag targets the exact pull-request head commit. A pull request merged into the default branch publishes the resolved bump unless it carries `release:skip`. A closed pull request cleans up its prereleases when `AutoCleanup` is enabled. `release:skip` never publishes a version, but a closed skipped pull request still receives prerelease cleanup. -```yaml -DatePrereleaseFormat: 'yyyyMMddHHmm' -IncrementalPrerelease: false -VersionPrefix: '' -``` +Cleanup uses the effective `VersionPrefix` to locate the version core, then matches the exact case-sensitive branch identifier. Version-like text in a prefix cannot select another branch's release. Empty and hyphenated prefixes remain valid. If you change the prefix, automatic cleanup retains releases under earlier prefixes. Close active prerelease series before a prefix change, or retain their releases for separate authorized cleanup. -This example uses the date format for the prerelease, disables the incremental prerelease and removes the version prefix. +The workflow must run for `labeled` and `unlabeled` events so both valid and invalid label transitions are evaluated. Do not use a workflow path filter to bypass the release decision on non-artifact changes; use `release:skip`. -## Example +This action is built on [GitHub-Script](https://github.com/PSModule/GitHub-Script), which uses the workflow token by default. -Add a workflow in your repository using the following example: +## Usage ```yaml name: Release-GHRepository @@ -92,27 +55,128 @@ on: - reopened - synchronize - labeled + - unlabeled concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.event.pull_request.merged && github.event.pull_request.base.ref || github.event.pull_request.number || github.ref }} + cancel-in-progress: false + +permissions: + contents: write # Required to create releases and tags + issues: write # Required to provision repository labels + pull-requests: write # Required to comment on pull requests jobs: Release-GHRepository: - runs-on: ubuntu-latest + runs-on: ubuntu-24.04 steps: - - name: Checkout Code - uses: actions/checkout@v4 + - name: Checkout code + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false - - name: Release-GHRepository - uses: PSModule/Release-GHRepository@v1 + - name: Release repository + uses: PSModule/Release-GHRepository@ ``` -## Permissions +Select the full immutable commit SHA of an authorized, published release that supports this contract. An open pull request's head is a development candidate, not a production dependency. A controlled major tag is an option only when the producer's release automation exclusively maintains it within its compatible stable line. + +The `pull_request_target` workflow checks out the trusted base branch. Do not check out or execute an untrusted pull-request head with this writable token. + +## Inputs + +Each setting has a matching named input and an effective standard in its description. One private schema in `action.yml` defines the types and standards, not a bundled settings file. All 16 file-configurable inputs have no concrete native defaults: omitted, null, and empty-string inputs retain file values. A supplied nonempty input overrides the file even when equal to a standard; explicit `false` remains an override. `SettingsFilePath` is a separate selector. + +| Name | Description | Effective default | Required | +| --- | --- | --- | --- | +| `AutoCleanup` | Delete prereleases after the pull request closes. | `true` | false | +| `SettingsFilePath` | Select the repository settings file before startup. | `.github\auto-release.yml` | false | +| `DefaultBump` | Select the bump when no explicit bump or skip label exists. Accepts exactly `patch`, `minor`, or `major` with case-sensitive matching. | `patch` | false | +| `CreateMajorTag` | Create or update the floating major tag after a stable release. | `true` | false | +| `CreateMinorTag` | Create or update the floating minor tag after a stable release. | `true` | false | +| `DatePrereleaseFormat` | Append a [.NET date and time format](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings) to prerelease versions. | `''` | false | +| `IncrementalPrerelease` | Increment the prerelease number; when false, keep only one prerelease for the branch. | `true` | false | +| `UsePRTitleAsReleaseName` | Use the pull-request title as the GitHub Release name. | `false` | false | +| `UsePRBodyAsReleaseNotes` | Use the pull-request body as release notes. | `true` | false | +| `UsePRTitleAsNotesHeading` | Add the pull-request title and number as the release-notes heading. | `true` | false | +| `VersionPrefix` | Prefix the version number. | `v` | false | +| `WhatIf` | Log release and label changes without mutating repository state. | `false` | false | +| `Debug` | Enable GitHub-Script debug output. | `false` | false | +| `Verbose` | Enable GitHub-Script verbose output. | `false` | false | +| `Version` | Select the GitHub module dependency by exact version or NuGet version range. | `''` (latest) | false | +| `Prerelease` | Allow a prerelease version of the GitHub module dependency. This does not select a repository prerelease. | `false` | false | +| `WorkingDirectory` | Set the execution directory before GitHub-Script starts. Relative values use `github.workspace`. | `github.workspace` | false | + +Use the `release:prerelease` label to select repository prerelease behavior. The similarly named `Prerelease` action input only controls dependency resolution for the GitHub module used internally. + +### Settings file path + +The default repository settings file path is `.github\auto-release.yml`. Use `SettingsFilePath` to select a custom file. Omit this selector to use the default path; an empty or whitespace-only path is invalid. Literal paths with spaces or brackets are supported. A directory or a non-file-system provider is not a settings file. If the selected file is absent, valid standards and nonempty named inputs remain effective. + +File selection and execution follow this order: + +1. Resolve a supplied nonempty `WorkingDirectory` input from `github.workspace`. Without that input, use `github.workspace` as the initial directory. +2. Resolve a relative `SettingsFilePath` from that initial directory. An absolute selector keeps its literal path. +3. Read the selected file once. Resolve each relative file-defined `WorkingDirectory` from `github.workspace`, not from the file's directory. +4. Apply the private schema standards, the selected file, then known nonempty named inputs. Use the effective `WorkingDirectory` for execution without selecting another file. + +`src\Initialize-ReleaseConfiguration.ps1` resolves and validates all settings before GitHub-Script starts. It forwards `Debug`, `Verbose`, `WorkingDirectory`, `Version`, and `Prerelease` to that action. The release script receives the resolved policy and does not read or merge the file again. Every supplied directory must exist, even when a later input would override it. + +The bootstrap reads the private schema, not description prose. There is no bundled defaults asset or input-presence heuristic. An owned bump label overrides the valid effective `DefaultBump`. The action reports whether the bump comes from an owned label, a named input, a repository setting, or the shared standard. + +The runner does not expose its original caller-supplied key list to a composite action after it merges native defaults. A concrete native default would make omission indistinguishable from an explicitly supplied equal value. For example, with file policy `DefaultBump: major`, omitting the input retains major; supplying `DefaultBump: patch` deliberately overrides it. The action never detects presence by comparing values with a standard. -If running the action in a restrictive mode, the following permissions needs to be granted to the action: +The runner represents both omitted and explicitly empty composite inputs as empty text. Both mean no override for file-configurable settings. Empty inputs cannot clear text configured in a file. Set `VersionPrefix: ''` or `DatePrereleaseFormat: ''` in the file to remove the prefix or date suffix. Set `Version: ''` in the file to select the latest GitHub dependency. + +There is no reserved omission value. Nonempty inputs go through normal validation, including whitespace. Booleans accept YAML `true` and `false` or case-insensitive strings containing exactly `true` or `false`; whitespace-only booleans and bumps are invalid. Text values remain literal strings. Every file layer is validated, so valid named inputs or owned labels cannot hide invalid standards or repository settings. + +The repository file must contain a mapping of supported settings. Every input in the table except `SettingsFilePath` is a valid file key. The file can contain only the settings that differ from the standards. Unknown keys, removed keys, null values, and invalid values fail before GitHub-Script starts. A valid override cannot hide an invalid lower layer. ```yaml -permissions: - contents: write # Required to create releases - pull-requests: write # Required to create comments on the PRs +DatePrereleaseFormat: 'yyyyMMddHHmm' +DefaultBump: patch +IncrementalPrerelease: false +VersionPrefix: '' +Debug: false +Verbose: true +Version: '[0.43.0, 1.0.0)' +Prerelease: false +WorkingDirectory: '.' +``` + +For an invocation-specific minor bump, even when the repository configures major: + +```yaml +with: + DefaultBump: minor + AutoCleanup: false +``` + +To select a custom settings file, inherit its bump, and force a read-only invocation: + +```yaml +with: + SettingsFilePath: .github\repository-release.settings.yml + WhatIf: true +``` + +`DatePrereleaseFormat` formats only the existing prerelease suffix. `DefaultBump` does not support date versioning or a disabled automatic bump. Use `release:skip` when validation must succeed without publication. + +## Release records + +The release-bound pull request's title and complete body contain the incremental adoption instructions, changed consumer interfaces, verification evidence, and resolved release decision. Compose those records across the release range you adopt; repository guides do not replace them. + +The [owned-label release record](https://github.com/PSModule/Release-GHRepository/pull/109) contains the caller migration and publisher bootstrap requirements for this contract. + +## Contributing + +Follow the [MSX coding standards](https://msxorg.github.io/docs/Coding-Standards/) and [contribution workflow](https://msxorg.github.io/docs/Ways-of-Working/Contribution-Workflow/). Keep release-decision changes separate from changes to stable-publication authority and recovery. + +For the credential-free local loop, use PowerShell 7 with Pester 6.1.0, powershell-yaml 0.4.12, PSSemVer 1.1.10, and the GitHub module installed: + +```powershell +Import-Module -Name Pester -RequiredVersion 6.1.0 +Invoke-Pester -Path .\tests ``` + +Tests use the real bootstrap, resolver, YAML parser, and version library. Controller tests simulate GitHub responses and guard publication commands; they do not establish live API or permission behavior. The read-only caller job uses the actual composite with `WhatIf: true`. Neither check establishes live publication or concurrency contention. diff --git a/action.yml b/action.yml index bd28559..5a04f6c 100644 --- a/action.yml +++ b/action.yml @@ -1,5 +1,5 @@ name: Release GHRepository (by PSModule) -description: Automatically creates releases based on pull requests and labels. +description: Creates GitHub releases from owned pull-request labels and effective release settings. author: PSModule branding: icon: upload-cloud @@ -7,118 +7,148 @@ branding: inputs: AutoCleanup: - description: Control whether to automatically delete the prerelease tags after the stable release is created. + description: >- + Delete pull-request prereleases and their tags after the pull request closes. + Effective standard default: true. required: false - default: 'true' - AutoPatching: - description: Control whether to automatically handle patches. If disabled, the action will only create a patch release if the pull request has a 'patch' label. - required: false - default: 'true' - ConfigurationFile: - description: The path to the configuration file. Settings in the configuration file take precedence over the action inputs. + SettingsFilePath: + description: >- + Select the repository settings file before startup. Relative paths use an explicit WorkingDirectory, + otherwise github.workspace. Nonempty named inputs override file values; omitted or empty inputs retain them. required: false default: .github\auto-release.yml + DefaultBump: + description: >- + The release bump without an owned bump or skip label. Accepts exactly patch, minor, or major. + Effective standard default: patch. Omit or leave empty to follow repository policy. + required: false CreateMajorTag: - description: Control whether to create a major tag when a pull request is merged into the main branch. + description: >- + Control whether to create a major tag when a pull request is merged into the main branch. + Effective standard default: true. required: false - default: 'true' CreateMinorTag: - description: Control whether to create a minor tag when a pull request is merged into the main branch. + description: >- + Control whether to create a minor tag when a pull request is merged into the main branch. + Effective standard default: true. required: false - default: 'true' DatePrereleaseFormat: - description: If specified, uses a date based prerelease scheme. The format should be a valid .NET format string like 'yyyyMMddHHmm'. - required: false - default: '' - IgnoreLabels: - description: A comma separated list of labels that do not trigger a release. + description: >- + Format the existing prerelease date suffix with a valid .NET format such as yyyyMMddHHmm. + Effective standard default: empty string (no date suffix). required: false - default: NoRelease IncrementalPrerelease: - description: Control whether to automatically increment the prerelease number. If disabled, the action will ensure only one prerelease exists for a given branch. - required: false - default: 'true' - MajorLabels: - description: A comma separated list of labels that trigger a major release. - required: false - default: major, breaking - MinorLabels: - description: A comma separated list of labels that trigger a minor release. - required: false - default: minor, feature - PatchLabels: - description: A comma separated list of labels that trigger a patch release. + description: >- + Automatically increment the prerelease number; when false, keep one prerelease for the branch. + Effective standard default: true. required: false - default: patch, fix UsePRTitleAsReleaseName: - description: When enabled, uses the pull request title as the name for the GitHub release. + description: >- + Use the pull request title as the GitHub release name. + Effective standard default: false. required: false - default: 'false' UsePRBodyAsReleaseNotes: - description: When enabled, uses the pull request body as the release notes for the GitHub release. + description: >- + Use the pull request body as GitHub release notes. + Effective standard default: true. required: false - default: 'true' UsePRTitleAsNotesHeading: - description: When enabled, the release notes will begin with the pull request title as a H1 heading followed by the pull request body. The title will reference the pull request number. + description: >- + Begin release notes with the pull request title and number as an H1 heading. + Effective standard default: true. required: false - default: 'true' VersionPrefix: - description: The prefix to use for the version number. + description: >- + Prefix the version number. + Effective standard default: v. required: false - default: v WhatIf: - description: If specified, the action will only log the changes it would make, but will not actually create or delete any releases or tags. + description: >- + Log planned label, release, tag, and comment changes without mutating repository state. + Effective standard default: false. required: false - default: 'false' Debug: - description: Enable debug output. + description: >- + Enable GitHub-Script debug output. Effective standard default: false. required: false - default: 'false' Verbose: - description: Enable verbose output. + description: >- + Enable GitHub-Script verbose output. Effective standard default: false. required: false - default: 'false' Version: - description: Specifies the version of the GitHub module to be installed. Accepts an exact version or a NuGet version range (for example '[1.2.0, 2.0.0)'). + description: >- + Select the GitHub module dependency by exact version or NuGet version range, such as '[1.2.0, 2.0.0)'. + Effective standard default: empty string (latest dependency version). required: false Prerelease: - description: Allow prerelease versions if available. + description: >- + Allow prerelease versions of the GitHub module dependency. Effective standard default: false. + This does not select repository prerelease mode; use the release:prerelease label. required: false - default: 'false' WorkingDirectory: - description: The working directory where the script will run from. + description: >- + Set the execution directory before GitHub-Script starts. Relative values use github.workspace. + Effective standard default: github.workspace. A file-defined directory does not select another settings file. required: false - default: ${{ github.workspace }} runs: using: composite steps: - - name: Release-GHRepository - uses: PSModule/GitHub-Script@8083ec1f733f00357ee4d0db0c6056686e483bc0 # v1.9.0 + - name: Resolve release settings + id: settings + shell: pwsh + working-directory: ${{ github.workspace }} env: + PSMODULE_AUTO_RELEASE_ACTION_PATH: ${{ github.action_path }} + PSMODULE_AUTO_RELEASE_SETTING_METADATA: | + AutoCleanup: { Type: Boolean, Default: true, Phase: Release } + DefaultBump: { Type: Bump, Default: patch, Phase: Release } + CreateMajorTag: { Type: Boolean, Default: true, Phase: Release } + CreateMinorTag: { Type: Boolean, Default: true, Phase: Release } + DatePrereleaseFormat: { Type: DateTimeFormat, Default: '', Phase: Release } + IncrementalPrerelease: { Type: Boolean, Default: true, Phase: Release } + UsePRTitleAsReleaseName: { Type: Boolean, Default: false, Phase: Release } + UsePRBodyAsReleaseNotes: { Type: Boolean, Default: true, Phase: Release } + UsePRTitleAsNotesHeading: { Type: Boolean, Default: true, Phase: Release } + VersionPrefix: { Type: Text, Default: v, Phase: Release } + WhatIf: { Type: Boolean, Default: false, Phase: Release } + Debug: { Type: Boolean, Default: false, Phase: Startup } + Verbose: { Type: Boolean, Default: false, Phase: Startup } + WorkingDirectory: { Type: DirectoryPath, Default: '.', Phase: Startup } + Version: { Type: VersionConstraint, Default: '', Phase: Startup } + Prerelease: { Type: Boolean, Default: false, Phase: Startup } PSMODULE_AUTO_RELEASE_INPUT_AutoCleanup: ${{ inputs.AutoCleanup }} - PSMODULE_AUTO_RELEASE_INPUT_AutoPatching: ${{ inputs.AutoPatching }} - PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile: ${{ inputs.ConfigurationFile }} + PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath: ${{ inputs.SettingsFilePath }} + PSMODULE_AUTO_RELEASE_INPUT_DefaultBump: ${{ inputs.DefaultBump }} PSMODULE_AUTO_RELEASE_INPUT_CreateMajorTag: ${{ inputs.CreateMajorTag }} PSMODULE_AUTO_RELEASE_INPUT_CreateMinorTag: ${{ inputs.CreateMinorTag }} PSMODULE_AUTO_RELEASE_INPUT_DatePrereleaseFormat: ${{ inputs.DatePrereleaseFormat }} - PSMODULE_AUTO_RELEASE_INPUT_IgnoreLabels: ${{ inputs.IgnoreLabels }} PSMODULE_AUTO_RELEASE_INPUT_IncrementalPrerelease: ${{ inputs.IncrementalPrerelease }} - PSMODULE_AUTO_RELEASE_INPUT_MajorLabels: ${{ inputs.MajorLabels }} - PSMODULE_AUTO_RELEASE_INPUT_MinorLabels: ${{ inputs.MinorLabels }} - PSMODULE_AUTO_RELEASE_INPUT_PatchLabels: ${{ inputs.PatchLabels }} PSMODULE_AUTO_RELEASE_INPUT_UsePRBodyAsReleaseNotes: ${{ inputs.UsePRBodyAsReleaseNotes }} PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsReleaseName: ${{ inputs.UsePRTitleAsReleaseName }} PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsNotesHeading: ${{ inputs.UsePRTitleAsNotesHeading }} PSMODULE_AUTO_RELEASE_INPUT_VersionPrefix: ${{ inputs.VersionPrefix }} PSMODULE_AUTO_RELEASE_INPUT_WhatIf: ${{ inputs.WhatIf }} + PSMODULE_AUTO_RELEASE_INPUT_Debug: ${{ inputs.Debug }} + PSMODULE_AUTO_RELEASE_INPUT_Verbose: ${{ inputs.Verbose }} + PSMODULE_AUTO_RELEASE_INPUT_WorkingDirectory: ${{ inputs.WorkingDirectory }} + PSMODULE_AUTO_RELEASE_INPUT_Version: ${{ inputs.Version }} + PSMODULE_AUTO_RELEASE_INPUT_Prerelease: ${{ inputs.Prerelease }} + run: | + $null = & (Join-Path -Path $env:PSMODULE_AUTO_RELEASE_ACTION_PATH -ChildPath 'src\Initialize-ReleaseConfiguration.ps1') + + - name: Release-GHRepository + uses: PSModule/GitHub-Script@8083ec1f733f00357ee4d0db0c6056686e483bc0 # v1.9.0 + env: + PSMODULE_AUTO_RELEASE_ACTION_PATH: ${{ github.action_path }} + PSMODULE_AUTO_RELEASE_RESOLVED_SETTINGS: ${{ steps.settings.outputs.ReleaseSettings }} with: - Debug: ${{ inputs.Debug }} - Prerelease: ${{ inputs.Prerelease }} - Verbose: ${{ inputs.Verbose }} - Version: ${{ inputs.Version }} + Debug: ${{ steps.settings.outputs.Debug }} + Prerelease: ${{ steps.settings.outputs.Prerelease }} + Verbose: ${{ steps.settings.outputs.Verbose }} + Version: ${{ steps.settings.outputs.Version }} Name: Release-GHRepository - WorkingDirectory: ${{ inputs.WorkingDirectory }} + WorkingDirectory: ${{ steps.settings.outputs.WorkingDirectory }} Script: | - # Release-GHRepository - ${{ github.action_path }}/src/main.ps1 + $releaseSettings = ConvertFrom-Json -InputObject $env:PSMODULE_AUTO_RELEASE_RESOLVED_SETTINGS + & (Join-Path -Path $env:PSMODULE_AUTO_RELEASE_ACTION_PATH -ChildPath 'src\main.ps1') -Settings $releaseSettings diff --git a/src/Initialize-ReleaseConfiguration.ps1 b/src/Initialize-ReleaseConfiguration.ps1 new file mode 100644 index 0000000..28488d9 --- /dev/null +++ b/src/Initialize-ReleaseConfiguration.ps1 @@ -0,0 +1,150 @@ +#Requires -Version 7.2 + +<# + .SYNOPSIS + Resolve action settings before GitHub-Script starts. + + .DESCRIPTION + Select the repository settings file from the explicitly supplied initial + directory or the workspace. Read the selected file once, then resolve all + settings and write the private startup and release-policy handoff. + + .EXAMPLE + .\Initialize-ReleaseConfiguration.ps1 -WorkspacePath $workspace + + Return the resolved settings. In Actions, also write the step outputs. + + .INPUTS + None + + You can't pipe objects to Initialize-ReleaseConfiguration.ps1. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + The resolved startup and release settings. +#> +[OutputType([PSCustomObject])] +[CmdletBinding()] +param( + # The known caller workspace, independent of the current directory. + [Parameter()] + [string] $WorkspacePath = [Environment]::GetEnvironmentVariable('GITHUB_WORKSPACE'), + + # The runner's output file; local callers can omit it to return settings only. + [Parameter()] + [string] $OutputPath = [Environment]::GetEnvironmentVariable('GITHUB_OUTPUT') +) + +$ErrorActionPreference = 'Stop' + +Import-Module -Name (Join-Path -Path $PSScriptRoot -ChildPath 'Release-GHRepository.Helpers.psm1') -Force +if ([string]::IsNullOrWhiteSpace($WorkspacePath) -or -not [IO.Path]::IsPathRooted($WorkspacePath) -or + -not (Test-Path -LiteralPath $WorkspacePath -PathType Container)) { + throw 'GITHUB_WORKSPACE must identify an existing absolute workspace directory.' +} +$WorkspacePath = [IO.Path]::GetFullPath($WorkspacePath) + +if (-not (Get-Module -ListAvailable -Name powershell-yaml)) { + for ($attempt = 1; $attempt -le 5; $attempt++) { + try { + Install-PSResource -Name powershell-yaml -TrustRepository -Repository PSGallery -WarningAction SilentlyContinue + break + } catch { + $installationError = $_ + Write-Warning "Installation of powershell-yaml failed: $installationError" + if ($attempt -eq 5) { + throw $installationError + } + Start-Sleep -Seconds 10 + } + } +} +Import-Module -Name powershell-yaml + +Write-Information '::group::Resolve release settings' -InformationAction Continue +try { + $actionDefinitionPath = [IO.Path]::GetFullPath((Join-Path -Path $PSScriptRoot -ChildPath '..\action.yml')) + $metadata = Get-ReleaseSettingSchema -Path $actionDefinitionPath + Write-Information "Reading action release standards [$actionDefinitionPath]" -InformationAction Continue + $inputs = @{} + foreach ($name in $metadata.Keys) { + $inputs[$name] = [Environment]::GetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$name") + } + + $initialDirectory = $WorkspacePath + if (-not [string]::IsNullOrEmpty($inputs.WorkingDirectory)) { + $initialParameters = @{ + Name = 'WorkingDirectory' + Type = $metadata.WorkingDirectory.Type + Value = $inputs.WorkingDirectory + WorkspacePath = $WorkspacePath + } + $initialDirectory = ConvertTo-ReleaseSettingValue @initialParameters + } + $settingsFilePath = [Environment]::GetEnvironmentVariable('PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath') + if ($null -eq $settingsFilePath) { + $actionDefinition = ConvertFrom-Yaml -Yaml ([IO.File]::ReadAllText($actionDefinitionPath)) + $settingsFilePath = $actionDefinition.inputs.SettingsFilePath.default + } + $pathParameters = @{ + Name = 'SettingsFilePath' + Path = $settingsFilePath + BaseDirectory = $initialDirectory + } + $settingsFilePath = Resolve-ReleaseFileSystemPath @pathParameters + if (Test-Path -LiteralPath $settingsFilePath -PathType Container) { + throw 'SettingsFilePath must select a file, not a directory.' + } + $loggedPath = ConvertTo-Json -InputObject $settingsFilePath -Compress + $configuration = @{} + if (Test-Path -LiteralPath $settingsFilePath -PathType Leaf) { + Write-Information "Reading settings file [$loggedPath]" -InformationAction Continue + $configuration = ConvertFrom-Yaml -Yaml ([IO.File]::ReadAllText($settingsFilePath)) + if ($null -eq $configuration) { + throw "Release settings file [$loggedPath] must be a mapping of supported settings." + } + } else { + Write-Information "Settings file not found at [$loggedPath]" -InformationAction Continue + } + + $configurationParameters = @{ + Metadata = $metadata + WorkspacePath = $WorkspacePath + Inputs = $inputs + Configuration = $configuration + } + $settings = Resolve-ReleaseConfiguration @configurationParameters + $outputs = [ordered]@{} + $releaseSettings = [ordered]@{} + foreach ($name in $metadata.Keys) { + if ($metadata[$name].Phase -eq 'Startup') { + $value = $settings.$name + if ($value -is [bool]) { + $value = $value.ToString().ToLowerInvariant() + } + $outputs[$name] = $value + } else { + $releaseSettings[$name] = $settings.$name + } + } + $releaseSettings.DefaultBumpSource = $settings.DefaultBumpSource + $outputs.ReleaseSettings = ConvertTo-Json -InputObject $releaseSettings -Compress + Write-Information ("Resolved startup settings: {0}" -f (ConvertTo-Json -InputObject $outputs -Compress)) -InformationAction Continue + + if (-not [string]::IsNullOrEmpty($OutputPath)) { + $outputParameters = @{ + Name = 'GITHUB_OUTPUT' + Path = $OutputPath + BaseDirectory = $WorkspacePath + } + $outputFilePath = Resolve-ReleaseFileSystemPath @outputParameters + foreach ($name in $outputs.Keys) { + $delimiter = [guid]::NewGuid().ToString('N') + [IO.File]::AppendAllText($outputFilePath, "$name<<$delimiter`n$($outputs[$name])`n$delimiter`n") + } + } + $settings +} finally { + Write-Information '::endgroup::' -InformationAction Continue +} diff --git a/src/Release-GHRepository.Helpers.psm1 b/src/Release-GHRepository.Helpers.psm1 new file mode 100644 index 0000000..3dadb16 --- /dev/null +++ b/src/Release-GHRepository.Helpers.psm1 @@ -0,0 +1,753 @@ +$ErrorActionPreference = 'Stop' + +$resourceGetModule = Import-Module -Name Microsoft.PowerShell.PSResourceGet -PassThru +$versioningPath = Join-Path -Path $resourceGetModule.ModuleBase -ChildPath 'dependencies\NuGet.Versioning.dll' +$script:versionRangeType = [Reflection.Assembly]::LoadFrom($versioningPath).GetType('NuGet.Versioning.VersionRange', $true) + +function Get-ReleaseSettingSchema { + <# + .SYNOPSIS + Read the private setting schema from the action's own metadata. + + .DESCRIPTION + Require one complete schema for the named settings. Keep the file + selector separate from the setting types, standards, and destinations. + + .EXAMPLE + Get-ReleaseSettingSchema -Path $actionPath + + Return the action's validated setting definitions. + + .INPUTS + None + + You can't pipe objects to Get-ReleaseSettingSchema. + + .OUTPUTS + System.Collections.IDictionary + + The private setting definitions. + #> + [OutputType([System.Collections.IDictionary])] + [CmdletBinding()] + param( + # The full path to the action's own metadata. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $Path + ) + + $actionDefinition = ConvertFrom-Yaml -Yaml ([IO.File]::ReadAllText($Path)) + $metadataYaml = $actionDefinition.runs.steps[0].env.PSMODULE_AUTO_RELEASE_SETTING_METADATA + if ($metadataYaml -isnot [string] -or [string]::IsNullOrWhiteSpace($metadataYaml)) { + throw 'The action release standards must be a nonempty YAML mapping.' + } + $metadata = ConvertFrom-Yaml -Yaml $metadataYaml -Ordered + if ($metadata -isnot [System.Collections.IDictionary]) { + throw 'The action release standards must be a mapping of setting definitions.' + } + $settingNames = @($actionDefinition.inputs.Keys | Where-Object { $_ -ne 'SettingsFilePath' }) + foreach ($name in $settingNames) { + if ($metadata.Keys -notcontains $name) { + throw "Release standard defaults are missing required setting [$name]." + } + } + foreach ($name in $metadata.Keys) { + if ($settingNames -notcontains $name) { + throw "Unsupported release setting [$name] in the action metadata." + } + $definition = $metadata[$name] + if ($definition -isnot [System.Collections.IDictionary] -or + $definition.Keys -notcontains 'Default' -or $definition.Keys -notcontains 'Type' -or + $definition.Keys -notcontains 'Phase' -or $definition.Count -ne 3) { + throw "Invalid metadata for release setting [$name]. Supply Type, Default, and Phase." + } + if (@('Boolean', 'Text', 'Bump', 'DateTimeFormat', 'VersionConstraint', 'DirectoryPath') -cnotcontains $definition.Type) { + throw "Invalid metadata type for release setting [$name]." + } + if (@('Startup', 'Release') -cnotcontains $definition.Phase) { + throw "Invalid metadata phase for release setting [$name]. Use Startup or Release." + } + } + $metadata +} + +function Resolve-ReleaseFileSystemPath { + <# + .SYNOPSIS + Resolve a literal file-system path from a known directory. + + .DESCRIPTION + Resolve relative paths without using the process's current directory. + Reject non-file-system providers and invalid path characters. + + .EXAMPLE + Resolve-ReleaseFileSystemPath -Name 'SettingsFilePath' -Path '.github\auto-release.yml' -BaseDirectory $workspace + + Return the selected absolute file-system path. + + .INPUTS + None + + You can't pipe objects to Resolve-ReleaseFileSystemPath. + + .OUTPUTS + System.String + + The absolute literal path. + #> + [OutputType([string])] + [CmdletBinding()] + param( + # The setting name used in path diagnostics. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $Name, + + # The literal path to resolve. + [Parameter(Mandatory)] + [AllowEmptyString()] + [string] $Path, + + # The absolute directory for relative paths. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $BaseDirectory + ) + + if ([string]::IsNullOrWhiteSpace($Path)) { + throw "$Name must be a nonempty path." + } + $candidate = $Path + if (-not [IO.Path]::IsPathRooted($Path) -and $Path -notmatch '\A[^\\/]+:') { + $candidate = Join-Path -Path $BaseDirectory -ChildPath $Path + } + $provider = $null + $drive = $null + $fullPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath( + $candidate, [ref] $provider, [ref] $drive + ) + if ($provider.Name -ne 'FileSystem') { + throw "$Name must use a FileSystem path." + } + $fullPath = [IO.Path]::GetFullPath($fullPath) + $relativePart = $fullPath.Substring([IO.Path]::GetPathRoot($fullPath).Length) + foreach ($part in $relativePart -split '[\\/]') { + if ($part.IndexOfAny([IO.Path]::GetInvalidFileNameChars()) -ge 0) { + throw "$Name must use a valid FileSystem path." + } + } + $fullPath +} + +function ConvertTo-ReleaseSettingValue { + <# + .SYNOPSIS + Validate and convert one supplied release-setting value. + + .DESCRIPTION + Use the private schema type to validate text, booleans, bumps, date + formats, dependency versions, and execution directories. + + .EXAMPLE + ConvertTo-ReleaseSettingValue -Name 'AutoCleanup' -Type Boolean -Value 'false' -WorkspacePath $workspace + + Return the Boolean false value. + + .INPUTS + None + + You can't pipe objects to ConvertTo-ReleaseSettingValue. + + .OUTPUTS + System.Boolean + + A validated Boolean setting. + + .OUTPUTS + System.String + + A validated text setting. + #> + [OutputType([bool], [string])] + [CmdletBinding()] + param( + # The supported release-setting name. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $Name, + + # The type supplied by the action's private schema. + [Parameter(Mandatory)] + [ValidateSet('Boolean', 'Text', 'Bump', 'DateTimeFormat', 'VersionConstraint', 'DirectoryPath')] + [string] $Type, + + # The supplied value, including null so invalid values can be diagnosed. + [Parameter(Mandatory)] + [AllowNull()] + [AllowEmptyString()] + [object] $Value, + + # The known workspace for relative execution-directory values. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $WorkspacePath + ) + + if ($Type -eq 'Boolean') { + if ($Value -is [bool]) { + $Value + } elseif ($Value -is [string] -and @('true', 'false') -contains $Value) { + $Value -eq 'true' + } else { + throw "Invalid release setting [$Name]. Use true or false." + } + return + } + if ($Value -isnot [string]) { + throw "Invalid release setting [$Name]. Use a string value." + } + if ($Type -eq 'Bump') { + $null = ConvertTo-ReleaseBump -DefaultBump $Value + } + if ($Type -eq 'DateTimeFormat' -and -not [string]::IsNullOrEmpty($Value)) { + try { + $null = [datetime]::new(2000, 1, 1).ToString($Value, [Globalization.CultureInfo]::InvariantCulture) + } catch [FormatException] { + throw 'Invalid DatePrereleaseFormat. Use a valid .NET date and time format string.' + } + } + if ($Type -eq 'VersionConstraint' -and -not [string]::IsNullOrEmpty($Value)) { + $versionRange = $null + if (-not $script:versionRangeType::TryParse($Value, [ref] $versionRange)) { + throw "Invalid release setting [$Name]. Use an exact dependency version or a NuGet version range." + } + } + if ($Type -eq 'DirectoryPath') { + $pathParameters = @{ + Name = $Name + Path = $Value + BaseDirectory = $WorkspacePath + } + $Value = Resolve-ReleaseFileSystemPath @pathParameters + if (-not (Test-Path -LiteralPath $Value -PathType Container)) { + throw "Invalid release setting [$Name]. Use an existing directory." + } + } + $Value +} + +function Resolve-ReleaseConfiguration { + <# + .SYNOPSIS + Resolve validated release settings from action standards and inputs. + + .DESCRIPTION + Apply repository settings over the private schema standards, then + nonempty named action inputs. Validate every supplied layer so invalid + values cannot be masked. Preserve explicit false and file empty text + values, and record the effective default-bump source. + + .EXAMPLE + $parameters = @{ + Metadata = $settingMetadata + WorkspacePath = $workspace + Configuration = @{ DefaultBump = 'major' } + Inputs = @{ DefaultBump = 'minor' } + } + Resolve-ReleaseConfiguration @parameters + + Return the effective release settings with DefaultBump set to minor. + + .INPUTS + None + + You can't pipe objects to Resolve-ReleaseConfiguration. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + The validated effective release settings. + #> + [OutputType([PSCustomObject])] + [CmdletBinding()] + param( + # Types and standards parsed from the action's private metadata declaration. + [Parameter(Mandatory)] + [System.Collections.IDictionary] $Metadata, + + # The known workspace for all relative WorkingDirectory values. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $WorkspacePath, + + # Named runtime inputs; null and empty strings do not override file policy. + [Parameter()] + [AllowNull()] + [System.Collections.IDictionary] $Inputs, + + # The parsed configuration file, which must be a mapping when supplied. + [Parameter()] + [AllowNull()] + [object] $Configuration + ) + + if ($null -ne $Configuration -and $Configuration -isnot [System.Collections.IDictionary]) { + throw 'Release configuration must be a mapping of supported settings.' + } + $defaults = [ordered]@{} + foreach ($name in $Metadata.Keys) { + $defaults[$name] = $Metadata[$name].Default + } + $retiredSettings = @('AutoPatching', 'IgnoreLabels', 'MajorLabels', 'MinorLabels', 'PatchLabels') + $layers = @( + [PSCustomObject]@{ Source = 'SharedDefault'; Values = $defaults } + [PSCustomObject]@{ Source = 'RepositorySetting'; Values = $Configuration } + [PSCustomObject]@{ Source = 'ActionInput'; Values = $Inputs } + ) + $settings = [ordered]@{} + $defaultBumpSource = 'SharedDefault' + foreach ($layer in $layers) { + if ($null -eq $layer.Values) { + continue + } + foreach ($name in $layer.Values.Keys) { + if ($retiredSettings -contains $name) { + throw "Release setting [$name] was removed. Use DefaultBump and the owned release: labels." + } + if ($Metadata.Keys -notcontains $name) { + throw "Unsupported release setting [$name]. Use the documented release settings." + } + $value = $layer.Values[$name] + $isEmpty = $null -eq $value -or ($value -is [string] -and $value.Length -eq 0) + if ($layer.Source -eq 'ActionInput' -and $isEmpty) { + continue + } + $valueParameters = @{ + Name = $name + Type = $Metadata[$name].Type + Value = $value + WorkspacePath = $WorkspacePath + } + $settings[$name] = ConvertTo-ReleaseSettingValue @valueParameters + if ($name -eq 'DefaultBump') { + $defaultBumpSource = $layer.Source + } + } + } + + $null = ConvertTo-ReleaseBump -DefaultBump $settings.DefaultBump + $settings.DefaultBumpSource = $defaultBumpSource + [PSCustomObject] $settings +} + +function Get-ReleaseLabelDefinition { + <# + .SYNOPSIS + Return the canonical release labels owned by Release-GHRepository. + + .DESCRIPTION + Return the canonical label names and repository metadata used when the action + provisions its owned release controls. + + .EXAMPLE + Get-ReleaseLabelDefinition + + Return all canonical release-label definitions. + + .INPUTS + None + + You can't pipe objects to Get-ReleaseLabelDefinition. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + A canonical release-label definition. + #> + [OutputType([PSCustomObject])] + [CmdletBinding()] + param() + + [PSCustomObject]@{ + Name = 'release:patch' + Color = '5ac3a5' + Description = 'Publish a patch release.' + } + [PSCustomObject]@{ + Name = 'release:minor' + Color = '616f09' + Description = 'Publish a minor release.' + } + [PSCustomObject]@{ + Name = 'release:major' + Color = 'b60205' + Description = 'Publish a major release.' + } + [PSCustomObject]@{ + Name = 'release:prerelease' + Color = '8d7bdf' + Description = 'Publish a prerelease from this open pull request.' + } + [PSCustomObject]@{ + Name = 'release:skip' + Color = 'ededed' + Description = 'Validate this change without publishing a release.' + } +} + +function Get-PrereleaseCleanupCandidate { + <# + .SYNOPSIS + Return prereleases that belong to a pull-request prerelease identifier. + + .DESCRIPTION + Select only releases marked as prereleases whose effective prefix is + followed by a valid version core and the exact case-sensitive identifier. + Retain releases under other historical prefixes. The identifier must + end the tag or be followed by a dot; later hyphens never select it. + + .EXAMPLE + Get-PrereleaseCleanupCandidate -Releases $releases -PrereleaseName 'feature123' -VersionPrefix 'v' + + Return prereleases tagged with -feature123 or -feature123.. + + .INPUTS + None + + You can't pipe objects to Get-PrereleaseCleanupCandidate. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + A prerelease that belongs to the requested identifier. + #> + [OutputType([PSCustomObject])] + [CmdletBinding()] + param( + # The GitHub release records to inspect. + [Parameter(Mandatory)] + [AllowEmptyCollection()] + [AllowNull()] + [PSCustomObject[]] $Releases, + + # The normalized pull-request prerelease identifier. + [Parameter(Mandatory)] + [ValidateNotNullOrEmpty()] + [string] $PrereleaseName, + + # The effective prefix that locates the actual version boundary. + [Parameter(Mandatory)] + [AllowEmptyString()] + [string] $VersionPrefix + ) + + $escapedPrereleaseName = [regex]::Escape($PrereleaseName) + $identifierPattern = "\A$escapedPrereleaseName(?:\.|\z)" + $versionPattern = '\A(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)-' + + $Releases | Where-Object { + if ($_.isPrerelease -ne $true) { + return $false + } + $tagName = [string] $_.tagName + if (-not $tagName.StartsWith($VersionPrefix, [StringComparison]::Ordinal)) { + return $false + } + $versionTag = $tagName.Substring($VersionPrefix.Length) + $separator = [regex]::Match($versionTag, $versionPattern) + if (-not $separator.Success) { + return $false + } + $identifier = $versionTag.Substring($separator.Length) + $identifier -cmatch $identifierPattern + } +} + +function ConvertTo-ReleaseBump { + <# + .SYNOPSIS + Convert a configured default bump into the internal release-bump value. + + .DESCRIPTION + Validate DefaultBump with case-sensitive matching and return the + corresponding internal Patch, Minor, or Major value. Require the + configured value rather than choosing a policy default. + + .EXAMPLE + ConvertTo-ReleaseBump -DefaultBump 'minor' + + Return Minor. + + .INPUTS + None + + You can't pipe objects to ConvertTo-ReleaseBump. + + .OUTPUTS + System.String + + The validated internal release-bump value. + #> + [OutputType([string])] + [CmdletBinding()] + param( + # The validated effective bump supplied by the settings resolver. + [Parameter()] + [AllowNull()] + [AllowEmptyString()] + [string] $DefaultBump + ) + + $validDefaultBumps = @('patch', 'minor', 'major') + if ($validDefaultBumps -cnotcontains $DefaultBump) { + throw "Invalid DefaultBump [$DefaultBump]. Use exactly one of: patch, minor, major." + } + + switch -CaseSensitive ($DefaultBump) { + 'patch' { 'Patch' } + 'minor' { 'Minor' } + 'major' { 'Major' } + } +} + +function Resolve-ReleaseDecision { + <# + .SYNOPSIS + Resolve a release decision from canonical pull-request labels. + + .DESCRIPTION + Evaluate only the five labels owned by Release-GHRepository. An explicit + bump label overrides DefaultBump, release:prerelease selects prerelease + mode, and release:skip suppresses publication. Reject conflicting owned-label + combinations. Require the validated effective DefaultBump; this pure + helper does not load standards or choose an automatic policy. + + .EXAMPLE + Resolve-ReleaseDecision -Labels @('release:minor') -DefaultBump 'major' + + Return a Minor stable-release decision. + + .EXAMPLE + Resolve-ReleaseDecision -Labels @('release:patch', 'release:prerelease') -DefaultBump 'minor' + + Return a Patch prerelease decision. + + .EXAMPLE + Resolve-ReleaseDecision -Labels @() -DefaultBump 'minor' + + Return a Minor stable-release decision from the configured default. + + .INPUTS + None + + You can't pipe objects to Resolve-ReleaseDecision. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + The validated release decision. + #> + [OutputType([PSCustomObject])] + [CmdletBinding()] + param( + # All labels currently applied to the pull request. + [Parameter(Mandatory)] + [AllowEmptyCollection()] + [AllowNull()] + [string[]] $Labels, + + # The validated effective bump supplied by the settings resolver. + [Parameter()] + [AllowNull()] + [AllowEmptyString()] + [string] $DefaultBump, + + # The validated settings layer that supplies the effective default. + [Parameter()] + [ValidateSet('SharedDefault', 'ActionInput', 'RepositorySetting')] + [string] $DefaultBumpSource = 'SharedDefault' + ) + + $resolvedDefaultBump = ConvertTo-ReleaseBump -DefaultBump $DefaultBump + $bumpLabelTypes = [ordered]@{ + 'release:patch' = 'Patch' + 'release:minor' = 'Minor' + 'release:major' = 'Major' + } + $ownedLabelNames = @($bumpLabelTypes.Keys) + @('release:prerelease', 'release:skip') + $ownedLabels = [System.Collections.Generic.HashSet[string]]::new( + [System.StringComparer]::Ordinal + ) + + foreach ($label in $Labels) { + if ($ownedLabelNames -ccontains $label) { + $null = $ownedLabels.Add($label) + } + } + + $hasSkip = $ownedLabels.Contains('release:skip') + $hasPrerelease = $ownedLabels.Contains('release:prerelease') + $bumpLabels = @($bumpLabelTypes.Keys | Where-Object { $ownedLabels.Contains($_) }) + + if ($hasSkip) { + if ($ownedLabels.Count -ne 1) { + throw 'Invalid release labels: release:skip must not be combined with another release label.' + } + + [PSCustomObject]@{ + Bump = 'None' + Prerelease = $false + Skip = $true + DefaultBumpApplied = $false + BumpSource = 'release:skip' + } + return + } + + if ($bumpLabels.Count -gt 1) { + throw "Conflicting release bump labels: [$($bumpLabels -join ', ')]. Apply exactly one bump label." + } + + $defaultBumpApplied = $bumpLabels.Count -eq 0 + $bump = if ($defaultBumpApplied) { + $resolvedDefaultBump + } else { + $bumpLabelTypes[$bumpLabels[0]] + } + + [PSCustomObject]@{ + Bump = $bump + Prerelease = $hasPrerelease + Skip = $false + DefaultBumpApplied = $defaultBumpApplied + BumpSource = if ($defaultBumpApplied) { $DefaultBumpSource } else { $bumpLabels[0] } + } +} + +function Resolve-PullRequestReleaseContext { + <# + .SYNOPSIS + Resolve branch-derived naming and the immutable target for a pull request. + + .DESCRIPTION + Keep the pull-request head branch for prerelease naming while selecting + the exact head commit SHA as the release target. + + .EXAMPLE + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = 'feature/example' + sha = '0123456789012345678901234567890123456789' + } + } + Resolve-PullRequestReleaseContext -PullRequest $pullRequest + + Return a prerelease name of featureexample and the supplied commit SHA as + the prerelease target. + + .INPUTS + None + + You can't pipe objects to Resolve-PullRequestReleaseContext. + + .OUTPUTS + System.Management.Automation.PSCustomObject + + The validated pull-request release context. + #> + [OutputType([PSCustomObject])] + [CmdletBinding()] + param( + # The pull request from the GitHub event payload. + [Parameter(Mandatory)] + [PSCustomObject] $PullRequest, + + # Permit non-prerelease contexts whose branch cannot name a prerelease. + [Parameter()] + [switch] $AllowEmptyPrereleaseName + ) + + $headRef = [string] $PullRequest.head.ref + $headSha = [string] $PullRequest.head.sha + + if ([string]::IsNullOrWhiteSpace($headRef)) { + throw 'Pull request head ref is required.' + } + if ([string]::IsNullOrWhiteSpace($headSha)) { + throw 'Pull request head SHA is required.' + } + if ($headSha -notmatch '\A[0-9a-fA-F]{40}\z') { + throw 'Pull request head SHA must be a 40-character hexadecimal commit.' + } + + $prereleaseName = $headRef -replace '[^a-zA-Z0-9]' + if ([string]::IsNullOrWhiteSpace($prereleaseName) -and -not $AllowEmptyPrereleaseName) { + throw "Pull request head ref [$headRef] does not contain a valid prerelease identifier." + } + + [PSCustomObject]@{ + HeadRef = $headRef + PrereleaseName = $prereleaseName + PrereleaseTarget = $headSha + } +} + +function Test-PrereleaseCreation { + <# + .SYNOPSIS + Test whether the current pull-request event may create a prerelease. + + .DESCRIPTION + Return true only when a validated release decision requests a prerelease + and the pull request remains open. + + .EXAMPLE + $decision = Resolve-ReleaseDecision -Labels @('release:patch', 'release:prerelease') -DefaultBump 'minor' + Test-PrereleaseCreation -ReleaseDecision $decision + + Return true for an open pull request carrying a valid prerelease decision. + + .EXAMPLE + $decision = Resolve-ReleaseDecision -Labels @('release:patch', 'release:prerelease') -DefaultBump 'minor' + Test-PrereleaseCreation -ReleaseDecision $decision -PullRequestClosed + + Return false after the pull request closes. + + .INPUTS + None + + You can't pipe objects to Test-PrereleaseCreation. + + .OUTPUTS + System.Boolean + + Whether the event may create a prerelease. + #> + [OutputType([bool])] + [CmdletBinding()] + param( + # The validated canonical release decision. + [Parameter(Mandatory)] + [PSCustomObject] $ReleaseDecision, + + # Indicate that the pull request is closed, whether merged or abandoned. + [Parameter()] + [switch] $PullRequestClosed + ) + + $ReleaseDecision.Prerelease -and -not $ReleaseDecision.Skip -and -not $PullRequestClosed +} + +Export-ModuleMember -Function @( + 'ConvertTo-ReleaseBump' + 'ConvertTo-ReleaseSettingValue' + 'Get-PrereleaseCleanupCandidate' + 'Get-ReleaseLabelDefinition' + 'Get-ReleaseSettingSchema' + 'Resolve-ReleaseDecision' + 'Resolve-ReleaseConfiguration' + 'Resolve-ReleaseFileSystemPath' + 'Resolve-PullRequestReleaseContext' + 'Test-PrereleaseCreation' +) diff --git a/src/main.ps1 b/src/main.ps1 index 089a75f..c35b61b 100644 --- a/src/main.ps1 +++ b/src/main.ps1 @@ -6,10 +6,21 @@ Justification = 'Parameter is used in dynamic parameter validation.' )] [CmdletBinding()] -param() +param( + # The release policy resolved by the bootstrap before GitHub-Script starts. + [Parameter(Mandatory)] + [ValidateNotNull()] + [PSCustomObject] $Settings +) + +$ErrorActionPreference = 'Stop' +$releaseSettings = $Settings + +$helperModulePath = Join-Path -Path $PSScriptRoot -ChildPath 'Release-GHRepository.Helpers.psm1' +Import-Module -Name $helperModulePath -Force LogGroup 'Loading libraries' { - 'powershell-yaml', 'PSSemVer' | ForEach-Object { + 'PSSemVer' | ForEach-Object { $name = $_ Write-Output "Installing module: $name" $count = 5 @@ -32,33 +43,23 @@ LogGroup 'Loading libraries' { } LogGroup 'Set configuration' { - if (-not (Test-Path -Path $env:PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile -PathType Leaf)) { - Write-Output "Configuration file not found at [$env:PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile]" - } else { - Write-Output "Reading from configuration file [$env:PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile]" - $configuration = ConvertFrom-Yaml -Yaml (Get-Content $env:PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile -Raw) - } - - $autoCleanup = ![string]::IsNullOrEmpty($configuration.AutoCleanup) ? $configuration.AutoCleanup -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_AutoCleanup -eq 'true' - $autoPatching = ![string]::IsNullOrEmpty($configuration.AutoPatching) ? $configuration.AutoPatching -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_AutoPatching -eq 'true' - $createMajorTag = ![string]::IsNullOrEmpty($configuration.CreateMajorTag) ? $configuration.CreateMajorTag -EQ 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_CreateMajorTag -EQ 'true' - $createMinorTag = ![string]::IsNullOrEmpty($configuration.CreateMinorTag) ? $configuration.CreateMinorTag -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_CreateMinorTag -eq 'true' - $datePrereleaseFormat = ![string]::IsNullOrEmpty($configuration.DatePrereleaseFormat) ? $configuration.DatePrereleaseFormat : $env:PSMODULE_AUTO_RELEASE_INPUT_DatePrereleaseFormat - $incrementalPrerelease = ![string]::IsNullOrEmpty($configuration.IncrementalPrerelease) ? $configuration.IncrementalPrerelease -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_IncrementalPrerelease -eq 'true' - $usePRBodyAsReleaseNotes = ![string]::IsNullOrEmpty($configuration.UsePRBodyAsReleaseNotes) ? $configuration.UsePRBodyAsReleaseNotes -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_UsePRBodyAsReleaseNotes -eq 'true' - $usePRTitleAsReleaseName = ![string]::IsNullOrEmpty($configuration.UsePRTitleAsReleaseName) ? $configuration.UsePRTitleAsReleaseName -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsReleaseName -eq 'true' - $usePRTitleAsNotesHeading = ![string]::IsNullOrEmpty($configuration.UsePRTitleAsNotesHeading) ? $configuration.UsePRTitleAsNotesHeading -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsNotesHeading -eq 'true' - $versionPrefix = ![string]::IsNullOrEmpty($configuration.VersionPrefix) ? $configuration.VersionPrefix : $env:PSMODULE_AUTO_RELEASE_INPUT_VersionPrefix - $whatIf = ![string]::IsNullOrEmpty($configuration.WhatIf) ? $configuration.WhatIf -eq 'true' : $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf -eq 'true' - - $ignoreLabels = (![string]::IsNullOrEmpty($configuration.IgnoreLabels) ? $configuration.IgnoreLabels : $env:PSMODULE_AUTO_RELEASE_INPUT_IgnoreLabels) -split ',' | ForEach-Object { $_.Trim() } - $majorLabels = (![string]::IsNullOrEmpty($configuration.MajorLabels) ? $configuration.MajorLabels : $env:PSMODULE_AUTO_RELEASE_INPUT_MajorLabels) -split ',' | ForEach-Object { $_.Trim() } - $minorLabels = (![string]::IsNullOrEmpty($configuration.MinorLabels) ? $configuration.MinorLabels : $env:PSMODULE_AUTO_RELEASE_INPUT_MinorLabels) -split ',' | ForEach-Object { $_.Trim() } - $patchLabels = (![string]::IsNullOrEmpty($configuration.PatchLabels) ? $configuration.PatchLabels : $env:PSMODULE_AUTO_RELEASE_INPUT_PatchLabels) -split ',' | ForEach-Object { $_.Trim() } + $autoCleanup = $releaseSettings.AutoCleanup + $defaultBump = $releaseSettings.DefaultBump + $defaultBumpSource = $releaseSettings.DefaultBumpSource + $createMajorTag = $releaseSettings.CreateMajorTag + $createMinorTag = $releaseSettings.CreateMinorTag + $datePrereleaseFormat = $releaseSettings.DatePrereleaseFormat + $incrementalPrerelease = $releaseSettings.IncrementalPrerelease + $usePRBodyAsReleaseNotes = $releaseSettings.UsePRBodyAsReleaseNotes + $usePRTitleAsReleaseName = $releaseSettings.UsePRTitleAsReleaseName + $usePRTitleAsNotesHeading = $releaseSettings.UsePRTitleAsNotesHeading + $versionPrefix = $releaseSettings.VersionPrefix + $whatIf = $releaseSettings.WhatIf Write-Output '-------------------------------------------------' Write-Output "Auto cleanup enabled: [$autoCleanup]" - Write-Output "Auto patching enabled: [$autoPatching]" + Write-Output "Default bump: [$defaultBump]" + Write-Output "Default bump source: [$defaultBumpSource]" Write-Output "Create major tag enabled: [$createMajorTag]" Write-Output "Create minor tag enabled: [$createMinorTag]" Write-Output "Date-based prerelease format: [$datePrereleaseFormat]" @@ -68,14 +69,38 @@ LogGroup 'Set configuration' { Write-Output "Use PR title as notes heading: [$usePRTitleAsNotesHeading]" Write-Output "Version prefix: [$versionPrefix]" Write-Output "What if mode: [$whatIf]" - Write-Output '' - Write-Output "Ignore labels: [$($ignoreLabels -join ', ')]" - Write-Output "Major labels: [$($majorLabels -join ', ')]" - Write-Output "Minor labels: [$($minorLabels -join ', ')]" - Write-Output "Patch labels: [$($patchLabels -join ', ')]" Write-Output '-------------------------------------------------' } +LogGroup 'Provision release labels' { + if ([string]::IsNullOrWhiteSpace($env:GITHUB_REPOSITORY)) { + throw 'GITHUB_REPOSITORY is required to provision release labels.' + } + + foreach ($definition in Get-ReleaseLabelDefinition) { + $arguments = @( + 'label' + 'create' + $definition.Name + '--repo' + $env:GITHUB_REPOSITORY + '--color' + $definition.Color + '--description' + $definition.Description + '--force' + ) + if ($whatIf) { + Write-Output "WhatIf: gh $($arguments -join ' ')" + } else { + gh @arguments + if ($LASTEXITCODE -ne 0) { + throw "Failed to provision the canonical label [$($definition.Name)]. gh exited with code [$LASTEXITCODE]." + } + } + } +} + LogGroup 'Event information - JSON' { $githubEventJson = Get-Content $env:GITHUB_EVENT_PATH $githubEventJson | Format-List | Out-String @@ -101,7 +126,20 @@ $actionType = $githubEvent.action $isMerged = ($pull_request.merged).ToString() -eq 'True' $prIsClosed = $pull_request.state -eq 'closed' $prBaseRef = $pull_request.base.ref -$prHeadRef = $pull_request.head.ref +$labels = @($pull_request.labels.name | Where-Object { $null -ne $_ }) +$decisionParameters = @{ + Labels = $labels + DefaultBump = $defaultBump + DefaultBumpSource = $defaultBumpSource +} +$releaseDecision = Resolve-ReleaseDecision @decisionParameters +$contextParameters = @{ + PullRequest = $pull_request + AllowEmptyPrereleaseName = (-not $releaseDecision.Prerelease) +} +$pullRequestReleaseContext = Resolve-PullRequestReleaseContext @contextParameters +$prHeadRef = $pullRequestReleaseContext.HeadRef +$prereleaseTarget = $pullRequestReleaseContext.PrereleaseTarget $targetIsDefaultBranch = $pull_request.base.ref -eq $defaultBranchName Write-Output '-------------------------------------------------' @@ -112,6 +150,7 @@ Write-Output "PR Merged: [$isMerged]" Write-Output "PR Closed: [$prIsClosed]" Write-Output "PR Base Ref: [$prBaseRef]" Write-Output "PR Head Ref: [$prHeadRef]" +Write-Output "PR Head SHA: [$prereleaseTarget]" Write-Output "Target is default branch: [$targetIsDefaultBranch]" Write-Output '-------------------------------------------------' @@ -120,27 +159,22 @@ LogGroup 'Pull request - details' { } LogGroup 'Pull request - Labels' { - $labels = @() - $labels += $pull_request.labels.name $labels | Format-List | Out-String } -$createRelease = $isMerged -and $targetIsDefaultBranch +$createRelease = $isMerged -and $targetIsDefaultBranch -and -not $releaseDecision.Skip $closedPullRequest = $prIsClosed -and -not $isMerged -$createPrerelease = $labels -Contains 'prerelease' -and -not $createRelease -and -not $closedPullRequest -$prereleaseName = $prHeadRef -replace '[^a-zA-Z0-9]' - -$ignoreRelease = ($labels | Where-Object { $ignoreLabels -contains $_ }).Count -gt 0 -if ($ignoreRelease) { - Write-Output 'Ignoring release creation.' - return -} +$createPrerelease = Test-PrereleaseCreation -ReleaseDecision $releaseDecision -PullRequestClosed:$prIsClosed +$prereleaseName = $pullRequestReleaseContext.PrereleaseName -$majorRelease = ($labels | Where-Object { $majorLabels -contains $_ }).Count -gt 0 -$minorRelease = ($labels | Where-Object { $minorLabels -contains $_ }).Count -gt 0 -and -not $majorRelease -$patchRelease = (($labels | Where-Object { $patchLabels -contains $_ }).Count -gt 0 -or $autoPatching) -and -not $majorRelease -and -not $minorRelease +$majorRelease = $releaseDecision.Bump -eq 'Major' +$minorRelease = $releaseDecision.Bump -eq 'Minor' +$patchRelease = $releaseDecision.Bump -eq 'Patch' Write-Output '-------------------------------------------------' +Write-Output "Default bump applied: [$($releaseDecision.DefaultBumpApplied)]" +Write-Output "Bump source: [$($releaseDecision.BumpSource)]" +Write-Output "Skip release: [$($releaseDecision.Skip)]" Write-Output "Create a release: [$createRelease]" Write-Output "Create a prerelease: [$createPrerelease]" Write-Output "Create a major release: [$majorRelease]" @@ -152,30 +186,34 @@ Write-Output '-------------------------------------------------' LogGroup 'Get releases' { $releases = gh release list --json 'createdAt,isDraft,isLatest,isPrerelease,name,publishedAt,tagName' | ConvertFrom-Json if ($LASTEXITCODE -ne 0) { - Write-Error 'Failed to list all releases for the repo.' - exit $LASTEXITCODE + throw "Failed to list all releases for the repo. gh exited with code [$LASTEXITCODE]." } $releases | Select-Object -Property name, isPrerelease, isLatest, publishedAt | Format-Table | Out-String } -LogGroup 'Get latest version' { - $latestRelease = $releases | Where-Object { $_.isLatest -eq $true } - $latestRelease | Format-List | Out-String - $latestVersionString = $latestRelease.tagName - if (![string]::IsNullOrEmpty($latestVersionString)) { - $latestVersion = $latestVersionString | ConvertTo-PSSemVer - Write-Output '-------------------------------------------------' - Write-Output 'Latest version:' - $latestVersion | Format-Table - $latestVersion = $latestVersion.ToString() +$latestVersion = $null +if (-not $releaseDecision.Skip) { + LogGroup 'Get latest version' { + $latestRelease = $releases | Where-Object { $_.isLatest -eq $true } + $latestRelease | Format-List | Out-String + $latestVersionString = $latestRelease.tagName + if (![string]::IsNullOrEmpty($latestVersionString)) { + $latestVersion = $latestVersionString | ConvertTo-PSSemVer + Write-Output '-------------------------------------------------' + Write-Output 'Latest version:' + $latestVersion | Format-Table + $latestVersion = $latestVersion.ToString() + } } +} else { + Write-Output 'Skip selected; no release version is resolved.' } Write-Output '-------------------------------------------------' Write-Output "Latest version: [$latestVersion]" Write-Output '-------------------------------------------------' -if ($createPrerelease -or $createRelease -or $whatIf) { +if (-not $releaseDecision.Skip -and ($createPrerelease -or $createRelease -or $whatIf)) { LogGroup 'Calculate new version' { $latestVersion = New-PSSemVer -Version $latestVersion $newVersion = New-PSSemVer -Version $latestVersion @@ -226,8 +264,7 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } else { gh release delete $newVersion --cleanup-tag --yes if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to delete the release [$newVersion]." - exit $LASTEXITCODE + throw "Failed to delete the release [$newVersion]. gh exited with code [$LASTEXITCODE]." } } } @@ -262,25 +299,24 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } # Add remaining parameters - $releaseCreateCommand += @('--target', $prHeadRef, '--prerelease') + $releaseCreateCommand += @('--target', $prereleaseTarget, '--prerelease') Write-Output "gh $($releaseCreateCommand -join ' ')" if (-not $whatIf) { # Execute the command and capture the output $releaseURL = gh @releaseCreateCommand if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to create the release [$newVersion]." - exit $LASTEXITCODE + throw "Failed to create the release [$newVersion]. gh exited with code [$LASTEXITCODE]." } } if ($whatIf) { - Write-Output 'WhatIf: gh pr comment $pull_request.number -b "The release [$newVersion] has been created."' + $commentPreview = 'WhatIf: gh pr comment {0} -b "The release [{1}] has been created."' -f $pull_request.number, $newVersion + Write-Output $commentPreview } else { gh pr comment $pull_request.number -b "The release [$newVersion]($releaseURL) has been created." if ($LASTEXITCODE -ne 0) { - Write-Error 'Failed to comment on the pull request.' - exit $LASTEXITCODE + throw "Failed to comment on the pull request. gh exited with code [$LASTEXITCODE]." } } } else { @@ -317,8 +353,7 @@ if ($createPrerelease -or $createRelease -or $whatIf) { if (-not $whatIf) { gh @releaseCreateCommand if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to create the release [$newVersion]." - exit $LASTEXITCODE + throw "Failed to create the release [$newVersion]. gh exited with code [$LASTEXITCODE]." } } @@ -329,8 +364,7 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } else { git tag -f $majorTag 'main' if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to create major tag [$majorTag]." - exit $LASTEXITCODE + throw "Failed to create major tag [$majorTag]. git exited with code [$LASTEXITCODE]." } } } @@ -342,8 +376,7 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } else { git tag -f $minorTag 'main' if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to create minor tag [$minorTag]." - exit $LASTEXITCODE + throw "Failed to create minor tag [$minorTag]. git exited with code [$LASTEXITCODE]." } } } @@ -353,8 +386,7 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } else { git push origin --tags --force if ($LASTEXITCODE -ne 0) { - Write-Error 'Failed to push tags.' - exit $LASTEXITCODE + throw "Failed to push tags. git exited with code [$LASTEXITCODE]." } } } @@ -365,11 +397,18 @@ if ($createPrerelease -or $createRelease -or $whatIf) { } LogGroup 'List prereleases using the same name' { - $prereleasesToCleanup = $releases | Where-Object { $_.tagName -like "*$prereleaseName*" } + $prereleasesToCleanup = @() + if ([string]::IsNullOrEmpty($prereleaseName)) { + Write-Output 'This branch has no prerelease identifier; cleanup has no candidates.' + } else { + $prereleasesToCleanup = @( + Get-PrereleaseCleanupCandidate -Releases $releases -PrereleaseName $prereleaseName -VersionPrefix $versionPrefix + ) + } $prereleasesToCleanup | Select-Object -Property name, publishedAt, isPrerelease, isLatest | Format-Table | Out-String } -if ((($closedPullRequest -or $createRelease) -and $autoCleanup) -or $whatIf) { +if (($prIsClosed -and $autoCleanup) -or $whatIf) { LogGroup "Cleanup prereleases for [$prereleaseName]" { foreach ($rel in $prereleasesToCleanup) { $relTagName = $rel.tagName @@ -379,8 +418,7 @@ if ((($closedPullRequest -or $createRelease) -and $autoCleanup) -or $whatIf) { } else { gh release delete $rel.tagName --cleanup-tag --yes if ($LASTEXITCODE -ne 0) { - Write-Error "Failed to delete release [$relTagName]." - exit $LASTEXITCODE + throw "Failed to delete release [$relTagName]. gh exited with code [$LASTEXITCODE]." } } } diff --git a/tests/Release-GHRepository.Helpers.Tests.ps1 b/tests/Release-GHRepository.Helpers.Tests.ps1 new file mode 100644 index 0000000..e0053d9 --- /dev/null +++ b/tests/Release-GHRepository.Helpers.Tests.ps1 @@ -0,0 +1,1034 @@ +[Diagnostics.CodeAnalysis.SuppressMessageAttribute( + 'PSUseDeclaredVarsMoreThanAssignments', '', + Justification = 'Variables are assigned in BeforeAll and used inside It blocks.' +)] +[CmdletBinding()] +param() + +BeforeAll { + Import-Module -Name powershell-yaml, PSSemVer + $modulePath = Join-Path -Path $PSScriptRoot -ChildPath '..\src\Release-GHRepository.Helpers.psm1' + Import-Module -Name $modulePath -Force + $actionPath = Join-Path -Path $PSScriptRoot -ChildPath '..\action.yml' + $settingMetadata = Get-ReleaseSettingSchema -Path $actionPath + $standardSettings = @{} + foreach ($name in $settingMetadata.Keys) { + $standardSettings[$name] = $settingMetadata[$name].Default + } +} + +Describe 'Resolve-ReleaseConfiguration' { + BeforeAll { + $resolveConfiguration = @{ + Metadata = $settingMetadata + WorkspacePath = $TestDrive + } + } + + It 'resolves the startup setting from repository settings' -ForEach @( + @{ Name = 'Debug'; Value = $true } + @{ Name = 'Verbose'; Value = $true } + @{ Name = 'Prerelease'; Value = $true } + @{ Name = 'Version'; Value = '[0.43.0, 1.0.0)' } + @{ Name = 'WorkingDirectory'; Value = 'TestDrive' } + ) { + if ($Name -eq 'WorkingDirectory') { + $Value = $TestDrive + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ $Name = $Value } + + $result.$Name | Should -Be $Value + $result.$Name.GetType() | Should -Be $Value.GetType() + } + + It 'retains a startup file setting when its input is ' -ForEach @( + @{ InputState = 'null'; InputValue = $null } + @{ InputState = 'empty'; InputValue = '' } + ) { + $configuration = @{ + Debug = $true + Verbose = $true + Prerelease = $true + Version = '[0.43.0, 1.0.0)' + WorkingDirectory = $TestDrive + } + $inputs = @{} + foreach ($name in $configuration.Keys) { + $inputs[$name] = $InputValue + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration $configuration -Inputs $inputs + + foreach ($name in $configuration.Keys) { + $result.$name | Should -Be $configuration[$name] + } + } + + It 'applies false and nonempty startup overrides even when equal to standards' { + $configuration = @{ + Debug = $true + Verbose = $true + Prerelease = $true + Version = '[0.43.0, 1.0.0)' + WorkingDirectory = Join-Path -Path $TestDrive -ChildPath 'execution' + } + $null = New-Item -Path $configuration.WorkingDirectory -ItemType Directory -Force + $inputs = @{ + Debug = 'false' + Verbose = $false + Prerelease = 'FALSE' + Version = '0.43.1' + WorkingDirectory = $TestDrive + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration $configuration -Inputs $inputs + + $result.Debug | Should -BeFalse + $result.Verbose | Should -BeFalse + $result.Prerelease | Should -BeFalse + $result.Version | Should -BeExactly '0.43.1' + $result.WorkingDirectory | Should -BeExactly $TestDrive + } + + It 'applies every documented controller default when settings are omitted' { + $result = Resolve-ReleaseConfiguration @resolveConfiguration + $expected = [ordered]@{ + AutoCleanup = $true + DefaultBump = 'patch' + CreateMajorTag = $true + CreateMinorTag = $true + DatePrereleaseFormat = '' + IncrementalPrerelease = $true + UsePRTitleAsReleaseName = $false + UsePRBodyAsReleaseNotes = $true + UsePRTitleAsNotesHeading = $true + VersionPrefix = 'v' + WhatIf = $false + Debug = $false + Verbose = $false + WorkingDirectory = $TestDrive + Version = '' + Prerelease = $false + } + + $result.PSObject.Properties.Name | Should -Be (@($expected.Keys) + 'DefaultBumpSource') + $result.DefaultBumpSource | Should -BeExactly 'SharedDefault' + foreach ($name in $expected.Keys) { + $result.$name | Should -Be $expected[$name] -Because "[$name] has a documented default" + $result.$name.GetType() | Should -Be $expected[$name].GetType() + } + } + + It 'uses a caller DefaultBump when the file omits it' { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ DefaultBump = 'minor' } -Configuration @{} + $decision = Resolve-ReleaseDecision -Labels @() -DefaultBump $result.DefaultBump + + $decision.Bump | Should -BeExactly 'Minor' + $decision.DefaultBumpApplied | Should -BeTrue + } + + It 'lets named inputs override repository settings without mutating either mapping' { + $inputs = @{ DefaultBump = 'patch'; AutoCleanup = 'true'; VersionPrefix = 'v' } + $configuration = [ordered]@{ DefaultBump = 'major'; AutoCleanup = $false; VersionPrefix = '' } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Inputs $inputs -Configuration $configuration + $decision = Resolve-ReleaseDecision -Labels @() -DefaultBump $result.DefaultBump + + $decision.Bump | Should -BeExactly 'Patch' + $result.DefaultBumpSource | Should -BeExactly 'ActionInput' + $result.AutoCleanup | Should -BeTrue + $result.VersionPrefix | Should -BeExactly 'v' + $inputs.DefaultBump | Should -BeExactly 'patch' + $inputs.AutoCleanup | Should -BeExactly 'true' + $configuration.DefaultBump | Should -BeExactly 'major' + $configuration.AutoCleanup | Should -BeFalse + $configuration.Count | Should -Be 3 + } + + It 'lets an owned bump override the effective configured default' { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ DefaultBump = 'major' } + $decision = Resolve-ReleaseDecision -Labels @('release:minor') -DefaultBump $result.DefaultBump + + $decision.Bump | Should -BeExactly 'Minor' + $decision.DefaultBumpApplied | Should -BeFalse + } + + It 'keeps file text when the named input is empty for ' -ForEach @( + @{ Name = 'VersionPrefix'; Configured = 'repo-' } + @{ Name = 'DatePrereleaseFormat'; Configured = 'yyyyMMdd' } + ) { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ $Name = '' } -Configuration @{ $Name = $Configured } + + $result.$Name | Should -BeExactly $Configured + } + + It 'preserves an empty repository value when the named input is omitted for ' -ForEach @( + @{ Name = 'VersionPrefix' } + @{ Name = 'DatePrereleaseFormat' } + ) { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ $Name = '' } -Inputs @{ $Name = '' } + + $result.$Name | Should -BeExactly '' + } + + It 'accepts boolean values and case-insensitive true/false strings for every boolean setting' { + $names = @( + 'AutoCleanup' + 'CreateMajorTag' + 'CreateMinorTag' + 'IncrementalPrerelease' + 'UsePRTitleAsReleaseName' + 'UsePRBodyAsReleaseNotes' + 'UsePRTitleAsNotesHeading' + 'WhatIf' + 'Debug' + 'Verbose' + 'Prerelease' + ) + + foreach ($name in $names) { + foreach ($value in @($true, $false, 'true', 'false', 'TRUE', 'FALSE')) { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ $name = $value } + + $result.$name | Should -BeOfType ([bool]) + $result.$name | Should -Be ($value.ToString() -eq 'true') + } + } + } + + It 'rejects invalid boolean setting []' -ForEach @( + @{ Value = '' } + @{ Value = 'yes' } + @{ Value = ' true ' } + @{ Value = 1 } + @{ Value = $null } + @{ Value = @('true', 'false') } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ WhatIf = $Value } } | + Should -Throw '*WhatIf*true or false*' + } + + It 'rejects an explicit invalid DefaultBump [] instead of selecting patch' -ForEach @( + @{ Value = '' } + @{ Value = $null } + @{ Value = 'Patch' } + @{ Value = 'date' } + @{ Value = 'none' } + @{ Value = 1 } + @{ Value = @('patch', 'minor') } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ DefaultBump = $Value } } | + Should -Throw '*DefaultBump*' + } + + It 'rejects an invalid named input' { + { Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ DefaultBump = 'invalid' } } | + Should -Throw '*DefaultBump*' + } + + It 'rejects an invalid named input even when the repository value is valid' { + $parameters = @{ + Inputs = @{ DefaultBump = 'invalid' } + Configuration = @{ DefaultBump = 'minor' } + } + { Resolve-ReleaseConfiguration @resolveConfiguration @parameters } | + Should -Throw '*DefaultBump*' + } + + It 'lets a named DefaultBump override repository settings' { + $parameters = @{ + Inputs = @{ DefaultBump = 'minor' } + Configuration = @{ DefaultBump = 'major' } + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration @parameters + + $result.DefaultBump | Should -BeExactly 'minor' + $result.DefaultBumpSource | Should -BeExactly 'ActionInput' + } + + It 'inherits repository settings when no named input is supplied' { + $parameters = @{ + Inputs = @{} + Configuration = @{ DefaultBump = 'major' } + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration @parameters + + $result.DefaultBump | Should -BeExactly 'major' + $result.DefaultBumpSource | Should -BeExactly 'RepositorySetting' + } + + It 'keeps repository policy when the named bump is ' -ForEach @( + @{ InputState = 'null'; InputValue = $null } + @{ InputState = 'empty'; InputValue = '' } + ) { + $parameters = @{ + Inputs = @{ DefaultBump = $InputValue } + Configuration = @{ DefaultBump = 'major' } + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration @parameters + + $result.DefaultBump | Should -BeExactly 'major' + $result.DefaultBumpSource | Should -BeExactly 'RepositorySetting' + } + + It 'records the action input as the default source even when it equals the shared default' { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ DefaultBump = 'patch' } + + $result.DefaultBump | Should -BeExactly 'patch' + $result.DefaultBumpSource | Should -BeExactly 'ActionInput' + } + + It 'records a nondefault named input as the decision source' { + $result = Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ DefaultBump = 'minor' } + + $result.DefaultBump | Should -BeExactly 'minor' + $result.DefaultBumpSource | Should -BeExactly 'ActionInput' + } + + It 'preserves explicit false while null and empty inputs keep file text' { + $parameters = @{ + Configuration = @{ AutoCleanup = $true; VersionPrefix = 'v'; DatePrereleaseFormat = 'yyyyMMdd' } + Inputs = @{ AutoCleanup = $false; VersionPrefix = $null; DatePrereleaseFormat = '' } + } + + $result = Resolve-ReleaseConfiguration @resolveConfiguration @parameters + + $result.AutoCleanup | Should -BeFalse + $result.VersionPrefix | Should -BeExactly 'v' + $result.DatePrereleaseFormat | Should -BeExactly 'yyyyMMdd' + } + + It 'rejects an invalid repository value even when the caller supplies a valid override' { + $parameters = @{ + Configuration = @{ DefaultBump = 'invalid' } + Inputs = @{ DefaultBump = 'patch' } + } + + { Resolve-ReleaseConfiguration @resolveConfiguration @parameters } | + Should -Throw '*DefaultBump*' + } + + It 'rejects named input settings []' -ForEach @( + @{ Name = 'DefaultBump'; Value = ' '; Message = '*DefaultBump*' } + @{ Name = 'DefaultBump'; Value = 'date'; Message = '*DefaultBump*' } + @{ Name = 'DefaultBump'; Value = 'inherit'; Message = '*DefaultBump*' } + @{ Name = 'AutoCleanup'; Value = 'invalid'; Message = '*AutoCleanup*true or false*' } + @{ Name = 'AutoCleanup'; Value = ' '; Message = '*AutoCleanup*true or false*' } + @{ Name = 'AutoCleanup'; Value = 'inherit'; Message = '*AutoCleanup*true or false*' } + @{ Name = 'AutoCleanup'; Value = 0; Message = '*AutoCleanup*true or false*' } + @{ Name = 'AutoPatching'; Value = $true; Message = '*AutoPatching*removed*' } + @{ Name = 'AutoPatching'; Value = $null; Message = '*AutoPatching*removed*' } + @{ Name = 'DefaultBunp'; Value = 'minor'; Message = '*Unsupported release setting*' } + @{ Name = 'DefaultBunp'; Value = ''; Message = '*Unsupported release setting*' } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Inputs @{ $Name = $Value } } | + Should -Throw $Message + } + + It 'rejects literal inherit as an invalid repository bump even with a valid input' { + $parameters = @{ + Configuration = @{ DefaultBump = 'inherit' } + Inputs = @{ DefaultBump = 'minor' } + } + + { Resolve-ReleaseConfiguration @resolveConfiguration @parameters } | + Should -Throw '*Invalid DefaultBump*' + } + + It 'rejects null and non-string text settings instead of coercing them' -ForEach @( + @{ Name = 'VersionPrefix'; Value = $null } + @{ Name = 'VersionPrefix'; Value = 1 } + @{ Name = 'DatePrereleaseFormat'; Value = $false } + @{ Name = 'DatePrereleaseFormat'; Value = @{ format = 'yyyyMMdd' } } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ $Name = $Value } } | + Should -Throw "*$Name*string*" + } + + It 'rejects an invalid prerelease date format before publication is considered' { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ DatePrereleaseFormat = '%' } } | + Should -Throw '*DatePrereleaseFormat*format*' + } + + It 'rejects the retired setting with migration guidance' -ForEach @( + @{ Name = 'AutoPatching' } + @{ Name = 'IgnoreLabels' } + @{ Name = 'MajorLabels' } + @{ Name = 'MinorLabels' } + @{ Name = 'PatchLabels' } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ $Name = 'legacy' } } | + Should -Throw "*$Name*removed*DefaultBump*release:*" + } + + It 'rejects an unknown setting instead of silently ignoring a typo' { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration @{ DefaultBunp = 'minor' } } | + Should -Throw '*Unsupported release setting*DefaultBunp*' + } + + It 'rejects a configuration root that is not a mapping' -ForEach @( + @{ Configuration = 'DefaultBump: minor' } + @{ Configuration = @('patch', 'minor') } + @{ Configuration = $true } + ) { + { Resolve-ReleaseConfiguration @resolveConfiguration -Configuration $Configuration } | + Should -Throw '*configuration must be a mapping*' + } +} + +Describe 'Get-ReleaseLabelDefinition' { + BeforeAll { + $definitions = @(Get-ReleaseLabelDefinition) + } + + It 'returns exactly the five canonical labels' { + $definitions.Name | Should -Be @( + 'release:patch' + 'release:minor' + 'release:major' + 'release:prerelease' + 'release:skip' + ) + } + + It 'returns a unique name for every definition' { + @($definitions.Name | Sort-Object -Unique).Count | Should -Be $definitions.Count + } + + It 'returns valid repository metadata for ' -ForEach @( + @{ Name = 'release:patch' } + @{ Name = 'release:minor' } + @{ Name = 'release:major' } + @{ Name = 'release:prerelease' } + @{ Name = 'release:skip' } + ) { + $definition = $definitions | Where-Object Name -CEQ $Name + + $definition.Color | Should -Match '^[0-9a-f]{6}$' + $definition.Description | Should -Not -BeNullOrEmpty + $definition.Description.Length | Should -BeLessOrEqual 100 + } +} + +Describe 'Get-PrereleaseCleanupCandidate' { + BeforeAll { + $releases = @( + [PSCustomObject]@{ + tagName = 'v1.2.3-123.1' + isPrerelease = $true + } + [PSCustomObject]@{ + tagName = 'v1.2.3-123' + isPrerelease = $true + } + [PSCustomObject]@{ + tagName = 'v1.2.3-1234.1' + isPrerelease = $true + } + [PSCustomObject]@{ + tagName = 'v1.2.3-other.123.1' + isPrerelease = $true + } + [PSCustomObject]@{ + tagName = 'v1.2.3' + isPrerelease = $false + } + [PSCustomObject]@{ + tagName = 'v123.0.0' + isPrerelease = $false + } + [PSCustomObject]@{ + tagName = 'v1.2.3-123.2' + isPrerelease = $false + } + ) + } + + It 'returns only prereleases with the exact numeric identifier segment' { + $result = @(Get-PrereleaseCleanupCandidate -Releases $releases -PrereleaseName '123' -VersionPrefix 'v') + + $result.tagName | Should -Be @('v1.2.3-123.1', 'v1.2.3-123') + } + + It 'uses the actual version boundary for ' -ForEach @( + @{ + PrefixCase = 'an own-branch release after version-like prefix text' + Prefix = 'release-1.2.3-' + Branch = 'feature' + ExpectedTag = 'release-1.2.3-2.0.4-feature.1' + ExpectedCount = 1 + } + @{ + PrefixCase = 'another branch after identifier-like prefix text' + Prefix = 'release-1.2.3-feature.extra-' + Branch = 'other' + ExpectedTag = 'release-1.2.3-feature.extra-2.0.4-other.1' + ExpectedCount = 0 + } + ) { + $parameters = @{ + Metadata = $settingMetadata + WorkspacePath = $TestDrive + Configuration = @{ VersionPrefix = $Prefix } + } + $settings = Resolve-ReleaseConfiguration @parameters + $version = New-PSSemVer -Version '2.0.4' + $version.Prefix = $settings.VersionPrefix + $version.Prerelease = $Branch + $version.BumpPrereleaseNumber() + $tagName = $version.ToString() + $tagName | Should -BeExactly $ExpectedTag + $records = @([PSCustomObject]@{ tagName = $tagName; isPrerelease = $true }) + + $result = @( + Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'feature' -VersionPrefix $settings.VersionPrefix + ) + + $result.Count | Should -Be $ExpectedCount + if ($ExpectedCount -eq 1) { + $result[0].tagName | Should -BeExactly $ExpectedTag + } + } + + It 'never returns stable releases whose versions overlap the identifier' { + $result = @(Get-PrereleaseCleanupCandidate -Releases $releases -PrereleaseName '123' -VersionPrefix 'v') + + $result | Where-Object { -not $_.isPrerelease } | Should -BeNullOrEmpty + $result.tagName | Should -Not -Contain 'v1.2.3' + $result.tagName | Should -Not -Contain 'v123.0.0' + $result.tagName | Should -Not -Contain 'v1.2.3-123.2' + } + + It 'does not match a longer or later prerelease identifier segment' { + $result = @(Get-PrereleaseCleanupCandidate -Releases $releases -PrereleaseName '123' -VersionPrefix 'v') + + $result.tagName | Should -Not -Contain 'v1.2.3-1234.1' + $result.tagName | Should -Not -Contain 'v1.2.3-other.123.1' + } + + It 'escapes regular-expression characters in the identifier' { + $regexReleases = @( + [PSCustomObject]@{ + tagName = 'v1.2.3-feature.test.1' + isPrerelease = $true + } + [PSCustomObject]@{ + tagName = 'v1.2.3-featureXtest.1' + isPrerelease = $true + } + ) + + $result = @( + Get-PrereleaseCleanupCandidate -Releases $regexReleases -PrereleaseName 'feature.test' -VersionPrefix 'v' + ) + + $result.tagName | Should -Be @('v1.2.3-feature.test.1') + } + + It 'never matches a name after the first SemVer prerelease separator' { + $tagNames = @( + 'v1.2.3-other-feature.1' + 'v1.2.3-other.1-feature.2' + 'v1.2.3-other-v4.5.6-feature.1' + 'v1.2.3-feature.1' + ) + $records = @($tagNames | ForEach-Object { [PSCustomObject]@{ tagName = $_; isPrerelease = $true } }) + + $result = @(Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'feature' -VersionPrefix 'v') + + $result.tagName | Should -Be @('v1.2.3-feature.1') + } + + It 'distinguishes case-sensitive branch identifiers' { + $records = @( + [PSCustomObject]@{ tagName = 'v1.2.3-Feature.1'; isPrerelease = $true } + [PSCustomObject]@{ tagName = 'v1.2.3-feature.1'; isPrerelease = $true } + ) + + $result = @(Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'Feature' -VersionPrefix 'v') + + $result.tagName | Should -Be @('v1.2.3-Feature.1') + } + + It 'ignores non-version tags and invalid version cores' { + $records = @( + [PSCustomObject]@{ tagName = 'notes-feature.1'; isPrerelease = $true } + [PSCustomObject]@{ tagName = 'v01.2.3-feature.1'; isPrerelease = $true } + ) + + @(Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'feature' -VersionPrefix 'v') | + Should -BeNullOrEmpty + } + + It 'retains cleanup with the effective prefix' -ForEach @( + @{ PrefixCase = 'empty'; Prefix = ''; ExpectedTag = '1.2.3-feature.1' } + @{ PrefixCase = 'hyphenated'; Prefix = 'release-v'; ExpectedTag = 'release-v1.2.3-feature.2' } + ) { + $records = @( + [PSCustomObject]@{ tagName = '1.2.3-feature.1'; isPrerelease = $true } + [PSCustomObject]@{ tagName = 'release-v1.2.3-feature.2'; isPrerelease = $true } + ) + + $result = @(Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'feature' -VersionPrefix $Prefix) + + $result.tagName | Should -Be @($ExpectedTag) + } + + It 'retains releases under historical prefixes rather than guessing their version boundary' { + $records = @( + [PSCustomObject]@{ tagName = 'v1.2.3-feature.1'; isPrerelease = $true } + [PSCustomObject]@{ tagName = 'release-1.2.3-2.0.4-feature.1'; isPrerelease = $true } + ) + + $result = @(Get-PrereleaseCleanupCandidate -Releases $records -PrereleaseName 'feature' -VersionPrefix 'release-1.2.3-') + + $result.tagName | Should -Be @('release-1.2.3-2.0.4-feature.1') + } + + It 'returns no candidates for an empty release list' { + $result = @(Get-PrereleaseCleanupCandidate -Releases @() -PrereleaseName 'feature' -VersionPrefix 'v') + + $result | Should -BeNullOrEmpty + } +} + +Describe 'ConvertTo-ReleaseBump' { + It 'converts to ' -ForEach @( + @{ DefaultBump = 'patch'; Expected = 'Patch' } + @{ DefaultBump = 'minor'; Expected = 'Minor' } + @{ DefaultBump = 'major'; Expected = 'Major' } + ) { + ConvertTo-ReleaseBump -DefaultBump $DefaultBump | Should -BeExactly $Expected + } + + It 'rejects omitted policy instead of selecting its own patch fallback' { + { ConvertTo-ReleaseBump } | Should -Throw '*Invalid DefaultBump*' + } + + It 'rejects invalid DefaultBump []' -ForEach @( + @{ DefaultBump = '' } + @{ DefaultBump = 'Patch' } + @{ DefaultBump = 'prerelease' } + @{ DefaultBump = 'none' } + @{ DefaultBump = $null } + ) { + { ConvertTo-ReleaseBump -DefaultBump $DefaultBump } | + Should -Throw '*Invalid DefaultBump*patch, minor, major*' + } +} + +Describe 'Resolve-ReleaseDecision' { + It 'resolves ' -ForEach @( + @{ + Name = 'a patch release' + Labels = @('release:patch') + Bump = 'Patch' + Prerelease = $false + Skip = $false + } + @{ + Name = 'a minor release' + Labels = @('release:minor') + Bump = 'Minor' + Prerelease = $false + Skip = $false + } + @{ + Name = 'a major release' + Labels = @('release:major') + Bump = 'Major' + Prerelease = $false + Skip = $false + } + @{ + Name = 'a patch prerelease' + Labels = @('release:patch', 'release:prerelease') + Bump = 'Patch' + Prerelease = $true + Skip = $false + } + @{ + Name = 'a minor prerelease' + Labels = @('release:minor', 'release:prerelease') + Bump = 'Minor' + Prerelease = $true + Skip = $false + } + @{ + Name = 'a major prerelease' + Labels = @('release:major', 'release:prerelease') + Bump = 'Major' + Prerelease = $true + Skip = $false + } + @{ + Name = 'a skipped release' + Labels = @('release:skip') + Bump = 'None' + Prerelease = $false + Skip = $true + } + @{ + Name = 'a bump alongside unrelated labels' + Labels = @('dependencies', 'release:patch', 'release:unknown') + Bump = 'Patch' + Prerelease = $false + Skip = $false + } + @{ + Name = 'a skip alongside unrelated labels' + Labels = @('documentation', 'release:skip', 'release:unknown') + Bump = 'None' + Prerelease = $false + Skip = $true + } + ) { + $result = Resolve-ReleaseDecision -Labels $Labels -DefaultBump $standardSettings.DefaultBump + + $result.Bump | Should -BeExactly $Bump + $result.Prerelease | Should -Be $Prerelease + $result.Skip | Should -Be $Skip + $result.DefaultBumpApplied | Should -BeFalse + } + + It 'rejects ' -ForEach @( + @{ + Name = 'patch and minor bumps' + Labels = @('release:patch', 'release:minor') + Message = '*Conflicting release bump labels*' + } + @{ + Name = 'minor and major bumps' + Labels = @('release:minor', 'release:major') + Message = '*Conflicting release bump labels*' + } + @{ + Name = 'all bump labels' + Labels = @('release:patch', 'release:minor', 'release:major') + Message = '*Conflicting release bump labels*' + } + @{ + Name = 'skip and patch' + Labels = @('release:skip', 'release:patch') + Message = '*release:skip must not be combined*' + } + @{ + Name = 'skip and prerelease' + Labels = @('release:skip', 'release:prerelease') + Message = '*release:skip must not be combined*' + } + ) { + { Resolve-ReleaseDecision -Labels $Labels -DefaultBump $standardSettings.DefaultBump } | Should -Throw $Message + } + + It 'requires resolved policy even with ' -ForEach @( + @{ LabelState = 'no owned label'; Labels = @() } + @{ LabelState = 'an owned major label'; Labels = @('release:major') } + ) { + { Resolve-ReleaseDecision -Labels $Labels } | Should -Throw '*Invalid DefaultBump*' + } + + It 'resolves from with the default' -ForEach @( + @{ + Name = 'an empty label set' + Labels = @() + DefaultBump = 'patch' + Expected = 'Patch' + Prerelease = $false + } + @{ + Name = 'a null label set' + Labels = $null + DefaultBump = 'minor' + Expected = 'Minor' + Prerelease = $false + } + @{ + Name = 'legacy bare labels' + Labels = @('Major', 'Minor', 'Patch', 'Prerelease', 'NoRelease') + DefaultBump = 'major' + Expected = 'Major' + Prerelease = $false + } + @{ + Name = 'lowercase bare labels' + Labels = @('major', 'minor', 'patch', 'prerelease') + DefaultBump = 'patch' + Expected = 'Patch' + Prerelease = $false + } + @{ + Name = 'noncanonical casing' + Labels = @('Release:Patch') + DefaultBump = 'minor' + Expected = 'Minor' + Prerelease = $false + } + @{ + Name = 'an unknown release label' + Labels = @('release:unknown') + DefaultBump = 'major' + Expected = 'Major' + Prerelease = $false + } + @{ + Name = 'the retired release:pre-release label' + Labels = @('release:pre-release') + DefaultBump = 'patch' + Expected = 'Patch' + Prerelease = $false + } + @{ + Name = 'prerelease without an explicit bump' + Labels = @('release:prerelease') + DefaultBump = 'minor' + Expected = 'Minor' + Prerelease = $true + } + ) { + $result = Resolve-ReleaseDecision -Labels $Labels -DefaultBump $DefaultBump + + $result.Bump | Should -BeExactly $Expected + $result.Prerelease | Should -Be $Prerelease + $result.Skip | Should -BeFalse + $result.DefaultBumpApplied | Should -BeTrue + } + + It 'applies each valid default to unlabeled and prerelease-only decisions' { + $expectedBumps = @{ + patch = 'Patch' + minor = 'Minor' + major = 'Major' + } + + foreach ($defaultBump in @('patch', 'minor', 'major')) { + foreach ($labels in @(@(), @('release:prerelease'))) { + $result = Resolve-ReleaseDecision -Labels $labels -DefaultBump $defaultBump + + $result.Bump | Should -BeExactly $expectedBumps[$defaultBump] + $result.Prerelease | Should -Be ($labels -ccontains 'release:prerelease') + $result.DefaultBumpApplied | Should -BeTrue + } + } + } + + It 'lets every explicit bump label override every valid default' { + $explicitBumps = [ordered]@{ + 'release:patch' = 'Patch' + 'release:minor' = 'Minor' + 'release:major' = 'Major' + } + + foreach ($defaultBump in @('patch', 'minor', 'major')) { + foreach ($entry in $explicitBumps.GetEnumerator()) { + $result = Resolve-ReleaseDecision -Labels @($entry.Key) -DefaultBump $defaultBump + + $result.Bump | Should -BeExactly $entry.Value + $result.DefaultBumpApplied | Should -BeFalse + } + } + } + + It 'lets release:skip override every valid default' { + foreach ($defaultBump in @('patch', 'minor', 'major')) { + $result = Resolve-ReleaseDecision -Labels @('release:skip') -DefaultBump $defaultBump + + $result.Bump | Should -BeExactly 'None' + $result.Skip | Should -BeTrue + $result.DefaultBumpApplied | Should -BeFalse + } + } + + It 'validates DefaultBump before applying an explicit decision' { + { Resolve-ReleaseDecision -Labels @('release:patch') -DefaultBump 'Patch' } | + Should -Throw '*Invalid DefaultBump*' + } + + It 'accepts exactly the nine valid subsets for every default bump' { + $ownedLabels = @( + 'release:patch' + 'release:minor' + 'release:major' + 'release:prerelease' + 'release:skip' + ) + $validSubsets = @( + '' + 'release:prerelease' + 'release:patch' + 'release:minor' + 'release:major' + 'release:patch,release:prerelease' + 'release:minor,release:prerelease' + 'release:major,release:prerelease' + 'release:skip' + ) + + foreach ($defaultBump in @('patch', 'minor', 'major')) { + for ($mask = 0; $mask -lt (1 -shl $ownedLabels.Count); $mask++) { + $labels = @( + for ($index = 0; $index -lt $ownedLabels.Count; $index++) { + if (($mask -band (1 -shl $index)) -ne 0) { + $ownedLabels[$index] + } + } + ) + $subset = ($labels | Sort-Object) -join ',' + + if ($validSubsets -ccontains $subset) { + { Resolve-ReleaseDecision -Labels $labels -DefaultBump $defaultBump } | + Should -Not -Throw -Because "[$subset] is valid with DefaultBump [$defaultBump]" + } else { + { Resolve-ReleaseDecision -Labels $labels -DefaultBump $defaultBump } | + Should -Throw -Because "[$subset] is not a valid release decision" + } + } + } + } + + Describe 'Resolve-PullRequestReleaseContext' { + It 'uses the branch for naming and the exact head SHA for the release target' { + $headSha = '0123456789012345678901234567890123456789' + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = 'feature/fork-release' + sha = $headSha + } + } + + $result = Resolve-PullRequestReleaseContext -PullRequest $pullRequest + + $result.HeadRef | Should -BeExactly 'feature/fork-release' + $result.PrereleaseName | Should -BeExactly 'featureforkrelease' + $result.PrereleaseTarget | Should -BeExactly $headSha + } + + It 'does not use a colliding base-repository branch name as the release target' { + $headSha = 'abcdefabcdefabcdefabcdefabcdefabcdefabcd' + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = 'main' + sha = $headSha + } + } + + $result = Resolve-PullRequestReleaseContext -PullRequest $pullRequest + + $result.PrereleaseName | Should -BeExactly 'main' + $result.PrereleaseTarget | Should -BeExactly $headSha + $result.PrereleaseTarget | Should -Not -BeExactly $result.HeadRef + } + + It 'rejects a pull request without a head ref' { + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = '' + sha = '0123456789012345678901234567890123456789' + } + } + + { Resolve-PullRequestReleaseContext -PullRequest $pullRequest } | + Should -Throw '*head ref is required*' + } + + It 'rejects a pull request without a head SHA' { + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = 'feature/missing-sha' + sha = '' + } + } + + { Resolve-PullRequestReleaseContext -PullRequest $pullRequest } | + Should -Throw '*head SHA is required*' + } + + It 'rejects a mutable or malformed head SHA []' -ForEach @( + @{ HeadSha = 'main' } + @{ HeadSha = 'abcdef' } + @{ HeadSha = '012345678901234567890123456789012345678g' } + @{ HeadSha = "0123456789012345678901234567890123456789`n" } + ) { + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = 'feature/invalid-sha' + sha = $HeadSha + } + } + + { Resolve-PullRequestReleaseContext -PullRequest $pullRequest } | + Should -Throw '*head SHA must be a 40-character hexadecimal commit*' + } + + It 'rejects a head ref that has no valid prerelease identifier' { + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = '---' + sha = '0123456789012345678901234567890123456789' + } + } + + { Resolve-PullRequestReleaseContext -PullRequest $pullRequest } | + Should -Throw '*does not contain a valid prerelease identifier*' + } + + It 'allows a valid non-prerelease branch without an ASCII prerelease identifier' { + $headRef = ([char] 0x2603).ToString() + $pullRequest = [PSCustomObject]@{ + head = [PSCustomObject]@{ + ref = $headRef + sha = '0123456789012345678901234567890123456789' + } + } + + $result = Resolve-PullRequestReleaseContext -PullRequest $pullRequest -AllowEmptyPrereleaseName + + $result.HeadRef | Should -BeExactly $headRef + $result.PrereleaseName | Should -BeExactly '' + } + } + + Describe 'Test-PrereleaseCreation' { + It 'returns for ' -ForEach @( + @{ + Name = 'an open prerelease pull request' + Labels = @('release:patch', 'release:prerelease') + Closed = $false + Expected = $true + } + @{ + Name = 'a closed prerelease pull request' + Labels = @('release:patch', 'release:prerelease') + Closed = $true + Expected = $false + } + @{ + Name = 'an open stable pull request' + Labels = @('release:patch') + Closed = $false + Expected = $false + } + @{ + Name = 'a closed stable pull request' + Labels = @('release:patch') + Closed = $true + Expected = $false + } + @{ + Name = 'an open skipped pull request' + Labels = @('release:skip') + Closed = $false + Expected = $false + } + ) { + $decision = Resolve-ReleaseDecision -Labels $Labels -DefaultBump $standardSettings.DefaultBump + $result = Test-PrereleaseCreation -ReleaseDecision $decision -PullRequestClosed:$Closed + + $result | Should -Be $Expected + } + } +} diff --git a/tests/Release-GHRepository.Tests.ps1 b/tests/Release-GHRepository.Tests.ps1 new file mode 100644 index 0000000..0813bca --- /dev/null +++ b/tests/Release-GHRepository.Tests.ps1 @@ -0,0 +1,965 @@ +[Diagnostics.CodeAnalysis.SuppressMessageAttribute( + 'PSUseDeclaredVarsMoreThanAssignments', '', + Justification = 'Variables are assigned in Pester setup and used by tests and mocks.' +)] +[CmdletBinding()] +param() + +$ErrorActionPreference = 'Stop' + +BeforeAll { + Import-Module -Name GitHub, powershell-yaml, PSSemVer + $mainPath = Join-Path -Path $PSScriptRoot -ChildPath '..\src\main.ps1' + $bootstrapPath = Join-Path -Path $PSScriptRoot -ChildPath '..\src\Initialize-ReleaseConfiguration.ps1' + $helperPath = Join-Path -Path $PSScriptRoot -ChildPath '..\src\Release-GHRepository.Helpers.psm1' + $actionPath = Join-Path -Path $PSScriptRoot -ChildPath '..\action.yml' + $actionDefinition = ConvertFrom-Yaml -Yaml (Get-Content -LiteralPath $actionPath -Raw) + $readBootstrapOutputs = { + param([string] $Path) + + $outputs = @{} + $reader = [IO.File]::OpenText($Path) + try { + while ($null -ne ($line = $reader.ReadLine())) { + if ($line -match '\A([^=]+)=(.*)\z') { + $outputs[$Matches[1]] = $Matches[2] + } elseif ($line -match '\A([^<]+)<<(.+)\z') { + $name = $Matches[1] + $delimiter = $Matches[2] + $lines = [Collections.Generic.List[string]]::new() + while ($null -ne ($line = $reader.ReadLine()) -and $line -cne $delimiter) { + $lines.Add($line) + } + if ($null -eq $line) { + throw 'The bootstrap output is missing its closing delimiter.' + } + $outputs[$name] = $lines -join "`n" + } else { + throw 'The bootstrap wrote an invalid runner output command.' + } + } + } finally { + $reader.Dispose() + } + $outputs + } + $runRelease = { + param( + [string] $ControllerPath = $mainPath, + [string] $ConfigurationPath = $bootstrapPath + ) + + $null = & $ConfigurationPath + $outputs = & $readBootstrapOutputs -Path $env:GITHUB_OUTPUT + $releaseSettings = ConvertFrom-Json -InputObject $outputs.ReleaseSettings + Push-Location -LiteralPath $outputs.WorkingDirectory + try { + & $ControllerPath -Settings $releaseSettings + } finally { + Pop-Location + } + } + $releaseSettingNames = @( + 'AutoCleanup' + 'DefaultBump' + 'CreateMajorTag' + 'CreateMinorTag' + 'DatePrereleaseFormat' + 'IncrementalPrerelease' + 'UsePRTitleAsReleaseName' + 'UsePRBodyAsReleaseNotes' + 'UsePRTitleAsNotesHeading' + 'VersionPrefix' + 'WhatIf' + ) + $fixtureStandardsYaml = @' +AutoCleanup: false +DefaultBump: minor +CreateMajorTag: true +CreateMinorTag: true +DatePrereleaseFormat: '' +IncrementalPrerelease: true +UsePRTitleAsReleaseName: false +UsePRBodyAsReleaseNotes: true +UsePRTitleAsNotesHeading: true +VersionPrefix: v +WhatIf: false +'@ + $headSha = '0123456789012345678901234567890123456789' + $authoredBody = @' +This release preserves the source-bound adoption record. + +## Adopting this release + +1. Select the reviewed release. +2. Keep the caller's explicit settings. + + +
+Technical details + +The complete record remains part of the release notes. + +
+ +Resolved release decision: release:major, stable. +'@ +} + +Describe 'Release-GHRepository configuration bootstrap' { + BeforeEach { + $bootstrapEnvironmentNames = @('GITHUB_WORKSPACE', 'GITHUB_OUTPUT') + @( + $actionDefinition.inputs.Keys | ForEach-Object { "PSMODULE_AUTO_RELEASE_INPUT_$_" } + ) + $bootstrapSavedEnvironment = @{} + foreach ($environmentName in $bootstrapEnvironmentNames) { + $bootstrapSavedEnvironment[$environmentName] = [Environment]::GetEnvironmentVariable($environmentName) + [Environment]::SetEnvironmentVariable($environmentName, $null) + } + $workspace = Join-Path -Path $TestDrive -ChildPath ([guid]::NewGuid().ToString('N')) + $null = New-Item -Path $workspace -ItemType Directory + $env:GITHUB_WORKSPACE = $workspace + $env:GITHUB_OUTPUT = Join-Path -Path $workspace -ChildPath 'outputs.txt' + $selectedFile = Join-Path -Path $workspace -ChildPath 'settings [literal path].yml' + $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath = $selectedFile + Mock Install-PSResource { throw 'Bootstrap tests use the installed parsing modules.' } + } + + AfterEach { + foreach ($environmentName in $bootstrapEnvironmentNames) { + [Environment]::SetEnvironmentVariable($environmentName, $bootstrapSavedEnvironment[$environmentName]) + } + } + + It 'resolves all startup standards from the workspace before dependency startup' { + $settings = & $bootstrapPath + + $settings.Debug | Should -BeFalse + $settings.Verbose | Should -BeFalse + $settings.Prerelease | Should -BeFalse + $settings.Version | Should -BeExactly '' + $settings.WorkingDirectory | Should -BeExactly $workspace + $settings.DefaultBump | Should -BeExactly 'patch' + $settings.DefaultBumpSource | Should -BeExactly 'SharedDefault' + $outputs = & $readBootstrapOutputs -Path $env:GITHUB_OUTPUT + $outputs.Count | Should -Be 6 + $outputs.Debug | Should -BeExactly 'false' + $outputs.Verbose | Should -BeExactly 'false' + $outputs.Prerelease | Should -BeExactly 'false' + $outputs.Version | Should -BeExactly '' + $outputs.WorkingDirectory | Should -BeExactly $workspace + $releaseSettings = ConvertFrom-Json -InputObject $outputs.ReleaseSettings + $releaseSettings.DefaultBump | Should -BeExactly 'patch' + $releaseSettings.VersionPrefix | Should -BeExactly 'v' + $releaseSettings.PSObject.Properties.Name | Should -Not -Contain 'Prerelease' + Should -Invoke Install-PSResource -Times 0 -Exactly + } + + It 'uses all five startup settings from a literal selected file' { + $executionDirectory = Join-Path -Path $workspace -ChildPath 'execution [directory]' + $null = New-Item -Path $executionDirectory -ItemType Directory + @' +Debug: true +Verbose: true +Prerelease: true +Version: '[0.43.0, 1.0.0)' +WorkingDirectory: 'execution [directory]' +DefaultBump: major +'@ | Set-Content -LiteralPath $selectedFile + + $settings = & $bootstrapPath + + $settings.Debug | Should -BeTrue + $settings.Verbose | Should -BeTrue + $settings.Prerelease | Should -BeTrue + $settings.Version | Should -BeExactly '[0.43.0, 1.0.0)' + $settings.WorkingDirectory | Should -BeExactly $executionDirectory + $settings.DefaultBump | Should -BeExactly 'major' + $settings.DefaultBumpSource | Should -BeExactly 'RepositorySetting' + $outputs = & $readBootstrapOutputs -Path $env:GITHUB_OUTPUT + $outputs.Debug | Should -BeExactly 'true' + $outputs.Verbose | Should -BeExactly 'true' + $outputs.Prerelease | Should -BeExactly 'true' + $outputs.Version | Should -BeExactly '[0.43.0, 1.0.0)' + $outputs.WorkingDirectory | Should -BeExactly $executionDirectory + $releaseSettings = ConvertFrom-Json -InputObject $outputs.ReleaseSettings + $releaseSettings.DefaultBump | Should -BeExactly 'major' + $releaseSettings.DefaultBumpSource | Should -BeExactly 'RepositorySetting' + } + + It 'selects a relative file from without rediscovery after file WorkingDirectory' -ForEach @( + @{ InitialDirectory = 'github.workspace'; ExplicitDirectory = $false } + @{ InitialDirectory = 'an explicit WorkingDirectory'; ExplicitDirectory = $true } + ) { + $initialDirectory = $workspace + if ($ExplicitDirectory) { + $initialDirectory = Join-Path -Path $workspace -ChildPath 'initial [directory]' + $null = New-Item -Path $initialDirectory -ItemType Directory + $env:PSMODULE_AUTO_RELEASE_INPUT_WorkingDirectory = 'initial [directory]' + } + $executionDirectory = Join-Path -Path $workspace -ChildPath 'execution [directory]' + $null = New-Item -Path $executionDirectory -ItemType Directory + $relativeFile = 'settings [selected].yml' + @' +WorkingDirectory: 'execution [directory]' +DefaultBump: minor +'@ | Set-Content -LiteralPath (Join-Path -Path $initialDirectory -ChildPath $relativeFile) + 'DefaultBump: invalid' | Set-Content -LiteralPath (Join-Path -Path $executionDirectory -ChildPath $relativeFile) + $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath = $relativeFile + + Push-Location -LiteralPath $TestDrive + try { + $settings = & $bootstrapPath + } finally { + Pop-Location + } + + $settings.DefaultBump | Should -BeExactly 'minor' + $settings.DefaultBumpSource | Should -BeExactly 'RepositorySetting' + if ($ExplicitDirectory) { + $settings.WorkingDirectory | Should -BeExactly $initialDirectory + } else { + $settings.WorkingDirectory | Should -BeExactly $executionDirectory + } + } + + It 'keeps all startup file values when named inputs are ' -ForEach @( + @{ InputState = 'omitted'; InputValue = $null } + @{ InputState = 'empty'; InputValue = '' } + ) { + @' +Debug: true +Verbose: true +Prerelease: true +Version: '[0.43.1]' +WorkingDirectory: '.' +'@ | Set-Content -LiteralPath $selectedFile + foreach ($name in @('Debug', 'Verbose', 'Prerelease', 'Version', 'WorkingDirectory')) { + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$name", $InputValue) + } + + $settings = & $bootstrapPath + + $settings.Debug | Should -BeTrue + $settings.Verbose | Should -BeTrue + $settings.Prerelease | Should -BeTrue + $settings.Version | Should -BeExactly '[0.43.1]' + $settings.WorkingDirectory | Should -BeExactly $workspace + } + + It 'applies named false and standard-valued startup overrides' { + $executionDirectory = Join-Path -Path $workspace -ChildPath 'execution' + $null = New-Item -Path $executionDirectory -ItemType Directory + @' +Debug: true +Verbose: true +Prerelease: true +Version: '[0.43.0, 1.0.0)' +WorkingDirectory: execution +'@ | Set-Content -LiteralPath $selectedFile + $env:PSMODULE_AUTO_RELEASE_INPUT_Debug = 'false' + $env:PSMODULE_AUTO_RELEASE_INPUT_Verbose = 'FALSE' + $env:PSMODULE_AUTO_RELEASE_INPUT_Prerelease = 'false' + $env:PSMODULE_AUTO_RELEASE_INPUT_Version = '[0.43.1]' + $env:PSMODULE_AUTO_RELEASE_INPUT_WorkingDirectory = $workspace + + $settings = & $bootstrapPath + + $settings.Debug | Should -BeFalse + $settings.Verbose | Should -BeFalse + $settings.Prerelease | Should -BeFalse + $settings.Version | Should -BeExactly '[0.43.1]' + $settings.WorkingDirectory | Should -BeExactly $workspace + } + + It 'accepts empty file Version text as latest dependency selection' { + "Version: ''" | Set-Content -LiteralPath $selectedFile + + $settings = & $bootstrapPath + + $settings.Version | Should -BeExactly '' + } + + It 'rejects an invalid file even when a valid named override would mask it' -ForEach @( + @{ Name = 'Debug'; InvalidValue = 'yes'; InputValue = 'false'; Message = '*Debug*true or false*' } + @{ Name = 'Verbose'; InvalidValue = 'null'; InputValue = 'false'; Message = '*Verbose*true or false*' } + @{ Name = 'Prerelease'; InvalidValue = '1'; InputValue = 'true'; Message = '*Prerelease*true or false*' } + @{ Name = 'Version'; InvalidValue = 'inherit'; InputValue = '[0.43.1]'; Message = '*Version*version*' } + @{ Name = 'WorkingDirectory'; InvalidValue = 'missing'; InputValue = '.'; Message = '*WorkingDirectory*directory*' } + ) { + "$Name`: $InvalidValue" | Set-Content -LiteralPath $selectedFile + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$Name", $InputValue) + + { & $bootstrapPath } | Should -Throw $Message + Test-Path -LiteralPath $env:GITHUB_OUTPUT | Should -BeFalse + } + + It 'rejects invalid selected paths rather than treating them as absent files' -ForEach @( + @{ PathCase = 'empty'; Value = ''; Message = '*SettingsFilePath*nonempty path*' } + @{ PathCase = 'whitespace'; Value = ' '; Message = '*SettingsFilePath*nonempty path*' } + @{ PathCase = 'directory'; Value = '.'; Message = '*SettingsFilePath*file*' } + @{ PathCase = 'provider'; Value = 'Env:\PATH'; Message = '*SettingsFilePath*path*' } + ) { + [Environment]::SetEnvironmentVariable('PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath', $Value) + + { & $bootstrapPath } | Should -Throw $Message + Test-Path -LiteralPath $env:GITHUB_OUTPUT | Should -BeFalse + } + + It 'rejects invalid named startup before writing the handoff' -ForEach @( + @{ SettingName = 'Debug'; InputValue = ' yes '; Message = '*Debug*true or false*' } + @{ SettingName = 'Verbose'; InputValue = ' '; Message = '*Verbose*true or false*' } + @{ SettingName = 'Prerelease'; InputValue = '1'; Message = '*Prerelease*true or false*' } + @{ SettingName = 'Version'; InputValue = 'latest'; Message = '*Version*version*' } + @{ SettingName = 'Version'; InputValue = '[2.0.0, 1.0.0)'; Message = '*Version*version*' } + @{ SettingName = 'WorkingDirectory'; InputValue = 'missing'; Message = '*WorkingDirectory*directory*' } + ) { + @' +Debug: false +Verbose: false +Prerelease: false +Version: '[0.43.1]' +WorkingDirectory: '.' +'@ | Set-Content -LiteralPath $selectedFile + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$SettingName", $InputValue) + + { & $bootstrapPath } | Should -Throw $Message + Test-Path -LiteralPath $env:GITHUB_OUTPUT | Should -BeFalse + } + + It 'rejects SettingsFilePath as a settings-file key' { + 'SettingsFilePath: another.yml' | Set-Content -LiteralPath $selectedFile + + { & $bootstrapPath } | Should -Throw '*Unsupported release setting*SettingsFilePath*' + Test-Path -LiteralPath $env:GITHUB_OUTPUT | Should -BeFalse + } +} + +Describe 'Release-GHRepository caller compatibility' { + BeforeEach { + $environmentNames = @( + 'GITHUB_REPOSITORY' + 'GITHUB_EVENT_PATH' + 'GITHUB_WORKSPACE' + 'GITHUB_OUTPUT' + 'PSMODULE_AUTO_RELEASE_INPUT_ConfigurationFile' + 'PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath' + 'PSMODULE_AUTO_RELEASE_INPUT_AutoCleanup' + 'PSMODULE_AUTO_RELEASE_INPUT_DefaultBump' + 'PSMODULE_AUTO_RELEASE_INPUT_CreateMajorTag' + 'PSMODULE_AUTO_RELEASE_INPUT_CreateMinorTag' + 'PSMODULE_AUTO_RELEASE_INPUT_DatePrereleaseFormat' + 'PSMODULE_AUTO_RELEASE_INPUT_IncrementalPrerelease' + 'PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsReleaseName' + 'PSMODULE_AUTO_RELEASE_INPUT_UsePRBodyAsReleaseNotes' + 'PSMODULE_AUTO_RELEASE_INPUT_UsePRTitleAsNotesHeading' + 'PSMODULE_AUTO_RELEASE_INPUT_VersionPrefix' + 'PSMODULE_AUTO_RELEASE_INPUT_WhatIf' + 'PSMODULE_AUTO_RELEASE_INPUT_Debug' + 'PSMODULE_AUTO_RELEASE_INPUT_Verbose' + 'PSMODULE_AUTO_RELEASE_INPUT_WorkingDirectory' + 'PSMODULE_AUTO_RELEASE_INPUT_Version' + 'PSMODULE_AUTO_RELEASE_INPUT_Prerelease' + ) + $savedEnvironment = @{} + foreach ($name in $environmentNames) { + $savedEnvironment[$name] = [Environment]::GetEnvironmentVariable($name) + if (Test-Path -LiteralPath "Env:\$name") { + Remove-Item -LiteralPath "Env:\$name" + } + } + + $env:GITHUB_REPOSITORY = 'example/repository' + $env:GITHUB_EVENT_PATH = Join-Path -Path $TestDrive -ChildPath 'event.json' + $env:GITHUB_WORKSPACE = $TestDrive + $env:GITHUB_OUTPUT = Join-Path -Path $TestDrive -ChildPath ('outputs-{0}.txt' -f [guid]::NewGuid().ToString('N')) + $settingsFileName = 'settings [custom path] {0}.yml' -f [guid]::NewGuid().ToString('N') + $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath = Join-Path -Path $TestDrive -ChildPath $settingsFileName + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = 'true' + $githubEvent = @{ + action = 'opened' + pull_request = @{ + number = 42 + title = 'The complete authored record is preserved' + body = $authoredBody + merged = $false + state = 'open' + base = @{ ref = 'main' } + head = @{ ref = 'feature/caller'; sha = $headSha } + labels = @() + } + } + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $releaseRecordsJson = '[{"tagName":"v2.0.3","isLatest":true,"isPrerelease":false}]' + $simulateLabelWrites = $false + Mock Install-PSResource {} + Mock Write-GitHubNotice {} + Mock git { throw 'A caller compatibility test must never invoke git.' } + Mock gh { + $global:LASTEXITCODE = 0 + if ($args[0] -eq 'repo' -and $args[1] -eq 'view') { + '{"defaultBranchRef":{"name":"main"}}' + } elseif ($args[0] -eq 'release' -and $args[1] -eq 'list') { + $releaseRecordsJson + } elseif ($simulateLabelWrites -and $args[0] -eq 'label' -and $args[1] -eq 'create') { + return + } else { + throw "A caller compatibility test must never mutate GitHub: gh $($args -join ' ')" + } + } + } + + AfterEach { + foreach ($name in $environmentNames) { + if ($null -eq $savedEnvironment[$name]) { + if (Test-Path -LiteralPath "Env:\$name") { + Remove-Item -LiteralPath "Env:\$name" + } + } else { + [Environment]::SetEnvironmentVariable($name, $savedEnvironment[$name]) + } + } + } + + It 'uses action standards without repository settings or injected input defaults' { + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[patch\]' + $output | Should -Match 'Auto cleanup enabled:\s+\[True\]' + $output | Should -Match 'Use PR body as release notes:\s+\[True\]' + $output | Should -Match 'gh release create v2\.0\.4 ' + $output.Contains($authoredBody) | Should -BeTrue + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'validates metadata-owned standards when they are ' -ForEach @( + @{ StandardsState = 'valid'; Message = $null } + @{ StandardsState = 'missing'; Message = '*action release standards*YAML mapping*' } + @{ StandardsState = 'empty'; Message = '*action release standards*YAML mapping*' } + @{ StandardsState = 'scalar'; Message = '*action release standards*mapping*' } + @{ StandardsState = 'unknown'; Message = '*Unsupported release setting*DefaultBunp*' } + @{ StandardsState = 'null value'; Message = '*WhatIf*true or false*' } + @{ StandardsState = 'invalid bump'; Message = '*Invalid DefaultBump*' } + @{ StandardsState = 'incomplete'; Message = '*standard defaults*missing*WhatIf*' } + @{ StandardsState = 'invalid startup boolean'; Message = '*Debug*true or false*' } + @{ StandardsState = 'invalid startup version'; Message = '*Version*version*' } + @{ StandardsState = 'invalid directory standard'; Message = '*WorkingDirectory*directory*' } + @{ StandardsState = 'nonmapping definition'; Message = '*Invalid metadata*Debug*' } + @{ StandardsState = 'missing default'; Message = '*Invalid metadata*Debug*' } + @{ StandardsState = 'unknown type'; Message = '*Invalid metadata type*Debug*' } + @{ StandardsState = 'unknown phase'; Message = '*Invalid metadata phase*Debug*' } + @{ StandardsState = 'extra definition field'; Message = '*Invalid metadata*Debug*' } + ) { + $fixtureDirectory = Join-Path -Path $TestDrive -ChildPath ([guid]::NewGuid().ToString('N')) + $fixtureSource = Join-Path -Path $fixtureDirectory -ChildPath 'src' + $null = New-Item -Path $fixtureSource -ItemType Directory -Force + Copy-Item -LiteralPath $mainPath, $helperPath, $bootstrapPath -Destination $fixtureSource + $fixtureMetadata = ConvertFrom-Yaml -Yaml (Get-Content -LiteralPath $actionPath -Raw) + $standardData = ConvertFrom-Yaml -Yaml $fixtureMetadata.runs.steps[0].env.PSMODULE_AUTO_RELEASE_SETTING_METADATA + $fixtureStandards = ConvertFrom-Yaml -Yaml $fixtureStandardsYaml + foreach ($name in $fixtureStandards.Keys) { + $standardData[$name].Default = $fixtureStandards[$name] + } + switch ($StandardsState) { + 'unknown' { $standardData.DefaultBunp = @{ Type = 'Bump'; Default = 'minor'; Phase = 'Release' } } + 'null value' { $standardData.WhatIf.Default = $null } + 'invalid bump' { $standardData.DefaultBump.Default = 'date' } + 'incomplete' { $standardData.Remove('WhatIf') } + 'invalid startup boolean' { $standardData.Debug.Default = 'yes' } + 'invalid startup version' { $standardData.Version.Default = 'not-a-version' } + 'invalid directory standard' { $standardData.WorkingDirectory.Default = 'missing' } + 'nonmapping definition' { $standardData.Debug = $true } + 'missing default' { $standardData.Debug.Remove('Default') } + 'unknown type' { $standardData.Debug.Type = 'Flag' } + 'unknown phase' { $standardData.Debug.Phase = 'Dependency' } + 'extra definition field' { $standardData.Debug.Unexpected = $true } + } + $standardYaml = ConvertTo-Yaml -Data $standardData + if ($StandardsState -eq 'empty') { + $standardYaml = '' + } elseif ($StandardsState -eq 'scalar') { + $standardYaml = 'minor' + } + $fixtureMetadata.runs.steps[0].env.PSMODULE_AUTO_RELEASE_SETTING_METADATA = $standardYaml + if ($StandardsState -eq 'missing') { + $fixtureMetadata.runs.steps[0].env.Remove('PSMODULE_AUTO_RELEASE_SETTING_METADATA') + } + ConvertTo-Yaml -Data $fixtureMetadata | + Set-Content -LiteralPath (Join-Path -Path $fixtureDirectory -ChildPath 'action.yml') + $fixtureMainPath = Join-Path -Path $fixtureSource -ChildPath 'main.ps1' + $fixtureBootstrapPath = Join-Path -Path $fixtureSource -ChildPath 'Initialize-ReleaseConfiguration.ps1' + + Push-Location -LiteralPath $TestDrive + try { + if ($Message) { + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'patch' + $env:PSMODULE_AUTO_RELEASE_INPUT_Debug = 'false' + $env:PSMODULE_AUTO_RELEASE_INPUT_Version = '[0.43.1]' + $env:PSMODULE_AUTO_RELEASE_INPUT_WorkingDirectory = $TestDrive + { & $runRelease -ControllerPath $fixtureMainPath -ConfigurationPath $fixtureBootstrapPath } | + Should -Throw $Message + Should -Invoke gh -Times 0 -Exactly + } else { + $output = (& $runRelease -ControllerPath $fixtureMainPath -ConfigurationPath $fixtureBootstrapPath) -join "`n" + + $output | Should -Match 'Default bump:\s+\[minor\]' + $output | Should -Match 'Default bump source:\s+\[SharedDefault\]' + $output | Should -Match 'Auto cleanup enabled:\s+\[False\]' + $output | Should -Match 'gh release create v2\.1\.0 ' + Should -Invoke gh -Times 2 -Exactly + } + } finally { + Pop-Location + } + Should -Invoke git -Times 0 -Exactly + } + + It 'uses the declared SettingsFilePath default when the file is ' -ForEach @( + @{ + FileState = 'present' + FilePresent = $true + ExpectedBump = 'minor' + ExpectedSource = 'RepositorySetting' + ExpectedVersion = 'v2.1.0' + } + @{ + FileState = 'absent' + FilePresent = $false + ExpectedBump = 'patch' + ExpectedSource = 'SharedDefault' + ExpectedVersion = 'v2.0.4' + } + ) { + $defaultSettingsPath = '.github\auto-release.yml' + $callerDirectory = Join-Path -Path $TestDrive -ChildPath ([guid]::NewGuid().ToString('N')) + $null = New-Item -Path (Join-Path -Path $callerDirectory -ChildPath '.github') -ItemType Directory + if ($FilePresent) { + 'DefaultBump: minor' | Set-Content -LiteralPath (Join-Path -Path $callerDirectory -ChildPath $defaultSettingsPath) + } + Remove-Item -LiteralPath 'Env:\PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath' + $env:GITHUB_WORKSPACE = $callerDirectory + + Push-Location -LiteralPath $callerDirectory + try { + $output = (& $runRelease) -join "`n" + } finally { + Pop-Location + } + + $output | Should -Match "Default bump:\s+\[$ExpectedBump\]" + $output | Should -Match "Default bump source:\s+\[$ExpectedSource\]" + $output | Should -Match "gh release create $([regex]::Escape($ExpectedVersion)) " + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'rejects a SettingsFilePath before contacting GitHub' -ForEach @( + @{ PathDescription = 'blank'; PathValue = '' } + @{ PathDescription = 'whitespace-only'; PathValue = ' ' } + ) { + [Environment]::SetEnvironmentVariable('PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath', $PathValue) + + { & $runRelease } | Should -Throw '*SettingsFilePath must be a nonempty path.*' + Should -Invoke gh -Times 0 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'uses a caller minor default for an unlabeled pull request' { + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'minor' + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[minor\]' + $output | Should -Match 'gh release create v2\.1\.0 ' + Should -Invoke gh -Times 2 -Exactly + } + + It 'keeps repository policy when the runner supplies empty release inputs' { + foreach ($settingName in $releaseSettingNames) { + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$settingName", '') + } + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = 'true' + @' +DefaultBump: minor +AutoCleanup: false +DatePrereleaseFormat: '' +VersionPrefix: '' +'@ | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[minor\]' + $output | Should -Match 'Auto cleanup enabled:\s+\[False\]' + $output | Should -Match 'Date-based prerelease format:\s+\[\]' + $output | Should -Match 'gh release create 2\.1\.0 ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'distinguishes existing file policy from a named bump that is ' -ForEach @( + @{ + InputState = 'omitted' + InputValue = $null + ExpectedBump = 'major' + ExpectedSource = 'RepositorySetting' + ExpectedVersion = 'v3.0.0' + } + @{ + InputState = 'empty' + InputValue = '' + ExpectedBump = 'major' + ExpectedSource = 'RepositorySetting' + ExpectedVersion = 'v3.0.0' + } + @{ + InputState = 'equal to the standard' + InputValue = 'patch' + ExpectedBump = 'patch' + ExpectedSource = 'ActionInput' + ExpectedVersion = 'v2.0.4' + } + ) { + if ($null -ne $InputValue) { + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = $InputValue + } + 'DefaultBump: major' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + $output = (& $runRelease) -join "`n" + + $output | Should -Match "Default bump:\s+\[$ExpectedBump\]" + $output | Should -Match "Default bump source:\s+\[$ExpectedSource\]" + $output | Should -Match "gh release create $([regex]::Escape($ExpectedVersion)) " + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'keeps action standards when all release inputs are empty' { + foreach ($settingName in $releaseSettingNames) { + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$settingName", '') + } + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = 'true' + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[patch\]' + $output | Should -Match 'Default bump source:\s+\[SharedDefault\]' + $output | Should -Match 'gh release create v2\.0\.4 ' + Should -Invoke gh -Times 2 -Exactly + } + + It 'lets an explicit owned major override a file minor default and preserves the complete record' { + 'DefaultBump: minor' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $githubEvent.pull_request.labels = @(@{ name = 'release:major' }, @{ name = 'dependencies' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump applied:\s+\[False\]' + $output | Should -Match 'gh release create v3\.0\.0 ' + $output.Contains($authoredBody) | Should -BeTrue + $output | Should -Match '# The complete authored record is preserved \(#42\)' + Should -Invoke gh -Times 2 -Exactly + } + + It 'ignores dependency, retired, and bare labels when using the caller default' { + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'minor' + $githubEvent.pull_request.labels = @( + @{ name = 'major' } + @{ name = 'dependencies' } + @{ name = 'release:pre-release' } + ) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump applied:\s+\[True\]' + $output | Should -Match 'Create a prerelease:\s+\[False\]' + $output | Should -Match 'gh release create v2\.1\.0 ' + } + + It 'lets a named DefaultBump override repository policy' { + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'minor' + 'DefaultBump: major' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[minor\]' + $output | Should -Match 'Default bump source:\s+\[ActionInput\]' + $output | Should -Match 'Bump source:\s+\[ActionInput\]' + $output | Should -Match 'gh release create v2\.1\.0 ' + Should -Invoke gh -Times 2 -Exactly + } + + It 'applies named patch and false while an empty text input keeps file policy' { + @' +DefaultBump: major +AutoCleanup: true +VersionPrefix: v +'@ | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'patch' + $env:PSMODULE_AUTO_RELEASE_INPUT_AutoCleanup = 'false' + $env:PSMODULE_AUTO_RELEASE_INPUT_VersionPrefix = '' + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Default bump:\s+\[patch\]' + $output | Should -Match 'Default bump source:\s+\[ActionInput\]' + $output | Should -Match 'Auto cleanup enabled:\s+\[False\]' + $output | Should -Match 'Version prefix:\s+\[v\]' + $output | Should -Match 'gh release create v2\.0\.4 ' + Should -Invoke gh -Times 2 -Exactly + } + + It 'does not mask an invalid file value with a valid explicit caller override' { + 'DefaultBump: invalid' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'patch' + + { & $runRelease } | Should -Throw '*DefaultBump*' + Should -Invoke gh -Times 0 -Exactly + } + + It 'keeps validation read-only when explicit WhatIf overrides a false repository setting' { + 'WhatIf: false' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'What if mode:\s+\[True\]' + $output | Should -Match 'WhatIf: gh label create ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'keeps the configured prerelease date format when its input is empty' { + @' +DatePrereleaseFormat: "'fixed'" +'@ | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_DatePrereleaseFormat = '' + $githubEvent.pull_request.labels = @(@{ name = 'release:prerelease' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match "Date-based prerelease format:\s+\['fixed'\]" + $output | Should -Match 'gh release create v2\.0\.4-featurecaller\.fixed\.1 ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'keeps a true file WhatIf policy when its named input is empty' { + 'WhatIf: true' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = '' + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'What if mode:\s+\[True\]' + $output | Should -Match 'WhatIf: gh label create ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'treats literal inherit as ordinary prefix text rather than an omission marker' { + 'VersionPrefix: repo-' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_VersionPrefix = 'inherit' + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Version prefix:\s+\[inherit\]' + $output | Should -Match 'Skipping release creation\.' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'accepts explicit false for WhatIf as a real override with only simulated label writes' { + 'WhatIf: true' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = 'false' + $simulateLabelWrites = $true + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'What if mode:\s+\[False\]' + $output | Should -Match 'Skipping release creation\.' + Should -Invoke gh -Times 5 -Exactly -ParameterFilter { $args[0] -eq 'label' -and $args[1] -eq 'create' } + Should -Invoke gh -Times 0 -Exactly -ParameterFilter { $args[0] -eq 'release' -and $args[1] -eq 'create' } + Should -Invoke git -Times 0 -Exactly + } + + It 'rejects invalid named inputs before contacting GitHub' -ForEach @( + @{ InputName = 'DefaultBump'; Value = 'date'; Message = '*DefaultBump*' } + @{ InputName = 'DefaultBump'; Value = 'inherit'; Message = '*DefaultBump*' } + @{ InputName = 'DefaultBump'; Value = ' '; Message = '*DefaultBump*' } + @{ InputName = 'WhatIf'; Value = 'invalid'; Message = '*WhatIf*true or false*' } + @{ InputName = 'WhatIf'; Value = 'inherit'; Message = '*WhatIf*true or false*' } + @{ InputName = 'WhatIf'; Value = ' '; Message = '*WhatIf*true or false*' } + ) { + [Environment]::SetEnvironmentVariable("PSMODULE_AUTO_RELEASE_INPUT_$InputName", $Value) + + { & $runRelease } | Should -Throw $Message + Should -Invoke gh -Times 0 -Exactly + } + + It 'validates a merged skipped pull request successfully without planning publication' { + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent.pull_request.merged = $true + $githubEvent.pull_request.state = 'closed' + $githubEvent.action = 'closed' + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Skip release:\s+\[True\]' + $output | Should -Match 'Skipping release creation\.' + $output | Should -Not -Match 'gh release create|git push|git tag' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke Write-GitHubNotice -Times 0 -Exactly + } + + It 'validates a skipped branch even when it has no ASCII prerelease identifier' { + $githubEvent.pull_request.head.ref = ([char] 0x2603).ToString() + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Skip release:\s+\[True\]' + $output | Should -Match 'no prerelease identifier' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'validates a closed skip without parsing a malformed latest version while retaining cleanup' { + $releaseRecordsJson = @' +[{"tagName":"not-a-semver","isLatest":true,"isPrerelease":false},{"tagName":"v2.0.4-featurecaller.1","isLatest":false,"isPrerelease":true}] +'@ + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent.pull_request.merged = $true + $githubEvent.pull_request.state = 'closed' + $githubEvent.action = 'closed' + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'Skipping release creation\.' + $output | Should -Match 'WhatIf: gh release delete v2\.0\.4-featurecaller\.1' + $output | Should -Not -Match 'gh release create|git tag|git push' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'keeps the bootstrap policy when files and raw inputs change after resolution' { + @' +DefaultBump: major +WhatIf: true +'@ | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $null = & $bootstrapPath + $outputs = & $readBootstrapOutputs -Path $env:GITHUB_OUTPUT + $releaseSettings = ConvertFrom-Json -InputObject $outputs.ReleaseSettings + 'Version: invalid' | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $env:PSMODULE_AUTO_RELEASE_INPUT_DefaultBump = 'minor' + $env:PSMODULE_AUTO_RELEASE_INPUT_WhatIf = 'false' + + $output = (& $mainPath -Settings $releaseSettings) -join "`n" + + $output | Should -Match 'Default bump:\s+\[major\]' + $output | Should -Match 'Default bump source:\s+\[RepositorySetting\]' + $output | Should -Match 'What if mode:\s+\[True\]' + $output | Should -Match 'gh release create v3\.0\.0 ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'keeps dependency Prerelease separate from repository prerelease mode' { + @' +Prerelease: true +Version: '[0.43.0, 1.0.0)' +'@ | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + $output = (& $runRelease) -join "`n" + + $outputs = & $readBootstrapOutputs -Path $env:GITHUB_OUTPUT + $outputs.Prerelease | Should -BeExactly 'true' + $outputs.Version | Should -BeExactly '[0.43.0, 1.0.0)' + $output | Should -Match 'Create a prerelease:\s+\[False\]' + $output | Should -Match 'gh release create v2\.0\.4 ' + $output | Should -Not -Match '--prerelease' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'plans cleanup only at the effective prefix boundary for ' -ForEach @( + @{ + PrefixCase = 'the own branch after version-like text' + Prefix = 'release-1.2.3-' + TagName = 'release-1.2.3-2.0.4-feature.1' + DeleteExpected = $true + } + @{ + PrefixCase = 'another branch after identifier-like text' + Prefix = 'release-1.2.3-feature.extra-' + TagName = 'release-1.2.3-feature.extra-2.0.4-other.1' + DeleteExpected = $false + } + ) { + "VersionPrefix: '$Prefix'" | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + $releaseRecordsJson = ConvertTo-Json -InputObject @( + @{ tagName = 'v2.0.3'; isLatest = $true; isPrerelease = $false } + @{ tagName = $TagName; isLatest = $false; isPrerelease = $true } + ) + $githubEvent.pull_request.head.ref = 'feature' + $githubEvent.pull_request.labels = @(@{ name = 'release:skip' }) + $githubEvent.pull_request.state = 'closed' + $githubEvent.action = 'closed' + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $deleteCommand = "WhatIf: gh release delete $TagName --cleanup-tag --yes" + $output.Contains($deleteCommand) | Should -Be $DeleteExpected + $output | Should -Not -Match 'gh release create|git tag|git push' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'targets a prerelease at the exact pull-request head without executing publication commands' { + $githubEvent.pull_request.labels = @(@{ name = 'release:prerelease' }, @{ name = 'release:minor' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + $output = (& $runRelease) -join "`n" + + $output | Should -Match 'gh release create v2\.1\.0-featurecaller\.1 ' + $output | Should -Match "--target $headSha --prerelease" + $output | Should -Match 'WhatIf: gh pr comment 42 ' + Should -Invoke gh -Times 2 -Exactly + Should -Invoke git -Times 0 -Exactly + } + + It 'rejects conflicting owned labels instead of falling back to the default' { + $githubEvent.pull_request.labels = @(@{ name = 'release:patch' }, @{ name = 'release:major' }) + $githubEvent | ConvertTo-Json -Depth 10 | Set-Content -LiteralPath $env:GITHUB_EVENT_PATH + + { & $runRelease } | Should -Throw '*Conflicting release bump labels*' + Should -Invoke gh -Times 1 -Exactly + } + + It 'rejects invalid effective file settings before calling GitHub' -ForEach @( + @{ Yaml = 'DefaultBump: null'; Message = '*DefaultBump*' } + @{ Yaml = 'DefaultBump: date'; Message = '*Invalid DefaultBump*' } + @{ Yaml = 'WhatIf: invalid'; Message = '*WhatIf*true or false*' } + @{ Yaml = "DatePrereleaseFormat: '%'"; Message = '*DatePrereleaseFormat*format*' } + @{ Yaml = 'AutoPatching: false'; Message = '*AutoPatching*removed*' } + @{ Yaml = 'DefaultBunp: minor'; Message = '*Unsupported release setting*' } + @{ Yaml = '- patch'; Message = '*configuration must be a mapping*' } + @{ Yaml = ''; Message = '*settings file*must be a mapping*' } + ) { + $Yaml | Set-Content -LiteralPath $env:PSMODULE_AUTO_RELEASE_INPUT_SettingsFilePath + + { & $runRelease } | Should -Throw $Message + Should -Invoke gh -Times 0 -Exactly + Should -Invoke git -Times 0 -Exactly + } +}