Build and Review PR #26 #50

Workflow file for this run

.github/workflows/build-and-review-pr.yml at 4a04ded

	name: Build and Review PR
	run-name: 'Build and Review PR #${{ github.event.pull_request.number }}'

	on:
	# https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token
	#
	# This workflow uses the pull_request trigger which prevents write permissions on the
	# GH_TOKEN and secrets access from public forks. This should remain as a pull_request
	# trigger to minimize the access public forks have in the repository. The reduced
	# permissions are adequate but do mean that re-compiles and readme changes will have to be
	# made manually by the PR author. These auto-updates could be done by this workflow
	# for branches but in order to re-trigger a PR build (which is needed for status checks),
	# we would make the commits with a different user and their PAT. To minimize exposure
	# and complication we will request those changes be manually made by the PR author.
	pull_request:
	types: [opened, synchronize, reopened]
	# paths:
	# Do not include specific paths here. We always want this build to run and produce a
	# status check which are branch protection rules can use. If this is skipped because of
	# path filtering, a status check will not be created and we won't be able to merge the PR
	# without disabling that requirement. If we have a status check that is always produced,
	# we can also use that to require all branches be up to date before they are merged.

	jobs:
	build-and-review-pr:
	# This reusable workflow will check to see if an action's source code has changed based on
	# whether the PR includes files that match the files-with-code arg or are in one of the
	# dirs-with-code directories. If there are source code changes, this reusable workflow
	# will then run the action's build (if one was provided) and update the README.md with the
	# the latest version of the action. If those two steps result in any changes that need to
	# be committed, the workflow will fail because the PR needs some updates. Instructions for
	# updating the PR will be available in the build log, the workflow summary and as a PR
	# comment if the PR came from a branch (not a fork).
	# This workflow assumes:
	# - The main README.md is at the root of the repo
	# - The README contains a contribution guidelines and usage examples section
	uses: im-open/.github/.github/workflows/reusable-build-and-review-pr.yml@v1
	with:
	action-name: ${{ github.repository }}
	default-branch: main
	readme-name: 'README.md'

	# The id of the contribution guidelines section of the README.md
	readme-contribution-id: '#contributing'

	# The id of the usage examples section of the README.md
	readme-examples-id: '#usage-examples'

	# The files that contain source code for the action. Only files that affect the action's execution
	# should be included like action.yml or package.json. Do not include files like README.md or .gitignore.
	# Files do not need to be explicitly provided here if they fall under one of the dirs in dirs-with-code.
	# ** This value must match the same files-with-code argument specified in increment-version-on-merge.yml.
	files-with-code: 'action.yml,package.json,package-lock.json'

	# The directories that contain source code for the action. Only dirs with files that affect the action's
	# execution should be included like src or dist. Do not include dirs like .github or node_modules.
	# ** This value must match the same dirs-with-code argument specified in increment-version-on-merge.yml.
	dirs-with-code: 'src,dist'

	# The npm script to run to build the action. This is typically 'npm run build' if the
	# action needs to be compiled. For composite-run-steps actions this is typically empty.
	build-command: 'npm run build'

	test:
	runs-on: ubuntu-latest

	env:
	# NOTE: This relies on the last release being v2.0.0. If it is removed, the test
	# that relies on it will fail, specifically the auto-generated release notes test.
	# Releases aren't utilized by users (tags are), it is just there for testing.
	COMMITISH: 'main'

	# Generated tags for each of the scenarios we'll be testing
	TAG_RELEASE_NO_ASSET: ''
	TAG_RELEASE_WITH_ASSET: ''
	TAG_RELEASE_WITH_NAME: ''
	TAG_BODY_FROM_INPUT: ''
	TAG_BODY_FROM_FILE: ''
	TAG_DRAFT_RELEASE: ''
	TAG_PRE_RELEASE: ''
	TAG_AUTO_GENERATED_NOTES: ''
	TAG_DUPLICATE_NO_ERROR: ''
	TAG_DUPLICATE_WITH_ERROR: ''
	TAG_ASSET_PATH_ERROR: ''
	TAG_ASSET_NAME_ERROR: ''
	TAG_ASSET_TYPE_ERROR: ''

	steps:

	#--------------------------------------
	# SETUP
	#--------------------------------------
	- name: Fail test job if fork
	run: \|
	if [ "${{ github.event.pull_request.head.repo.fork }}" == "true" ]; then
	echo "This test job requires write scopes on GITHUB_TOKEN that PRs from forks will not have access to. Before this PR can be merged, the tests should be run on an intermediate branch created by repository owners."
	exit 1
	fi

	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: Setup - Checkout the action
	uses: actions/checkout@v4

	- name: Setup - Dynamically generate tags for each of the scenarios to use with their release
	run: \|
	tag=$(date +'%Y%m%d%H%M%S')
	echo "TAG_RELEASE_NO_ASSET=releaseNoAssetTag_$tag" >> $GITHUB_ENV
	echo "TAG_RELEASE_WITH_ASSET=releaseWithAssetTag_$tag" >> $GITHUB_ENV
	echo "TAG_RELEASE_WITH_NAME=releaseWithNameTag_$tag" >> $GITHUB_ENV
	echo "TAG_BODY_FROM_INPUT=bodyFromArgTag_$tag" >> $GITHUB_ENV
	echo "TAG_BODY_FROM_FILE=bodyFromFileTag_$tag" >> $GITHUB_ENV
	echo "TAG_DRAFT_RELEASE=draftReleaseTag_$tag" >> $GITHUB_ENV
	echo "TAG_PRE_RELEASE=preReleaseTag_$tag" >> $GITHUB_ENV

	# All three of these releases will use the same tag. The release notes tag
	# will stand on its own and should succeed. The other two purposely duplicate it.
	echo "TAG_AUTO_GENERATED_NOTES=autoGeneratedReleaseNotesTag_$tag" >> $GITHUB_ENV
	echo "TAG_DUPLICATE_NO_ERROR=autoGeneratedReleaseNotesTag_$tag" >> $GITHUB_ENV
	echo "TAG_DUPLICATE_WITH_ERROR=autoGeneratedReleaseNotesTag_$tag" >> $GITHUB_ENV

	echo "TAG_ASSET_PATH_ERROR=assetPathErrorTag_$tag" >> $GITHUB_ENV
	echo "TAG_ASSET_NAME_ERROR=assetNameErrorTag_$tag" >> $GITHUB_ENV
	echo "TAG_ASSET_TYPE_ERROR=assetTypeErrorTag_$tag" >> $GITHUB_ENV

	#--------------------------------------
	# REGULAR RELEASE WITH DEFAULT VALUES
	#--------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a production ready release
	uses: ./
	if: always()
	id: prod-release
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_RELEASE_NO_ASSET }}
	commitish: ${{ env.COMMITISH}}
	#release-name: ''

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.prod-release.outcome }}"

	- name: And the release should exist on GitHub with props that match the inputs and defaults
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchActionOutputs = require('./test/assert-release-props-match-action-outputs.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.prod-release.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedPropsFromInputs = {
	// These items should match the args exactly
	tagName: '${{ env.TAG_RELEASE_NO_ASSET }}',
	commitish: '${{ env.COMMITISH }}',

	// These items have default values, test here so we don't need specific tests for the defaults
	releaseName: '${{ env.TAG_RELEASE_NO_ASSET }}',
	draft: false,
	preRelease: false,
	body: ''
	};
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	const hasAssets = false;
	const expectedPropsFromOutputs = JSON.parse(`${{ toJSON(steps.prod-release.outputs) }}`);
	assertReleasePropsMatchActionOutputs(core, actualRelease, hasAssets, expectedPropsFromOutputs);

	#--------------------------------------
	# REGULAR RELEASE WITH AN ASSET
	#--------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a production ready release with an asset
	uses: ./
	if: always()
	id: prod-release-asset
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_RELEASE_WITH_ASSET }}
	commitish: ${{ env.COMMITISH}}
	asset-path: './test/files/test-asset.txt'
	asset-name: 'prod-release-test-asset'
	asset-content-type: 'application/text'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.prod-release-asset.outcome }}"

	- name: And the release should exist on GitHub with the populated release url props
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchActionOutputs = require('./test/assert-release-props-match-action-outputs.js');

	const releaseId = '${{ steps.prod-release-asset.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const hasAssets = true;
	const expectedPropsFromOutputs = JSON.parse(`${{ toJSON(steps.prod-release-asset.outputs) }}`);
	assertReleasePropsMatchActionOutputs(core, actualRelease, hasAssets, expectedPropsFromOutputs);

	#--------------------------------------
	# RELEASE WITH A NAME
	#--------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a production ready release with a name
	uses: ./
	if: always()
	id: with-name
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_RELEASE_WITH_NAME }}
	commitish: ${{ env.COMMITISH }}
	release-name: 'My test release'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.with-name.outcome }}"

	- name: And the release should exist on GitHub with the specified name
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.with-name.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedPropsFromInputs = {
	releaseName: 'My test release',
	tagName: '${{ env.TAG_RELEASE_WITH_NAME }}'
	};
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	#--------------------------------------
	# BODY FROM INPUT ARG
	#--------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a release with a body that comes from an input arg
	uses: ./
	if: always()
	id: body-from-input
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_BODY_FROM_INPUT }}
	commitish: ${{ env.COMMITISH }}
	body: 'This is the body of the commit that came from an input arg.'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.body-from-input.outcome }}"

	- name: And the release should exist on GitHub with the specified body
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.body-from-input.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedPropsFromInputs = { body: 'This is the body of the commit that came from an input arg.' };
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	#--------------------------------------
	# BODY FROM INPUT FILE
	#--------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a release with a body that comes from a file
	uses: ./
	if: always()
	id: body-from-file
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_BODY_FROM_FILE }}
	commitish: ${{ env.COMMITISH }}
	body-path: './test/files/test-body.txt'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.body-from-file.outcome }}"

	- name: And the release should exist on GitHub with the specified body
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const fs = require('fs');
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.body-from-file.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedBody = fs.readFileSync('./test/files/test-body.txt', 'utf8');
	const expectedPropsFromInputs = { body: expectedBody };
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	#-----------------------------------------------
	# DRAFT RELEASE
	#-----------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a draft release
	uses: ./
	if: always()
	id: draft-release
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_DRAFT_RELEASE }}
	commitish: ${{ env.COMMITISH }}
	draft: 'true'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.draft-release.outcome }}"

	- name: And the release should exist on GitHub as a draft release
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchActionOutputs = require('./test/assert-release-props-match-action-outputs.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.draft-release.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedPropsFromInputs = { draft: true };
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	const hasAssets = false;
	const expectedPropsFromOutputs = JSON.parse(`${{ toJSON(steps.draft-release.outputs) }}`);
	assertReleasePropsMatchActionOutputs(core, actualRelease, hasAssets, expectedPropsFromOutputs);

	#-----------------------------------------------
	# PRE-RELEASE
	#-----------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a pre-release
	uses: ./
	if: always()
	id: pre-release
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_PRE_RELEASE }}
	commitish: ${{ env.COMMITISH }}
	prerelease: 'true'

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.pre-release.outcome }}"

	- name: And the release should exist on GitHub as a pre-release
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertReleasePropsMatchActionOutputs = require('./test/assert-release-props-match-action-outputs.js');
	const assertReleasePropsMatchInputArgs = require('./test/assert-release-props-match-input-args.js');

	const releaseId = '${{ steps.pre-release.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedPropsFromInputs = { preRelease: true };
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	const hasAssets = false;
	const expectedPropsFromOutputs = JSON.parse(`${{ toJSON(steps.pre-release.outputs) }}`);
	assertReleasePropsMatchActionOutputs(core, actualRelease, hasAssets, expectedPropsFromOutputs);

	#-----------------------------------------------
	# AUTO GENERATE RELEASE NOTES
	#-----------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a release with auto-generated release notes
	uses: ./
	if: always()
	id: auto-generated-notes
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_AUTO_GENERATED_NOTES }}
	commitish: ${{ env.COMMITISH }}
	generate-release-notes: true

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.auto-generated-notes.outcome }}"

	- name: And the release should exist on GitHub with the release notes generated from the commits
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const fs = require('fs');
	const assertReleaseExists = require('./test/assert-release-exists.js');
	const assertBodyIncludesFragments = require('./test/assert-value-includes-fragments.js');

	const releaseId = '${{ steps.auto-generated-notes.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	const expectedStart = fs.readFileSync('./test/files/test-notes-start.txt', 'utf8');
	let expectedEnd = fs.readFileSync('./test/files/test-notes-end.txt', 'utf8');
	expectedEnd = expectedEnd.replace('REPLACEME', '${{ env.TAG_AUTO_GENERATED_NOTES }}')

	assertBodyIncludesFragments(core, actualRelease.body, expectedStart, expectedEnd);

	#-----------------------------------------------
	# DUPLICATE EXISTING RELEASE WITHOUT REMOVING IT
	#-----------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a release that duplicates another release without including the flag to first remove it
	uses: ./
	if: always()
	id: duplicate-with-error
	continue-on-error: true # This is needed because we expect the step to fail. We need it to "pass" in order for the test job to succeed.
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	# Use the same tag-name and commitish that the release we are duplicating used
	tag-name: ${{ env.TAG_AUTO_GENERATED_NOTES }}
	commitish: ${{ env.COMMITISH }}
	delete-existing-release: false

	- name: Then the outcome should be failure
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "failure" --actual "${{ steps.duplicate-with-error.outcome }}"

	#-----------------------------------------
	# DUPLICATE EXISTING RELEASE AND REMOVE IT
	#-----------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a duplicate release with flag to remove existing release set
	uses: ./
	if: always()
	id: duplicate-no-error
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}

	# This flag should delete the existing release and let it be re-created
	delete-existing-release: true

	# Use the same tag-name and commitish that the release we are duplicating used
	tag-name: ${{ env.TAG_AUTO_GENERATED_NOTES }}
	commitish: ${{ env.COMMITISH }}

	- name: Then the outcome should be success
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "success" --actual "${{ steps.duplicate-no-error.outcome }}"

	- name: And the release should have been re-created with a new id
	if: always()
	run: \|
	./test/assert-values-do-not-match.sh --name "Release Id" \
	--value1 "${{ steps.auto-generated-notes.outputs.release-id }}" \
	--value2 "${{ steps.duplicate-no-error.outputs.release-id }}"

	- name: And the new release should exist on GitHub
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseExists = require('./test/assert-release-exists.js');

	const releaseId = '${{ steps.duplicate-no-error.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	- name: And the original release should no longer exist
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	const assertReleaseDoesNotExists = require('./test/assert-release-does-not-exist.js');

	const originalId = '${{ steps.auto-generated-notes.outputs.release-id }}';
	await assertReleaseDoesNotExists(github, core, originalId);

	#----------------------------------------------------------------
	# ASSET ERROR - exclude asset-path BUT INCLUDE OTHERS
	#----------------------------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a
	uses: ./
	if: always()
	id: error-asset-path
	continue-on-error: true # This is needed because we expect the step to fail. We need it to "pass" in order for the test job to succeed.
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_ASSET_PATH_ERROR }}
	commitish: ${{ env.COMMITISH }}
	asset-path: '' # cause a failure by ommitting one of the required asset args
	asset-name: 'prod-release-test-asset'
	asset-content-type: 'application/text'

	- name: Then the outcome should be failure
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "failure" --actual "${{ steps.error-asset-path.outcome }}"

	- name: And the action should return undefined values
	if: always()
	run: \|
	./test/assert-values-match.sh --name "release ID" --expected "" --actual "${{ steps.error-asset-path.outputs.release-id }}"
	./test/assert-values-match.sh --name "html url" --expected "" --actual "${{ steps.error-asset-path.outputs.release-html-url }}"
	./test/assert-values-match.sh --name "asset upload url" --expected "" --actual "${{ steps.error-asset-path.outputs.asset-upload-url }}"
	./test/assert-values-match.sh --name "asset download url" --expected "" --actual "${{ steps.error-asset-path.outputs.asset-browser-download-url }}"

	#----------------------------------------------------------------
	# ASSET ERROR - exclude asset-name - BUT INCLUDE OTHERS
	#----------------------------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a
	uses: ./
	if: always()
	id: error-asset-name
	continue-on-error: true # This is needed because we expect the step to fail. We need it to "pass" in order for the test job to succeed.
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_ASSET_PATH_ERROR }}
	commitish: ${{ env.COMMITISH }}
	asset-path: './test/files/test-asset.txt'
	asset-name: '' # cause a failure by ommitting one of the required asset args
	asset-content-type: 'application/text'

	- name: Then the outcome should be failure
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "failure" --actual "${{ steps.error-asset-name.outcome }}"

	- name: And the action should return undefined values
	if: always()
	run: \|
	./test/assert-values-match.sh --name "release ID" --expected "" --actual "${{ steps.error-asset-name.outputs.release-id }}"
	./test/assert-values-match.sh --name "html url" --expected "" --actual "${{ steps.error-asset-name.outputs.release-html-url }}"
	./test/assert-values-match.sh --name "asset upload url" --expected "" --actual "${{ steps.error-asset-name.outputs.asset-upload-url }}"
	./test/assert-values-match.sh --name "asset download url" --expected "" --actual "${{ steps.error-asset-name.outputs.asset-browser-download-url }}"

	#----------------------------------------------------------------
	# ASSET ERROR - exclude asset-content-type - BUT INCLUDE OTHERS
	#----------------------------------------------------------------
	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	- name: When creating a
	uses: ./
	if: always()
	id: error-asset-type
	continue-on-error: true # This is needed because we expect the step to fail. We need it to "pass" in order for the test job to succeed.
	with:
	github-token: ${{ secrets.GITHUB_TOKEN }}
	tag-name: ${{ env.TAG_ASSET_PATH_ERROR }}
	commitish: ${{ env.COMMITISH }}
	asset-path: './test/files/test-asset.txt'
	asset-name: 'prod-release-test-asset'
	asset-content-type: '' # cause a failure by ommitting one of the required asset args

	- name: Then the outcome should be failure
	if: always()
	run: ./test/assert-values-match.sh --name "step outcome" --expected "failure" --actual "${{ steps.error-asset-type.outcome }}"

	- name: And the action should return undefined values
	if: always()
	run: \|
	./test/assert-values-match.sh --name "release ID" --expected "" --actual "${{ steps.error-asset-type.outputs.release-id }}"
	./test/assert-values-match.sh --name "html url" --expected "" --actual "${{ steps.error-asset-type.outputs.release-html-url }}"
	./test/assert-values-match.sh --name "asset upload url" --expected "" --actual "${{ steps.error-asset-type.outputs.asset-upload-url }}"
	./test/assert-values-match.sh --name "asset download url" --expected "" --actual "${{ steps.error-asset-type.outputs.asset-browser-download-url }}"

	- name: Teardown - Cleanup all the releases by deleting them
	if: always()
	uses: actions/github-script@v7
	with:
	script: \|
	// Not all of these will end up with a tag and a release, but run them all just in case any of the tests
	// fail unexpectedly. We don't want a bunch of test releases and tags cluttering up the real thing.

	const deleteReleaseFromGitHub = require('./test/teardown/delete-release-from-github.js');
	await deleteReleaseFromGitHub(github, core, '${{ steps.prod-release.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.prod-release-asset.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.with-name.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.body-from-input.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.body-from-file.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.draft-release.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.pre-release.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.auto-generated-notes.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.duplicate-with-error.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.duplicate-no-error.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.error-asset-path.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.error-asset-name.outputs.release-id }}');
	await deleteReleaseFromGitHub(github, core, '${{ steps.error-asset-type.outputs.release-id }}');

	const deleteTagFromGitHub = require('./test/teardown/delete-tag-from-github.js');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_RELEASE_NO_ASSET }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_RELEASE_WITH_ASSET }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_RELEASE_WITH_NAME }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_BODY_FROM_INPUT }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_BODY_FROM_FILE }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_DRAFT_RELEASE }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_PRE_RELEASE }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_AUTO_GENERATED_NOTES }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_AUTO_GENERATED_NOTES }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_AUTO_GENERATED_NOTES }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_ASSET_PATH_ERROR }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_ASSET_NAME_ERROR }}');
	await deleteTagFromGitHub(github, core, '${{ env.TAG_ASSET_TYPE_ERROR }}');

	- name: '-------------------------------------------------------------------------------------------------------'
	run: echo ""

	build-branch:
	runs-on: ubuntu-latest

	env:
	NEXT_VERSION: 'v3.2.0'
	HAS_CODE_CHANGES: true
	IS_FORK: false
	PR_SOURCE: 'branch'
	README: 'README.md'
	HAS_BUILD_STEP: true
	NEEDS_BUILD_COMMIT: false
	NEEDS_README_COMMIT: false

	steps:
	- name: Action Source Code Changed (open for details)
	run: \|
	if [ "${{env.HAS_CODE_CHANGES}}" == "true" ]; then
	echo "This PR changes the action's source code. Proceed with subsequent steps and jobs."
	else
	echo "This PR does not change the action's source code. Skipping subsequent steps and jobs."
	fi

	# ----------------------------------------------------------------------------------------------------
	#
	# The remaining steps in this build will use the env.HAS_CODE_CHANGES condition. Setting it on each
	# step rather than the job will ensure this job always runs and that we can use it for status checks.
	#
	# ----------------------------------------------------------------------------------------------------

	- name: PR Source - ${{ env.PR_SOURCE }}
	if: env.HAS_CODE_CHANGES == 'true'
	run: echo "PRs can come from a branch or a fork. This PR is from a ${{ env.PR_SOURCE }}."

	- name: Checkout
	if: env.HAS_CODE_CHANGES == 'true'
	uses: actions/checkout@v4

	# -----------------------------------
	# Check if action has been recompiled
	# -----------------------------------
	- name: If action has build step - Setup Node 20.x
	uses: actions/setup-node@v4
	if: env.HAS_CODE_CHANGES == 'true' && env.HAS_BUILD_STEP == 'true'
	with:
	node-version: 20.x # Default is 20.x

	- name: If action has build step - Build the action
	if: env.HAS_CODE_CHANGES == 'true' && env.HAS_BUILD_STEP == 'true'
	run: npm run build

	- name: If action has build step - Check for unstaged build changes (open for details)
	if: env.HAS_CODE_CHANGES == 'true' && env.HAS_BUILD_STEP == 'true'
	run: \|
	if [[ "$(git status --porcelain)" != "" ]]; then
	echo "The action needs to be re-built"
	echo "NEEDS_BUILD_COMMIT=true" >> "$GITHUB_ENV"
	else
	echo "The action has already been re-built"
	fi

	- name: Fail the workflow if there are any outstanding changes
	uses: actions/upload-artifact@v4
	with:
	name: index.js
	path: ./dist/index.js
	retention-days: 1

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Build and Review PR #26 #50

Workflow file

Build and Review PR #26 #50

Jobs

Run details

Workflow file for this run