OneRange

GitHub Copilot: Essentials — Testing Playbook

A focused playbook for testing with GitHub Copilot. Learners use Copilot Chat to write unit and edge-case tests for untested code, find the root cause of a test that fails on its own and make it deterministic, and prove their tests really guard the rules by breaking the code on purpose. They leave with a repeatable way to get tests from Copilot that catch bugs instead of locking them in. About 45 minutes including the final.

What this course covers

The course runs across 3 topics, each one a short adaptive session rather than a recorded lecture. The tutor explains the idea, works an example, checks understanding, and adjusts the next step to the answer given.

  • Writing unit and edge-case tests with Copilot Chat — Give Copilot the code and the written rule, ask it to list the behaviours and boundary values first, then ask for tests with exact expected values in your team's framework (/tests where the chat offers it). Check every expected value against the rule, not against what the current code returns, so a bug is caught instead of locked in.
  • Fixing failing and flaky tests — Ask Copilot for the root cause before any fix: tests that read the real clock, use random data, depend on test order or share state fail on their own. Learners make time an input with a sensible default and keep the test strict, rather than deleting, skipping or loosening it.
  • Does the test really guard the behaviour? — A passing test only matters if it fails when the rule breaks. Learners break one rule on purpose on a copy, see which tests fail, rewrite weak checks such as 'is a number' into exact amounts, and can do the same in agent mode on a branch, reading each terminal command before it runs and reviewing every edit.

Skills you build

Results are measured against named skills in the OneRange taxonomy of more than 10,000 skills, so a manager sees proficiency per skill rather than a completion tick.

Who it is for

Software developers. The material is pitched at beginner level, and takes roughly 45 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

It sits in the Tool: GitHub Copilot track of the Vero AI Catalog, and can be assigned to one person, a team, or the whole company.

How it is delivered and assessed

Delivery is conversational and interactive, including code lab exercises. There is no video to sit through and no slide deck to click past.

Understanding is checked with a lab assessment of 5 items, with a pass mark of 70%.

Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Also in this track

  • All GitHub Copilot training courses →
  • GitHub Copilot: Essentials — Docs & Onboarding Playbook — A focused playbook for documentation and onboarding with GitHub Copilot. Learners use Copilot Chat to explain an unfamiliar module, audit an out-of-date README, write a new README and doc comments, and produce a handoff note in which every claim is traced to a line of code. They leave with docs a new teammate can trust and a habit of checking Copilot's claims against the code. About 45 minutes including the final.
  • GitHub Copilot: Essentials — Refactoring & Migration Playbook — A focused playbook for safe refactoring and migration with GitHub Copilot. Learners pin today's behaviour with characterization tests, use Copilot Chat to rename, extract a function and simplify legacy code in small behaviour-preserving steps, then migrate off a deprecated Python call without breaking anything. They leave with a step-by-step routine that keeps every refactor protected by tests. About 45 minutes including the final.
  • GitHub Copilot: Essentials — Coding with GitHub Copilot — The developer starting point for the GitHub Copilot family: coding with GitHub Copilot. Learners get access and sign in, work with inline suggestions, use chat in the editor with the right context, choose between ask, plan and agent, use Copilot Chat on github.com, and review everything Copilot produces. Ends with a fix-and-explain lab.
  • GitHub Copilot: Essentials — Code Review Playbook — A focused playbook for code review with GitHub Copilot. Learners ask Copilot Chat for a specific, line-referenced review of a pull request written by a coding agent, covering correctness, security, risky edits and missing tests, then check every finding against the code and decide which AI review comments to accept. They leave with a review routine that uses Copilot as a second pair of eyes without trusting it blindly. About 45 minutes including the final.
  • GitHub Copilot: Core — Agent Mode, Code Review & Cloud Agent Hand-offs — The working level of GitHub Copilot after Essentials. Developers run agent mode on multi-file tasks and review every edit, choose context on purpose, set up repository custom instructions and prompt files, respond to Copilot code review on pull requests, hand their first issues to Copilot cloud agent, use Copilot on github.com and keep company code safe. Ends with one change taken through the whole workflow.
  • GitHub Copilot: Placement Check — Start here. The placement check places developers at Essentials, Core, Advanced or Mastery so you can assign training from the right level.
  • GitHub Copilot Pathway — Coding with GitHub Copilot, from first suggestions to running it across an engineering org: inline suggestions, chat and agent basics (Essentials); agent mode, custom instructions, Copilot code review and first cloud agent hand-offs (Core); custom agents, MCP, Copilot CLI and cloud agent environments (Advanced); and policies, metrics, rollout and incident response at org scale (Mastery). Also includes 4 optional playbooks (Testing, Code Review, Refactoring & Migration, Docs & Onboarding) to take any time after Essentials; they don't count toward the certificate.

Related

Frequently asked questions

How long does this course take?

It runs roughly 45 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

How is it assigned to a team?

An administrator assigns it from the Vero dashboard to one person, a team, a department or the whole company, and sees progress and results per person and per skill.

Can we customise it with our own documents and terminology?

Yes. Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Course code TUL-GHC-121.