Microsoft GitHub Actions Exam (GH-200)

✅ **a non-zero exit code **

Reasoning: GitHub Actions runners interpret a non-zero exit code from any step's command or script as a failure. This is the fundamental, universal mechanism for signaling failure across shell, JavaScript, and Docker actions. ❌ Why the other choices are incorrect:

• Option A is incorrect: The dist/ folder contains compiled JavaScript code; it's the location of the code, not a mechanism for status signaling.
• Option B is incorrect: A composite run step bundles multiple steps. While steps within it can fail, "composite run step" itself isn't the method of failure signaling from code.
• Option C is incorrect: Output variables pass data between steps. They are not the standard or primary method for marking an action step as failed.
• Option E is incorrect: Dockerfile CMD defines the default command to run in a Docker container. The exit code of that command determines success or failure, not the CMD instruction itself.
• Option F is incorrect: The @actions/github toolkit provides API client access. While @actions/core has setFailed, the fundamental mechanism recognized by the runner is the non-zero exit code.

✅

Reasoning: A composite action is specifically identified in its action.yml metadata file by setting the runs.using key to composite. This configuration explicitly tells GitHub Actions how to execute the action's defined steps. ❌ Why the other choices are incorrect:

• Option A is incorrect: Repository names are descriptive and not a technical requirement or identifier for an action's type. A composite action repository can have any name.
• Option B is incorrect: An init.sh file is not a standard or required file for identifying any type of GitHub Action, including composite actions.
• Option C is incorrect: Dockerfile and package.json files are used to define Docker container actions and JavaScript actions, respectively. They do not identify a composite action, which is a different action type.

✅

Reasoning: The path input is required for the actions/cache action. It specifies the files, directories, or wildcard patterns on the runner that the action should cache or restore.

Reasoning: The key input is mandatory. It provides a unique identifier for the cache entry when saving and is subsequently used to search for and restore a matching cache. ❌ Why the other choices are incorrect:

• Option B is incorrect: dependency is not a valid input parameter for the GitHub cache action. The path input defines the items to be cached.
• Option D is incorrect: restore-keys is an optional input parameter, used for providing fallback keys if the primary key does not yield a cache hit. It is not required.
• Option E is incorrect: cache-hit is an output of the cache action, indicating whether a cache was restored, not an input parameter.
• Option F is incorrect: ref is not a recognized input parameter for the actions/cache action. Caching operates within the current workflow context.

✅

Reasoning: The action.yml metadata file's runs.using property explicitly declares the action's execution environment. For JavaScript actions, this value must be a specific Node.js version (e.g., node16, node20), directly indicating it is a JavaScript-based action type. ❌ Why the other choices are incorrect:

• Option A is incorrect: .github/workflows directories contain workflow definitions, not the action's metadata file itself. A js.yml file there would define a workflow, not identify a reusable action as JavaScript-based.
• Option B is incorrect: Repository names are arbitrary and descriptive. While they might hint at the language, they are not a definitive technical mechanism to identify an action's specific type.
• Option D is incorrect: While package.json is common in JavaScript projects, the action.yml file doesn't directly reference it to define the action's type. The runs.using property, not package.json presence, specifies the Node.js runtime.

✅

Reasoning: This code block correctly uses pre: 'start.js' to define the script that runs before main, and pre-if: github.event_name == 'push' to apply the conditional expression. This standard action.yml syntax perfectly matches the requirement for conditionally running a script at the action's start. ❌ Why the other choices are incorrect:

• Option A is incorrect: The pre-if key is for the conditional expression only; it cannot define the script itself. The syntax pre-if:... then 'start.js' is invalid.
• Option C is incorrect: start and start-if are not valid keywords in action.yml for defining a pre-entrypoint script and its condition. The correct keyword is pre.
• Option D is incorrect: before and before-if are not valid keywords in action.yml. The standard and documented keyword for running a script before the main entrypoint is pre.

✅

Reasoning: actions/checkout@v3 is the most common and recommended method to target a specific major release version (v3 in this case). This syntax allows for automatic updates to minor versions and bug fixes within that major release, ensuring stability and access to the latest patches. ❌ Why the other choices are incorrect:

• Option B is incorrect: steps:- uses: actions/checkout refers to the default branch (e.g., main or master), which can be unstable if the maintainer pushes breaking changes directly to the default branch. It does not target a specific major release.
• Option C is incorrect: steps:- uses: actions/checkout@U1673995124 uses an arbitrary, non-standard string that does not correspond to a valid Git ref (tag, branch, or SHA) in GitHub Actions for versioning.
• Option D is incorrect: steps:- uses: actions/checkout@ac593995615ec2ede58e132d2e21d2b1cbd6127c targets a specific Git commit SHA. While precise, it's not the most common way to target a major release as it locks to an immutable point, preventing automatic receipt of minor version updates or bug fixes within that major release.

✅ **setting a debug message **

Reasoning: Workflow commands like echo "::debug::message" send diagnostic information from the runner to the GitHub Actions log. This data helps in debugging workflow execution and is explicitly sent from the runner.

Reasoning: Workflow commands such as echo "::set-output name=myOutput::value" (or echo "myOutput=value" >> $GITHUB_OUTPUT) transmit output values from a step or job on the runner, making them available for subsequent steps or jobs in the workflow. ❌ Why the other choices are incorrect:

• Option A is incorrect: Reading from environment variables is about consuming information on the runner, not sending information from it to the workflow context.
• Option C is incorrect: Populating variables in a Dockerfile relates to defining environment within a container during its build or run, not a workflow command that sends information from the runner to the GitHub Actions workflow.

✅ **core.setFailed(error.message); **

Reasoning: The core.setFailed function is the correct and standard method within the @actions/core library to mark a GitHub Action as failed. When called, it causes the action and, subsequently, the entire workflow run to fail, providing the error message as context. ❌ Why the other choices are incorrect:

• Option A is incorrect: The @actions/core library does not include a setException method. This is not a valid function for reporting exceptions to fail an action.
• Option B is incorrect: action is not a defined object in the provided scope. While core.error exists, it only logs an error message but does not fail the action; setFailed is required to fail the run.
• Option D is incorrect: The @actions/core library does not have a core.action property, nor a setException method. This option combines two non-existent elements.

✅

Reasoning: TypeScript transpiles directly into JavaScript. GitHub Actions' "JavaScript action" type is designed to execute Node.js-based JavaScript files, which perfectly accommodates compiled TypeScript code. This provides the most native and suitable execution environment. ❌ Why the other choices are incorrect:

• Option A is incorrect: Docker container actions run code within a container. While possible, it's an encapsulation method, not the most suitable action type for TypeScript itself, as it adds unnecessary overhead compared to direct Node.js execution.
• Option B is incorrect: TypeScript is a programming language that compiles to JavaScript, not a Bash script. It cannot be directly executed as a Bash script.
• Option C is incorrect: Composite run steps bundle multiple workflow steps into one. While a compiled TypeScript action could be a step within a composite action, "composite run step" isn't the underlying action type for the TypeScript code itself.

✅

Reasoning: The check_run webhook event is specifically designed to trigger workflows based on activity related to GitHub Checks API. Third-party code quality providers use the Checks API to report status. A follow-up workflow can be configured to trigger on check_run events, specifically when the status is completed and the check_run.name matches the integration, signaling its conclusion. ❌ Why the other choices are incorrect:

• Option A is incorrect: The workflow_run event triggers for other GitHub Actions workflows, not directly for the completion of an external Checks API integration. It wouldn't directly capture the third-party check's completion status.
• Option C is incorrect: The pull_request event triggers on pull request activity (e.g., opened, synchronized). While code quality runs on PRs, this event doesn't signify the completion of a distinct, external code quality check run.
• Option D is incorrect: The deployment event triggers for code deployment activities. This is unrelated to the completion of a code quality analysis performed by a third-party provider using the Checks API.