Python Institute Associate Tester with Python (PCAT-31-0x) Exam Syllabus

• Describe software testing and recognize various software testing traits.

- Levels of Testing

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

- Software Testing Definitions

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

- Testing Principles

• 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

• Describe conditions for starting and stopping test activities.

- The Test Pyramid

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

- Code coverage

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

• Explain the purpose and benefits of test automation.

- The Code Refactoring Loop

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

- Code Refactoring

• Implement the Arrange, Act, Assert (AAA) triplet in automated tests using Python, ensuring clear and maintainable test structures.
• 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.

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

- Context Managers

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

- Function Decorators

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

- Class Decorators

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

- Different Types of Python Methods

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

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

- xUnit Architecture

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

- Running Tests

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

- Good Practices

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

- Specialized Assertions

• 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

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

- AAA Pattern Used in Practice

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

- Using the unittest Module

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

• 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

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

- Marking Tests for Special Conditions

• 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

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

- Using Test Doubles

• 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

• 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

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

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

- Implementing the Red, Green, Refactor Phases

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

- Behavior-Driven Development Fundamentals

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