PCPP2 key terms

Setup and teardown code that puts the environment into a known state before a test runs and restores it afterward, such as creating a temporary database or closing a socket connection.

unittest methods that run before and after each test method in a TestCase class, used to prepare shared state and release resources so tests stay independent.

A statement that checks whether an actual value matches an expected one; if it fails, the test framework records a failure and continues or aborts according to the framework's rules.

A unittest context manager or method that passes only when the enclosed code raises the specified exception type, used to verify error handling paths.

A stand-in object that records calls and returns configured values, letting a test isolate a unit from slow or unreliable collaborators such as databases and network services.

Replacing an attribute or module at runtime, often with pytest's monkeypatch fixture, so a test can substitute a fake dependency and undo the change automatically afterward.

A function decorated with @pytest.fixture whose return value is injected into tests that name it as a parameter, supporting setup, teardown via yield, and reusable scopes.

Running one test function against several input and expected-output sets, declared with pytest.mark.parametrize, so each combination is reported as a separate test result.

The smallest unit of testing: a class or function containing one or more assertions that exercises a specific behavior and reports pass, fail, or error.

An organized collection of test cases and fixtures executed together, often discovered by naming conventions such as files beginning with test_ or classes inheriting from unittest.TestCase.

The component that discovers tests, executes them, and reports results; unittest provides TextTestRunner and pytest provides its own runner with plugins and rich output.

Any substitute for a real dependency in a test, including stubs, fakes, spies, and mocks, chosen according to how much behavior and verification the test needs.

A creational pattern that guarantees a class has exactly one instance and provides a global access point, often implemented in Python by overriding new or using a module-level instance.

A creational pattern where a function or method decides which concrete class to instantiate, so callers request an object by intent rather than naming a specific class.

A structural pattern that wraps a complicated subsystem behind one simplified interface, reducing coupling for callers that only need common operations.

A structural pattern in which a surrogate object controls access to a real object, adding lazy loading, permission checks, caching, or logging while exposing the same interface.

A behavioral pattern where a subject keeps a list of observers and notifies them when its state changes, decoupling event producers from the components that react.

A behavioral pattern that encapsulates a request as an object with an execute method, enabling queuing, logging, undo, and decoupling of invokers from receivers.

A behavioral pattern where a base class defines the skeleton of an algorithm and delegates variable steps to subclass overrides, fixing order while allowing customization.

A behavioral pattern where an object changes its behavior by delegating to a state object, making transitions explicit instead of relying on large conditional blocks.

A class from the abc module that cannot be instantiated until its abstract methods are implemented, used to define contracts for subclasses and support structural design.

A standard library package that starts separate OS processes, each with its own interpreter and memory, bypassing the GIL to use multiple CPU cores for CPU-bound work.

A standard library module for running multiple threads inside one process with shared memory, suited to I/O-bound tasks because only one thread executes Python bytecode at a time.

The global interpreter lock, a mutex in CPython that lets only one thread execute Python bytecode at a time, which limits thread-based parallelism for CPU-heavy code.

A module for launching external programs, connecting their standard input, output, and error streams, and inspecting exit codes, replacing older functions such as os.system.

The subprocess class that starts a child program without waiting, exposing stdin, stdout, stderr, poll, wait, and communicate for interactive control of the process.

A one-way channel connecting the output of one process to the input of another, created with subprocess.PIPE or os.pipe and often used to chain command-line tools.

A process-safe FIFO from multiprocessing that pickles objects between processes, giving producers and consumers a synchronized way to exchange data without shared memory.

A synchronization primitive that only one thread or process may hold at a time, protecting a critical section from concurrent modification and preventing race conditions.

A bug where the result depends on the unpredictable timing of concurrent operations, typically fixed by locks, queues, or atomic operations rather than by adding sleeps.

An endpoint for network communication identified by an address and port; Python's socket module wraps the BSD socket API for TCP and UDP programming.

Server-side socket calls that attach a socket to a local address and port and then mark it ready to accept incoming connection requests from clients.

The pattern of calling accept to get a client socket, handling the request, closing that connection, and repeating, often with threads or selectors for concurrency.

An ssl.SSLContext object holding certificates, protocol versions, and verification settings used to wrap a socket so traffic is encrypted and the peer is authenticated.

Checking that a server's TLS certificate chains to a trusted authority and matches the requested hostname; disabled checks expose clients to interception attacks.

An approach that separates the network control plane from the data plane, letting centralized software configure forwarding rules on switches through APIs instead of per-device CLI work.

Using scripts and libraries to configure, audit, and monitor network devices consistently, replacing manual command entry and reducing configuration drift across many devices.

A third-party library implementing SSHv2 in Python, used to open sessions to network devices, run commands, and transfer files programmatically over an encrypted channel.

The standard interface Python database drivers follow, defining connect, cursor, execute, fetchone, fetchall, commit, and rollback so code stays portable across drivers.

A database handle created from a connection that sends SQL statements and holds result rows for fetching, either one at a time or all at once.

A statement written with placeholders whose values are supplied separately, preventing SQL injection and letting the driver handle quoting and type conversion.

An attack that inserts malicious SQL through unsanitized input; it is prevented by parameterized queries and by never building statements with string concatenation.

A group of database operations treated as one unit that is either fully committed or fully rolled back, keeping data consistent when errors occur mid-sequence.

Object-relational mapping, a layer such as SQLAlchemy that maps Python classes to tables and objects to rows, generating SQL while letting code work with domain models.

In an ORM, a unit-of-work object that tracks loaded and modified instances, batches changes, and flushes them to the database inside a transaction.

A non-relational database that stores flexible JSON-like documents instead of fixed tables, allowing nested fields and schema variation across records.

The four basic persistence operations: create, read, update, and delete, implemented in SQL with INSERT, SELECT, UPDATE, and DELETE and mirrored by ORM and NoSQL APIs.