smartest 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f8abe11f15ae34b9c69f3c63baa01a2c724d5027b6acb842c9ed19fd3ab0fd4
-  data.tar.gz: 1db282b10807ae9e31115cabe6df364979e57690455a0da30775c7e9c5f65349
+  metadata.gz: 71422e8f16922c132f0fb06024693ff0d7b502fe6cd2c6050491f1605b105daa
+  data.tar.gz: a1c14eb9ab5448753a4e5f1b04faab8ade071b31e8943ed4f34f821c88722477
 SHA512:
-  metadata.gz: 60bd8acff86dc1ad7f2e4614b4dc1d34d0f2ba60d3ccdccece9f451dd9ea57510b77b572f69fa6163e5299165778e8bed051d93f8568cdc1c6c21416ed639f3d
-  data.tar.gz: 5ae7701a9471265a7ff113d9db3dae538ea47b6314a7a8162c817f8bfe425cce757d1b32b12a08d70b7912f6643cb777154b96f4e960710a90de4a12595e7ae9
+  metadata.gz: b5850a77ec4f8ac2d7b887151b5439af643928d9b62bb08c444c1b93f8a3eef4381f9bc0ad78d070c11cbde1d115d9fdb59c88f24535513ef3c819070206ba73
+  data.tar.gz: 9ac959479ddfdc0979a9a9bb9a11e9366f53d2cb03aecef02f96fff01c3417f9cc42c0ee87b954ccc7176171120b7b711dfb105fe40dd665e61a08a6af6ebd07

data/README.md

@@ -194,6 +194,8 @@ expect { action }.to raise_error(ErrorClass)
 expect { action }.to raise_error(/message/)
 expect { action }.to raise_error(ErrorClass, /message/)
 expect { action }.to change { value }
+expect(actual).to matcher.or(other_matcher)
+expect(actual).to matcher.and(other_matcher)
 ```
 
 Examples:
@@ -261,6 +263,28 @@ specific order, preserve duplicate counts, and can use matcher objects such as
 `change` is only supported with `expect { ... }` block expectations and must be
 written with a value block.
 
+Matchers can be composed with `.or` and `.and`:
+
+```ruby
+expect(result).to include("NetworkError").or include("Failed to fetch")
+expect(response.status).to eq(200).or(eq(304))
+expect("report.txt").to start_with("report").and end_with(".txt")
+```
+
+`.or` passes when any matcher matches and short-circuits the right-hand matcher
+when the left-hand matcher passes. `.and` passes only when every matcher matches.
+`not_to` does not support composed matchers and raises `ArgumentError` when used
+with `.and` or `.or`.
+
+Composed `change` matchers observe one action block execution:
+
+```ruby
+expect {
+  count += 1
+  total += 1
+}.to change { count }.by(1).and change { total }.by(1)
+```
+
 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

@@ -718,9 +718,11 @@ MVP expectation API:
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
 expect { action }.to change { value }
+expect(actual).to matcher.or(other_matcher)
+expect(actual).to matcher.and(other_matcher)
 ```
 
-Current built-in matchers include:
+Current built-in matchers and composition helpers include:
 
 ```ruby
 eq(expected)
@@ -737,6 +739,8 @@ raise_error(ErrorClass)
 raise_error(/message/)
 raise_error(ErrorClass, /message/)
 change { value }
+matcher.or(other_matcher)
+matcher.and(other_matcher)
 ```
 
 Internal model:
@@ -748,8 +752,17 @@ expect(actual)
 eq(expected)
   => EqMatcher
 
+EqMatcher
+  < Smartest::Matcher
+
+Smartest::Matcher#or(other_matcher)
+  => OrMatcher
+
+Smartest::Matcher#and(other_matcher)
+  => AndMatcher
+
 ExpectationTarget#to(matcher)
-  => matcher.match!(actual)
+  => matcher.matches?(actual)
 ```
 
 Example:
@@ -761,17 +774,36 @@ class Smartest::ExpectationTarget
   end
 
   def to(matcher)
-    matcher.match!(@actual)
+    return self if matcher.matches?(@actual)
+
+    raise AssertionFailed, matcher.failure_message
   end
 
   def not_to(matcher)
-    matcher.not_match!(@actual)
+    if matcher.respond_to?(:supports_negated_expectation?) && !matcher.supports_negated_expectation?
+      raise ArgumentError, matcher.negated_expectation_error
+    end
+
+    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
   end
 end
 ```
 
 Assertion failures should raise `Smartest::AssertionFailed`.
 
+Matcher composition is logical composition over the same actual value. `or`
+passes when any matcher matches and should short-circuit later matchers after a
+match. `and` passes only when every matcher matches. `not_to` with composed
+matchers is intentionally unsupported and raises `ArgumentError`.
+
 ## Reporter
 
 The initial reporter should be simple.

data/lib/smartest/expectation_target.rb

@@ -13,6 +13,10 @@ module Smartest
     end
 
     def not_to(matcher)
+      if matcher.respond_to?(:supports_negated_expectation?) && !matcher.supports_negated_expectation?
+        raise ArgumentError, matcher.negated_expectation_error
+      end
+
       if matcher.respond_to?(:does_not_match?)
         return self if matcher.does_not_match?(@actual)
 

data/lib/smartest/init_generator.rb

@@ -38,7 +38,7 @@ module Smartest
             name.to_s.match?(/\\Abe_.+\\z/) || super
           end
 
-          class Matcher
+          class Matcher < Smartest::Matcher
             def initialize(predicate_name, arguments, block)
               @predicate_name = predicate_name
               @predicate = "\#{predicate_name}?"
@@ -63,14 +63,14 @@ module Smartest
               "expected \#{@actual.inspect} not to be \#{description}"
             end
 
-            private
-
             def description
               return @predicate_name if @arguments.empty?
 
               "\#{@predicate_name} \#{argument_description}"
             end
 
+            private
+
             def argument_description
               @arguments.map(&:inspect).join(", ")
             end

data/lib/smartest/matchers.rb

@@ -54,7 +54,162 @@ module Smartest
     end
   end
 
-  class EqMatcher
+  class Matcher
+    def and(other_matcher)
+      AndMatcher.new(self, other_matcher)
+    end
+
+    def or(other_matcher)
+      OrMatcher.new(self, other_matcher)
+    end
+
+    def description
+      self.class.name || "matcher"
+    end
+  end
+
+  class CompoundMatcher < Matcher
+    attr_reader :matchers
+
+    NEGATED_EXPECTATION_ERROR = "not_to does not support matcher composition with .and or .or"
+
+    def initialize(*matchers)
+      @matchers = matchers.flat_map do |matcher|
+        matcher.is_a?(self.class) ? matcher.matchers : matcher
+      end
+      reset_result
+    end
+
+    def supports_negated_expectation?
+      false
+    end
+
+    def negated_expectation_error
+      NEGATED_EXPECTATION_ERROR
+    end
+
+    private
+
+    def reset_result
+      @actual = nil
+      @failed_matchers = []
+      @matched_matchers = []
+    end
+
+    def actual_description
+      @actual.respond_to?(:call) ? "block" : @actual.inspect
+    end
+
+    def matcher_description(matcher)
+      description = if matcher.respond_to?(:description)
+                      matcher.description
+                    else
+                      matcher.inspect
+                    end
+
+      matcher.is_a?(CompoundMatcher) ? "(#{description})" : description
+    end
+
+    def joined_description(separator)
+      @matchers.map { |matcher| matcher_description(matcher) }.join(separator)
+    end
+
+    def failure_messages
+      @failed_matchers.filter_map do |matcher|
+        matcher.failure_message if matcher.respond_to?(:failure_message)
+      end
+    end
+
+    def composed_block_expectation?(actual)
+      actual.respond_to?(:call) &&
+        @matchers.all? { |matcher| matcher.respond_to?(:composable_block_expectation?) } &&
+        @matchers.all?(&:composable_block_expectation?)
+    end
+
+    def run_composed_block_expectation(actual)
+      @matchers.each(&:prepare_composed_block_expectation)
+      actual.call
+      @matchers.each(&:finish_composed_block_expectation)
+      @matchers.each do |matcher|
+        if matcher.composed_block_matches?
+          @matched_matchers << matcher
+        else
+          @failed_matchers << matcher
+        end
+      end
+    end
+  end
+
+  class AndMatcher < CompoundMatcher
+    def matches?(actual)
+      reset_result
+      @actual = actual
+
+      if composed_block_expectation?(actual)
+        run_composed_block_expectation(actual)
+        return @failed_matchers.empty?
+      end
+
+      @matchers.each do |matcher|
+        if matcher.matches?(actual)
+          @matched_matchers << matcher
+        else
+          @failed_matchers << matcher
+          return false
+        end
+      end
+
+      true
+    end
+
+    def failure_message
+      message = "expected #{actual_description} to match all of #{description}"
+      details = failure_messages
+      details.empty? ? message : "#{message}; #{details.join('; ')}"
+    end
+
+    def negated_failure_message
+      "expected #{actual_description} not to match all of #{description}"
+    end
+
+    def description
+      joined_description(" and ")
+    end
+  end
+
+  class OrMatcher < CompoundMatcher
+    def matches?(actual)
+      reset_result
+      @actual = actual
+
+      @matchers.each do |matcher|
+        if matcher.matches?(actual)
+          @matched_matchers << matcher
+          return true
+        end
+
+        @failed_matchers << matcher
+      end
+
+      false
+    end
+
+    def failure_message
+      message = "expected #{actual_description} to match any of #{description}"
+      details = failure_messages
+      details.empty? ? message : "#{message}; #{details.join('; ')}"
+    end
+
+    def negated_failure_message
+      "expected #{actual_description} not to match any of #{description}"
+    end
+
+    def description
+      joined_description(" or ")
+    end
+  end
+
+  class EqMatcher < Matcher
     def initialize(expected)
       @expected = expected
     end
@@ -77,7 +232,7 @@ module Smartest
     end
   end
 
-  class IncludeMatcher
+  class IncludeMatcher < Matcher
     def initialize(expected)
       @expected = expected
     end
@@ -102,7 +257,7 @@ module Smartest
     end
   end
 
-  class StartWithMatcher
+  class StartWithMatcher < Matcher
     def initialize(*prefixes)
       @prefixes = prefixes
     end
@@ -135,7 +290,7 @@ module Smartest
     end
   end
 
-  class EndWithMatcher
+  class EndWithMatcher < Matcher
     def initialize(*suffixes)
       @suffixes = suffixes
     end
@@ -168,7 +323,7 @@ module Smartest
     end
   end
 
-  class BeAKindOfMatcher
+  class BeAKindOfMatcher < Matcher
     def initialize(expected_class)
       @expected_class = expected_class
     end
@@ -203,7 +358,7 @@ module Smartest
     end
   end
 
-  class BeNilMatcher
+  class BeNilMatcher < Matcher
     def matches?(actual)
       @actual = actual
       actual.nil?
@@ -222,7 +377,7 @@ module Smartest
     end
   end
 
-  class MatchMatcher
+  class MatchMatcher < Matcher
     def initialize(regexp)
       @regexp = regexp
     end
@@ -247,7 +402,7 @@ module Smartest
     end
   end
 
-  class ContainExactlyMatcher
+  class ContainExactlyMatcher < Matcher
     def initialize(expected_items, matcher_name:)
       @expected_items = expected_items
       @matcher_name = matcher_name
@@ -369,7 +524,7 @@ module Smartest
     end
   end
 
-  class RaiseErrorMatcher
+  class RaiseErrorMatcher < Matcher
     def initialize(*expected_error)
       @expected_type = expected_type_for(expected_error)
       @expected_error_class = expected_error.find { |item| error_class?(item) }
@@ -403,6 +558,10 @@ module Smartest
       "expected block not to raise #{expected_description}, but raised #{actual_error_description}"
     end
 
+    def description
+      "raise #{expected_description}"
+    end
+
     private
 
     def expected_type_for(expected_error)
@@ -446,7 +605,7 @@ module Smartest
     end
   end
 
-  class ChangeMatcher
+  class ChangeMatcher < Matcher
     UNSET = Object.new
 
     def initialize(value_block)
@@ -498,6 +657,31 @@ module Smartest
       "expected value not to change, but #{observed_description}"
     end
 
+    def description
+      expected_description
+    end
+
+    def composable_block_expectation?
+      true
+    end
+
+    def prepare_composed_block_expectation
+      reset_result
+      @callable = true
+      @before_value = @value_block.call
+    end
+
+    def finish_composed_block_expectation
+      @after_value = @value_block.call
+      calculate_delta if delta_expected?
+    end
+
+    def composed_block_matches?
+      return false unless @callable
+
+      positive_failures.empty?
+    end
+
     private
 
     def reset_result

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/smartest/smartest_test.rb

@@ -218,6 +218,74 @@ test("supports basic matchers") do
   expect(status).to eq(0)
 end
 
+test("supports matcher composition with and and or") do
+  action_calls = 0
+  first_value = 0
+  second_value = 10
+
+  expect("NetworkError").to include("Network").or include("Failed to fetch")
+  expect(304).to eq(200).or(eq(201)).or(eq(304))
+  expect("report.txt").to start_with("report").and end_with(".txt")
+  expect {
+    action_calls += 1
+    first_value += 1
+    second_value += 1
+  }.to change { first_value }.by(1).and change { second_value }.by(1)
+
+  expect(action_calls).to eq(1)
+end
+
+test("reports matcher composition failures") do
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect("permission denied").to include("NetworkError").or include("Failed to fetch")
+  end
+
+  expect(error.message).to include(
+    'expected "permission denied" to match any of include "NetworkError" or include "Failed to fetch"'
+  )
+  expect(error.message).to include('expected "permission denied" to include "NetworkError"')
+  expect(error.message).to include('expected "permission denied" to include "Failed to fetch"')
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect("error.log").to start_with("error").and end_with(".txt")
+  end
+
+  expect(error.message).to include('expected "error.log" to match all of start with "error" and end with ".txt"')
+  expect(error.message).to include('expected "error.log" to end with ".txt"')
+end
+
+test("rejects negated matcher composition") do
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    expect("public token").not_to include("password").or include("secret")
+  end
+
+  expect(error.message).to eq("not_to does not support matcher composition with .and or .or")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    expect("report.log").not_to start_with("report").and end_with(".txt")
+  end
+
+  expect(error.message).to eq("not_to does not support matcher composition with .and or .or")
+end
+
+test("short-circuits or matcher composition") do
+  right_matcher = Class.new(Smartest::Matcher) do
+    def matches?(_actual)
+      raise "right matcher should not be evaluated"
+    end
+
+    def failure_message
+      "right matcher failed"
+    end
+
+    def negated_failure_message
+      "right matcher matched"
+    end
+  end.new
+
+  expect("ok").to eq("ok").or(right_matcher)
+end
+
 test("reports be_a and match matcher failures") do
   suite = Smartest::Suite.new
   suite.tests.add(
@@ -1368,7 +1436,7 @@ test("cli loads matcher files registered in test helper") do
     RUBY
     File.write(File.join(matchers_dir, "have_status_matcher.rb"), <<~RUBY)
       module HaveStatusMatcher
-        class MatcherImpl
+        class MatcherImpl < Smartest::Matcher
           def initialize(expected)
             @expected = expected
           end
@@ -1385,6 +1453,10 @@ test("cli loads matcher files registered in test helper") do
           def negated_failure_message
             "expected \#{@actual.inspect} not to have status \#{@expected.inspect}"
           end
+
+          def description
+            "have status \#{@expected.inspect}"
+          end
         end
 
         def have_status(expected)
@@ -1773,6 +1845,7 @@ test("cli initializes a runnable test scaffold") do
     expect(helper_contents).to include("use_matcher PredicateMatcher")
     predicate_matcher_contents = File.read(File.join(dir, "smartest/matchers/predicate_matcher.rb"))
     expect(predicate_matcher_contents).to include("module PredicateMatcher")
+    expect(predicate_matcher_contents).to include("class Matcher < Smartest::Matcher")
     expect(File.read(File.join(dir, "smartest/example_test.rb"))).to include('require "test_helper"')
 
     nested_fixtures_dir = File.join(dir, "smartest/fixtures/nested")
@@ -1802,7 +1875,7 @@ test("cli initializes a runnable test scaffold") do
     FileUtils.mkdir_p(nested_matchers_dir)
     File.write(File.join(nested_matchers_dir, "auto_loaded_matcher.rb"), <<~RUBY)
       module AutoLoadedMatcher
-        class Matcher
+        class Matcher < Smartest::Matcher
           def initialize(expected)
             @expected = expected
           end
@@ -1819,6 +1892,10 @@ test("cli initializes a runnable test scaffold") do
           def negated_failure_message
             "expected \#{@actual.inspect} not to auto-eq \#{@expected.inspect}"
           end
+
+          def description
+            "auto-eq \#{@expected.inspect}"
+          end
         end
 
         def auto_eq(expected)
@@ -1846,6 +1923,7 @@ test("cli initializes a runnable test scaffold") do
       test("generated predicate matcher") do
         expect("").to be_empty
         expect(2).to be_between(1, 3)
+        expect(2).to be_odd.or be_even
       end
     RUBY
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Yusuke Iwaki