Test Driven Development
Test Driven Development (TDD) is a software development methodology that relies on the repetition of a very short development cycle: first the developer writes an automated failing test case that defines a desired improvement or new function, then produces the minimum amount of code to pass that test, and finally refactors the new code to acceptable standards. This approach promotes meticulous unit testing, encourages simple design, and inspires confidence in the codebase's reliability, making it a cornerstone of modern agile and DevOps practices.
Assessment criteria
Topic Overview
The City & Guilds Level 3 Certificate in ICT Systems and Principles is a vocational qualification designed to equip students with the practical skills and theoretical knowledge needed to work in the ICT industry. It covers a broad range of topics including computer hardware, software, networking, database design, and web development. This qualification is ideal for those seeking a career as an IT technician, network administrator, or systems analyst, as it provides a solid foundation in both system architecture and problem-solving techniques.
The course is structured around mandatory units that explore the principles of ICT systems, such as how data is stored and transmitted, the role of operating systems, and the fundamentals of programming. Optional units allow students to specialise in areas like cybersecurity or multimedia. By the end of the certificate, students will be able to configure and troubleshoot computer systems, design simple networks, and create functional databases. This hands-on approach ensures learners are job-ready and can apply their skills in real-world scenarios.
In the wider context of computer science, this qualification bridges the gap between theoretical concepts and practical application. While A-Level Computer Science focuses more on algorithms and computational thinking, the City & Guilds certificate emphasises the operational aspects of ICT systems. This makes it particularly valuable for students who prefer a more applied learning style and want to enter the workforce directly after their studies.
Key Concepts
Core ideas you must understand for this topic
- →System architecture: Understanding the components of a computer system (CPU, memory, storage) and how they interact to execute instructions.
- →Networking fundamentals: Knowledge of network topologies, protocols (e.g., TCP/IP), and devices (routers, switches) to enable data communication.
- →Database design: Using entity-relationship diagrams and normalisation to create efficient, relational databases that minimise redundancy.
- →Programming principles: Writing structured code using sequence, selection, and iteration, with an emphasis on debugging and testing.
- →Health and safety legislation: Applying relevant laws (e.g., Health and Safety at Work Act) when setting up and maintaining ICT equipment.
Learning Objectives
What you need to know and understand
- Explain the core principles and benefits of unit testing and TDD
- Apply the Red-Green-Refactor cycle to incrementally develop software features
- Write effective unit tests using a chosen testing framework
- Employ appropriate test doubles and assertions to isolate code behaviour
- Refactor production code without altering its external behaviour
- Evaluate test suite effectiveness using coverage metrics and quality criteria
- Understand the principles of Unit Testing and Test Driven Development, Understand Test Driven Development techniques, Be able to implement a Test Driven Development Solution, Be able to to test and evaluate a solution using Test Driven Development
- Understand the principles of Unit Testing and Test Driven Development, Understand Test Driven Development techniques, Be able to implement a Test Driven Development Solution, Be able to to test and evaluate a solution using Test Driven Development
Assessment Criteria
Key criteria assessors look for in your portfolio
- Award credit for clear evidence of test-first development, with failing tests written before production code
- Check that documentation shows a logical progression from failing tests to passing tests after each increment
- Look for appropriate use of mocking, stubbing, or fakes to isolate units under test
- Expect justification of refactoring decisions with reference to code quality and test stability
- Credit evidence of analysis of test coverage and identification of any gaps in the test suite
- Understand principles of unit testing and TDD.
- Apply TDD techniques effectively.
- Implement a TDD solution.
- Test and evaluate a solution using TDD.
- Explain the red-green-refactor cycle of TDD.
- Write unit tests before implementing code.
- Refactor code to improve design while keeping tests passing.
- Evaluate the effectiveness of a TDD approach.
Assessment Guidance
Guidance for achieving higher grades
- 💡Structure your portfolio or reports to explicitly show each TDD step: red (failing test), green (minimal passing code), refactor (improved code) with comments
- 💡Include evidence of deliberately failing test runs early in the cycle to prove that tests are not passing by default
- 💡Discuss the rationale behind your selection of testing framework and any test doubles, linking them to TDD best practices
- 💡Demonstrate critical evaluation by highlighting how TDD influenced your design decisions and code maintainability
- 💡Follow the red-green-refactor cycle.
- 💡Write simple, focused tests.
- 💡Practice the TDD cycle with simple examples.
- 💡Ensure tests are independent and repeatable.
- 💡Use a testing framework appropriate to the language.
- 💡When answering questions about network topologies, always draw a diagram if possible. Even a simple sketch can help you explain the advantages and disadvantages clearly, and examiners reward visual communication.
- 💡For database questions, remember to state the primary key and foreign key relationships explicitly. Many students lose marks by not clearly identifying how tables are linked.
- 💡In programming tasks, always include comments in your code to explain your logic. This shows the examiner that you understand the process, even if your syntax has minor errors.
Common Mistakes
Common errors to avoid in your coursework
- Writing unit tests after the production code, which defeats the purpose of TDD and reduces test effectiveness
- Conflating unit tests with integration or system tests, leading to slow, brittle, and hard-to-maintain test suites
- Neglecting the Refactor phase, resulting in messy code that accumulates technical debt despite passing tests
- Testing only positive scenarios and ignoring edge cases, invalid inputs, and error handling paths
- Writing tests after code instead of before.
- Insufficient test coverage.
- Writing tests after code instead of before.
- Creating tests that are too broad or too narrow.
- Neglecting to refactor after tests pass.
- Misconception: 'IP addresses are permanent and never change.' Correction: IP addresses can be dynamic (assigned by DHCP) or static; many devices receive a new IP each time they connect to a network.
- Misconception: 'More RAM always makes a computer faster.' Correction: While RAM improves multitasking, adding RAM beyond what the system needs does not increase speed; the bottleneck may be the CPU or storage.
- Misconception: 'Normalisation always means splitting tables into the smallest possible pieces.' Correction: Normalisation aims to reduce redundancy and dependency, but over-normalisation can lead to complex queries and performance issues; third normal form is often sufficient.
Frequently Asked Questions
Common questions students ask about this topic
Pass / Merit / Distinction Evidence Checklist
How your portfolio evidence is graded for CITY & GUILDS LIMITED Test Driven Development
Every vocational unit is marked against named criteria rather than an exam percentage. Your tutor's brief lists the exact codes for this unit — here is what each band is asking you to do.
Demonstrate baseline knowledge, accurate terminology, and core practical application.
Provide detailed analysis, structured explanations, and clear workplace reasoning.
Deliver thorough evaluation, original problem solving, and fully justified recommendations.
Before You Start
Prior knowledge that will help with this topic
- •Basic understanding of computer hardware components (e.g., CPU, RAM, hard drive) from GCSE ICT or equivalent.
- •Familiarity with using common software applications like word processors and spreadsheets.
- •Elementary mathematical skills, particularly in binary and hexadecimal number systems.
Coursework AI Review
Paste your assignment brief and check your draft against its P/M/D criteria
Key Terminology
Essential terms to know
- Unit testing fundamentals
- Red-Green-Refactor cycle
- Test automation and coverage
- Code design and refactoring
- Integration and acceptance testing
- Continuous integration practices
- Understand the principles of Unit Testing and Test Driven Development, Understand Test Driven Development techniques, Be able to implement a Test Driven Development Solution, Be able to to test and evaluate a solution using Test Driven Development
- Understand the principles of Unit Testing and Test Driven Development, Understand Test Driven Development techniques, Be able to implement a Test Driven Development Solution, Be able to to test and evaluate a solution using Test Driven Development
Ready to learn?
AI-powered learning tailored to this unit