smartest 0.2.0.alpha2 → 0.2.0.alpha4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0953c11bf61f80c4a310701920e5b6a22727149ed135d86678b3e49b25c8a92
-  data.tar.gz: d51839a9cb597da3d63a15aa803661946ceb3ae2a6982317ea108797f4203380
+  metadata.gz: 944d35bc0a1be2293c8e276d16436693ff7dd6a2d37218f9f65af3b7a47f90f5
+  data.tar.gz: edd55fb6442a92e74146eaffc76a3b881463a16b4ce3c72a877734e0f6e36f52
 SHA512:
-  metadata.gz: 2e3be2ebdc5b116e6f16e396d4befda198c0063bb4da6e7f487266642d1edd8083bcc4dce9b37746969fdcbd9916424068f043344cc732edf4738f849fb87d9c
-  data.tar.gz: 0c299af8b8dd05fac80ec1eefaeade8f747f8d2776e87ba6cb684ff84c619be8a21dfd3e33c99fa43d05ee0d40aabc361f86ab1e33af696a5a9ef4c9ee78054d
+  metadata.gz: 5406cfcb57b56c71140c98565da884a184b8d14dcd41f8d6f65f218010d5ef7672eee6c3ad874dcc22a2d415097c9f9926f3a22c31ea3f5dafcf6dd00c2c795d
+  data.tar.gz: '0666928711e5ec22a5f9d671714597eb9e0a7e98edcf11d334bf72301c42739a8ae71104dff5784fa4728c10c186188e9f5278137ebbf7d22f6e14e745964927'

data/CHANGELOG.md

@@ -8,7 +8,7 @@
 - Support required keyword-argument fixture injection and fixture dependencies.
 - Support per-test fixture caching and cleanup.
 - Support suite-scoped fixtures through `suite_fixture`.
-- Support `eq`, `include`, `be_nil`, and `raise_error` matchers.
+- Support `eq`, `include`, `start_with`, `end_with`, `be_nil`, `raise_error`, and `change` matchers.
 - Support custom matcher modules through `use_matcher`.
 - Generate an opt-in `PredicateMatcher` custom matcher for `be_<predicate>` calls.
 - Add the `smartest` CLI.

data/README.md

@@ -178,6 +178,10 @@ Smartest uses an expectation style:
 ```ruby
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
+expect { action }.to raise_error(ErrorClass)
+expect { action }.to raise_error(/message/)
+expect { action }.to raise_error(ErrorClass, /message/)
+expect { action }.to change { value }
 ```
 
 Examples:
@@ -190,6 +194,26 @@ end
 test("array") do
   expect([1, 2, 3]).to include(2)
 end
+
+test("URL") do
+  expect("about:blank").to start_with("about:")
+end
+
+test("download") do
+  expect("screenshot.png").to end_with(".png")
+end
+
+test("type") do
+  expect("smartest").to be_a(String)
+end
+
+test("URL pattern") do
+  expect("https://example.test").to match(%r{\Ahttps://})
+end
+
+test("events") do
+  expect(%i[request close open]).to contain_exactly(:open, :request, :close)
+end
 ```
 
 Supported matchers include:
@@ -197,10 +221,34 @@ Supported matchers include:
 ```ruby
 eq(expected)
 include(expected)
+start_with(prefix, ...)
+end_with(suffix, ...)
+be_a(ClassOrModule)
+be_an(ClassOrModule)
 be_nil
+match(regexp)
+contain_exactly(item, ...)
+match_array(items)
 raise_error(ErrorClass)
+raise_error(/message/)
+raise_error(ErrorClass, /message/)
+change { value }
+change { value }.from(before).to(after)
+change { value }.by(delta)
 ```
 
+`raise_error` accepts an error class, a message regexp, or both. Use an error
+class to check the raised exception class, a regexp to check the raised
+exception message, or both to require both conditions. No-argument and exact
+string message forms are not supported.
+
+`contain_exactly` and `match_array` compare collections without requiring a
+specific order, preserve duplicate counts, and can use matcher objects such as
+`match(/foo/)` or `eq(42)` as expected items.
+
+`change` is only supported with `expect { ... }` block expectations and must be
+written with a value block.
+
 Custom matcher modules can be registered from `around_suite` or `around_test`
 with `use_matcher`. The generated scaffold includes a `PredicateMatcher` custom
 matcher for `be_<predicate>` calls. See [Matchers](documentation/docs/matchers.md).

data/SMARTEST_DESIGN.md

@@ -717,6 +717,26 @@ MVP expectation API:
 ```ruby
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
+expect { action }.to change { value }
+```
+
+Current built-in matchers include:
+
+```ruby
+eq(expected)
+include(expected)
+start_with(prefix, ...)
+end_with(suffix, ...)
+be_a(ClassOrModule)
+be_an(ClassOrModule)
+be_nil
+match(regexp)
+contain_exactly(item, ...)
+match_array(items)
+raise_error(ErrorClass)
+raise_error(/message/)
+raise_error(ErrorClass, /message/)
+change { value }
 ```
 
 Internal model:
@@ -1235,8 +1255,6 @@ Possible future features:
 - custom reporters
 - JSON output
 - richer matchers
-- block expectations
-- `raise_error`
 - file-scoped fixtures
 - parallel execution
 - watch mode

data/lib/smartest/expectation_target.rb

@@ -13,6 +13,12 @@ module Smartest
     end
 
     def not_to(matcher)
+      if matcher.respond_to?(:does_not_match?)
+        return self if matcher.does_not_match?(@actual)
+
+        raise AssertionFailed, matcher.negated_failure_message
+      end
+
       return self unless matcher.matches?(@actual)
 
       raise AssertionFailed, matcher.negated_failure_message

data/lib/smartest/matchers.rb

@@ -10,12 +10,47 @@ module Smartest
       IncludeMatcher.new(expected)
     end
 
+    def start_with(*prefixes)
+      StartWithMatcher.new(*prefixes)
+    end
+
+    def end_with(*suffixes)
+      EndWithMatcher.new(*suffixes)
+    end
+
+    def be_a(expected_class)
+      BeAKindOfMatcher.new(expected_class)
+    end
+
+    def be_an(expected_class)
+      BeAKindOfMatcher.new(expected_class)
+    end
+
     def be_nil
       BeNilMatcher.new
     end
 
-    def raise_error(expected_error = StandardError)
-      RaiseErrorMatcher.new(expected_error)
+    def match(regexp)
+      MatchMatcher.new(regexp)
+    end
+
+    def contain_exactly(*expected_items)
+      ContainExactlyMatcher.new(expected_items, matcher_name: "contain exactly")
+    end
+
+    def match_array(expected_items)
+      ContainExactlyMatcher.new(expected_items, matcher_name: "match array")
+    end
+
+    def raise_error(*expected_error)
+      RaiseErrorMatcher.new(*expected_error)
+    end
+
+    def change(*args, &block)
+      raise ArgumentError, "change does not support arguments; use change { ... }" if args.any?
+      raise ArgumentError, "change requires a block" unless block
+
+      ChangeMatcher.new(block)
     end
   end
 
@@ -36,6 +71,10 @@ module Smartest
     def negated_failure_message
       "expected #{@actual.inspect} not to eq #{@expected.inspect}"
     end
+
+    def description
+      "eq #{@expected.inspect}"
+    end
   end
 
   class IncludeMatcher
@@ -57,6 +96,111 @@ module Smartest
     def negated_failure_message
       "expected #{@actual.inspect} not to include #{@expected.inspect}"
     end
+
+    def description
+      "include #{@expected.inspect}"
+    end
+  end
+
+  class StartWithMatcher
+    def initialize(*prefixes)
+      @prefixes = prefixes
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.start_with?(*@prefixes)
+    rescue NoMethodError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to start with #{expected_description}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to start with #{expected_description}"
+    end
+
+    def description
+      "start with #{expected_description}"
+    end
+
+    private
+
+    def expected_description
+      return "no prefixes" if @prefixes.empty?
+
+      @prefixes.map(&:inspect).join(" or ")
+    end
+  end
+
+  class EndWithMatcher
+    def initialize(*suffixes)
+      @suffixes = suffixes
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.end_with?(*@suffixes)
+    rescue NoMethodError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to end with #{expected_description}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to end with #{expected_description}"
+    end
+
+    def description
+      "end with #{expected_description}"
+    end
+
+    private
+
+    def expected_description
+      return "no suffixes" if @suffixes.empty?
+
+      @suffixes.map(&:inspect).join(" or ")
+    end
+  end
+
+  class BeAKindOfMatcher
+    def initialize(expected_class)
+      @expected_class = expected_class
+    end
+
+    def matches?(actual)
+      @actual = actual
+      actual.is_a?(@expected_class)
+    rescue TypeError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to be a kind of #{expected_description}, but was #{actual_class_description}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to be a kind of #{expected_description}, but was #{actual_class_description}"
+    end
+
+    def description
+      "be a kind of #{expected_description}"
+    end
+
+    private
+
+    def expected_description
+      @expected_class.to_s
+    end
+
+    def actual_class_description
+      @actual.class.to_s
+    end
   end
 
   class BeNilMatcher
@@ -72,11 +216,164 @@ module Smartest
     def negated_failure_message
       "expected #{@actual.inspect} not to be nil"
     end
+
+    def description
+      "be nil"
+    end
+  end
+
+  class MatchMatcher
+    def initialize(regexp)
+      @regexp = regexp
+    end
+
+    def matches?(actual)
+      @actual = actual
+      @regexp.match?(actual)
+    rescue NoMethodError, TypeError
+      false
+    end
+
+    def failure_message
+      "expected #{@actual.inspect} to match #{@regexp.inspect}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to match #{@regexp.inspect}"
+    end
+
+    def description
+      "match #{@regexp.inspect}"
+    end
+  end
+
+  class ContainExactlyMatcher
+    def initialize(expected_items, matcher_name:)
+      @expected_items = expected_items
+      @matcher_name = matcher_name
+      reset_result
+    end
+
+    def matches?(actual)
+      @actual = actual
+      reset_result
+      return false unless actual_items?
+
+      match_items
+      @missing_items.empty? && @extra_items.empty?
+    end
+
+    def failure_message
+      details = failure_details
+      message = "expected #{@actual.inspect} to #{@matcher_name} #{format_expected_items(@expected_items)}"
+      details.empty? ? message : "#{message}; #{details.join('; ')}"
+    end
+
+    def negated_failure_message
+      "expected #{@actual.inspect} not to #{@matcher_name} #{format_expected_items(@expected_items)}"
+    end
+
+    def description
+      "#{@matcher_name} #{format_expected_items(@expected_items)}"
+    end
+
+    private
+
+    def reset_result
+      @actual_items = nil
+      @missing_items = @expected_items.dup
+      @extra_items = []
+    end
+
+    def actual_items?
+      return false unless @actual.respond_to?(:to_a)
+
+      @actual_items = @actual.to_a
+      true
+    end
+
+    def match_items
+      adjacency = build_adjacency
+      actual_matches = Array.new(@actual_items.length)
+      expected_order(adjacency).each do |expected_index|
+        assign_expected_item(expected_index, adjacency, actual_matches, [])
+      end
+
+      matched_expected_indexes = actual_matches.compact
+      @missing_items = []
+      @expected_items.each_with_index do |item, index|
+        @missing_items << item unless matched_expected_indexes.include?(index)
+      end
+      @extra_items = []
+      @actual_items.each_with_index do |item, index|
+        @extra_items << item if actual_matches[index].nil?
+      end
+    end
+
+    def build_adjacency
+      @expected_items.map do |expected_item|
+        @actual_items.each_index.select do |actual_index|
+          expected_item_matches_actual_item?(expected_item, @actual_items[actual_index])
+        end
+      end
+    end
+
+    def expected_order(adjacency)
+      (0...@expected_items.length).sort_by { |index| [adjacency[index].length, index] }
+    end
+
+    def assign_expected_item(expected_index, adjacency, actual_matches, seen_actual_indexes)
+      adjacency[expected_index].each do |actual_index|
+        next if seen_actual_indexes.include?(actual_index)
+
+        seen_actual_indexes << actual_index
+        if actual_matches[actual_index].nil? ||
+           assign_expected_item(actual_matches[actual_index], adjacency, actual_matches, seen_actual_indexes)
+          actual_matches[actual_index] = expected_index
+          return true
+        end
+      end
+
+      false
+    end
+
+    def expected_item_matches_actual_item?(expected_item, actual_item)
+      if expected_item.respond_to?(:matches?)
+        expected_item.matches?(actual_item)
+      else
+        actual_item == expected_item
+      end
+    end
+
+    def failure_details
+      return ["actual did not provide items"] unless @actual_items
+
+      details = []
+      details << "missing: #{format_expected_items(@missing_items)}" unless @missing_items.empty?
+      details << "extra: #{format_actual_items(@extra_items)}" unless @extra_items.empty?
+      details
+    end
+
+    def format_expected_items(items)
+      "[#{items.map { |item| format_expected_item(item) }.join(', ')}]"
+    end
+
+    def format_actual_items(items)
+      "[#{items.map(&:inspect).join(', ')}]"
+    end
+
+    def format_expected_item(item)
+      return item.description if item.respond_to?(:description)
+
+      item.inspect
+    end
   end
 
   class RaiseErrorMatcher
-    def initialize(expected_error)
-      @expected_error = expected_error
+    def initialize(*expected_error)
+      @expected_type = expected_type_for(expected_error)
+      @expected_error_class = expected_error.find { |item| error_class?(item) }
+      @expected_message_regexp = expected_error.find { |item| item.is_a?(Regexp) }
       @actual_error = nil
       @callable = true
     end
@@ -92,18 +389,196 @@ module Smartest
       raise if Smartest.fatal_exception?(error)
 
       @actual_error = error
-      error.is_a?(@expected_error)
+      expected_error_matches?(error)
+    end
+
+    def failure_message
+      return "expected a block to raise #{expected_description}" unless @callable
+      return "expected block to raise #{expected_description}, but nothing was raised" unless @actual_error
+
+      "expected block to raise #{expected_description}, but raised #{actual_error_description}"
+    end
+
+    def negated_failure_message
+      "expected block not to raise #{expected_description}, but raised #{actual_error_description}"
+    end
+
+    private
+
+    def expected_type_for(expected_error)
+      return :class if expected_error.length == 1 && error_class?(expected_error.first)
+      return :message_regexp if expected_error.length == 1 && expected_error.first.is_a?(Regexp)
+      return :class_and_message_regexp if expected_error.length == 2 &&
+                                          error_class?(expected_error[0]) &&
+                                          expected_error[1].is_a?(Regexp)
+
+      raise ArgumentError, "raise_error supports an error class, message regexp, or error class and message regexp"
+    end
+
+    def error_class?(value)
+      value.is_a?(Class) && value <= Exception
+    end
+
+    def expected_error_matches?(error)
+      case @expected_type
+      when :class
+        error.is_a?(@expected_error_class)
+      when :message_regexp
+        @expected_message_regexp.match?(error.message)
+      when :class_and_message_regexp
+        error.is_a?(@expected_error_class) && @expected_message_regexp.match?(error.message)
+      end
+    end
+
+    def expected_description
+      case @expected_type
+      when :class
+        @expected_error_class.to_s
+      when :message_regexp
+        "error with message matching #{@expected_message_regexp.inspect}"
+      when :class_and_message_regexp
+        "#{@expected_error_class} with message matching #{@expected_message_regexp.inspect}"
+      end
+    end
+
+    def actual_error_description
+      "#{@actual_error.class}: #{@actual_error.message}"
+    end
+  end
+
+  class ChangeMatcher
+    UNSET = Object.new
+
+    def initialize(value_block)
+      @value_block = value_block
+      @expected_from = UNSET
+      @expected_to = UNSET
+      @expected_delta = UNSET
+      reset_result
+    end
+
+    def from(expected)
+      @expected_from = expected
+      self
+    end
+
+    def to(expected)
+      @expected_to = expected
+      self
+    end
+
+    def by(expected_delta)
+      @expected_delta = expected_delta
+      self
+    end
+
+    def matches?(actual)
+      run_change(actual)
+      return false unless @callable
+
+      positive_failures.empty?
+    end
+
+    def does_not_match?(actual)
+      run_change(actual)
+      return false unless @callable
+
+      negated_failures.empty?
     end
 
     def failure_message
-      return "expected a block to raise #{@expected_error}" unless @callable
-      return "expected block to raise #{@expected_error}, but nothing was raised" unless @actual_error
+      return "expected a block to change value" unless @callable
 
-      "expected block to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
+      "expected value to #{expected_description}, but #{observed_description}#{failed_modifier_description}"
     end
 
     def negated_failure_message
-      "expected block not to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
+      return "expected a block not to change value" unless @callable
+
+      "expected value not to change, but #{observed_description}"
+    end
+
+    private
+
+    def reset_result
+      @callable = true
+      @before_value = nil
+      @after_value = nil
+      @actual_delta = UNSET
+      @failed_modifiers = []
+    end
+
+    def run_change(actual)
+      reset_result
+      @callable = actual.respond_to?(:call)
+      return unless @callable
+
+      @before_value = @value_block.call
+      actual.call
+      @after_value = @value_block.call
+      calculate_delta if delta_expected?
+    end
+
+    def positive_failures
+      @failed_modifiers = []
+      @failed_modifiers << "change" if !delta_expected? && @before_value == @after_value
+      @failed_modifiers << "from(#{@expected_from.inspect})" if from_expected? && @before_value != @expected_from
+      @failed_modifiers << "to(#{@expected_to.inspect})" if to_expected? && @after_value != @expected_to
+      @failed_modifiers << "by(#{@expected_delta.inspect})" if delta_expected? && @actual_delta != @expected_delta
+      @failed_modifiers
+    end
+
+    def negated_failures
+      @failed_modifiers = []
+      @failed_modifiers << "change" unless @before_value == @after_value
+      @failed_modifiers
+    end
+
+    def expected_description
+      parts = ["change"]
+      parts << "from #{@expected_from.inspect}" if from_expected?
+      parts << "to #{@expected_to.inspect}" if to_expected?
+      parts << "by #{@expected_delta.inspect}" if delta_expected?
+      parts.join(" ")
+    end
+
+    def observed_description
+      if delta_expected?
+        delta_description = if @actual_delta.equal?(UNSET)
+                              "could not calculate a numeric difference"
+                            else
+                              "changed by #{@actual_delta.inspect}"
+                            end
+
+        "#{delta_description} from #{@before_value.inspect} before to #{@after_value.inspect} after"
+      else
+        "was #{@before_value.inspect} before and #{@after_value.inspect} after"
+      end
+    end
+
+    def failed_modifier_description
+      failures = positive_failures
+      return "" if failures.empty?
+
+      "; failed modifiers: #{failures.join(', ')}"
+    end
+
+    def calculate_delta
+      @actual_delta = @after_value - @before_value
+    rescue NoMethodError, TypeError
+      @actual_delta = UNSET
+    end
+
+    def from_expected?
+      !@expected_from.equal?(UNSET)
+    end
+
+    def to_expected?
+      !@expected_to.equal?(UNSET)
+    end
+
+    def delta_expected?
+      !@expected_delta.equal?(UNSET)
     end
   end
 end

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.2.0.alpha2"
+  VERSION = "0.2.0.alpha4"
 end

data/smartest/smartest_test.rb

@@ -48,6 +48,15 @@ class SelfTestRegisteredFixture < Smartest::Fixture
   end
 end
 
+class SelfTestBaseType; end
+class SelfTestChildType < SelfTestBaseType; end
+
+module SelfTestMarkerType; end
+
+class SelfTestMarkedType
+  include SelfTestMarkerType
+end
+
 around_suite do |suite|
   use_fixture SelfTestRegisteredFixture
   suite.run
@@ -172,9 +181,34 @@ test("supports basic matchers") do
       "matchers",
       proc do
         expect([1, 2, 3]).to include(2)
+        expect("about:blank").to start_with("about:")
+        expect("https://cdn-b.test/assets/app.js").to start_with(
+          "https://cdn-a.test",
+          "https://cdn-b.test"
+        )
+        expect("screenshot.png").to end_with(".jpg", ".png")
+        expect("https://example.test").not_to start_with("about:")
+        expect("report.txt").not_to end_with(".png")
+        expect(Object.new).not_to start_with("prefix")
+        expect(SelfTestChildType.new).to be_a(SelfTestBaseType)
+        expect(SelfTestMarkedType.new).to be_an(SelfTestMarkerType)
         expect(nil).to be_nil
         expect("value").not_to be_nil
+        expect("https://example.test").to match(%r{\Ahttps://})
+        expect("about:blank").not_to match(%r{\Ahttps://})
+        expect(%w[request close request]).to contain_exactly("request", "request", "close")
+        expect(%i[request close open]).to match_array(%i[open request close])
+        expect(["foo", 42]).to contain_exactly(match(/foo/), eq(42))
+        expect(["ab", "ac"]).to contain_exactly(match(/a/), "ab")
+        expect([nil, false]).to contain_exactly(false, nil)
+        expect([:request]).not_to contain_exactly(:request, :request)
         expect { raise ArgumentError, "bad" }.to raise_error(ArgumentError)
+        expect { raise RuntimeError, "request timed out" }.to raise_error(/timed out/)
+        expect { raise ArgumentError, "bad input" }.to raise_error(ArgumentError, /bad/)
+        expect { raise ArgumentError, "bad" }.not_to raise_error(RuntimeError)
+        expect { raise ArgumentError, "bad" }.not_to raise_error(/timed out/)
+        expect { raise ArgumentError, "bad" }.not_to raise_error(ArgumentError, /timed out/)
+        expect { :ok }.not_to raise_error(/timed out/)
       end
     )
   )
@@ -184,6 +218,253 @@ test("supports basic matchers") do
   expect(status).to eq(0)
 end
 
+test("reports be_a and match matcher failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad type",
+      proc { expect(nil).to be_a(String) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated type",
+      proc { expect(SelfTestChildType.new).not_to be_an(SelfTestBaseType) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad regex",
+      proc { expect("about:blank").to match(%r{\Ahttps://}) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated regex",
+      proc { expect("https://example.test").not_to match(%r{\Ahttps://}) }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("expected nil to be a kind of String, but was NilClass")
+  expect(output).to include("not to be a kind of SelfTestBaseType, but was SelfTestChildType")
+  expect(output).to include('expected "about:blank" to match /\\Ahttps:\\/\\//')
+  expect(output).to include('expected "https://example.test" not to match /\\Ahttps:\\/\\//')
+end
+
+test("reports contain_exactly and match_array matcher failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad collection",
+      proc { expect(["foo", "baz", 2]).to contain_exactly(match(/foo/), eq(42), "bar") }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad duplicate count",
+      proc { expect([:request]).to match_array(%i[request request]) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated collection",
+      proc { expect(%w[b a]).not_to contain_exactly("a", "b") }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include('expected ["foo", "baz", 2] to contain exactly [match /foo/, eq 42, "bar"]')
+  expect(output).to include('missing: [eq 42, "bar"]')
+  expect(output).to include('extra: ["baz", 2]')
+  expect(output).to include("expected [:request] to match array [:request, :request]")
+  expect(output).to include("missing: [:request]")
+  expect(output).to include('expected ["b", "a"] not to contain exactly ["a", "b"]')
+end
+
+test("reports raise_error matcher failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "nothing raised",
+      proc { expect { :ok }.to raise_error(/timeout/) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad message",
+      proc { expect { raise RuntimeError, "permission denied" }.to raise_error(/timeout/) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated message",
+      proc { expect { raise RuntimeError, "timeout after 1s" }.not_to raise_error(/timeout/) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad class and message class",
+      proc { expect { raise RuntimeError, "timeout after 1s" }.to raise_error(ArgumentError, /timeout/) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad class and message message",
+      proc { expect { raise ArgumentError, "permission denied" }.to raise_error(ArgumentError, /timeout/) }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated class and message",
+      proc { expect { raise ArgumentError, "timeout after 1s" }.not_to raise_error(ArgumentError, /timeout/) }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include("expected block to raise error with message matching /timeout/, but nothing was raised")
+  expect(output).to include(
+    "expected block to raise error with message matching /timeout/, but raised RuntimeError: permission denied"
+  )
+  expect(output).to include(
+    "expected block not to raise error with message matching /timeout/, but raised RuntimeError: timeout after 1s"
+  )
+  expect(output).to include(
+    "expected block to raise ArgumentError with message matching /timeout/, but raised RuntimeError: timeout after 1s"
+  )
+  expect(output).to include(
+    "expected block to raise ArgumentError with message matching /timeout/, but raised ArgumentError: permission denied"
+  )
+  expect(output).to include(
+    "expected block not to raise ArgumentError with message matching /timeout/, but raised ArgumentError: timeout after 1s"
+  )
+end
+
+test("rejects unsupported raise_error argument forms") do
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    raise_error
+  end
+
+  expect(error.message).to eq("raise_error supports an error class, message regexp, or error class and message regexp")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    raise_error("timeout")
+  end
+
+  expect(error.message).to eq("raise_error supports an error class, message regexp, or error class and message regexp")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    raise_error(String)
+  end
+
+  expect(error.message).to eq("raise_error supports an error class, message regexp, or error class and message regexp")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    raise_error(RuntimeError, "timeout")
+  end
+
+  expect(error.message).to eq("raise_error supports an error class, message regexp, or error class and message regexp")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    raise_error(/timeout/, RuntimeError)
+  end
+
+  expect(error.message).to eq("raise_error supports an error class, message regexp, or error class and message regexp")
+end
+
+test("reports start_with and end_with matcher failures") do
+  suite = Smartest::Suite.new
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad prefix",
+      proc { expect("https://example.test/path").to start_with("about:") }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad suffix",
+      proc { expect("asset.gif").to end_with(".jpg", ".png") }
+    )
+  )
+  suite.tests.add(
+    SmartestSelfTest.test_case(
+      "bad negated suffix",
+      proc { expect("screenshot.png").not_to end_with(".png") }
+    )
+  )
+
+  status, output = SmartestSelfTest.run_suite(suite)
+
+  expect(status).to eq(1)
+  expect(output).to include('expected "https://example.test/path" to start with "about:"')
+  expect(output).to include('expected "asset.gif" to end with ".jpg" or ".png"')
+  expect(output).to include('expected "screenshot.png" not to end with ".png"')
+end
+
+test("supports change matcher for block expectations") do
+  value = 0
+  action_calls = 0
+
+  expect {
+    action_calls += 1
+    value += 2
+  }.to change { value }.from(0).to(2).by(2)
+
+  expect(action_calls).to eq(1)
+  expect { value }.not_to change { value }
+end
+
+test("reports change matcher failures with before and after values") do
+  value = 0
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect { value += 1 }.to change { value }.from(0).to(2).by(2)
+  end
+
+  expect(error.message).to include("0 before")
+  expect(error.message).to include("1 after")
+  expect(error.message).to include("to(2)")
+  expect(error.message).to include("by(2)")
+end
+
+test("fails negated change matcher when the value changes") do
+  value = 0
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect { value += 1 }.not_to change { value }
+  end
+
+  expect(error.message).to include("expected value not to change")
+  expect(error.message).to include("0 before")
+  expect(error.message).to include("1 after")
+end
+
+test("requires change matcher value and action blocks") do
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    change
+  end
+
+  expect(error.message).to eq("change requires a block")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    change(:value) { :other }
+  end
+
+  expect(error.message).to include("change does not support arguments")
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect(:value).to change { :other }
+  end
+
+  expect(error.message).to include("expected a block to change value")
+end
+
 test("registers matcher modules for suite execution contexts") do
   status_matcher = Class.new do
     def initialize(expected)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.2.0.alpha2
+  version: 0.2.0.alpha4
 platform: ruby
 authors:
 - Yusuke Iwaki