minitest-proptest 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e01d66af6e62a9d5931cd1da501b08679e8f78a4aa625aa694c28029ae5228a9
-  data.tar.gz: 3d99ae675bbeac0c89c807a535c7400fc0806a223a68c0d1a50eb2cb2917c148
+  metadata.gz: d2f1cde4cf0a022319a3336a06e5509275ea420b5b36d39835f938c6ef830fae
+  data.tar.gz: 50a1ce6ade048840831ad943840c914cda998da1e6f7b98c07d02b7ee859d2db
 SHA512:
-  metadata.gz: 2a4abe803c73e8e254dfa2022e5bcbb84f3bdf6c1e502f7fa34d3d95c06dad05f44be371a935907135f8bb7f67cd1240b24835c7cf233e1fd85f52608ed53ac8
-  data.tar.gz: dd81efa85c34580d0d29cfbf21ab5042f0af14f493b7041712a61fd491638c5a6e02d79e758a459a03671110bf057474f9fae34c96c96607e8c0f1e7853c2e31
+  metadata.gz: 6af2348e841f27a7401a64cc777dde8aad6a1487289cea278ecb6ec2771602143bce354dad192c55d2c57c4aa828ed6a34842d048a1dcb41d45d09fcc5e9e96a
+  data.tar.gz: 8919b2d754966201a1f489c0b6594128e36fcf3301774cbabb0f67848b363d2702143829301042e0c8344dc0950c62995f2bf10147d94e4bbedc1e5f853cf063

data/lib/minitest/proptest/gen/value_generator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Proptest
+    class Gen
+      # Methods for value generation
+      class ValueGenerator
+        attr_accessor :entropy
+        attr_writer :type_parameters
+
+        def self.with_shrink_function(&f)
+          define_method(:shrink_function, &f)
+          self
+        end
+
+        def self.with_score_function(&f)
+          define_method(:score_function, &f)
+          self
+        end
+
+        def self.with_append(bound_min, bound_max, &f)
+          define_singleton_method(:bound_max) { bound_max }
+          define_singleton_method(:bound_min) { bound_min }
+          define_method(:append) do |other|
+            @value = f.call(value, other.value)
+            self
+          end
+          self
+        end
+
+        def self.with_empty(&f)
+          define_singleton_method(:empty) do |gen|
+            temp = new(gen)
+            temp.instance_variable_set(:@value, f.call)
+            temp
+          end
+          self
+        end
+
+        def self.bound_max
+          1
+        end
+
+        def self.bound_min
+          0
+        end
+
+        # append is not expected to be called unless overridden
+        def append(_other)
+          self
+        end
+
+        def self.empty(gen)
+          self.new(gen)
+        end
+
+        def force(v)
+          temp = self.class.new(ArgumentError)
+          temp.instance_variable_set(:@value, v)
+          temp.type_parameters = @type_parameters
+          temp
+        end
+
+        def generate_value
+          gen = @generated.reduce(@generator) do |g, val|
+            g.call(val)
+            g
+          end
+
+          while gen.is_a?(Proc) || gen.is_a?(Method)
+            gen = gen.call(*@type_parameters.map(&:value))
+            gen = gen.value if gen.is_a?(ValueGenerator)
+          end
+
+          gen
+        end
+
+        def value
+          return false if @value == false
+
+          @value ||= generate_value
+        end
+
+        def prefix_entropy_generation(vals)
+          @generated = vals + @generated
+        end
+
+        def score
+          value
+          fs = @type_parameters.map { |x| x.method(:score_function) }
+          score_function(*fs, value)
+        end
+
+        def score_function(v)
+          v.to_i.abs
+        end
+
+        def shrink_candidates
+          fs = @type_parameters.map { |x| x.method(:shrink_function) }
+          os = score
+          candidates = shrink_function(*fs, value)
+          candidates
+            .map    { |c| [force(c).score, c] }
+            .reject { |(s, _)| s > os }
+            .sort   { |x, y| x.first <=> y.first }
+            .uniq
+        end
+
+        def shrink_function(x)
+          [x.itself]
+        end
+
+        def shrink_parameter(x)
+          @shrink_parameter.call(x)
+        end
+
+        # Generator helpers
+
+        def sized(n)
+          entropy.call(n + 1)
+        end
+
+        def one_of(r)
+          r.to_a[sized(r.to_a.length - 1)]
+        end
+      end
+    end
+  end
+end

data/lib/minitest/proptest/gen.rb

@@ -1,128 +1,12 @@
+# frozen_string_literal: true
+
+require 'minitest/proptest/gen/value_generator'
+
 module Minitest
   module Proptest
+    # Generic value generation and shrinking implementations, and
+    # support for built-in types.
     class Gen
-      class ValueGenerator
-        attr_accessor :entropy
-        attr_writer :type_parameters
-
-        def self.with_shrink_function(&f)
-          define_method(:shrink_function, &f)
-          self
-        end
-
-        def self.with_score_function(&f)
-          define_method(:score_function, &f)
-          self
-        end
-
-        def self.with_append(bound_min, bound_max, &f)
-          define_singleton_method(:bound_max) { bound_max }
-          define_singleton_method(:bound_min) { bound_min }
-          define_method(:append) do |other|
-            @value = f.call(value, other.value)
-            self
-          end
-          self
-        end
-
-        def self.with_empty(&f)
-          define_singleton_method(:empty) do |gen|
-            temp = new(gen)
-            temp.instance_variable_set(:@value, f.call)
-            temp
-          end
-          self
-        end
-
-        def self.bound_max
-          1
-        end
-
-        def self.bound_min
-          0
-        end
-
-        # append is not expected to be called unless overridden
-        def append(other)
-          self
-        end
-
-        def self.empty(gen)
-          self.new(gen)
-        end
-
-        def force(v)
-          temp = self.class.new(ArgumentError)
-          temp.instance_variable_set(:@value, v)
-          temp.type_parameters = @type_parameters
-          temp
-        end
-
-        def generate_value
-          gen = @generated.reduce(@generator) do |gen, val|
-            gen.call(val)
-            gen
-          end
-
-          while gen.is_a?(Proc) || gen.is_a?(Method)
-            gen = gen.call(*@type_parameters.map(&:value))
-            if gen.is_a?(ValueGenerator)
-              gen = gen.value
-            end
-          end
-
-          gen
-        end
-
-        def value
-          return false if @value == false
-          @value ||= generate_value
-        end
-
-        def prefix_entropy_generation(vals)
-          @generated = vals + @generated
-        end
-
-        def score
-          value
-          fs = @type_parameters.map { |x| x.method(:score_function) }
-          score_function(*fs, value)
-        end
-
-        def score_function(v)
-          v.to_i.abs
-        end
-
-        def shrink_candidates
-          fs = @type_parameters.map { |x| x.method(:shrink_function) }
-          os = score
-          candidates = shrink_function(*fs, value)
-          candidates
-            .map    { |c| [force(c).score, c] }
-            .reject { |(s, _)| s > os }
-            .sort   { |x, y| x.first <=> y.first }
-            .uniq
-        end
-
-        def shrink_function(x)
-          [x.itself]
-        end
-
-        def shrink_parameter(x)
-          @shrink_parameter.call(x)
-        end
-
-        # Generator helpers
-
-        def sized(n)
-          entropy.call(n + 1)
-        end
-
-        def one_of(r)
-          r.to_a[sized(r.to_a.length - 1)]
-        end
-      end
-
       class Int8 < Integer; end
       class Int16 < Integer; end
       class Int32 < Integer; end
@@ -146,7 +30,7 @@ module Minitest
       instance_variable_set(:@_generators, {})
 
       def self.create_type_constructor(arity, classes)
-        constructor = ->(c1) do
+        constructor = ->(_c1) do
           if classes.length == arity
             f.call(*classes)
           else
@@ -168,8 +52,8 @@ module Minitest
 
         new_class.define_method(:generator, &f)
 
-        instance_variable_get(:@_generators)[klass] = new_class #.method(:new)
-        self.const_set((klass.name + 'Gen').split('::').last, new_class)
+        instance_variable_get(:@_generators)[klass] = new_class
+        self.const_set("#{klass.name}Gen".split('::').last, new_class)
         new_class
       end
 
@@ -197,11 +81,11 @@ module Minitest
           end
         else
           classgen = ->() do
-            classes[1..-1].map do |c|
-              if c.is_a?(Array)
-                self.for(*c)
+            classes[1..].map do |k|
+              if k.is_a?(Array)
+                self.for(*k)
               else
-                self.for(c)
+                self.for(k)
               end
             end
           end
@@ -268,7 +152,7 @@ module Minitest
         elsif xs2.empty?
           [[]]
         else
-          [xs2] + list_remove.call(k, (n-k), xs2).map { |ys| xs1 + ys }
+          [xs2] + list_remove.call(k, (n - k), xs2).map { |ys| xs1 + ys }
         end
       end
 
@@ -308,11 +192,11 @@ module Minitest
         else
           h1 = xs1.reduce({}) { |c, e| c.merge({ e => h[e] }) }
           h2 = xs2.reduce({}) { |c, e| c.merge({ e => h[e] }) }
-          [h1, h2] + list_remove.call(k, (n-k), h2).map { |ys| h1.merge(ys.to_h) }
+          [h1, h2] + list_remove.call(k, (n - k), h2).map { |ys| h1.merge(ys.to_h) }
         end
       end
 
-      hash_shrink = ->(fk, fv, h) do
+      hash_shrink = ->(_fk, _fv, h) do
         candidates = []
         n          = h.length
         k          = n
@@ -333,40 +217,40 @@ module Minitest
           -(((r & (MAX_SIZE ^ SIGN_BIT)) - 1) ^ (MAX_SIZE ^ SIGN_BIT))
         end
       end.with_shrink_function do |i|
-        i = if (i & SIGN_BIT).zero?
+        j = if (i & SIGN_BIT).zero?
               i
             else
               -(((i & (MAX_SIZE ^ SIGN_BIT)) - 1) ^ (MAX_SIZE ^ SIGN_BIT))
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(Int8) do
         r = sized(0xff)
         (r & 0x80).zero? ? r : -(((r & 0x7f) - 1) ^ 0x7f)
       end.with_shrink_function do |i|
-        i = (i & 0x80).zero? ? i : -(((i & 0x7f) - 1) ^ 0x7f)
-        integral_shrink.call(i)
+        j = (i & 0x80).zero? ? i : -(((i & 0x7f) - 1) ^ 0x7f)
+        integral_shrink.call(j)
       end
 
       generator_for(Int16) do
         r = sized(0xffff)
         (r & 0x8000).zero? ? r : -(((r & 0x7fff) - 1) ^ 0x7fff)
       end.with_shrink_function do |i|
-        i = (i & 0x8000).zero? ? i : -(((i & 0x7fff) - 1) ^ 0x7fff)
-        integral_shrink.call(i)
+        j = (i & 0x8000).zero? ? i : -(((i & 0x7fff) - 1) ^ 0x7fff)
+        integral_shrink.call(j)
       end
 
       generator_for(Int32) do
         r = sized(0xffffffff)
         (r & 0x80000000).zero? ? r : -(((r & 0x7fffffff) - 1) ^ 0x7fffffff)
       end.with_shrink_function do |i|
-        i = if (i & 0x80000000).zero?
+        j = if (i & 0x80000000).zero?
               i
             else
               -(((i & 0x7fffffff) - 1) ^ 0x7fffffff)
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(Int64) do
@@ -377,12 +261,12 @@ module Minitest
           -(((r & 0x7fffffffffffffff) - 1) ^ 0x7fffffffffffffff)
         end
       end.with_shrink_function do |i|
-        i = if (i & 0x8000000000000000).zero?
+        j = if (i & 0x8000000000000000).zero?
               i
             else
               -(((i & 0x7fffffffffffffff) - 1) ^ 0x7fffffffffffffff)
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(UInt8) do
@@ -416,8 +300,7 @@ module Minitest
         (0..3)
           .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
           .join
-          .unpack('f')
-          .first
+          .unpack1('f')
       end.with_shrink_function do |f|
         float_shrink.call(f)
       end.with_score_function do |f|
@@ -433,8 +316,7 @@ module Minitest
         (0..7)
           .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
           .join
-          .unpack('d')
-          .first
+          .unpack1('d')
       end.with_shrink_function do |f|
         float_shrink.call(f)
       end.with_score_function do |f|
@@ -450,8 +332,7 @@ module Minitest
         (0..7)
           .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
           .join
-          .unpack('d')
-          .first
+          .unpack1('d')
       end.with_shrink_function do |f|
         float_shrink.call(f)
       end.with_score_function do |f|
@@ -466,17 +347,13 @@ module Minitest
         sized(0x7f).chr
       end.with_shrink_function do |c|
         integral_shrink.call(c.ord).reject(&:negative?).map(&:chr)
-      end.with_score_function do |c|
-        c.ord
-      end
+      end.with_score_function(&:ord)
 
       generator_for(Char) do
         sized(0xff).chr
       end.with_shrink_function do |c|
         integral_shrink.call(c.ord).reject(&:negative?).map(&:chr)
-      end.with_score_function do |c|
-        c.ord
-      end
+      end.with_score_function(&:ord)
 
       generator_for(String) do
         sized(0xff).chr
@@ -490,7 +367,7 @@ module Minitest
         end
       end.with_append(0, 0x20) do |x, y|
         x + y
-      end.with_empty { "" }
+      end.with_empty { '' }
 
       generator_for(Array) do |x|
         [x]
@@ -513,10 +390,10 @@ module Minitest
         end
       end.with_append(0, 0x10) do |xm, ym|
         xm.merge(ym)
-      end.with_empty { Hash.new }
+      end.with_empty { {} }
 
       generator_for(Bool) do
-        sized(0x1).even? ? false : true
+        sized(0x1).odd?
       end.with_score_function do |_|
         1
       end

data/lib/minitest/proptest/property.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Minitest
   module Proptest
+    # Property evaluation - status, scoring, shrinking
     class Property
-
       attr_reader :result, :status, :trivial
+
       def initialize(
         # The function which proves the property
         test_proc,
@@ -19,7 +22,10 @@ module Minitest
         max_size: 0x100,
         # Maximum number of shrink attempts (default of half of max unsigned int
         # on the system architecture adopted from QuickCheck
-        max_shrinks: 0x7fffffffffffffff
+        max_shrinks: 0x7fffffffffffffff,
+        # Previously discovered counter-example.  If this exists, it should be
+        # run before any test cases are generated.
+        previous_failure: []
       )
         @test_proc         = test_proc
         @random            = random.call
@@ -36,9 +42,11 @@ module Minitest
         @valid_test_cases  = 0
         @generated         = []
         @arbitrary         = nil
+        @previous_failure  = previous_failure.to_a
       end
 
       def run!
+        rerun!
         iterate!
         shrink!
       end
@@ -56,31 +64,31 @@ module Minitest
 
       def explain
         prop = if @status.valid?
-                 "The property was proved to satsfaction across " +
+                 'The property was proved to satsfaction across ' \
                    "#{@valid_test_cases} assertions."
                elsif @status.invalid?
-                 "The property was determined to be invalid due to " +
-                   "#{@exception.class.name}: #{@exception.message}\n" +
-                   @exception.backtrace.map { |l| "    #{l}" }.join("\n")
+                 'The property was determined to be invalid due to ' \
+                   "#{@exception.class.name}: #{@exception.message}\n" \
+                   "#{@exception.backtrace.map { |l| "    #{l}" }.join("\n")}"
                elsif @status.overrun?
-                 "The property attempted to generate more than #{@max_size} " +
-                   "bytes of entropy, violating the property's maximum size." +
-                   "This might be rectified by increasing max_size."
+                 "The property attempted to generate more than #{@max_size} " \
+                   "bytes of entropy, violating the property's maximum " \
+                   'size.  This might be rectified by increasing max_size.'
                elsif @status.unknown?
-                 "The property has not yet been tested."
+                 'The property has not yet been tested.'
                elsif @status.interesting?
-                 "The property has found the following counterexample after " +
-                   "#{@valid_test_cases} valid " +
-                   "example#{@valid_test_cases == 1 ? '' : 's'}:\n" +
-                   @generated.map(&:value).inspect
+                 'The property has found the following counterexample after ' \
+                   "#{@valid_test_cases} valid " \
+                   "example#{@valid_test_cases == 1 ? '' : 's'}:\n" \
+                   "#{@generated.map(&:value).inspect}"
                end
         trivial = if @trivial
-                    "\nThe test does not appear to use any generated values " +
-                      "and as such is likely not generating much value.  " +
-                      "Consider reworking this test to make use of arbitrary " +
-                      "data."
+                    "\nThe test does not appear to use any generated values " \
+                      'and as such is likely not generating much value.  ' \
+                      'Consider reworking this test to make use of arbitrary ' \
+                      'data.'
                   else
-                    ""
+                    ''
                   end
         prop + trivial
       end
@@ -104,11 +112,43 @@ module Minitest
       rescue => e
         @status = Status.invalid
         @exception = e
-        raise e
+      end
+
+      def rerun!
+        return if @previous_failure.empty?
+
+        old_generator  = @generator
+        old_random     = @random
+        old_arbitrary  = @arbitrary
+
+        index = -1
+        @arbitrary = ->(*classes) do
+          index += 1
+          raise IndexError if index >= @previous_failure.length
+
+          a = @generator.for(*classes)
+          a = a.force(@previous_failure[index])
+          @generated << a
+          @previous_failure[index]
+        end
+
+        @generator = ::Minitest::Proptest::Gen.new(@random)
+        if instance_eval(&@test_proc)
+          @generated = []
+        else
+          @result = @generated
+          @status = Status.interesting
+        end
+
+        # Clean up after we're done
+        @generator = old_generator
+        @random    = old_random
+        @arbitrary = old_arbitrary
       end
 
       def shrink!
         return if @result.nil?
+
         old_random     = @random
         old_generator  = @generator
         best_score     = @generated.map(&:score).reduce(&:+)
@@ -117,10 +157,10 @@ module Minitest
         old_arbitrary  = @arbitrary
 
         to_test = candidates
-          .map    { |x| x.map { |y| [y] } }
-          .reduce { |c, e| c.flat_map { |a| e.map { |b| a + b } } }
-          .sort   { |x, y| x.map(&:first).reduce(&:+) <=> y.map(&:first).reduce(&:+) }
-          .uniq
+                  .map    { |x| x.map { |y| [y] } }
+                  .reduce { |c, e| c.flat_map { |a| e.map { |b| a + b } } }
+                  .sort   { |x, y| x.map(&:first).reduce(&:+) <=> y.map(&:first).reduce(&:+) }
+                  .uniq
         run = { run: 0, index: -1 }
 
         @arbitrary = ->(*classes) do
@@ -141,8 +181,8 @@ module Minitest
           if to_test[run[:run]].map(&:first).reduce(&:+) < best_score
             unless instance_eval(&@test_proc)
               best_generated = @generated
-              # Because we pre-sorted our shrink candidates, the first hit is
-              # necessarily the best scoring
+              # The first hit is guaranteed to be the best scoring due to the
+              # shrink candidates are pre-sorted.
               break
             end
           end
@@ -169,7 +209,7 @@ module Minitest
       def continue_shrink?
         !@trivial &&
           !@status.invalid? &&
-          !@status.overrun?
+          !@status.overrun? &&
           @calls < @max_shrinks
       end
     end

data/lib/minitest/proptest/status.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minitest
   module Proptest
     # Sum type representing the possible statuses of a test run.

data/lib/minitest/proptest/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Proptest
-    VERSION = '0.0.2'
+    VERSION = '0.1.0'
   end
 end

data/lib/minitest/proptest.rb

@@ -1,20 +1,150 @@
+# frozen_string_literal: true
+
 require 'minitest'
 require 'minitest/proptest/gen'
 require 'minitest/proptest/property'
 require 'minitest/proptest/status'
 require 'minitest/proptest/version'
+require 'yaml'
 
 module Minitest
+  class ResultsDatabase < Minitest::AbstractReporter
+    def initialize(pathname)
+      super()
+
+      results = if File.file?(pathname)
+                  YAML.load_file(pathname)
+                else
+                  {}
+                end
+      self.class.instance_variable_set(:@_results, results) unless self.class.instance_variable_defined?(:@_results)
+    end
+
+    def report
+      return unless Proptest.use_db?
+
+      File.write(Proptest.result_db, self.class.instance_variable_get(:@_results).to_yaml)
+    end
+
+    def lookup(file, classname, methodname)
+      self.class.instance_variable_get(:@_results)
+          .dig(file, classname, methodname)
+          .to_a
+    end
+
+    def record_failure(file, classname, methodname, generated)
+      return unless Proptest.use_db?
+
+      results = self.class.instance_variable_get(:@_results)
+      results[file] ||= {}
+      results[file][classname] ||= {}
+      results[file][classname][methodname] = generated
+    end
+
+    def strike_failure(file, classname, methodname)
+      return unless Proptest.use_db?
+
+      results = self.class.instance_variable_get(:@_results)
+      return unless results.key?(file)
+
+      return unless results[file].key?(classname)
+
+      results[file][classname].delete(methodname)
+      results[file].delete(classname) if results[file][classname].empty?
+      results.delete(file) if results[file].empty?
+    end
+  end
+
   module Proptest
     DEFAULT_RANDOM = Random.method(:new)
     DEFAULT_MAX_SUCCESS = 100
     DEFAULT_MAX_DISCARD_RATIO = 10
     DEFAULT_MAX_SIZE = 0x100
     DEFAULT_MAX_SHRINKS = (((1 << (1.size * 8)) - 1) / 2)
+    DEFAULT_DB_LOCATION = File.join(Dir.pwd, '.proptest_failures.yml')
+
+    self.instance_variable_set(:@_random, DEFAULT_RANDOM)
+    self.instance_variable_set(:@_max_success, DEFAULT_MAX_SUCCESS)
+    self.instance_variable_set(:@_max_discard_ratio, DEFAULT_MAX_DISCARD_RATIO)
+    self.instance_variable_set(:@_max_size, DEFAULT_MAX_SIZE)
+    self.instance_variable_set(:@_max_shrinks, DEFAULT_MAX_SHRINKS)
+    self.instance_variable_set(:@_result_db, DEFAULT_DB_LOCATION)
+    self.instance_variable_set(:@_use_db, false)
 
     def self.set_seed(seed)
       self.instance_variable_set(:@_random_seed, seed)
     end
+
+    def self.max_success=(success)
+      self.instance_variable_set(:@_max_success, success)
+    end
+
+    def self.max_discard_ratio=(discards)
+      self.instance_variable_set(:@_max_discard_ratio, discards)
+    end
+
+    def self.max_size=(size)
+      self.instance_variable_set(:@_max_size, size)
+    end
+
+    def self.max_shrinks=(shrinks)
+      self.instance_variable_set(:@_max_shrinks, shrinks)
+    end
+
+    def self.result_db=(location)
+      self.instance_variable_set(:@_result_db, File.expand_path(location))
+    end
+
+    def self.use_db!(use = true)
+      self.instance_variable_set(:@_use_db, use)
+    end
+
+    def self.seed
+      self.instance_variable_get(:@_random_seed)
+    end
+
+    def self.max_success
+      self.instance_variable_get(:@_max_success)
+    end
+
+    def self.max_discard_ratio
+      self.instance_variable_get(:@_max_discard_ratio)
+    end
+
+    def self.max_size
+      self.instance_variable_get(:@_max_size)
+    end
+
+    def self.max_shrinks
+      self.instance_variable_get(:@_max_shrinks)
+    end
+
+    def self.result_db
+      self.instance_variable_get(:@_result_db)
+    end
+
+    def self.use_db?
+      self.instance_variable_get(:@_use_db)
+    end
+
+    def self.record_failure(file, classname, methodname, generated)
+      self.instance_variable_get(:@_results)
+          .record_failure(file, classname, methodname, generated)
+    end
+
+    def self.strike_failure(file, classname, methodname)
+      self.instance_variable_get(:@_results)
+          .strike_failure(file, classname, methodname)
+    end
+
+    def self.reporter
+      return self.instance_variable_get(:@_results) if self.instance_variable_defined?(:@_results)
+
+      reporter = Minitest::ResultsDatabase.new(result_db)
+      self.instance_variable_set(:@_results, reporter)
+
+      reporter
+    end
   end
 end
 

data/lib/minitest/proptest_plugin.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'minitest'
 require 'minitest/proptest'
 require 'minitest/proptest/gen'
 require 'minitest/proptest/property'
 require 'minitest/proptest/status'
 require 'minitest/proptest/version'
+require 'yaml'
 
 module Minitest
   def self.plugin_proptest_init(options)
@@ -18,8 +21,30 @@ module Minitest
       end
     end
 
-    if options.has_key?(:seed)
-      Proptest.set_seed(options[:seed])
+    self.reporter << Proptest.reporter
+
+    Proptest.set_seed(options[:seed]) if options.key?(:seed)
+  end
+
+  def self.plugin_proptest_options(opts, _options)
+    opts.on('--max-success', Integer, "Maximum number of successful cases to verify for each property (Default: #{Minitest::Proptest::DEFAULT_MAX_SUCCESS})") do |max_success|
+      Proptest.max_success = max_success
+    end
+    opts.on('--max-discard-ratio', Integer, "Maximum ratio of successful cases versus discarded cases per property (Default: #{Minitest::Proptest::DEFAULT_MAX_DISCARD_RATIO}:1)") do |max_success|
+      Proptest.max_success = max_success
+    end
+    opts.on('--max-size', Integer, "Maximum amount of entropy a single case may use in bytes (Default: #{Minitest::Proptest::DEFAULT_MAX_SIZE} bytes)") do |max_size|
+      Proptest.max_size = max_size
+    end
+    opts.on('--max-shrinks', Integer, "Maximum number of shrink iterations a single failure reduction may use (Default: #{Minitest::Proptest::DEFAULT_MAX_SHRINKS})") do |max_shrinks|
+      Proptest.max_shrinks = max_shrinks
+    end
+    opts.on('--results-db', String, "Location of the file to persist most recent failure cases.  Implies --use-db.  (Default: #{Minitest::Proptest::DEFAULT_DB_LOCATION})") do |db_path|
+      Proptest.result_db = db_path
+      Proptest.use_db!
+    end
+    opts.on('--use-db', 'Persist previous failures in a database and use them before generating new values.  Helps prevent flaky builds.  (Default: false)') do
+      Proptest.use_db!
     end
   end
 
@@ -34,17 +59,26 @@ module Minitest
                        Proptest::DEFAULT_RANDOM
                      end
 
+      file, methodname = caller.first.split(/:\d+:in +/)
+      classname = self.class.name
+      methodname.gsub!(/(?:^`|'$)/, '')
+
       prop = Minitest::Proptest::Property.new(
         f,
         random: random_thunk,
-        max_success: Proptest::DEFAULT_MAX_SUCCESS,
-        max_discard_ratio: Proptest::DEFAULT_MAX_DISCARD_RATIO,
-        max_size: Proptest::DEFAULT_MAX_SIZE,
-        max_shrinks: Proptest::DEFAULT_MAX_SHRINKS
+        max_success: Proptest.max_success,
+        max_discard_ratio: Proptest.max_discard_ratio,
+        max_size: Proptest.max_size,
+        max_shrinks: Proptest.max_shrinks,
+        previous_failure: Proptest.reporter.lookup(file, classname, methodname)
       )
       prop.run!
 
-      unless prop.status.valid? && !prop.trivial
+      if prop.status.valid? && !prop.trivial
+        Proptest.strike_failure(file, classname, methodname)
+      else
+        Proptest.record_failure(file, classname, methodname, prop.result.map(&:value))
+
         raise Minitest::Assertion, prop.explain
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-proptest
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Tina Wuest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2024-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -33,6 +33,7 @@ extra_rdoc_files: []
 files:
 - lib/minitest/proptest.rb
 - lib/minitest/proptest/gen.rb
+- lib/minitest/proptest/gen/value_generator.rb
 - lib/minitest/proptest/property.rb
 - lib/minitest/proptest/status.rb
 - lib/minitest/proptest/version.rb
@@ -44,6 +45,7 @@ metadata:
   homepage_uri: https://github.com/wuest/minitest-proptest
   source_code_uri: https://github.com/wuest/minitest-proptest
   changelog_uri: https://github.com/wuest/minitest-proptest/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -59,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Property testing in Minitest