Build and Review PR #26 #36

Workflow file for this run

.github/workflows/build-and-review-pr.yml at 074c660

	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 a release created for v2.0.0. If it is removed, the test
	# that relies on it will fail, specifically the auto-generated release notes test.
	COMMITISH: '525c2ff7b76faa30e5d71b715e8b1dc1e5a1af53' # v2.0.1

	# 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
	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
	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
	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
	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
	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
	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.auto-generated-notes.outputs.release-id }}';
	const actualRelease = await assertReleaseExists(github, core, releaseId);

	let expectedNotes = fs.readFileSync('./test/files/test-notes.txt', 'utf8');
	expectedNotes = expectedNotes.replace('REPLACEME', '${{ env.TAG_AUTO_GENERATED_NOTES }}')
	const expectedPropsFromInputs = { body: expectedNotes};
	assertReleasePropsMatchInputArgs(core, actualRelease, expectedPropsFromInputs);

	#-----------------------------------------------
	# 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
	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
	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
	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
	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
	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
	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 ""

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Build and Review PR #26 #36

Workflow file

Build and Review PR #26 #36

Jobs

Run details

Workflow file for this run