PCAT™ – Certified Associate Tester with Python: EXAM SYLLABUS



PCAT-31-01 Exam Syllabus


Status: ACTIVE

PCAT-31-01 badge

The exam is broken down into six blocks:

Block 1 → 7 items, Weight: 16.7%
Block 2 → 4 items, Weight: 9.5%
Block 3 → 5 items, Weight: 11.9%
Block 4 → 12 items, Weight: 28.6%
Block 5 → 11 items, Weight: 26.2%
Block 6 → 3 items, Weight: 7.1%





Objectives covered by the block (7 exam items)

Software Testing Concepts and Terminology

  • 1.1 Describe software testing and recognize various software testing traits.

Levels of Testing

  • 1.2 Describe the different levels of testing (unit testing, integration testing, system testing, and acceptance testing) and explain their purposes.

Software Testing Definitions

  • 1.3 Identify and differentiate between errors, defects, bugs, and failures.

Testing Principles

  • 1.4 Explain the seven principles of software testing: testing shows the presence of defects, exhaustive testing is impossible, early testing, defect clustering, pesticide paradox, testing is context-dependent, and the absence-of-errors fallacy.

Start and End of the Testing Process

  • 1.5 Describe conditions for starting and stopping test activities.

The Test Pyramid

  • 1.6 Explain the purpose of end-to-end (e2e) tests, integration tests, and unit tests.

Code coverage

  • 1.7 Explain and measure code coverage, and understand the concept of dead code.


Objectives covered by the block (4 exam items)

The Goal and Importance of Test Automation

  • 2.1 Explain the purpose and benefits of test automation.

The Code Refactoring Loop

  • 2.2 Describe the code refactoring loop and explain the concept of continuous improvement in code quality through refactoring.

Code Refactoring

  • 2.3 Implement the Arrange, Act, Assert (AAA) triplet in automated tests using Python, ensuring clear and maintainable test structures.
  • 2.4 Apply the DRY (Don't Repeat Yourself) and KISS (Keep It Simple, Stupid) principles in code refactoring to improve the quality, readability, and maintainability of Python code.


Objectives covered by the block (5 exam items)

The Assertion Statement

  • 3.1 Explain the concept of assertions, including their role in code correctness, syntactic sugar, Python code execution optimization, and test-doubles.

Context Managers

  • 3.2 Demonstrate the use of the with statement and explain the concept of the code sandwich pattern for managing resources.

Function Decorators

  • 3.3 Explain the purpose of function decorators, including decorator attributes and decorator stacking, and implement basic function decorators in Python.

Class Decorators

  • 3.4 Implement class decorators to modify or extend class behavior in Python.

Different Types of Python Methods

  • 3.5 Distinguish between instance methods, static methods, and class methods, and explain their appropriate use cases.


Objectives covered by the block (12 exam items)

Anatomy of a Unit Test

  • 4.1 Explain the F.I.R.S.T principles of unit testing (Fast, Independent, Repeatable, Self-validating, and Timely).

xUnit Architecture

  • 4.2 Describe the concepts of test case, test suite, test fixture, test runner, and file separation within the xUnit architecture.

Running Tests

  • 4.3 Explain the foundations of test execution, including how to run tests using different tools and frameworks in Python.

Good Practices

  • 4.4 Explain good practices regarding test file structure and naming conventions to ensure maintainability and readability.

Specialized Assertions

  • 4.5 Implement unit tests using specialized assertions such as assertEqual, assertAlmostEqual, assertTrue, assertFalse, assertIs, assertIn, assertGreater, assertLess, and assertRaises.

Unit Tests as a Source of Documentation

  • 4.6 Argue how unit tests can serve as valuable documentation by providing clear examples of code usage and expected behavior.

AAA Pattern Used in Practice

  • 4.7 Implement unit tests according to the Arrange, Act, Assert (AAA) pattern to ensure clarity and consistency in test cases.

Using the unittest Module

  • 4.8 Utilize Python's unittest module to create and run unit tests, and explain its key components such as TestCase, setUp, tearDown, and test discovery.


Objectives covered by the block (11 exam items)

Unit Test Preparation

  • 5.1 Contrast the purpose of test fixtures at the method, class, and module levels, and implement appropriate fixtures to set up and tear down test environments.

Unit Test Parametrization

  • 5.2 Implement parameterized unit tests to run the same test logic with different input values, using the unittest framework.

Marking Tests for Special Conditions

  • 5.3 Demonstrate how to select tests to be skipped conditionally and unconditionally by utilizing the @unittest.skip, @unittest.skipIf, and @unittest.expectedFailure decorators, and explain scenarios where these are useful.

Selective Test Execution

  • 5.4 Identify the advantages of selective test execution and implement it using naming patterns or other criteria to run specific test subsets.

Using Test Doubles

  • 5.5 Implement test doubles, such as mocks and stubs, using the Mock and MagicMock classes from the unittest.mock module to isolate units of code under test.

Mocking with Patch

  • 5.6 Implement test-doubles using the patch mechanism from the unittest.mock module to replace parts of the system under test with mock objects during test execution.

Handling Exceptions in Unit Tests

  • 5.7 Explain how to handle exceptions in unit tests and write tests that verify exception handling code paths to ensure robustness.


Objectives covered by the block (3 exam items)

Test-Driven Development Fundamentals

  • 6.1 Explain the concept of Test-Driven Development (TDD), including its principles, workflow, and advantages and disadvantages.

Implementing the Red, Green, Refactor Phases

  • 6.2 Explain the TDD cycle of Red, Green, and Refactor, and how to develop code following these phases.

Behavior-Driven Development Fundamentals

  • 6.3 Describe the principles of Behavior-Driven Development (BDD), including the Given, When, Then syntax for writing behavior specifications.

Last updated: July 5, 2024
Aligned with Exam PCAT-31-01

MQC Profile

A minimally qualified candidate (MQC) for the PCAT exam is expected to have a foundational understanding of software testing principles and practices, including various levels of testing such as unit, integration, system, and acceptance testing. They should possess basic programming skills in Python and be familiar with test automation, TDD, and BDD approaches. The candidate should also have a grasp of software engineering principles, such as code refactoring and using test doubles. Furthermore, they must demonstrate knowledge of test design and execution, utilizing tools like unittest, and have the capability to implement testing best practices. Effective communication skills are essential to present testing insights coherently, catering to diverse audiences.

This profile represents a blend of technical proficiency, analytical thinking, and communication skills crucial for navigating the complexities of software testing environments.

Block 1: Software Testing Essentials (16.7% of total exam)

Minimum Coverage: A candidate must demonstrate a basic understanding of software testing concepts and terminology, levels of testing, software testing definitions, and testing principles. They should also be familiar with the start and end of the testing process, the test pyramid, and code coverage.

Block 2: Test Automation and Code Refactoring (9.5% of total exam)

Minimum Coverage: Proficiency in explaining the purpose and benefits of test automation, describing the code refactoring loop, and implementing the Arrange, Act, Assert (AAA) triplet in automated tests using Python. They should also apply the DRY and KISS principles in code refactoring.

Block 3: Assertions, Context Managers, Decorators, and Python Methods (11.9% of total exam)

Minimum Coverage: Understanding the concept of assertions, the use of context managers, function and class decorators, and the different types of Python methods. They should be able to implement these techniques to enhance code quality and testing.

Block 4: Foundations of Unit Testing (28.6% of total exam)

Minimum Coverage: Basic capability to explain the F.I.R.S.T principles of unit testing, describe the xUnit architecture, run tests using different tools and frameworks, and follow good practices for test file structure and naming conventions. They should also implement specialized assertions, understand the value of unit tests as documentation, and utilize the unittest module.

Block 5: Advanced Unit Testing Techniques (26.2% of total exam)

Minimum Coverage: Proficiency in setting up and tearing down test environments with appropriate fixtures, implementing parameterized unit tests, marking tests for special conditions, and selectively executing tests. They should also be able to use test doubles and the patch mechanism from unittest.mock, and handle exceptions in unit tests.

Block 6: Test-Driven and Behavior-Driven Development (7.1% of total exam)

Minimum Coverage: Understanding the concepts and principles of Test-Driven Development (TDD) and Behavior-Driven Development (BDD). They should be able to explain the TDD cycle of Red, Green, Refactor, and describe the Given, When, Then syntax for writing behavior specifications.

To pass the PCAT exam, a candidate's cumulative average score across all blocks must reach 70%.