PCAT™ – Certified Associate Tester with Python: EXAM SYLLABUS

Exam Syllabus Contents

• Block 1: Software Testing Essentials
• Block 2: Test Automation and Code Refactoring
• Block 3: Assertions, Context Managers, Decorators, and Python Methods
• Block 4: Foundations of Unit Testing
• Block 5: Advanced Unit Testing Techniques
• Block 6: Test-Driven and Behavior-Driven Development

Block 1: Software Testing Essentials

7 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.

Block 2: Test Automation and Code Refactoring

3 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.

Block 3: Assertions, Context Managers, Decorators, and Methods

5 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

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.

Block 4: Foundations of Unit Testing

8 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.

Block 5: Advanced Unit Testing Techniques

7 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.

Block 6: Test-Driven and Behavior-Driven Development

3 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.