rspock 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e4d05a65bb9d040615d65ceee976bc3b0fef696d54921b9fb47160c07c18dc2
-  data.tar.gz: 8d2b4a392f6ea3cff0133278a7994b2934fea9d2a3d695da4a9da66d2727ae25
+  metadata.gz: d6c10b52d342827b092af647c5bc144f4e381dff91167eedf93a0f99c9488ee2
+  data.tar.gz: 20ea274b4fa0e3a79eefb88f33c53ddf84adfc582fd37fe3e2ee9688a8137747
 SHA512:
-  metadata.gz: c59e0798461d56be30b9579cd09b72b373a2b70039139295cc42bf610031e73be438e93f0645963cfb29d6617cab0096b0de978a954950ec6f9c21c13e1d510a
-  data.tar.gz: 2d36558c145a2684e169331d7f277f2aa7b09b39c642b331dcf4ec36757228a0ccf6c8ab1ce5b8be7408b157061ae30ef0b7a45108ea012a1462742cbb480b87
+  metadata.gz: '019855311bf85f23d10fb75d3b1c0020b52fbf2ae7083205ca69a3f15b142ee7c2ba24e9be0506c690e65b42302b347ea7dc256c596edf1069ec8a0700aad666'
+  data.tar.gz: a559d70b0f3509d361234019935a2105c4a2b96ddac5ce0df7198edff346fe83a5c7a9c889d5152fbf0a856a60edd069017c3b24f88b144eda651ab35a57b47b

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.5.0] - 2026-02-28
+
+### Added
+
+- Exception conditions: `raises ExceptionClass` in Then blocks wraps the preceding When block in an exception assertion.
+- Exception capture: `e = raises ExceptionClass` captures the exception for further assertions in the same Then block.
+- Exception conditions work with data-driven `Where` blocks.
+
+### Changed
+
+- Renamed interaction outcome nodes from `rspock_returns` / `rspock_raises` to `rspock_stub_returns` / `rspock_stub_raises` to distinguish them from the new exception condition `rspock_raises`.
+
 ## [2.4.0] - 2026-02-28
 
 ### Added
@@ -140,7 +152,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release.
 
-[Unreleased]: https://github.com/rspockframework/rspock/compare/v2.4.0...HEAD
+[Unreleased]: https://github.com/rspockframework/rspock/compare/v2.5.0...HEAD
+[2.5.0]: https://github.com/rspockframework/rspock/compare/v2.4.0...v2.5.0
 [2.4.0]: https://github.com/rspockframework/rspock/compare/v2.3.1...v2.4.0
 [2.3.1]: https://github.com/rspockframework/rspock/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/rspockframework/rspock/compare/v2.2.0...v2.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rspock (2.4.0)
+    rspock (2.5.0)
       ast_transform (~> 2.0)
       minitest (~> 5.0)
       mocha (>= 1.0)

data/README.md

@@ -19,6 +19,7 @@ Note: RSpock is heavily inspired by Spock for the Groovy programming language.
 * Spock-style implicit assertions: every statement in Then/Expect blocks is an assertion (no assertion API needed)
 * Binary operator assertions: `==`, `!=`, `=~`, `!~`, `>`, `<`, `>=`, `<=` with clear error messages
 * General statement assertions: bare boolean expressions (e.g. `obj.valid?`, `list.include?(x)`) and negation (`!obj.empty?`) with source-text error messages
+* [Exception conditions](#exception-conditions): `raises ExceptionClass` in Then blocks wraps the When block in an exception assertion, with optional capture for property assertions
 * [Interaction-based testing](#mocking-with-interactions), i.e. `1 * object.receive("message")` in Then blocks, with optional [return value stubbing](#stubbing-return-values) via `>>`, [exception stubbing](#stubbing-exceptions) via `>> raises(...)`, and [block forwarding verification](#block-forwarding-verification) via `&block`
 * (Planned) BDD-style custom reporter that outputs information from Code Blocks
 * (Planned) Capture all Then block violations
@@ -166,6 +167,46 @@ The Then block describes the response from the stimulus. Following Spock's core
 
 **Variable assignments** pass through unchanged and execute in source order after the stimulus.
 
+##### Exception Conditions
+
+Use `raises` in a Then block to assert that the preceding When block raises a specific exception:
+
+```ruby
+When "Dividing by zero"
+1 / 0
+
+Then "An error is raised"
+raises ZeroDivisionError
+```
+
+To inspect the exception, capture it into a variable:
+
+```ruby
+When "Parsing bad input"
+JSON.parse("not json")
+
+Then "A parse error is raised with a message"
+e = raises JSON::ParserError
+e.message.include?("unexpected token")
+```
+
+The captured variable is available for further assertions in the same Then block. Exception conditions work with data-driven `Where` blocks as well:
+
+```ruby
+When "Parsing invalid input"
+JSON.parse(input)
+
+Then "The expected error is raised"
+raises expected_error
+
+Where
+input          | expected_error
+"not json"     | JSON::ParserError
+"{invalid"     | JSON::ParserError
+```
+
+Only **one** `raises` condition is allowed per Then block, and `raises` is **not supported** in Expect blocks (use a When + Then block instead).
+
 #### Expect Block
 
 The Expect block is useful when expressing the stimulus and the response in one statement is more natural. The same assertion rules apply as in Then blocks — every statement is an assertion unless it's a variable assignment.

data/lib/rspock/ast/interaction_to_mocha_mock_transformation.rb

@@ -10,14 +10,14 @@ module RSpock
     # Output: receiver.expects(:message).with(*args).times(n).returns(value)
     #
     # The outcome node type maps directly to the Mocha chain method:
-    #   :rspock_returns -> .returns(value)
-    #   :rspock_raises  -> .raises(exception_class, ...)
+    #   :rspock_stub_returns -> .returns(value)
+    #   :rspock_stub_raises  -> .raises(exception_class, ...)
     #
     # When block_pass is present, wraps the expects chain with a BlockCapture.capture call.
     class InteractionToMochaMockTransformation < ASTTransform::AbstractTransformation
       OUTCOME_METHODS = {
-        rspock_returns: :returns,
-        rspock_raises: :raises,
+        rspock_stub_returns: :returns,
+        rspock_stub_raises: :raises,
       }.freeze
 
       def initialize(index = 0)

data/lib/rspock/ast/node.rb

@@ -73,12 +73,20 @@ module RSpock
     class OutcomeNode < Node
     end
 
-    class ReturnsNode < OutcomeNode
-      register :rspock_returns
+    class StubReturnsNode < OutcomeNode
+      register :rspock_stub_returns
     end
 
-    class RaisesNode < OutcomeNode
+    class StubRaisesNode < OutcomeNode
+      register :rspock_stub_raises
+    end
+
+    class RaisesNode < Node
       register :rspock_raises
+
+      def exception_class = children[0]
+      def capture_var     = children[1]
+      def capture_name    = capture_var&.children&.[](0)
     end
 
     class InteractionNode < Node

data/lib/rspock/ast/parser/expect_block.rb

@@ -25,6 +25,11 @@ module RSpock
         def to_rspock_node
           statement_parser = StatementParser.new
           spock_children = @children.map { |child| statement_parser.parse(child) }
+
+          if spock_children.any? { |c| c.type == :rspock_raises }
+            raise BlockError, "raises() is not supported in Expect blocks @ #{range}. Use a When + Then block instead."
+          end
+
           s(:rspock_expect, *spock_children)
         end
       end

data/lib/rspock/ast/parser/interaction_parser.rb

@@ -14,7 +14,7 @@ module RSpock
       #   [1] receiver     - e.g. s(:send, nil, :subscriber)
       #   [2] message      - e.g. s(:sym, :receive)
       #   [3] args         - nil if no args, s(:array, *arg_nodes) otherwise
-      #   [4] outcome      - nil if no >>, otherwise s(:rspock_returns, value) or s(:rspock_raises, *args)
+      #   [4] outcome      - nil if no >>, otherwise s(:rspock_stub_returns, value) or s(:rspock_stub_raises, *args)
       #   [5] block_pass   - nil if no &, otherwise s(:block_pass, ...)
       class InteractionParser
         include RSpock::AST::NodeBuilder
@@ -63,9 +63,9 @@ module RSpock
 
         def parse_outcome(node)
           if node.type == :send && node.children[0].nil? && node.children[1] == :raises
-            s(:rspock_raises, *node.children[2..])
+            s(:rspock_stub_raises, *node.children[2..])
           else
-            s(:rspock_returns, node)
+            s(:rspock_stub_returns, node)
           end
         end
 

data/lib/rspock/ast/parser/statement_parser.rb

@@ -16,6 +16,7 @@ module RSpock
         ASSIGNMENT_TYPES = %i[lvasgn masgn op_asgn or_asgn and_asgn].freeze
 
         def parse(node)
+          return build_raises(node) if raises_condition?(node)
           return node if assignment?(node)
           return build_binary_statement(node) if binary_statement?(node)
 
@@ -24,6 +25,32 @@ module RSpock
 
         private
 
+        def raises_condition?(node)
+          direct_raises?(node) || assigned_raises?(node)
+        end
+
+        def direct_raises?(node)
+          node.type == :send && node.children[0].nil? && node.children[1] == :raises
+        end
+
+        def assigned_raises?(node)
+          node.type == :lvasgn &&
+            node.children[1]&.type == :send &&
+            node.children[1].children[0].nil? &&
+            node.children[1].children[1] == :raises
+        end
+
+        def build_raises(node)
+          if node.type == :lvasgn
+            variable = s(:sym, node.children[0])
+            exception_class = node.children[1].children[2]
+            s(:rspock_raises, exception_class, variable)
+          else
+            exception_class = node.children[2]
+            s(:rspock_raises, exception_class)
+          end
+        end
+
         def assignment?(node)
           ASSIGNMENT_TYPES.include?(node.type)
         end

data/lib/rspock/ast/parser/then_block.rb

@@ -30,6 +30,11 @@ module RSpock
             statement_parser.parse(child)
           end
 
+          raises_count = spock_children.count { |c| c.type == :rspock_raises }
+          if raises_count > 1
+            raise BlockError, "Then block @ #{range} may contain at most one raises() condition"
+          end
+
           s(:rspock_then, *spock_children)
         end
       end

data/lib/rspock/ast/test_method_transformation.rb

@@ -117,16 +117,25 @@ module RSpock
 
       def build_test_body(body_node, hoisted_setups)
         body_children = []
+        blocks = body_node.children
 
-        body_node.children.each do |block_node|
+        blocks.each_with_index do |block_node, i|
           case block_node.type
           when :rspock_given
             body_children.concat(block_node.children)
           when :rspock_when
             body_children.concat(hoisted_setups)
-            body_children.concat(block_node.children)
+            raises_node = find_raises_in_next_then(blocks, i)
+
+            if raises_node
+              body_children << build_assert_raises(block_node, raises_node)
+            else
+              body_children.concat(block_node.children)
+            end
           when :rspock_then, :rspock_expect
-            body_children.concat(block_node.children)
+            block_node.children.each do |child|
+              body_children << child unless child.type == :rspock_raises
+            end
           when :rspock_cleanup
             # handled below as ensure
           end
@@ -143,6 +152,31 @@ module RSpock
         MethodCallToLVarTransformation.new(:_test_index_, :_line_number_).run(ast)
       end
 
+      # --- Raises condition helpers ---
+
+      def find_raises_in_next_then(blocks, current_index)
+        next_block = blocks[current_index + 1]
+        return nil unless next_block&.type == :rspock_then
+
+        next_block.children.find { |c| c.type == :rspock_raises }
+      end
+
+      def build_assert_raises(when_node, raises_node)
+        when_body = when_node.children.length == 1 ? when_node.children[0] : s(:begin, *when_node.children)
+
+        assert_raises_call = s(:block,
+          s(:send, nil, :assert_raises, raises_node.exception_class),
+          s(:args),
+          when_body
+        )
+
+        if raises_node.capture_name
+          s(:lvasgn, raises_node.capture_name, assert_raises_call)
+        else
+          assert_raises_call
+        end
+      end
+
       # --- Where block helpers ---
 
       def build_where_iterator(data_rows)

data/lib/rspock/version.rb

@@ -1,3 +1,3 @@
 module RSpock
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspock
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Jean-Philippe Duchesne
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-28 00:00:00.000000000 Z
+date: 2026-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler