This guide walks you through setting up automated testing for a software project from scratch: choosing a testing tool, installing it, writing your first tests, running them locally, and wiring them into an automated pipeline so they execute every time code changes. By the end, you will have a working test suite that runs without manual intervention and reports pass or fail status on every commit.
Get monitors, keyboards and dev gear delivered free — and shop member deals
- Fast, free delivery on millions of items
- Access to Prime Big Deal Days deals on October 6–7
- Prime Video, Amazon Music and more included
Hands-On Automated Testing with Playwright: Create Fast, Reliable, and Scalable Tests for Modern Web Apps with Microsoft’s Automa…
- ✔ Format: Book
- ✔ Topic: Automated testing with Playwright
- ✔ Framework Covered: Microsoft Playwright
Software Testing with Selenium: Automated Testing Tool Book for Beginners
- ✔ Format: Book
- ✔ Topic: Selenium automated testing
- ✔ Level: Beginner
Automated Testing Unleashed: Automated Testing Engineering Fundamentals — The Complete Handbook, Volume 1
- ✔ Format: Book
- ✔ Series: Automated Testing Unleashed: The Complete Handbook
- ✔ Volume: 1
This guide is written for developers who can write basic application code and use a terminal, but who have little or no experience with automated testing. It uses JavaScript with the Jest framework and GitHub Actions as the concrete example, because that combination is free, widely documented, and representative of how most testing tools work. The same sequence — choose tool, install, configure, write test, run, automate — applies to pytest for Python, JUnit for Java, or Jest-equivalents for other languages.
Difficulty: intermediate. Plan for 2–4 hours for a first-time setup, including writing your first few tests.
Difficulty: Intermediate | Time: 2-4 hours
What You’ll Need
Tools & Materials:
- A computer with Node.js (version 18 or later) and npm installed — verify with `node -v` and `npm -v` in a terminal
- A code editor such as VS Code
- A terminal (Terminal on macOS/Linux, PowerShell on Windows)
- An existing code project with at least one function you want to test
- A GitHub account and your project pushed to a GitHub repository (required only for the automation step)
Knowledge:
- Basic command-line usage (changing directories, running commands)
- Ability to write and read simple functions in JavaScript or a comparable language
- Familiarity with Git basics: committing and pushing code
If you do not have an existing project, create a small one first: a folder with a single file containing a pure function (for example, a function that adds two numbers or validates an email string). Pure functions — same input, same output, no side effects — are the easiest starting point for automated tests. If you use a different language, keep this guide open for the process and substitute the equivalent commands listed in the FAQ.
Hands-On Automated Testing with Playwright: Create Fast, Reliable, and Scalable Tests for Modern Web Apps with Microsoft’s Automa…
For readers who want their automation skills to feel current the moment they finish the last chapter, this is the pick we point to first. Playwright has become the framework of choice for modern web teams, and a hands-on guide built around it teaches exactly the kind of skills that translate directly into greenfield projects: fast test execution, resilient selectors, and scalable test architecture. The hands-on framing matters here. Compared with the Selenium book lower in our ranking, this guide is aimed at people who already write code and want to apply it immediately, not at readers learning testing concepts from scratch.The tradeoff is shelf life. Playwright evolves quickly, and printed technical content about fast-moving frameworks ages faster than books covering settled tools. Specific APIs, configuration details, and best practices may drift between versions, which means readers should expect to supplement the book with official documentation as the framework advances. That is a reasonable price for working with a tool this well-suited to modern web applications, but it is a real cost. We also note that detailed third-party descriptions of the book’s interior content are limited, so buyers are placing meaningful trust in the publisher’s framing — something we factor into the ranking rather than ignore.Where this book clearly wins is positioning. If you already develop in JavaScript or TypeScript ecosystems and want to add a genuinely in-demand automation skill, this is the strongest match in the lineup. If you are brand new to testing entirely, starting here is like learning to drive in a race car — powerful, but unforgiving.
Pros:
- Covers Playwright, one of the most in-demand automation frameworks in modern web development
- Practical, hands-on structure that gets readers writing real tests quickly
- Explicit focus on building reliable and scalable tests, not just toy examples
- Well matched to JavaScript/TypeScript teams working on contemporary web apps
Cons:
- Playwright evolves rapidly, so specific technical details may become outdated
- Assumes existing programming comfort — steeper on-ramp for non-developers
- Limited verifiable detail about the book’s internal content and depth
Best for: Developers and QA engineers who already code and want to master a modern, in-demand automation framework
Not ideal for: Complete beginners to software testing, or readers who need a framework-agnostic foundation first
Bottom line: The strongest choice for working developers who want immediately relevant, modern automation skills — provided they accept a shorter shelf life than slower-moving alternatives.
“The strongest choice for working developers who want immediately relevant, modern automation skills — provided they accept a shorter shelf life than slower-moving alternatives.”
Software Testing with Selenium: Automated Testing Tool Book for Beginners
Not everyone picking up an automation book is a seasoned developer, and this is the entry in our lineup that respects that reality. Selenium remains the most widely recognized testing tool in the industry, and a beginner-focused guide built around it gives newcomers two things at once: a gentle introduction to automation concepts and a skill that hiring managers actually recognize. Compared with the Playwright book at the top of our ranking, the learning curve here is deliberately flatter. Where the Playwright guide assumes you can already write code comfortably, a beginner-labeled Selenium book starts from fundamentals.The honest tradeoff is depth and currency. Selenium is a mature, stable tool — which is precisely why it is beginner-friendly — but it is no longer where the industry’s momentum is concentrated. Readers who invest solely in Selenium may eventually need to pick up a modern framework like Playwright to stay current, a gap the top pick in this roundup directly fills. We also have to be transparent: publicly available detail about this book’s specific content is limited, so buyers should verify that its depth matches their needs — a short beginner guide and a comprehensive Selenium course-in-a-book are very different products that share the same title territory.Still, the role it plays is genuinely useful. For career changers, manual testers moving into automation, or students building a first resume, learning Selenium first is a defensible and pragmatic strategy. This book makes the most sense as a first step, not a final destination.
Pros:
- Focused specifically on Selenium, the most widely recognized automation tool in the industry
- Explicitly designed for beginners with a gentler learning curve
- Teaches skills that remain heavily represented in job listings and enterprise environments
- Single-tool focus keeps beginners from being overwhelmed by framework comparisons
Cons:
- Selenium is mature rather than cutting-edge, so skills may need supplementing later
- Limited detail available about the book’s actual scope and depth
- Beginner focus means advanced automation engineering topics are likely out of reach
Best for: Career changers and manual testers taking their first step into test automation
Not ideal for: Experienced developers seeking a modern framework or advanced automation architecture
Bottom line: A sensible, low-friction on-ramp into automation for newcomers, best treated as a stepping stone toward broader or more modern skills.
“A sensible, low-friction on-ramp into automation for newcomers, best treated as a stepping stone toward broader or more modern skills.”
Automated Testing Unleashed: Automated Testing Engineering Fundamentals — The Complete Handbook, Volume 1
Where the first two picks teach you a tool, this one teaches you the discipline — and that difference is its entire value proposition. Automated Testing Unleashed focuses on engineering fundamentals rather than a single framework, which means the concepts covered — test strategy, maintainability, automation architecture — stay relevant even as specific tools rise and fall. For readers who want to understand why tests fail and how to design suites that survive refactors, this is the only entry in the lineup that addresses that layer directly. Compared with the Selenium book, it trades approachability for durability: what you learn here will not be obsolete when the next framework arrives.The structure is both a strength and a limitation. As volume one of a multi-part handbook series, it is designed as the beginning of a longer journey rather than a complete education in one purchase. Readers who want a quick path to writing their first automated tests will find this slower going than either framework-specific guide — fundamentals-first books front-load concepts before delivering the satisfaction of working code. We also flag the same transparency issue that affects the other picks: there is little verifiable detail about the book’s interior content, so buyers are relying on the series positioning and title scope when assessing depth.This pick makes the most sense for QA engineers and team leads who need to think about automation strategically — choosing what to automate, designing for maintainability, and building processes — rather than for someone who simply needs to learn one tool this month. It is the deepest investment of the three, and the slowest to pay off, but potentially the most durable.
Pros:
- Comprehensive coverage of automation engineering fundamentals, not just one tool
- Tool-agnostic knowledge that remains relevant as frameworks change
- Part of a structured handbook series supporting progressive, continued learning
- Addresses strategy and design decisions that framework books typically skip
Cons:
- Volume one of a series, so not a complete education on its own
- No description or review content available to verify depth and quality
- Fundamentals-first pacing delays hands-on payoff compared with framework guides
Best for: QA engineers, team leads, and serious students who want tool-agnostic automation engineering foundations
Not ideal for: Readers who need to get productive with a specific framework quickly
Bottom line: The right choice for readers building a lasting career foundation in automation engineering, provided they accept a longer, multi-volume commitment.
“The right choice for readers building a lasting career foundation in automation engineering, provided they accept a longer, multi-volume commitment.”
As an Amazon Associate we earn from qualifying purchases.
Before You Start
Decide what kind of testing you are setting up before you install anything, because the tool choice depends on it. Unit tests check individual functions in isolation and are where nearly every team should start. Integration tests check that multiple parts work together, and end-to-end tests drive a real browser or application. This guide covers unit tests with Jest, and the steps transfer directly to the other levels later.
One warning worth acting on: commit your project to Git before you begin. Installing and configuring testing tools touches several configuration files, and you want a clean rollback point if something goes wrong.
Step-by-Step Instructions
Step 1: Install the testing framework as a development dependency
Open a terminal in your project’s root folder and run:
npm install --save-dev jest
The --save-dev flag records Jest in the devDependencies section of package.json, which keeps it out of production installs.
Tip: If your project has nopackage.jsonyet, runnpm init -yfirst, then install Jest.
Check: Run npx jest --version. It should print a version number such as 29.x.x with no errors.
Step 2: Add a test script to package.json
Open package.json in your editor. Find the "scripts" object and add a test entry so it reads:
"scripts": { "test": "jest" }
This lets you (and later the automation pipeline) run all tests with the single command npm test instead of typing the full Jest invocation.
Tip: If a"test"line already exists with placeholder text likeecho \"Error: no test specified\", replace it — do not add a duplicate key.
Check: Run npm test. Jest should start and report that no tests were found — that is expected at this point, not an error.
Step 3: Create the test folder and first test file
Create a folder named __tests__ in your project root (the double underscores are a Jest convention). Inside it, create a file named after the module you are testing, for example math.test.js if your code file is math.js. In the test file, write your first test:
test('adds 1 + 2 to equal 3', () => { expect(1 + 2).toBe(3); });
This deliberately tests a trivial expression so you can verify the toolchain works before testing real code.
Tip: Do not skip the trivial first test. It isolates setup problems from logic problems: if this passes, your configuration is correct.
Check: Run npm test. You should see output ending in Tests: 1 passed, 1 total.
Step 4: Write a real test against your own code
At the top of your test file, import the function you want to test. For example: const { add } = require('../math'); if math.js sits one level above the test folder. Then write a test that calls your function with a known input and asserts the expected output:
test('add returns the sum of two numbers', () => { expect(add(2, 3)).toBe(5); });
Follow the pattern for two or three more cases, including at least one edge case — zero, negative numbers, or an empty string, depending on your function.
Tip: Use one assertion concept per test and name each test after the behavior it checks, not the function name. A name like ‘rejects email addresses without a domain’ tells you exactly what broke when it fails.
Check: Run npm test and confirm all tests pass. Then temporarily break your function (change a + to a -), run the tests again, and watch them fail. Restore the fix. Seeing a deliberate failure proves the tests actually detect problems.
Step 5: Test failure paths, not just success paths
Add at least one test that confirms your function behaves correctly on bad input. If your function should throw an error, test for it:
expect(() => validateEmail('not-an-email')).toThrow();
If it should return null or false, assert that instead. A test suite that only covers happy paths gives false confidence.
Check: All tests still pass, and your suite contains at least one test per behavior: normal input, edge input, and invalid input.
Step 6: Create the automation pipeline in GitHub Actions
In your repository root, create the folder path .github/workflows and add a file named tests.yml with this content:
name: Tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
- run: npm ci
> - run: npm test
This tells GitHub to check out your code, install dependencies, and run the test suite on every push and pull request.
Tip: Usenpm cirather thannpm installin pipelines — it performs a clean, reproducible install from your lockfile.
Check: Commit and push the workflow file, then open your repository on GitHub, click the Actions tab, and watch the run labeled ‘Tests’ execute and finish with a green checkmark.
Step 7: Verify the pipeline blocks broken code
Break one of your tests on purpose — change an expected value from 5 to 6 — commit, and push. Open the Actions tab and watch the run. It must finish with a red X and show exactly which test failed and why. Revert the change and push again; the next run should return to green.
Tip: If the pipeline stays green even after you broke a test, your workflow is not running the tests at all — see Troubleshooting below.
Check: You have observed both a red (failing) and green (passing) pipeline run, and the failure message clearly identified the broken test.
Common Mistakes to Avoid
- Installing the testing framework as a regular dependency instead of a dev dependency — Always use
npm install --save-dev. Production builds stay smaller and faster, and deployment platforms will not attempt to run test tooling. - Testing implementation details instead of behavior — Assert on what a function returns and what effects it causes, never on internal variables or the number of times something was called unless that is the contract. Behavior-based tests survive refactoring; implementation tests break on every change and erode trust in the suite.
- Writing all assertions in one giant test — Keep one logical assertion per test function. When a combined test fails, you cannot tell which behavior broke, and the first failing assertion hides the rest.
- Pushing the workflow file without a lockfile, causing
npm cito fail — Make surepackage-lock.jsonexists and is committed. Runnpm installlocally once to generate it if it is missing.
Troubleshooting
Problem: Jest reports ‘No tests found’ even though test files exist
Solution: Check the folder name and file name. Jest looks for files ending in .test.js or .spec.js, or any file inside a __tests__ folder. A typo such as math.tests.js will not be picked up. Run npx jest --listTests to see exactly which files Jest detects.
Problem: Tests pass locally but fail in the GitHub Actions pipeline
Solution: Compare environment differences. The most common causes: a missing package-lock.json, a dependency installed globally on your machine but not in package.json, or code that depends on local files or environment variables absent from the pipeline. Add the missing dependency or set the variable in the repository’s Secrets settings under Settings → Secrets and variables → Actions.
Problem: The Actions run shows green but clearly did not run any tests
Solution: Open the run log and read each step. If the test step shows ‘0 tests found’ or exits instantly, the workflow is running in the wrong directory or the test script in package.json points to the wrong command. If your project lives in a subfolder, add working-directory: ./your-subfolder to the run steps.
Problem: Cannot find module errors when the test imports your source code
Solution: Check the relative path in your import. A test in __tests__/math.test.js reaching a file in the project root needs require('../math') — two dots, not one. Also confirm the file extension and the export: the source file must use module.exports for require to find it.
What Success Looks Like
Your setup is complete and working when all of the following are true:
- Running
npm testlocally executes every test file and reports all tests passing within seconds. - Deliberately breaking code causes a test to fail with a message that names the failing behavior.
- Every push to GitHub triggers a ‘Tests’ run in the Actions tab without any manual action.
- A broken push produces a red X on the commit; a fixed push produces a green checkmark.
- Your suite covers at least normal, edge, and invalid input for each tested function.
Next Steps
With the pipeline in place, grow the suite deliberately rather than all at once. Add tests whenever you fix a bug — write a test that reproduces the bug first, confirm it fails, then fix the code and confirm it passes. This builds regression coverage where it pays off most.
Next capabilities to add, in order of value:
- Coverage reporting: run
npx jest --coverageto see which code paths lack tests. - Branch protection: in GitHub, under Settings → Branches, require the Tests check to pass before a pull request can merge.
- Integration tests once unit coverage is solid, then end-to-end browser tests with a tool such as Playwright if your project has a user interface.
- A lint step in the same workflow so style errors never reach review.
Frequently Asked Questions
Can I use this process with Python or another language instead of JavaScript?
Yes. The sequence is identical: install the tool, add a test command, write a test file, run it, and add it to CI. For Python, use pytest (pip install pytest, run with pytest); for Java, use JUnit with Maven or Gradle; for Go, the built-in go test needs no installation at all. Only the install commands and the workflow’s setup step change.
How many tests do I need before this is worthwhile?
Even three to five tests deliver the main benefit: the pipeline detects breakage automatically. Start by testing your most-used and most fragile functions. A practical early target is covering every bug you fix plus the core calculations or validations in your code. Coverage percentage matters less than whether the tests check meaningful behavior.
My tests are slow. Does that matter?
Yes. Unit tests should each run in milliseconds, and the whole suite should finish in seconds, because slow suites get skipped. Slowness usually means a test touches the network, a database, or the filesystem. Replace those external calls with mocks or stubs so the test exercises your logic, not the outside service.
What is the difference between unit, integration, and end-to-end tests?
Unit tests check one function in isolation with no external dependencies. Integration tests check that components work together — for example, that your code correctly reads from a test database. End-to-end tests drive the full application, often through a real browser. Build unit tests first; they are fast, cheap, and pinpoint failures precisely. Add the other layers selectively where unit tests cannot catch the risks you care about.
Does automated testing replace manual testing?
No. Automated tests excel at catching regressions — things that used to work and broke — and at checking logic repeatedly without fatigue. They cannot judge whether an interface is usable or whether a feature makes sense to a person. Use automation as a safety net for correctness and keep short manual checks for experience and design questions.
Halloween Picks
halloween
As an affiliate, we earn on qualifying purchases.
