smartest 0.2.0.alpha2 → 0.2.0.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0953c11bf61f80c4a310701920e5b6a22727149ed135d86678b3e49b25c8a92
-  data.tar.gz: d51839a9cb597da3d63a15aa803661946ceb3ae2a6982317ea108797f4203380
+  metadata.gz: 17a325d82883047881ac13538f95b3af038e361668869860034acc530ce2e398
+  data.tar.gz: 19c6a1a345e7e0fd02a12ae007a48f38c1be264debd3b23b0b6085d687a867bf
 SHA512:
-  metadata.gz: 2e3be2ebdc5b116e6f16e396d4befda198c0063bb4da6e7f487266642d1edd8083bcc4dce9b37746969fdcbd9916424068f043344cc732edf4738f849fb87d9c
-  data.tar.gz: 0c299af8b8dd05fac80ec1eefaeade8f747f8d2776e87ba6cb684ff84c619be8a21dfd3e33c99fa43d05ee0d40aabc361f86ab1e33af696a5a9ef4c9ee78054d
+  metadata.gz: 5b4aeb31472fca3b0911dfb29d4034405f493ac37e3019888a67f1c13c0b1f4aac99dc33b87c7e79a8d363b7bf12f7682b97bea396ebc56b558b592a7658eee9
+  data.tar.gz: 4e1c0cc3b739b62af8c4eeef394662f8115e35f890cdde87ce32117eca26c4064b627a08a2ca204c856276d2a603de8c4c55e2f9c71d2f68c44fd864e13c2ecc

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,8 @@ 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 change { value }
 ```
 
 Examples:
@@ -190,6 +192,14 @@ 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
 ```
 
 Supported matchers include:
@@ -197,10 +207,18 @@ Supported matchers include:
 ```ruby
 eq(expected)
 include(expected)
+start_with(prefix, ...)
+end_with(suffix, ...)
 be_nil
 raise_error(ErrorClass)
+change { value }
+change { value }.from(before).to(after)
+change { value }.by(delta)
 ```
 
+`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,19 @@ 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_nil
+raise_error(ErrorClass)
+change { value }
 ```
 
 Internal model:
@@ -1235,8 +1248,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,6 +10,14 @@ module Smartest
       IncludeMatcher.new(expected)
     end
 
+    def start_with(*prefixes)
+      StartWithMatcher.new(*prefixes)
+    end
+
+    def end_with(*suffixes)
+      EndWithMatcher.new(*suffixes)
+    end
+
     def be_nil
       BeNilMatcher.new
     end
@@ -17,6 +25,13 @@ module Smartest
     def raise_error(expected_error = StandardError)
       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
 
   class EqMatcher
@@ -59,6 +74,64 @@ module Smartest
     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
+
+    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
+
+    private
+
+    def expected_description
+      return "no suffixes" if @suffixes.empty?
+
+      @suffixes.map(&:inspect).join(" or ")
+    end
+  end
+
   class BeNilMatcher
     def matches?(actual)
       @actual = actual
@@ -106,4 +179,140 @@ module Smartest
       "expected block not to raise #{@expected_error}, but raised #{@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 change value" unless @callable
+
+      "expected value to #{expected_description}, but #{observed_description}#{failed_modifier_description}"
+    end
+
+    def negated_failure_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.alpha3"
 end

data/smartest/smartest_test.rb

@@ -172,6 +172,15 @@ 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(nil).to be_nil
         expect("value").not_to be_nil
         expect { raise ArgumentError, "bad" }.to raise_error(ArgumentError)
@@ -184,6 +193,93 @@ test("supports basic matchers") do
   expect(status).to eq(0)
 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.alpha3
 platform: ruby
 authors:
 - Yusuke Iwaki