pbt 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8415f37c2819e6370e7d418cb96d8ae2467fec24cfca1e64088c925874dc0c34
-  data.tar.gz: f6b38e54ec98fa669cc379c6c181e210d5fab02fc076a343e941aa17cb5be476
+  metadata.gz: 9ce157507d0afc004a4d8993baecfb14dc4f0a14d381a996c33c15a02e8c496e
+  data.tar.gz: 71d314990ce4ee1ae4012a9af90666931edecba089851f8e3ea686696048c154
 SHA512:
-  metadata.gz: cf614cf7100cbbf13f197dbc2a088e43c8b01fac31eaddc8d24ce5f1da7ed14140e3c59e3cafa6b0a22eee7014965c99df444d90dc70bcfbf07862f077ebb738
-  data.tar.gz: df70247adc89586f9ebb813427fe3efdcfd5ba93deea286dea8f5120dae92bc293f6a7f7ff2bcb2a5bdd263ed7e5108d7c358c4a96eb978e037143f02356a1db
+  metadata.gz: fad18a8a7075e2e4f737f4daf1b79b8aceac8c65a0a1c566d7aa3eea35f0c14b4b868a9a249039411c4951ecf7c8419f715a9e1227348425c964b5e3914ee05c
+  data.tar.gz: f6747cd209851c8d4b5b8dc122f1bd7ee0c4fde21c994a3de3f49365251eddbd6883aa0ddb8582bbb057e57177b8c35a08a351cac44d4ae6c663da16c7ea4b0b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.4.0] - 2024-05-06
+
+- Allow to use RSpec::Matchers for `worker: :none, :thread, :process` also.
+- Make error message short to keep focusing on failure causes.
+- Fix a bug for a case when parameters cannot be passed to a test block correctly.
+
 ## [0.3.0] - 2024-04-21
 
 - Add experimental_ractor_rspec_integration mode. Be careful, it's quite experimental.

data/README.md

@@ -205,7 +205,7 @@ You can configure `Pbt` by calling `Pbt.configure` before running tests.
 ```ruby
 Pbt.configure do |config|
   # Whether to print verbose output. Default is `false`.
-  config.verbose = 100
+  config.verbose = false
 
   # The concurrency method to use. `:ractor`, `:thread`, `:process` and `:none` are supported. Default is `:none`.
   config.worker = :none

data/benchmark/README.md

@@ -21,8 +21,8 @@ Interestingly, both multi-process (`worker: :process`) and multi-thread (`worker
 The following benchmarks are the results of running the benchmark suite.
 
 - macOS 14.4.1, Apple M1 Pro 10 cores (8 performance and 2 efficiency)
-- ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin22]
-- pbt commit hash 6f2c1cf1ab36d5d83a89fabb22da431e3600fe25
+- ruby 3.3.1 (2024-04-23 revision c56cd86388) +MN [arm64-darwin23]
+- pbt commit hash ecaecceb73a171042e52dbad25074f4f7dcfd55a
 
 ---
 
@@ -32,17 +32,17 @@ This runs a script that does not do any IO or CPU bound work.
 
 ```
 ruby benchmark/success_simple.rb
-ruby 3.3.0 (2023-12-25 revision 5124f9ac75) +MN [arm64-darwin22]
+ruby 3.3.1 (2024-04-23 revision c56cd86388) +MN [arm64-darwin23]
 Warming up --------------------------------------
-              ractor    19.000 i/100ms
-             process     2.000 i/100ms
-              thread   114.000 i/100ms
-                none   234.000 i/100ms
+              ractor    21.000 i/100ms
+             process     3.000 i/100ms
+              thread   111.000 i/100ms
+                none   172.000 i/100ms
 Calculating -------------------------------------
-              ractor     75.717 (± 4.0%) i/s -    380.000 in   5.025954s
-             process      1.712 (± 0.0%) i/s -     10.000 in   5.840821s
-              thread      1.019k (±34.0%) i/s -      4.560k in   5.028774s
-                none      1.616k (±24.1%) i/s -      7.722k in   5.003744s
+              ractor     73.709 (± 8.1%) i/s -    378.000 in   5.166176s
+             process      1.868 (± 0.0%) i/s -     12.000 in   6.423704s
+              thread      1.028k (±33.4%) i/s -      4.773k in   5.123614s
+                none      1.534k (±24.4%) i/s -      7.224k in   5.037993s
 ```
 
 ### Benchmark success:cpu_bound
@@ -51,17 +51,17 @@ This runs a script that does CPU bound work.
 
 ```
 ruby benchmark/success_cpu_bound.rb
-ruby 3.3.0 (2023-12-25 revision 5124f9ac75) +MN [arm64-darwin22]
+ruby 3.3.1 (2024-04-23 revision c56cd86388) +MN [arm64-darwin23]
 Warming up --------------------------------------
               ractor     3.000 i/100ms
              process     2.000 i/100ms
               thread     1.000 i/100ms
                 none     1.000 i/100ms
 Calculating -------------------------------------
-              ractor     35.688 (± 8.4%) i/s -    180.000 in   5.079922s
-             process     15.329 (± 6.5%) i/s -     78.000 in   5.097040s
-              thread      7.654 (± 0.0%) i/s -     39.000 in   5.095252s
-                none      7.707 (± 0.0%) i/s -     39.000 in   5.060309s
+              ractor     39.273 (± 2.5%) i/s -    198.000 in   5.042910s
+             process     20.631 (± 4.8%) i/s -    104.000 in   5.068093s
+              thread      7.657 (± 0.0%) i/s -     39.000 in   5.096493s
+                none      7.765 (± 0.0%) i/s -     39.000 in   5.022829s
 ```
 
 ### Benchmark success:io_bound
@@ -70,17 +70,17 @@ This runs a script that does IO bound work.
 
 ```
 ruby benchmark/success_io_bound.rb
-ruby 3.3.0 (2023-12-25 revision 5124f9ac75) +MN [arm64-darwin22]
+ruby 3.3.1 (2024-04-23 revision c56cd86388) +MN [arm64-darwin23]
 Warming up --------------------------------------
               ractor    11.000 i/100ms
              process     2.000 i/100ms
-              thread    16.000 i/100ms
-                none    21.000 i/100ms
+              thread    15.000 i/100ms
+                none    20.000 i/100ms
 Calculating -------------------------------------
-              ractor     55.907 (± 3.6%) i/s -    286.000 in   5.122098s
-             process      9.916 (± 0.0%) i/s -     50.000 in   5.044945s
-              thread    131.280 (±17.5%) i/s -    656.000 in   5.148757s
-                none    144.364 (± 4.8%) i/s -    735.000 in   5.102093s
+              ractor     53.841 (± 3.7%) i/s -    275.000 in   5.114164s
+             process     10.077 (± 0.0%) i/s -     52.000 in   5.166346s
+              thread    130.750 (±16.8%) i/s -    645.000 in   5.057727s
+                none    151.102 (± 4.0%) i/s -    760.000 in   5.038146s
 ```
 
 ### Benchmark failure:simple
@@ -89,15 +89,15 @@ This runs a script that fails and shrink happens.
 
 ```
 ruby benchmark/failure_simple.rb
-ruby 3.3.0 (2023-12-25 revision 5124f9ac75) +MN [arm64-darwin22]
+ruby 3.3.1 (2024-04-23 revision c56cd86388) +MN [arm64-darwin23]
 Warming up --------------------------------------
               ractor     7.000 i/100ms
              process     1.000 i/100ms
               thread    14.000 i/100ms
-                none   288.000 i/100ms
+                none   264.000 i/100ms
 Calculating -------------------------------------
-              ractor     13.104 (± 7.6%) i/s -     70.000 in   5.358898s
-             process      0.060 (± 0.0%) i/s -      1.000 in  16.545525s
-              thread    111.493 (±20.6%) i/s -    532.000 in   5.012879s
-                none      2.445k (±19.0%) i/s -     12.096k in   5.086548s
+              ractor     12.466 (± 8.0%) i/s -     63.000 in   5.080393s
+             process      0.059 (± 0.0%) i/s -      1.000 in  17.091278s
+              thread    110.228 (±20.0%) i/s -    532.000 in   5.054091s
+                none      2.425k (±23.1%) i/s -     11.616k in   5.053378s
 ```

data/benchmark/failure_simple.rb

@@ -4,11 +4,13 @@ require "benchmark/ips"
 # With this seed, the 4th case fails and it shrinks happens 13 times.
 seed = 17243810592888013452170775373100387856
 
+def task(x) = (x > 100) ? raise : nil
+
 Benchmark.ips do |x|
   x.report("ractor") do
-    Pbt.assert(worker: :ractor, seed:) do
+    Pbt.assert(worker: :ractor, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        raise if x > 100
+        task(x)
       end
     end
   rescue Pbt::PropertyFailure
@@ -16,9 +18,9 @@ Benchmark.ips do |x|
   end
 
   x.report("process") do
-    Pbt.assert(worker: :process, seed:) do
+    Pbt.assert(worker: :process, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        raise if x > 100
+        task(x)
       end
     end
   rescue Pbt::PropertyFailure
@@ -26,9 +28,9 @@ Benchmark.ips do |x|
   end
 
   x.report("thread") do
-    Pbt.assert(worker: :thread, seed:) do
+    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        raise if x > 100
+        task(x)
       end
     end
   rescue Pbt::PropertyFailure
@@ -36,9 +38,9 @@ Benchmark.ips do |x|
   end
 
   x.report("none") do
-    Pbt.assert(worker: :none, seed:) do
+    Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        raise if x > 100
+        task(x)
       end
     end
   rescue Pbt::PropertyFailure

data/benchmark/success_cpu_bound.rb

@@ -8,43 +8,43 @@ require "benchmark/ips"
 #  (x=9, y=4, z=0) calls 55229 times.
 #  (x=8, y=4, z=0) calls 12605 times.
 #  (x=8, y=3, z=0) calls 305 times.
-def tarai(x, y, z)
-  (x <= y) ? y : tarai(tarai(x - 1, y, z),
-    tarai(y - 1, z, x),
-    tarai(z - 1, x, y))
+def task(x, y, z)
+  (x <= y) ? y : task(task(x - 1, y, z),
+    task(y - 1, z, x),
+    task(z - 1, x, y))
 end
 
 a, b, c = [9, 4, 0]
 
 Benchmark.ips do |x|
   x.report("ractor") do
-    Pbt.assert(worker: :ractor) do
-      Pbt.property(Pbt.constant(a), Pbt.constant(b), Pbt.constant(c)) do |x, y, z|
-        tarai(x, y, z)
+    Pbt.assert(worker: :ractor, num_runs: 100) do
+      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
+        task(x, y, z)
       end
     end
   end
 
   x.report("process") do
-    Pbt.assert(worker: :process) do
-      Pbt.property(Pbt.constant(a), Pbt.constant(b), Pbt.constant(c)) do |x, y, z|
-        tarai(x, y, z)
+    Pbt.assert(worker: :process, num_runs: 100) do
+      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
+        task(x, y, z)
       end
     end
   end
 
   x.report("thread") do
-    Pbt.assert(worker: :thread) do
-      Pbt.property(Pbt.constant(a), Pbt.constant(b), Pbt.constant(c)) do |x, y, z|
-        tarai(x, y, z)
+    Pbt.assert(worker: :thread, num_runs: 100) do
+      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
+        task(x, y, z)
       end
     end
   end
 
   x.report("none") do
-    Pbt.assert(worker: :none) do
-      Pbt.property(Pbt.constant(a), Pbt.constant(b), Pbt.constant(c)) do |x, y, z|
-        tarai(x, y, z)
+    Pbt.assert(worker: :none, num_runs: 100) do
+      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
+        task(x, y, z)
       end
     end
   end

data/benchmark/success_io_bound.rb

@@ -3,7 +3,7 @@ require "benchmark/ips"
 
 # Read file generated by https://www.lipsum.com/
 # 150 paragraphs, 13689 words, 92206 bytes.
-def read_file(str)
+def task(str)
   File.read(File.join(__dir__, "example.txt")) + str
 end
 
@@ -11,33 +11,33 @@ seed = 17243810592888013452170775373100387856
 
 Benchmark.ips do |x|
   x.report("ractor") do
-    Pbt.assert(worker: :ractor, seed:) do
+    Pbt.assert(worker: :ractor, seed:, num_runs: 100) do
       Pbt.property(Pbt.ascii_string) do |str|
-        read_file(str)
+        task(str)
       end
     end
   end
 
   x.report("process") do
-    Pbt.assert(worker: :process, seed:) do
+    Pbt.assert(worker: :process, seed:, num_runs: 100) do
       Pbt.property(Pbt.ascii_string) do |str|
-        read_file(str)
+        task(str)
       end
     end
   end
 
   x.report("thread") do
-    Pbt.assert(worker: :thread, seed:) do
+    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
       Pbt.property(Pbt.ascii_string) do |str|
-        read_file(str)
+        task(str)
       end
     end
   end
 
   x.report("none") do
-    Pbt.assert(worker: :none, seed:) do
+    Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.ascii_string) do |str|
-        read_file(str)
+        task(str)
       end
     end
   end

data/benchmark/success_simple.rb

@@ -3,35 +3,37 @@ require "benchmark/ips"
 
 seed = 17243810592888013452170775373100387856
 
+def task(x) = x + 1
+
 Benchmark.ips do |x|
   x.report("ractor") do
-    Pbt.assert(worker: :ractor, seed:) do
+    Pbt.assert(worker: :ractor, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        x + 1
+        task(x)
       end
     end
   end
 
   x.report("process") do
-    Pbt.assert(worker: :process, seed:) do
+    Pbt.assert(worker: :process, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        x + 1
+        task(x)
       end
     end
   end
 
   x.report("thread") do
-    Pbt.assert(worker: :thread, seed:) do
+    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        x + 1
+        task(x)
       end
     end
   end
 
   x.report("none") do
-    Pbt.assert(worker: :none, seed:) do
+    Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|
-        x + 1
+        task(x)
       end
     end
   end

data/lib/pbt/check/rspec_adapter/property_extension.rb

@@ -29,12 +29,14 @@ module Pbt
         # @param val [Object]
         # @return [Ractor]
         def run_in_ractor(val)
-          Ractor.new(@class_name, @method_name, val) do |class_name, method_name, val|
+          Ractor.new(@class_name, @method_name, @predicate.parameters.size, val) do |class_name, method_name, param_size, val|
             klass = RSpecAdapter.const_get(class_name)
             if val.is_a?(Hash)
               klass.new.send(method_name, **val)
-            else
+            elsif param_size >= 2
               klass.new.send(method_name, *val)
+            else
+              klass.new.send(method_name, val)
             end
           end
         end

data/lib/pbt/check/runner_methods.rb

@@ -114,7 +114,8 @@ module Pbt
           begin
             property.run(val)
             runner.handle_result(c)
-          rescue => e
+          # Catch all exceptions including RSpec's ExpectationNotMet (It inherits Exception).
+          rescue Exception => e # standard:disable Lint/RescueException:
             c.exception = e
             runner.handle_result(c)
             break # Ignore the rest of the cases. Just pick up the first failure.
@@ -162,7 +163,8 @@ module Pbt
         Parallel.map_with_index(runner, in_threads: Parallel.processor_count) do |val, index|
           Case.new(val:, index:).tap do |c|
             property.run(val)
-          rescue => e
+          # Catch all exceptions including RSpec's ExpectationNotMet (It inherits Exception).
+          rescue Exception => e # standard:disable Lint/RescueException:
             c.exception = e
             # It's possible to break this loop here by raising `Parallel::Break`.
             # But if it raises, we cannot fetch all cases' result. So this loop continues until the end.
@@ -183,7 +185,8 @@ module Pbt
         Parallel.map_with_index(runner, in_processes: Parallel.processor_count) do |val, index|
           Case.new(val:, index:).tap do |c|
             property.run(val)
-          rescue => e
+          # Catch all exceptions including RSpec's ExpectationNotMet (It inherits Exception).
+          rescue Exception => e # standard:disable Lint/RescueException:
             c.exception = e
             # It's possible to break this loop here by raising `Parallel::Break`.
             # But if it raises, we cannot fetch all cases' result. So this loop continues until the end.

data/lib/pbt/reporter/run_details_reporter.rb

@@ -20,8 +20,6 @@ module Pbt
           message << error_backtrace
           message << if @run_details.verbose
             verbose_details
-          else
-            hint
           end
 
           raise PropertyFailure, message.join("\n") if message.size > 0
@@ -34,17 +32,17 @@ module Pbt
       def format_error_message
         <<~MSG.chomp
           Property failed after #{@run_details.num_runs} test(s)
-          { seed: #{@run_details.seed} }
-          Counterexample: #{@run_details.counterexample}
-          Shrunk #{@run_details.num_shrinks} time(s)
-          Got #{@run_details.error_instance.class}: #{@run_details.error_message}
+            seed: #{@run_details.seed}
+            counterexample: #{@run_details.counterexample}
+            Shrunk #{@run_details.num_shrinks} time(s)
+            Got #{@run_details.error_instance.class}: #{@run_details.error_message}
         MSG
       end
 
       def error_backtrace
         return "" if @run_details.error_instance.backtrace_locations.nil? # It can be nil.
 
-        i = @run_details.verbose ? -1 : 10
+        i = @run_details.verbose ? -1 : 3
         "    #{@run_details.error_instance.backtrace_locations[..i].join("\n    ")}"
       end
 
@@ -89,14 +87,6 @@ module Pbt
 
         "\nExecution summary:\n#{summary_lines.join("\n")}\n"
       end
-
-      # @return [String]
-      def hint
-        [
-          "\nHint: Set `verbose: true` in order to check the list of all failing values encountered during the run.",
-          "Hint: Set `seed: #{@run_details.seed}` in order to reproduce the failed test case with the same values."
-        ].join("\n")
-      end
     end
   end
 end

data/lib/pbt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pbt
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ohbarye
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-21 00:00:00.000000000 Z
+date: 2024-05-06 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Property-Based Testing tool for Ruby, utilizing Ractor for parallelizing