Git Basics for Testers

Why it matters

"Which build did you test?" is a question Git answers precisely. Without a commit id a failure is hard to reproduce, and nobody can prove that a retest ran on the version with the fix. "Fails on main at 3f9c2ab" can be reproduced by anyone on the team.

Git also shows what changed: the diff since the last tested version is direct input for choosing regression tests. And automated tests, test data and pipeline files live in the same repository as the product code, so maintaining them means committing, branching and merging like a developer.

Repository, commit and the three places a change lives

A repository is a project folder plus its full history, kept in a hidden .git directory. The team's shared copy, the remote, usually named origin, lives on a server; git clone copies it to your machine with the whole history. Later, git fetch downloads new commits and records where the remote's branches now point under names such as origin/main, without touching your files; git pull also brings your current branch up to date, and git push sends your own commits to origin.

A change passes through three places: the working tree (the files you edit), the staging area or index (the changes you select with git add) and the history (git commit records a snapshot of what is staged). Git names each commit by a hash, a fixed-length fingerprint calculated from the commit's content and history: 40 hexadecimal characters (SHA-1 in most repositories), usually shown shortened to the first seven or more, such as 3f9c2ab. Change one character and the id changes, so a commit id names exactly one version. The SHA-1 Generator shows this on any text; Git hashes a commit in its own internal format, so you will not reproduce a commit id with it.

$ git clone https://git.example.com/shop/web.git  # the repository and its history
$ cd web
$ git fetch                     # later: get new commits from origin; files untouched
$ git pull                      # fetch, then bring your current branch up to date
$ git status                    # what is modified, staged or untracked
$ git add tests/checkout/vat.spec.ts
$ git commit -m "Add VAT test for a total ending in .005"
$ git push                      # send your new commits to origin

Try it: SHA-1 Generator

Branches, HEAD and merges

A branch is a movable name that points to one commit; each new commit on the branch moves the name forward. main (in older repositories often master) usually holds the integrated product, and developers create a short-lived branch per change, such as fix/vat-rounding, so unfinished work disturbs nobody. HEAD is what you have checked out, normally a branch.

A merge brings one branch's commits into another. If the target has not moved since the branch started, Git simply moves its name forward (a fast-forward); if both sides have new commits, it creates a merge commit with two parents. If both sides changed the same lines, Git stops with a merge conflict and a person writes the result. Even a clean merge combines changes that were never run together, so a merged build deserves its own test. Branching strategies and pull requests are the next lesson.

In git log --graph, each * is a commit and the lines lead to its parents; the names in brackets show where branches, tags and HEAD point.

$ git switch -c fix/vat-rounding   # new branch at the current commit, switch to it
$ git commit -am "Fix VAT rounding for totals ending in .005"  # -a stages edited files
$ git switch main
$ git pull                         # fast-forward: two new commits from colleagues
$ git merge fix/vat-rounding       # both sides moved on: Git makes a merge commit
$ git log --oneline --graph -5
*   9e41d07 (HEAD -> main) Merge branch 'fix/vat-rounding' into main
|\
| * 3f9c2ab (fix/vat-rounding) Fix VAT rounding for totals ending in .005
* | c7d2e18 (origin/main) Add Arabic labels to the invoice PDF
* | 5b0a9f4 Update minimum order total to 50.00 SAR
|/
* 1d2e3f4 (tag: v2.3.0) Release 2.3.0

Reading history with log, show and diff

git log lists commits, newest first; git show displays one commit and its changes; git diff compares any two versions. A tag is a fixed name for one commit, typically a release such as v2.3.0.

In the diff below, --- and +++ name the old and the new file, lines starting with - were removed, lines starting with + were added, and @@ -9,5 +9,5 @@ means the excerpt starts at line 9 and spans five lines in both versions; the text after the second @@ is only an earlier line of the file, shown for orientation.

• git log --oneline v2.3.0..main: everything in main that is not in release v2.3.0.
• git log --oneline -- src/checkout/: only the commits that touched the checkout folder.
• git diff --stat v2.3.0 main: the changed files and line counts between two versions.
• git tag --contains 3f9c2ab: the releases that already include a fix.

$ git diff v2.3.0 main -- src/checkout/vat.ts
diff --git a/src/checkout/vat.ts b/src/checkout/vat.ts
index 4b1e2c0..9d7a3f1 100644
--- a/src/checkout/vat.ts
+++ b/src/checkout/vat.ts
@@ -9,5 +9,5 @@ import { roundHalfUp } from './money';
 // VAT rate in this example: 15 %
 export function vatFor(net: number): number {
   const rate = 0.15;
-  return Math.round(net * rate * 100) / 100;
+  return roundHalfUp(net * rate, 2);
 }

Try it: Text Diff

Worked example: what changed since the last release

You tested release v2.3.0 last week; today you are asked for a regression pass on the latest main. Before opening the application, you ask Git what changed; the commands and their output are at the end of this section. Read them file by file:

• vat.ts: one line of VAT rounding changed. Test amounts whose VAT ends in half a halala, such as a net price of 1.10 SAR (VAT 0.165). git grep shows that totals and refunds call vatFor too, so refunds join the scope.
• min-order.ts: the minimum order is now 50.00 SAR. Test 49.99 and 50.00, as in boundary value analysis; if no ticket or release note mentions the change, ask before testing.
• labels.ar.json: new Arabic invoice labels. Check the Arabic PDF invoice and its right-to-left layout.
• vat.spec.ts: new unit tests. Values they cover need less manual effort; values they miss go on your list.
• Write "Regression on main at 9e41d07, changes since v2.3.0" in the test report and in every bug report.

$ git fetch origin
$ git log --oneline v2.3.0..origin/main
9e41d07 (origin/main) Merge branch 'fix/vat-rounding' into main
3f9c2ab Fix VAT rounding for totals ending in .005
c7d2e18 Add Arabic labels to the invoice PDF
5b0a9f4 Update minimum order total to 50.00 SAR
$ git diff --stat v2.3.0 origin/main
 src/checkout/min-order.ts  |  4 ++--
 src/checkout/vat.ts        |  2 +-
 src/invoice/labels.ar.json | 18 ++++++++++++++++++
 tests/checkout/vat.spec.ts | 21 +++++++++++++++++++++
 4 files changed, 42 insertions(+), 3 deletions(-)
$ git grep -n "vatFor(" origin/main -- src
origin/main:src/checkout/total.ts:27:  const vat = vatFor(net);
origin/main:src/checkout/vat.ts:10:export function vatFor(net: number): number {
origin/main:src/refunds/refund.ts:41:  return amount + vatFor(amount);

Try it: Regression Scenario Generator

Frequently asked questions

References

• Reference — GitGit projectThe official reference for every Git command and its options, grouped by task — setup, branching, sharing, patching, inspection and debugging.
• Pro Git, 2nd Edition (Scott Chacon and Ben Straub)Apress · 2014The Pro Git book, free to read online: Git basics, branching and merging, distributed workflows and how Git stores its data.
• ISTQB Certified Tester Foundation Level (CTFL) v4.0ISTQB · 2023The foundation syllabus of software testing: test levels and types, test design techniques, test management and tools.