RSpec

describe and context both create an example group and behave identically; it defines one example in a group. A nested group is a subclass of its parent, inheriting let, hooks and helpers, and each example runs in a fresh group instance.

eq passes when actual == expected, eql when actual.eql?(expected), and equal or be(x) only when both are the same object (equal?). Bare be with no argument passes for any truthy value. eq is the default for values.

A plain double accepts stubs for any method name, so it stays green when the real class changes. instance_double(SmsGateway) only lets you stub or expect instance methods SmsGateway really defines, and checks calls against their parameters.

let is lazy, running its block on first call and memoizing the value for one example. let! also adds a before hook, so it always runs. An instance variable set in before always runs too, and reads as nil if misspelled.

Wrap the call in a block: expect { order.checkout! }.to raise_error(OutOfStockError, /SKU A1/). Pass both a class and a message; a bare raise_error also matches a NoMethodError from a typo, so the spec can pass without reaching the code.

RSpec runs examples in defined order unless config.order = :random or --order rand is set. A random run ends by printing its seed, such as Randomized with seed 4821, and rspec --seed 4821 replays exactly that order.

rspec --init writes .rspec, holding --require spec_helper, and spec/spec_helper.rb. Only three settings in that file are active; random order, :focus filtering, failure persistence and profiling sit in a commented-out =begin block.

and_return sets the reply, and with several values returns them in order, repeating the last. and_raise raises an exception class or instance. and_call_original runs the real method, so it works only on partial doubles, never on a pure double.

expect(...).to receive is set before the action; have_received checks afterwards that a recorded message arrived. It needs a spy or a message allowed beforehand, otherwise it fails: not a spy or method not stubbed.

When the outer group describes a class, subject is ShoppingList.new, built lazily and memoized per example like a let. subject(:list) { ... } replaces it and also names it; is_expected is shorthand for expect(subject) in one-line examples.

change { order.total_cents } evaluates the value before and after running the expect block and compares them, refined by by, from and to. output(...).to_stdout captures what the block prints; yield_control checks that the method yielded to the probe block it was given.

Use contain_exactly("A1", "B2") or match_array(["A1", "B2"]) when the collection must hold exactly those elements in any order. eq also demands the order; include only demands the listed elements and ignores extras.

--only-failures reruns just the examples that failed last time and needs config.example_status_persistence_file_path set. --next-failure also stops at the first failure in defined order. --profile reports the slowest examples and groups, ten by default.

--tag slow runs only examples whose metadata has slow set, and --tag ~slow excludes them. filter_run_when_matching :focus narrows a run to focused examples only when some exist, so a fit left in a commit makes CI run just that one.

With verify_partial_doubles off, which is rspec-mocks' default in RSpec 3.13, a real object can be stubbed with methods it no longer has. Turned on, stubs are checked for existence and argument signature; return values and pure doubles stay unchecked.

before(:context) runs once per group, not per example. Its instance variables reach every example as references to the same objects, so mutations leak between examples, and let, subject and test doubles are unsupported there.

it_behaves_like evaluates shared examples in a new nested group, isolating their lets; include_examples evaluates them in the current group, where a second inclusion overrides the first one's lets. shared_context is an alias used for setup via include_context.

Normally the first failed expectation raises and ends the example. Inside aggregate_failures, RSpec records every failed expectation and reports them together at the end. Compound and/or instead combine two matchers against one actual value in a single expectation.

Call RSpec::Matchers.define :have_total_cents do |expected| ... end with a match block returning truthy or falsy, and add failure_message showing the data needed to diagnose it. RSpec supplies a default description and message from the name and arguments.

rspec --seed 4821 --bisect reruns subsets in that order: it checks the failure needs other examples first, then repeatedly discards half of the passing ones, and prints a minimal reproduction command naming the victim and the example that pollutes it.

stub_const replaces or defines a constant for one example and restores it afterwards. Its name must be fully qualified: inside module Notifications, stub_const("SmsGateway", fake) stubs ::SmsGateway, not Notifications::SmsGateway.

RSpec::Core::RakeTask.new(:spec) defines a rake task that runs the rspec executable in a subprocess over spec/{,/*/}/*_spec.rb. If examples fail, fail_on_error (true by default) makes rake exit with rspec's exit status.