Hands-on lab — Day 41: Thinking in Automation: Scripts, Hooks, and Pipelines

#!/usr/bin/env bash
# hook_demo.sh — a complete, offline walkthrough of a real pre-commit hook.
#
# It creates a throwaway git repository in a temporary directory, installs the
# reference pre-commit hook, then:
#   2. attempts to commit a file with trailing whitespace  -> the hook BLOCKS it
#   3. fixes the file and commits cleanly                   -> the hook ALLOWS it
#   4. runs the fail-fast pipeline both green and forced to fail
# The temporary repository is deleted on exit. No network, no sudo, no changes
# outside the temp directory.
set -uo pipefail

# Locate this script's directory so we can find pre-commit and pipeline.sh
# even after we cd into the temporary repository.
here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Create an isolated, self-cleaning workspace.
work="$(mktemp -d 2>/dev/null || mktemp -d -t hookdemo)"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

cd "${work}"
git init -q
# A local identity so commits work without touching your global git config.
git config user.email "learner@example.local"
git config user.name "Automation Learner"

echo "=== 1. Installing the pre-commit hook ==="
mkdir -p .git/hooks
cp "${here}/pre-commit" .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit
echo "Hook installed at .git/hooks/pre-commit (executable)."
echo

echo "=== 2. Attempting a BAD commit (trailing whitespace) ==="
# The three trailing spaces after "hello" are the defect the hook catches.
printf 'echo "hello"   \n' > bad.sh
git add bad.sh
if git commit -q -m "add bad.sh" 2>&1; then
  echo "UNEXPECTED: the bad commit was allowed."
else
  echo "Result: the hook BLOCKED the bad commit (exit non-zero), as intended."
fi
echo

echo "=== 3. Fixing the file and committing CLEAN ==="
printf 'echo "hello"\n' > bad.sh   # same file, trailing whitespace removed
git add bad.sh
if git commit -q -m "add clean script" 2>&1; then
  echo "Result: the hook ALLOWED the clean commit."
else
  echo "UNEXPECTED: the clean commit was blocked."
fi
echo

echo "=== 4. Running the pipeline ==="
echo "--- pipeline: all stages ---"
bash "${here}/pipeline.sh" || true
echo "--- pipeline: forced failure at 'test' ---"
bash "${here}/pipeline.sh" test || true
echo

echo "Demo complete. Temporary repository at ${work} will now be removed."

#!/usr/bin/env bash
# pipeline.sh — a tiny fail-fast pipeline.
#
# It runs four stages in order: lint, test, build, deploy. Each stage prints a
# line and "passes" — unless you name a stage as the first argument, in which
# case that stage fails, the pipeline stops there, and the later stages never
# run. This demonstrates the core property of a real CI pipeline: fail fast.
#
# Usage:
#   bash pipeline.sh          # every stage passes, exit 0
#   bash pipeline.sh test     # the 'test' stage fails, pipeline stops, exit 1
#
# Runs offline; writes nothing outside its own console output.
set -uo pipefail

fail_stage="${1:-none}"   # the stage to simulate a failure at (default: none)

run_stage() {
  local name="$1"
  echo "==> stage: ${name}"
  if [ "${name}" = "${fail_stage}" ]; then
    echo "    ${name}: FAILED" >&2
    return 1
  fi
  return 0
}

for stage in lint test build deploy; do
  if ! run_stage "${stage}"; then
    echo "Pipeline stopped at '${stage}'. Later stages did not run." >&2
    exit 1
  fi
done

echo "Pipeline succeeded: every stage green."
exit 0

#!/usr/bin/env bash
# pre-commit — a quality gate git runs before recording a commit.
#
# It inspects only the files staged for this commit and rejects the commit
# (by exiting non-zero) if any of them has a problem. This is the reference
# hook installed by hook_demo.sh and by the test suite. It runs offline and
# touches nothing outside the repository it is invoked in.
#
# Checks:
#   1. trailing whitespace on any line of a staged text file
#   2. shell syntax errors in staged *.sh files (via `bash -n`, which parses
#      a script without running it)
set -u

fail=0

# List files staged for this commit that were Added, Copied, or Modified.
staged="$(git diff --cached --name-only --diff-filter=ACM)"

for f in ${staged}; do
  [ -f "${f}" ] || continue

  # Check 1: trailing whitespace (one or more spaces/tabs at end of a line).
  if grep -nE '[ 	]+$' "${f}" >/dev/null 2>&1; then
    echo "pre-commit: trailing whitespace in ${f}" >&2
    fail=1
  fi

  # Check 2: shell syntax for *.sh files.
  case "${f}" in
    *.sh)
      if ! bash -n "${f}" 2>/dev/null; then
        echo "pre-commit: shell syntax error in ${f}" >&2
        fail=1
      fi
      ;;
  esac
done

if [ "${fail}" -ne 0 ]; then
  echo "pre-commit: commit rejected." >&2
  echo "pre-commit: fix the issues above, or bypass with 'git commit --no-verify' (discouraged)." >&2
  exit 1
fi

echo "pre-commit: quality gate passed."
exit 0

lesson_id: D041
day: 41
kind: shell-scripting
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-041-thinking-in-automation-scripts-hooks-and
run_commands:
  - bash examples/hook_demo.sh
  - bash examples/pipeline.sh
  - bash examples/pipeline.sh test
  - bash starter/hook_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# nothing to clean: every script works in a self-deleting temp directory'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), bash tests/run_tests.sh → 6 checks, 0 failure(s)'

# Dependencies — Day 041 lab

**Only a POSIX shell and git.** This lab deliberately has zero installable
dependencies beyond what a developer machine already has:

- `bash` ≥ 3.2 — preinstalled on macOS and every mainstream Linux distribution.
- `git` — the version-control tool from Week 5. Check with `git --version`.
- Standard utilities used by the scripts: `mktemp`, `grep`, `printf`, `chmod`,
  and `bash -n` — all part of the base system.

No Python, Node, package installs, network access, API keys, or `sudo` are
required. Every script runs entirely inside a temporary directory it creates and
deletes, so it changes nothing on your machine.

If `git` is missing:

- **macOS:** `xcode-select --install` (installs the command-line developer tools, including git).
- **Debian/Ubuntu:** `sudo apt install git`.
- **Fedora:** `sudo dnf install git`.

# Automation worksheet — Day 041

Fill this in as you work through the lab and the lesson. Keep it: the Week 6
project reuses these decisions.

## 1. What does your pre-commit hook check?

List every check your `pre-commit` hook performs, and state exactly what makes a
commit fail each one.

- Check 1: _______________________________________________
  - A commit fails it when: ______________________________
- Check 2: _______________________________________________
  - A commit fails it when: ______________________________

Which single line in the hook actually causes git to abort the commit?

- Answer: ________________________________________________

## 2. One thing you WOULD automate in this course's workflow

Name a real, repeated task in how you work through this course (for example:
running the day's tests before committing, or reformatting your notes).

- Task: __________________________________________________
- Which rung of the ladder fits it (script / scheduled / hook / CI)? _________
- Why that rung, and not a higher or lower one? __________
  ________________________________________________________

## 3. One thing you would NOT automate

Name a task you have decided to leave manual, and justify it with the heuristic
from the lesson (rare? steps keep changing? needs human judgment? irreversible?).

- Task: __________________________________________________
- Why leave it manual: ___________________________________
  ________________________________________________________

## 4. Reflection (2–3 sentences)

Where would you draw the line between what your local hook checks and what a
shared CI pipeline checks, and why?

- Answer: ________________________________________________
  ________________________________________________________
  ________________________________________________________

#!/usr/bin/env bash
# hook_demo.sh (STARTER) — build your own pre-commit hook and pipeline.
#
# This skeleton already sets up a throwaway git repository and installs a hook
# with ONE check (trailing whitespace). Complete the four numbered exercises
# below. The finished reference version is examples/hook_demo.sh — try the
# exercises yourself first, then compare.
#
# Run it at any time to see your progress:
#   bash starter/hook_demo.sh
set -uo pipefail

here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
work="$(mktemp -d 2>/dev/null || mktemp -d -t hookstart)"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

cd "${work}"
git init -q
git config user.email "learner@example.local"
git config user.name "Automation Learner"
mkdir -p .git/hooks

# -------------------------------------------------------------------------
# EXERCISE 1: write a hook check.
# The hook below already rejects trailing whitespace. Add a SECOND check that
# rejects any staged *.sh file with a shell syntax error. Inside the `case`
# block, use `bash -n "${f}"` (it parses a script without running it) and set
# `fail=1` plus an explanatory message if it fails. Uncomment and complete the
# marked lines.
# -------------------------------------------------------------------------
cat > .git/hooks/pre-commit <<'HOOK'
#!/usr/bin/env bash
set -u
fail=0
staged="$(git diff --cached --name-only --diff-filter=ACM)"
for f in ${staged}; do
  [ -f "${f}" ] || continue

  # Check 1 (provided): trailing whitespace.
  if grep -nE '[ 	]+$' "${f}" >/dev/null 2>&1; then
    echo "pre-commit: trailing whitespace in ${f}" >&2
    fail=1
  fi

  # Check 2 (EXERCISE 1): shell syntax for *.sh files.
  case "${f}" in
    *.sh)
      # if ! bash -n "${f}" 2>/dev/null; then
      #   echo "pre-commit: shell syntax error in ${f}" >&2
      #   fail=1
      # fi
      : # remove this no-op line once you complete the check above
      ;;
  esac
done
if [ "${fail}" -ne 0 ]; then
  echo "pre-commit: commit rejected." >&2
  exit 1
fi
echo "pre-commit: quality gate passed."
exit 0
HOOK
chmod +x .git/hooks/pre-commit
echo "Hook installed."

# -------------------------------------------------------------------------
# EXERCISE 2: make it block a bad commit.
# Create a file with trailing whitespace, stage it, and try to commit. The hook
# should reject it. The commands are given; run the script to see the result.
# -------------------------------------------------------------------------
printf 'echo "hello"   \n' > bad.sh    # note the trailing spaces
git add bad.sh
if git commit -q -m "add bad.sh" 2>&1; then
  echo "The bad commit was allowed — check your hook."
else
  echo "Good: the hook BLOCKED the bad commit."
fi

# -------------------------------------------------------------------------
# EXERCISE 3: fix the file and commit clean.
# Overwrite bad.sh with a clean version (no trailing whitespace), stage it, and
# commit. The hook should allow it.
# -------------------------------------------------------------------------
printf 'echo "hello"\n' > bad.sh
git add bad.sh
if git commit -q -m "add clean script" 2>&1; then
  echo "Good: the hook ALLOWED the clean commit."
else
  echo "The clean commit was blocked — check your hook."
fi

# -------------------------------------------------------------------------
# EXERCISE 4: add a pipeline stage.
# The stage list below runs lint -> test -> build. Add a fourth stage, "deploy",
# so the list reads: lint test build deploy. Then run the script and watch the
# pipeline print your new stage.
# -------------------------------------------------------------------------
echo "--- pipeline ---"
for stage in lint test build; do   # EXERCISE 4: add 'deploy' to this list
  echo "==> stage: ${stage}"
done
echo "Pipeline finished."

#!/usr/bin/env bash
# Tests for the Day 041 lab. Run from anywhere:
#   bash tests/run_tests.sh
#
# Verifies real behavior, not just file existence:
#   - the pre-commit hook BLOCKS a commit with trailing whitespace (non-zero)
#   - the pre-commit hook ALLOWS a clean commit (zero)
#   - the pre-commit hook BLOCKS a commit with a shell syntax error
#   - the pipeline FAILS FAST on a failing stage (non-zero, later stages skipped)
#   - the pipeline SUCCEEDS when every stage passes (zero)
# Offline; needs only git and bash. Exits 0 on success, non-zero on any failure.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# --- Set up a throwaway repo with the reference hook installed. ---
work="$(mktemp -d 2>/dev/null || mktemp -d -t hooktest)"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

cd "${work}"
git init -q
git config user.email "test@example.local"
git config user.name "Test Runner"
mkdir -p .git/hooks
cp "${lab_dir}/examples/pre-commit" .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

echo "Testing the pre-commit hook ..."

# 1. Bad commit: trailing whitespace must be rejected.
printf 'echo "hi"   \n' > bad.sh
git add bad.sh
if git commit -q -m "bad" >/dev/null 2>&1; then
  check "hook blocks a commit with trailing whitespace" "no"
else
  check "hook blocks a commit with trailing whitespace" "yes"
fi

# 2. Clean commit: no defects must be allowed.
printf 'echo "hi"\n' > bad.sh
git add bad.sh
if git commit -q -m "clean" >/dev/null 2>&1; then
  check "hook allows a clean commit" "yes"
else
  check "hook allows a clean commit" "no"
fi

# 3. Syntax-error commit: broken shell must be rejected.
printf 'if [ 1 -eq 1 ]; then\n  echo oops\n' > broken.sh   # missing 'fi'
git add broken.sh
if git commit -q -m "broken" >/dev/null 2>&1; then
  check "hook blocks a commit with a shell syntax error" "no"
else
  check "hook blocks a commit with a shell syntax error" "yes"
fi

echo "Testing the pipeline ..."

# 4. Pipeline succeeds when every stage passes.
if bash "${lab_dir}/examples/pipeline.sh" >/dev/null 2>&1; then
  check "pipeline succeeds when all stages pass" "yes"
else
  check "pipeline succeeds when all stages pass" "no"
fi

# 5. Pipeline fails fast on a failing stage.
if bash "${lab_dir}/examples/pipeline.sh" test >/dev/null 2>&1; then
  check "pipeline fails fast on a failing stage" "no"
else
  check "pipeline fails fast on a failing stage" "yes"
fi

# 6. Fail fast really skips later stages: build/deploy must NOT appear.
ff_out="$(bash "${lab_dir}/examples/pipeline.sh" test 2>&1)"
if echo "${ff_out}" | grep -q "stage: build"; then
  check "later stages are skipped after a failure" "no"
else
  check "later stages are skipped after a failure" "yes"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]