Index

[A][B][C][D][E][F][G][H][I][J][L][M][N][O][P][Q][R][S][T][U][V][W][X][Y]

A

AAA (arrange, act, and assert) pattern
  avoiding if statements
  avoiding multiple AAA sections
  differentiating system under test
  dropping AAA comments
  overview
  reusing code in test sections
    in act sections
    in arrange sections
    in assert sections
  section size
    arrange section
    number of assertions in assert section
    sections larger than a single line
    teardown phase
abstractions, 2^nd
Active Record pattern
adapters
aggregates
ambient context
anti-patterns
  code pollution
  exposing private state
  leaking domain knowledge to tests
  mocking concrete classes
  private methods
    acceptability of testing
    insufficient coverage
    test fragility
  time
    as ambient context
    as explicit dependency
API (application programming interface), 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th
  missing abstractions
  public vs. private
  well-designed, 2^nd, 3^rd, 4^th
application behavior
application services layer
arrange, act, and assert pattern.
    See AAA pattern.
assertion libraries, using to improve test readability
assertion-free testing
asynchronous communications
atomic updates
automation concepts
  black-box vs. white-box testing
  Test Pyramid

B

backward migration
bad tests
black-box testing, 2^nd
Boolean switches
branch coverage metric
brittle tests, 2^nd, 3^rd
brittleness, 2^nd
bugs, 2^nd, 3^rd, 4^th, 5^th
business logic, 2^nd, 3^rd, 4^th

C

CanExecute/Execute pattern, 2^nd
CAP theorem
captured data
circular dependencies
  defined
  eliminating
classical school of unit testing
  dependencies
  end-to-end tests
  integration tests
  isolation issue
  mocks
    mocking out out-of-process dependencies
    using mocks to verify behavior
  precise bug location
  testing large graph of interconnected classes
  testing one class at a time
cleanup phase
clusters, grouping into aggregates
code complexity, 2^nd
code coverage metric
code coverage tools
code depth
code pollution, 2^nd, 3^rd
code width
collaborators, 2^nd, 3^rd
command query separation.
    See CQS principle.
commands
communication-based testing, 2^nd
  feedback speed
  maintainability
  overuse of
  protection against regressions and feedback speed
  resistance to refactoring
  vulnerability to false alarms

communications
  between applications, 2^nd
  between classes in application, 2^nd
conditional logic
  CanExecute/Execute pattern
  domain events for tracking changes in the domain model
constructors, reusing test fixtures between tests
containers
controllers, 2^nd
  simplicity
coverage metrics, measuring test suite quality with
  aiming for particular coverage number
  branch coverage metric
  code coverage metric
  problems with
    code paths in external libraries
    impossible to verify all possible outcomes
CQS (command query separation) principle
CRUD (create, read, update, and delete) operations
CSV files
cyclic dependency
cyclomatic complexity

D

data inconsistencies
data mapping
data motion
data, bundling
database backup, restoring
database management system (DBMS)

database testing
  common questions
    testing reads
    testing repositories
  database transaction management
    in integration tests
    in production code
  prerequisites for
    keeping database in source control system
    reference data as part of database schema
    separate instances for every developer
    state-based vs. migration-based database delivery
  reusing code in test sections
    creating too many database transactions
    in act sections
    in arrange sections
    in assert sections
  test data life cycle
    avoiding in-memory databases
    clearing data between test runs
    parallel vs. sequential test execution
database transaction management
  in integration tests
  in production code
    separating connections from transactions
    upgrading transaction to unit of work
database transactions
daysFromNow parameter
DBMS (database management system)
dead code
deliveryDate parameter
dependencies, 2^nd
  classical school of unit testing
  London school of unit testing
  out-of-process, 2^nd
  shared, 2^nd
  types of
Detroit approach, unit testing
diagnostic logging, 2^nd
discovered abstractions
Docker container
domain events, tracking changes in domain model
domain layers, 2^nd, 3^rd
domain model, 2^nd, 3^rd
  connecting with external applications
  testability
domain significance
dummy test double

E

EasyMock
edge cases, 2^nd, 3^rd
encapsulation, 2^nd
end-to-end tests, 2^nd, 3^rd, 4^th
  classical school of unit testing
  London school of unit testing
  possibility of creating ideal tests
enterprise applications
Entity Framework, 2^nd
entropy
error handling
exceptions
expected parameter
explicit inputs and outputs
external libraries
external reads, 2^nd
external state
external writes, 2^nd

F

Fail Fast principle, 2^nd
failing preconditions
fake dependencies
fake test double
false negatives
false positives, 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th
  causes of
  importance of
fast feedback, 2^nd, 3^rd, 4^th, 5^th, 6^th
fat controllers
feedback loop, shortening
feedback speed, 2^nd
fixed state
Fluent Assertions
fragile tests, 2^nd
frameworks
functional architecture
  defined
  drawbacks of
    applicability of
    code base size increases
    performance drawbacks
  functional programming
  hexagonal architecture
  transitioning to output-based testing
    audit system
    refactoring toward functional architecture
    using mocks to decouple tests from filesystem
functional core, 2^nd, 3^rd
functional programming
functional testing, 2^nd, 3^rd

G

Git
Given-When-Then pattern
GUI (graphical user interface) tests

H

handwritten mocks, 2^nd
happy paths, 2^nd, 3^rd
helper methods
hexagonal architecture, 2^nd, 3^rd
  defining
  functional architecture
  purpose of
hexagons, 2^nd, 3^rd
hidden outputs
high coupling, reusing test fixtures between tests
HTML tags
humble controller
Humble Object pattern, 2^nd, 3^rd, 4^th
humble objects
humble wrappers

I

ideal tests
  brittle tests
  end-to-end tests
  possibility of creating
  trivial tests
if statements, 2^nd, 3^rd, 4^th, 5^th
immutability
immutable classes
immutable core, 2^nd
immutable events
immutable objects, 2^nd
implementation details
incoming interactions
infrastructure code
infrastructure layer
in-memory databases
in-process dependencies
INSERT statements
integer type

integration testing
  best practices
    eliminating circular dependencies
    making domain model boundaries explicit
    multiple act sections
    reducing number of layers
  classical school of unit testing
  database transaction management in
  defined
  example of
    categorizing database and message bus
    end-to-end testing
    first version
    scenarios
  failing fast
  interfaces for abstracting dependencies
    in-process dependencies
    loose coupling and
    out-of-process dependencies
  logging functionality
    amount of logging
    introducing wrapper on top of ILogger
    passing around logger instances
    structured logging
    whether to test or not
    writing tests for support and diagnostic logging
  London school of unit testing
  out-of-process dependencies
    types of
    when real databases are unavailable
    working with both
  role of
  Test Pyramid
interconnected classes
internal keyword
invariant violations, 2^nd
invariants, 2^nd

isolation issue
  classical school of unit testing
  London school of unit testing
isSuccess flag

J

JMock
JSON files

L

logging functionality testing
  amount of logging
  introducing wrapper on top of ILogger
  passing around logger instances
  structured logging
  whether to test or not
  writing tests for support and diagnostic logging
London school of unit testing
  dependencies
  end-to-end tests
  integration tests
  isolation issue
  mocks
    mocking out out-of-process dependencies
    using mocks to verify behavior
  precise bug location
  testing large graph of interconnected classes
  testing one class at a time
loose coupling, interfaces for abstracting dependencies and

M

maintainability, 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th, 8^th
  comparing testing styles
    communication-based tests
    output-based tests
    state-based tests
managed dependencies, 2^nd, 3^rd
mathematical functions
merging domain events
message bus, 2^nd, 3^rd, 4^th
method signatures
method under test (MUT)
Microsoft MSTest
migration-based database delivery
missing abstractions
mock chains
mocking frameworks
mockist style, unit testing
Mockito
mocks, 2^nd
  best practices
    for integration tests only
    not just one mock per test
    only mock types that you own
    verifying number of calls
  decoupling tests from filesystem
  defined
  London school vs. classical school
    mocking out out-of-process dependencies
    using mocks to verify behavior
  maximizing value of
    IDomainLogger
    replacing mocks with spies
    verifying interactions at system edges
  mocking concrete classes
  observable behavior vs. implementation details
    leaking implementation details
    observable behavior vs. public API
    well-designed API and encapsulation
  stubs
    asserting interactions with stubs
    commands and queries
    mock (tool) vs. mock (test double)
    types of test doubles
    using mocks and stubs together
  test doubles
  test fragility
    defining hexagonal architecture
    intra-system vs. inter-system communications
model database
Model-View-Controller (MVC) pattern
Moq, 2^nd, 3^rd
MSTest
MUT (method under test)
mutable objects
mutable shell, 2^nd
MVC (Model-View-Controller) pattern

N

naming tests
  guidelines for
  renaming tests to meet guidelines
NHibernate
noise, reducing
NSubstitute
NuGet package
NUnit, 2^nd

O

object graphs
Object Mother
object-oriented programming (OOP), 2^nd
object-relational mapping (ORM), 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th
observable behavior, 2^nd, 3^rd, 4^th, 5^th
  leaking implementation details
  public API
  well-designed API and encapsulation
OCP (Open-Closed principle)
OOP (object-oriented programming), 2^nd
Open-Closed principle (OCP)
operations, 2^nd
orchestration, separating business logic from, 2^nd
ORM (object-relational mapping), 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th
outcoming interactions
out-of-process collaborators
out-of-process dependencies, 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th, 8^th, 9^th, 10^th, 11^th, 12^th, 13^th
  integration testing
    interfaces for abstracting dependencies
    types of
    when real databases are unavailable
    working with both
output value
output-based testing, 2^nd, 3^rd
  feedback speed
  maintainability
  protection against regressions and feedback speed
  resistance to refactoring
  transitioning to functional architecture and
    audit system
    refactoring toward functional architecture
    using mocks to decouple tests from filesystem
overcomplicated code
overspecification

P

parallel test execution
parameterized tests, 2^nd
partition tolerance
performance
persistence state
preconditions
private APIs
private constructors
private dependencies, 2^nd, 3^rd
private keyword
private methods
  acceptability of testing
  insufficient coverage and
  reusing test fixtures between tests
  test fragility and
Product array
production code
protection against regressions, 2^nd, 3^rd, 4^th, 5^th, 6^th
  comparing testing styles
  importance of false positives and false negatives
  maximizing test accuracy
Public API, 2^nd
pure functions

Q

queries

R

random number generators
read operations
readability
read-decide-act approach
refactoring
  analysis of optimal test coverage
    testing domain layer and utility code
    testing from other three quadrants
    testing preconditions
  conditional logic in controllers
    CanExecute/Execute pattern
    domain events for tracking changes in the domain model
  identifying code to refactor
    four types of code
    Humble Object pattern for splitting overcomplicated code
  resistance to
    comparing testing styles
    importance of false positives and false negatives
    maximizing test accuracy
  to parameterized tests
    general discussion
    generating data for parameterized tests
  toward valuable unit tests
    application services layer
    Company class
    customer management system
    making implicit dependencies explicit
    removing complexity from application service
reference data, 2^nd, 3^rd
referential transparency
regression errors, 2^nd, 3^rd
regressions, 2^nd
repositories, 2^nd, 3^rd
resistance to refactoring, 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th, 8^th, 9^th
  comparing testing styles
  importance of false positives and false negatives
  maximizing test accuracy
return statement
return true statement
reusability

S

scalability
sequential test execution
shallowness
shared dependencies, 2^nd, 3^rd, 4^th, 5^th, 6^th
side effects, 2^nd
signal-to-noise ratio
Single Responsibility principle, 2^nd, 3^rd
single-line act section
SMTP service, 2^nd, 3^rd, 4^th
software bugs, 2^nd
software entropy
source of truth
spies, 2^nd
spy test double
SQL scripts, 2^nd, 3^rd
SQLite
state, 2^nd
state verification
state-based database delivery
state-based testing, 2^nd, 3^rd, 4^th
  feedback speed
  maintainability
  protection against regressions and feedback speed
  resistance to refactoring
stubs, mocks
  asserting interactions with stubs
  commands and queries
  mock (tool) vs. mock (test double)
  types of test doubles
  using mocks and stubs together
sub-renderers collection
support logging, 2^nd
sustainability
sustainable growth
SUT (system under test), 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th, 8^th, 9^th, 10^th, 11^th, 12^th, 13^th, 14^th, 15^th, 16^th, 17^th, 18^th
switch statement
synchronous communications
system leaks

T

tables
tautology tests
TDD (test-driven development), 2^nd
tell-don’t-ask principle
test code
test coverage
Test Data Builder
test data life cycle
  avoiding in-memory databases
  clearing data between test runs
  parallel vs. sequential test execution
test doubles, 2^nd, 3^rd, 4^th, 5^th, 6^th
test fixtures
  defined
  reusing between tests
    constructors
    high coupling
    private factory methods
    reusing between tests
test fragility, mocks and
  defining hexagonal architecture
  intra-system vs. inter-system communications
test isolation

Test Pyramid
  general discussion
  integration testing

test suites
  characteristics of successful suites
    integration into development cycle
    maximum value with minimum maintenance costs
    targeting most important parts of code base
  coverage metrics, measuring test suite quality with
    aiming for particular coverage number
    branch coverage metric
    code coverage metric
    problems with
third-party applications, 2^nd
tight coupling
time
  as ambient context
  as explicit dependency
trivial code
trivial tests
true negative
true positive
two-line act section

U

UI (user interface) tests
unit of behavior, 2^nd
unit of work, 2^nd

unit testing
  anatomy of
    AAA pattern
    assertion libraries, using to improve test readability
    naming tests
    refactoring to parameterized tests
    reusing test fixtures between tests
    xUnit testing framework
  automation concepts
    black-box vs. white-box testing
    Test Pyramid
  characteristics of successful test suites
    integration into development cycle
    maximum value with minimum maintenance costs
    targeting most important parts of code base
  classical school of
    dependencies
    end-to-end tests
    integration tests
    isolation issue
    precise bug location
    testing large graph of interconnected classes
    testing one class at a time
  coverage metrics, measuring test suite quality with
    aiming for particular coverage number
    branch coverage metric
    code coverage metric
    problems with
  current state of
  defined
  four pillars of
    feedback speed
    maintainability
    protection against regressions
    resistance to refactoring
  functional architecture
    defined
    drawbacks of
    functional programming
    hexagonal architecture
    transitioning to output-based testing
  goal of
  good vs. bad tests
  ideal tests
    brittle tests
    end-to-end tests
    possibility of creating
    trivial tests
  London school of
    dependencies
    end-to-end tests
    integration tests
    isolation issue
    precise bug location
    testing large graph of interconnected classes
    testing one class at a time
  styles of
    communication-based testing
    comparing
    output-based testing
    state-based testing
units of behavior
units of code, 2^nd, 3^rd, 4^th, 5^th
unmanaged dependencies, 2^nd, 3^rd, 4^th, 5^th, 6^th, 7^th, 8^th, 9^th
user controller
user interface (UI) tests

V

value objects, 2^nd
void type
volatile dependencies

W

white-box testing
write operation

X

xUnit testing framework

Y

YAGNI (You aren’t gonna need it) principle