module Minitest::Spec::DSL - minitest: Ruby Standard Library Documentation

# module Minitest::Spec::DSL

Oh look! A `Minitest::Spec::DSL` module! Eat your heart out DHH.

### Constants

TYPES

  Contains pairs of matchers and `Spec` classes to be used to calculate the superclass of a top-level describe. This allows for automatically customizable spec types.

  See: `register_spec_type` and `spec_type`

### Public Instance Methods

after(_type = nil, &block) click to toggle source

Define an ‘after’ action. Inherits the way normal methods should.

NOTE: `type` is ignored and is only there to make porting easier.

Equivalent to `Minitest::Test#teardown`.

Calls superclass method

    # File minitest-5.25.4/lib/minitest/spec.rb, line 206
    def after _type = nil, &block
      define_method :teardown do
        self.instance_eval(&block)
        super()
      end
    end

before(_type = nil, &block) click to toggle source

Define a ‘before’ action. Inherits the way normal methods should.

NOTE: `type` is ignored and is only there to make porting easier.

Equivalent to `Minitest::Test#setup`.

Calls superclass method

    # File minitest-5.25.4/lib/minitest/spec.rb, line 192
    def before _type = nil, &block
      define_method :setup do
        super()
        self.instance_eval(&block)
      end
    end

it(desc = "anonymous", &block) click to toggle source

Define an expectation with name `desc`. Name gets morphed to a proper test method name. For some freakish reason, people who write specs don’t like class inheritance, so this goes way out of its way to make sure that expectations aren’t inherited.

This is also aliased to `specify` and doesn’t require a `desc` arg.

Hint: If you do want inheritance, use minitest/test. You can mix and match between assertions and expectations as much as you want.

    # File minitest-5.25.4/lib/minitest/spec.rb, line 224
    def it desc = "anonymous", &block
      block ||= proc { skip "(no tests defined)" }

      @specs ||= 0
      @specs += 1

      name = "test_%04d_%s" % [ @specs, desc ]

      undef_klasses = self.children.reject { |c| c.public_method_defined? name }

      define_method name, &block

      undef_klasses.each do |undef_klass|
        undef_klass.send :undef_method, name
      end

      name
    end

Also aliased as: specify
let(name, &block) click to toggle source

Essentially, define an accessor for `name` with `block`.

Why use let instead of def? I honestly don’t know.

    # File minitest-5.25.4/lib/minitest/spec.rb, line 248
    def let name, &block
      name = name.to_s
      pre, post = "let '#{name}' cannot ", ". Please use another name."
      methods = Minitest::Spec.instance_methods.map(&:to_s) - %w[subject]
      raise ArgumentError, "#{pre}begin with 'test'#{post}" if
        name.start_with? "test"
      raise ArgumentError, "#{pre}override a method in Minitest::Spec#{post}" if
        methods.include? name

      define_method name do
        @_memoized ||= {}
        @_memoized.fetch(name) { |k| @_memoized[k] = instance_eval(&block) }
      end
    end

register_spec_type(*args, &block) click to toggle source

Register a new type of spec that matches the spec’s description. This method can take either a Regexp and a spec class or a spec class and a block that takes the description and returns true if it matches.

Eg:

    register_spec_type(/Controller$/, Minitest::Spec::Rails)

or:

    register_spec_type(Minitest::Spec::RailsModel) do |desc|
      desc.superclass == ActiveRecord::Base
    end

    # File minitest-5.25.4/lib/minitest/spec.rb, line 147
    def register_spec_type *args, &block
      if block then
        matcher, klass = block, args.first
      else
        matcher, klass = *args
      end
      TYPES.unshift [matcher, klass]
    end

spec_type(desc, *additional) click to toggle source

Figure out the spec class to use based on a spec’s description. Eg:

    spec_type("BlahController") # => Minitest::Spec::Rails

    # File minitest-5.25.4/lib/minitest/spec.rb, line 161
    def spec_type desc, *additional
      TYPES.find { |matcher, _klass|
        if matcher.respond_to? :call then
          matcher.call desc, *additional
        else
          matcher === desc.to_s
        end
      }.last
    end

specify(desc = "anonymous", &block)
Alias for: it
subject(&block) click to toggle source

Another lazy man’s accessor generator. Made even more lazy by setting the name for you to `subject`.

    # File minitest-5.25.4/lib/minitest/spec.rb, line 267
    def subject &block
      let :subject, &block
    end