smartest 0.2.0.alpha3 → 0.2.0.alpha4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17a325d82883047881ac13538f95b3af038e361668869860034acc530ce2e398
-  data.tar.gz: 19c6a1a345e7e0fd02a12ae007a48f38c1be264debd3b23b0b6085d687a867bf
+  metadata.gz: 944d35bc0a1be2293c8e276d16436693ff7dd6a2d37218f9f65af3b7a47f90f5
+  data.tar.gz: edd55fb6442a92e74146eaffc76a3b881463a16b4ce3c72a877734e0f6e36f52
 SHA512:
-  metadata.gz: 5b4aeb31472fca3b0911dfb29d4034405f493ac37e3019888a67f1c13c0b1f4aac99dc33b87c7e79a8d363b7bf12f7682b97bea396ebc56b558b592a7658eee9
-  data.tar.gz: 4e1c0cc3b739b62af8c4eeef394662f8115e35f890cdde87ce32117eca26c4064b627a08a2ca204c856276d2a603de8c4c55e2f9c71d2f68c44fd864e13c2ecc
+  metadata.gz: 5406cfcb57b56c71140c98565da884a184b8d14dcd41f8d6f65f218010d5ef7672eee6c3ad874dcc22a2d415097c9f9926f3a22c31ea3f5dafcf6dd00c2c795d
+  data.tar.gz: '0666928711e5ec22a5f9d671714597eb9e0a7e98edcf11d334bf72301c42739a8ae71104dff5784fa4728c10c186188e9f5278137ebbf7d22f6e14e745964927'

data/README.md

@@ -179,6 +179,8 @@ Smartest uses an expectation style:
 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 }
 ```
 
@@ -200,6 +202,18 @@ 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:
@@ -209,13 +223,29 @@ 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.
 

data/SMARTEST_DESIGN.md

@@ -727,8 +727,15 @@ 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 }
 ```
 

data/lib/smartest/matchers.rb

@@ -18,12 +18,32 @@ module Smartest
       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)
@@ -51,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
@@ -72,6 +96,10 @@ module Smartest
     def negated_failure_message
       "expected #{@actual.inspect} not to include #{@expected.inspect}"
     end
+
+    def description
+      "include #{@expected.inspect}"
+    end
   end
 
   class StartWithMatcher
@@ -94,6 +122,10 @@ module Smartest
       "expected #{@actual.inspect} not to start with #{expected_description}"
     end
 
+    def description
+      "start with #{expected_description}"
+    end
+
     private
 
     def expected_description
@@ -123,6 +155,10 @@ module Smartest
       "expected #{@actual.inspect} not to end with #{expected_description}"
     end
 
+    def description
+      "end with #{expected_description}"
+    end
+
     private
 
     def expected_description
@@ -132,6 +168,41 @@ module Smartest
     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
     def matches?(actual)
       @actual = actual
@@ -145,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
@@ -165,18 +389,60 @@ 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_error}" unless @callable
-      return "expected block to raise #{@expected_error}, but nothing was raised" unless @actual_error
+      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_error}, but raised #{@actual_error.class}: #{@actual_error.message}"
+      "expected block to raise #{expected_description}, but raised #{actual_error_description}"
     end
 
     def negated_failure_message
-      "expected block not to raise #{@expected_error}, but raised #{@actual_error.class}: #{@actual_error.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
 

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.2.0.alpha3"
+  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
@@ -181,9 +190,25 @@ test("supports basic matchers") do
         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
     )
   )
@@ -193,6 +218,166 @@ 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(

metadata

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