🔬 धडा 12 — Debugging आणि testing: पाहा, सिद्ध करा

📍 तुम्ही इथे आहात: 12 पैकी धडा 12 · 🎓 शेवटचा

📦 या ब्रँचमध्ये काय आहे

धडे 01–12 — पूर्ण कोर्स. script ओळ-ओळ चालताना पाहणे, linter, आणि bash च्या सुमारे तीस ओळींमधला test runner — आणि capstone म्हणून backup.

tests/run_tests.sh — 14 checks: नोंदवही tool चे यशाचे आणि अपयशाचे मार्ग, backup चा dry run, verification, rotation आणि lock
bin/backup.sh — ज्याचा test होत आहे ती गोष्ट

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

केअरटेकर काहीतरी विचित्र करतो तेव्हा तुम्ही त्याला प्रत्येक आदेश करताना तो मोठ्याने म्हणायला सांगता — bash -x. रात्री घंटा कार्डे चालवण्याआधी ती बरोबर आहेत याची खात्री करायची असेल, तर तुम्ही प्रत्येकाची तालीम घेता आणि तुलना करता — जे झाले आणि जे व्हायला हवे होते त्याची: हाच test. bash मधला test म्हणजे फक्त: command चालवा, त्याचे output आणि exit code पाहा, pass मोजा. framework आवृत्तीला bats म्हणतात; कल्पना एका कार्डवर मावते.

🗺️ आकृती

flowchart LR
  T["check 'name' 'wanted' \"$(cmd)\""] --> C{"got contains wanted?"}
  C -->|yes| P["✅ pass++"]
  C -->|no| F["❌ fail++ · show wanted vs got"]
  P & F --> S["N passed, M failed · exit 1 if any failed"]

❓ काय

bash -x script.sh प्रत्येक command चालवल्याप्रमाणे, expand करून छापतो. एका block भोवती set -x / set +x. PS4='+ ${BASH_SOURCE}:${LINENO}: ' file आणि ओळ जोडतो. bash -n फक्त syntax तपासतो. bash -v ओळी expand न करता छापतो.
shellcheck: unquoted variables, [ विरुद्ध [[, निरुपयोगी cat, -r शिवाय read, dead code. तो CI मध्ये चालवा.
test म्हणजे: एक नवा fixture (प्रत्येक run साठी temp नोंदवही), command, एक तुलना (output मध्ये आहे, किंवा exit code बरोबर आहे), एक मोजणी, CI साठी एक exit code. अपयशाचे मार्ग test करा — set -e ते करत नाही.
bats: @test "name" { run cmd; [ "$status" -eq 0 ]; [[ "$output" == *x* ]]; } — तोच आकार, setup/teardown आणि TAP output सह.

🤔 का

"चालणारी" script तिच्या लेखकाने फक्त यशाच्या मार्गावर चालवलेली असते. देखरेखीशिवाय चालणाऱ्या scripts ना बाकी सगळे मार्ग भेटतात. चौदा छोटे checks regression घंटेच्या आधी पकडतात.

🔧 कसे (या repo मध्ये)

run_tests.sh: check() [[ "$got" == *"$want"* ]] ने तुलना करते; exit_code() $? पकडते; trap सह mktemp मधून temp नोंदवही; backup tests temp --dest वापरतात, rotation साठी तीनदा चालतात, आणि नकार सिद्ध करण्यासाठी lock हाताने बनवतात; शेवटची ओळ [[ $fail -eq 0 ]] हा CI वाचतो तो exit code आहे.

🧪 करून पाहा

bash tests/run_tests.sh
bash -x bin/school.sh list --class 3A 2>&1 | head -12             # every expansion, every command
PS4='+ ${LINENO}: ' bash -x bin/school.sh report 2>&1 | grep '^+' | head -5
command -v shellcheck && shellcheck bin/*.sh lib/*.sh tests/*.sh && echo "shellcheck clean"
# break something on purpose, watch a test catch it:
sed -i.bak 's/valid_class "\$class" || die/true || die/' bin/school.sh; bash tests/run_tests.sh | grep -E '❌|passed'; mv bin/school.sh.bak bin/school.sh

✅ तपासा — तुम्हाला काय दिसायला हवे

14 passed, 0 failed आणि exit 0; trace मध्ये values भरलेल्या + local class=, + tail, + grep ओळी दिसतात; मुद्दाम बिघडवल्यावर नेमका एकच test fail होतो (enrol rejects a bad class) आणि सारांश 13 passed, 1 failed सांगतो; file पूर्ववत केल्यावर पुन्हा हिरवे होते.

🏁 तुम्ही आत्ताच काय सिद्ध केले

तुम्ही कोणत्याही script ला विचार करताना पाहू शकता, तिला lint करू शकता, आणि अपयशाच्या मार्गातला regression पकडणारा test लिहू शकता — bash पलीकडे कोणत्याही tools शिवाय.

⚠️ नेहमीच्या चुका

फक्त यशाचा मार्ग test करणे. देखरेखीशिवाय चालणाऱ्या scripts अपयशाच्या मार्गांवरच तुटतात.
खरी data file वापरणारे tests. नेहमी fixtures.
300 ओळींच्या script वर PS4 ओळ क्रमांकांशिवाय bash -x output वाचणे.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: deploy script सुद्धा code आहे. तिला इतर सगळ्यांसारखा linter, tests आणि CI job मिळतो, नाहीतर पहाटे 3 वाजता page येतो.

🏆 Capstone

backup.sh scheduled, locked, rotated, verified आणि tested आहे. एक feature सुरुवातीपासून शेवटपर्यंत जोडा: --include data/*.csv (एकच नाही, प्रत्येक नोंदवहीचा backup), यशाच्या मार्गासाठी एक test आणि चुकीच्या pattern साठी एक test सह. मग तो cron किंवा CI schedule मधून एक आठवडा चालवा आणि log वाचा.

🎓 कोर्स पूर्ण झाला

अभ्यास योजना बाराही धड्यांवर खूण करते; quiz ते तपासते; CI/CD शाळा या scripts प्रत्येक push वर चालवते, आणि School portal वर certificate आहे.

🔬 Lesson 12 — Debugging & testing: see it, prove it

📍 You are here: Lesson 12 of 12 · 🎓 The last one

📦 What's in this branch

Lessons 01–12 — the whole course. Watching a script run line by line, the linter, and a test runner in about thirty lines of bash — with the backup as the capstone.

tests/run_tests.sh — 14 checks: the register tool's happy and failure paths, the backup's dry run, verification, rotation and lock
bin/backup.sh — the thing under test

🧒 Explain like I'm 5

When the caretaker does something odd, you ask them to say each order out loud as they do it — bash -x. When you want to be sure the cards are right before the bell rings them at night, you rehearse each one and compare what happened to what should have: a test. A test in bash is just: run the command, look at its output and exit code, count the passes. The framework version is called bats; the idea fits on a card.

🗺️ Diagram

flowchart LR
  T["check 'name' 'wanted' \"$(cmd)\""] --> C{"got contains wanted?"}
  C -->|yes| P["✅ pass++"]
  C -->|no| F["❌ fail++ · show wanted vs got"]
  P & F --> S["N passed, M failed · exit 1 if any failed"]

❓ What

bash -x script.sh prints every command as executed, expanded. set -x / set +x around one block. PS4='+ ${BASH_SOURCE}:${LINENO}: ' adds file and line. bash -n checks syntax only. bash -v echoes lines unexpanded.
shellcheck: unquoted variables, [ vs [[, useless cat, read without -r, dead code. Run it in CI.
A test: a fresh fixture (a temp register per run), the command, a comparison (output contains, or exit code equals), a count, an exit code for CI. Test the failure paths — set -e does not.
bats: @test "name" { run cmd; [ "$status" -eq 0 ]; [[ "$output" == *x* ]]; } — the same shape with setup/teardown and TAP output.

🤔 Why

A script that "works" has been run on the happy path by its author. Unattended scripts meet every other path. Fourteen small checks catch the regression before the bell does.

🔧 How (in this repo)

run_tests.sh: check() compares with [[ "$got" == *"$want"* ]]; exit_code() captures $?; a temp register from mktemp with a trap; the backup tests use a temp --dest, run three times for rotation, and create the lock by hand to prove the refusal; the last line [[ $fail -eq 0 ]] is the exit code CI reads.

🧪 Try it

bash tests/run_tests.sh
bash -x bin/school.sh list --class 3A 2>&1 | head -12             # every expansion, every command
PS4='+ ${LINENO}: ' bash -x bin/school.sh report 2>&1 | grep '^+' | head -5
command -v shellcheck && shellcheck bin/*.sh lib/*.sh tests/*.sh && echo "shellcheck clean"
# break something on purpose, watch a test catch it:
sed -i.bak 's/valid_class "\$class" || die/true || die/' bin/school.sh; bash tests/run_tests.sh | grep -E '❌|passed'; mv bin/school.sh.bak bin/school.sh

✅ Verify — what you should see

14 passed, 0 failed and exit 0; the trace shows + local class=, + tail, + grep lines with values filled in; after the sabotage exactly one test fails (enrol rejects a bad class) and the summary says 13 passed, 1 failed; restoring the file makes it green again.

🏁 What you just proved

You can watch any script think, lint it, and write a test that catches a regression in a failure path — with no tools beyond bash.

⚠️ Common mistakes

Testing only the happy path. The failure paths are where unattended scripts break.
Tests that use the real data file. Fixtures, always.
Reading bash -x output without PS4 line numbers on a 300-line script.

🏭 Why this matters in production: the deploy script is code. It gets a linter, tests and a CI job like everything else, or it gets a 3 a.m. page.

🏆 Capstone

backup.sh is scheduled, locked, rotated, verified and tested. Add one feature end to end: --include data/*.csv (back up every register, not one), with a test for the happy path and one for a bad pattern. Then run it from cron or a CI schedule for a week and read the log.

🎓 The course is complete

The study plan ticks the twelve off; the quiz checks them; the CI/CD school runs these scripts on every push, and the School portal has the certificate.

← Previousci and containers Finished! Take the quiz →check what stuck

This page is the lesson's README from the lesson-12-debugging-testing branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.