PCAT™ – Certified Associate Tester with Python: EXAM SYLLABUS

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.