prop_check 0.6.0

data/lib/prop_check/property.rb

@@ -0,0 +1,207 @@
+require 'stringio'
+
+require 'prop_check/property/configuration'
+require 'prop_check/property/check_evaluator'
+module PropCheck
+  class Property
+
+    def self.forall(**bindings, &block)
+
+      property = new(bindings)
+
+      return property.check(&block) if block_given?
+
+      property
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+
+    attr_reader :bindings, :condition
+
+    def initialize(**bindings)
+      raise ArgumentError, 'No bindings specified!' if bindings.empty?
+
+      @bindings = bindings
+      @condition = -> { true }
+      @config = self.class.configuration
+    end
+
+    def configuration
+      @config
+    end
+
+    def with_config(**config, &block)
+      @config = @config.merge(config)
+
+      return self.check(&block) if block_given?
+
+      self
+    end
+
+    def where(&new_condition)
+      original_condition = @condition.dup
+      @condition = -> { instance_exec(&original_condition) && instance_exec(&new_condition) }
+
+      self
+    end
+
+    def check(&block)
+      binding_generator = PropCheck::Generators.fixed_hash(bindings)
+
+      n_runs = 0
+      n_successful = 0
+
+      # Loop stops at first exception
+      attempts_enumerator(binding_generator).each do |generator_result|
+        n_runs += 1
+        check_attempt(generator_result, n_successful, &block)
+        n_successful += 1
+      end
+
+      ensure_not_exhausted!(n_runs)
+    end
+
+    private def ensure_not_exhausted!(n_runs)
+      return if n_runs >= @config.n_runs
+
+      raise GeneratorExhaustedError, """
+        Could not perform `n_runs = #{@config.n_runs}` runs,
+        (exhausted #{@config.max_generate_attempts} tries)
+        because too few generator results were adhering to
+        the `where` condition.
+
+        Try refining your generators instead.
+        """
+    end
+
+    private def check_attempt(generator_result, n_successful, &block)
+      CheckEvaluator.new(generator_result.root, &block).call
+
+    # immediately stop (without shrinnking) for when the app is asked
+    # to close by outside intervention
+    rescue SignalException, SystemExit
+      raise
+
+    # We want to capture _all_ exceptions (even low-level ones) here,
+    # so we can shrink to find their cause.
+    # don't worry: they all get reraised
+    rescue Exception => e
+      output, shrunken_result, shrunken_exception, n_shrink_steps = show_problem_output(e, generator_result, n_successful, &block)
+      output_string = output.is_a?(StringIO) ? output.string : e.message
+
+      e.define_singleton_method :prop_check_info do
+        {
+          original_input: generator_result.root,
+          original_exception_message: e.message,
+          shrunken_input: shrunken_result,
+          shrunken_exception: shrunken_exception,
+          n_successful: n_successful,
+          n_shrink_steps: n_shrink_steps
+        }
+      end
+
+      raise e, output_string, e.backtrace
+    end
+
+    private def attempts_enumerator(binding_generator)
+
+      rng = Random::DEFAULT
+      n_runs = 0
+      size = 1
+      (0...@config.max_generate_attempts)
+        .lazy
+        .map { binding_generator.generate(size, rng) }
+        .reject { |val| val.root == :"_PropCheck.filter_me" }
+        .select { |val| CheckEvaluator.new(val.root, &@condition).call }
+        .map do |result|
+          n_runs += 1
+          size += 1
+
+          result
+        end
+        .take_while { n_runs <= @config.n_runs }
+    end
+
+    private def show_problem_output(problem, generator_results, n_successful, &block)
+      output = @config.verbose ? STDOUT : StringIO.new
+      output = pre_output(output, n_successful, generator_results.root, problem)
+      shrunken_result, shrunken_exception, n_shrink_steps = shrink2(generator_results, output, &block)
+      output = post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
+
+      [output, shrunken_result, shrunken_exception, n_shrink_steps]
+    end
+
+    private def pre_output(output, n_successful, generated_root, problem)
+      output.puts ""
+      output.puts "(after #{n_successful} successful property test runs)"
+      output.puts "Failed on: "
+      output.puts "`#{print_roots(generated_root)}`"
+      output.puts ""
+      output.puts "Exception message:\n---\n#{problem}"
+      output.puts "---"
+      output.puts ""
+
+      output
+    end
+
+    private def post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
+      output.puts ''
+      output.puts "Shrunken input (after #{n_shrink_steps} shrink steps):"
+      output.puts "`#{print_roots(shrunken_result)}`"
+      output.puts ""
+      output.puts "Shrunken exception:\n---\n#{shrunken_exception}"
+      output.puts "---"
+      output.puts ""
+
+      output
+    end
+
+    private def print_roots(lazy_tree_hash)
+      lazy_tree_hash.map do |name, val|
+        "#{name} = #{val.inspect}"
+      end.join(", ")
+    end
+
+    private def shrink2(bindings_tree, io, &fun)
+      io.puts 'Shrinking...' if @config.verbose
+      problem_child = bindings_tree
+      siblings = problem_child.children.lazy
+      parent_siblings = nil
+      problem_exception = nil
+      shrink_steps = 0
+      (0..@config.max_shrink_steps).each do
+        begin
+          sibling = siblings.next
+        rescue StopIteration
+          break if parent_siblings.nil?
+
+          siblings = parent_siblings.lazy
+          parent_siblings = nil
+          next
+        end
+
+        shrink_steps += 1
+        io.print '.' if @config.verbose
+
+        begin
+          CheckEvaluator.new(sibling.root, &fun).call
+        rescue Exception => problem
+          problem_child = sibling
+          parent_siblings = siblings
+          siblings = problem_child.children.lazy
+          problem_exception = problem
+        end
+      end
+
+      io.puts "(Note: Exceeded #{@config.max_shrink_steps} shrinking steps, the maximum.)" if shrink_steps >= @config.max_shrink_steps
+
+      [problem_child.root, problem_exception, shrink_steps]
+    end
+  end
+end

data/lib/prop_check/property/check_evaluator.rb

@@ -0,0 +1,45 @@
+module PropCheck
+  class Property
+    ##
+    # A wrapper class that implements the 'Cloaker' concept
+    # which allows us to refer to variables set in 'bindings',
+    # while still being able to access things that are only in scope
+    # in the creator of '&block'.
+    #
+    # This allows us to bind the variables specified in `bindings`
+    # one way during checking and another way during shrinking.
+    class CheckEvaluator
+      include RSpec::Matchers if Object.const_defined?('RSpec')
+
+      def initialize(bindings, &block)
+        @caller = block.binding.receiver
+        @block = block
+        define_named_instance_methods(bindings)
+      end
+
+      def call
+        self.instance_exec(&@block)
+      end
+
+      private def define_named_instance_methods(results)
+        results.each do |name, result|
+          define_singleton_method(name) { result }
+        end
+      end
+
+      ##
+      # Dispatches to caller whenever something is not part of `bindings`.
+      # (No need to invoke this method manually)
+      def method_missing(method, *args, &block)
+        @caller.__send__(method, *args, &block) || super
+      end
+
+      ##
+      # Checks respond_to of caller whenever something is not part of `bindings`.
+      # (No need to invoke this method manually)
+      def respond_to_missing?(*args)
+        @caller.respond_to?(*args) || super
+      end
+    end
+  end
+end

data/lib/prop_check/property/configuration.rb

@@ -0,0 +1,14 @@
+module PropCheck
+  class Property
+    Configuration = Struct.new(:verbose, :n_runs, :max_generate_attempts, :max_shrink_steps, keyword_init: true) do
+
+      def initialize(verbose: false, n_runs: 1_000, max_generate_attempts: 10_000, max_shrink_steps: 10_000)
+        super
+      end
+
+      def merge(other)
+        Configuration.new(**self.to_h.merge(other.to_h))
+      end
+    end
+  end
+end

data/lib/prop_check/rspec.rb

@@ -0,0 +1,14 @@
+module PropCheck
+  ##
+  # Integration with RSpec
+  module RSpec
+    # To make it available within examples
+    def self.extend_object(obj)
+      obj.define_method(:forall) do |*args, **kwargs, &block|
+        PropCheck::Property.forall(*args, **kwargs) do
+          instance_exec(self, &block)
+        end
+      end
+    end
+  end
+end

data/lib/prop_check/version.rb

@@ -0,0 +1,3 @@
+module PropCheck
+  VERSION = "0.6.0"
+end

data/prop_check.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "prop_check/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "prop_check"
+  spec.version       = PropCheck::VERSION
+  spec.authors       = ["Qqwy/Wiebe-Marten Wijnja"]
+  spec.email         = ["w-m@wmcode.nl"]
+
+  spec.summary       = %q{PropCheck allows you to do property-based testing , including shrinking. (akin to Haskell's QuickCheck, Erlang's PropEr, Elixir's StreamData)}
+  spec.description   = %q{PropCheck allows you to do property-based testing , including shrinking. (akin to Haskell's QuickCheck, Erlang's PropEr, Elixir's StreamData). This means that your test are run many times with different, autogenerated inputs, and as soon as a failing case is found, this input is simplified, in the end giving you back the simplest input that made the test fail.}
+  spec.homepage      = "https://github.com/Qqwy/ruby-prop_check/"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/Qqwy/ruby-prop_check/"
+    spec.metadata["changelog_uri"] = "https://github.com/Qqwy/ruby-prop_check/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: prop_check
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Qqwy/Wiebe-Marten Wijnja
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: PropCheck allows you to do property-based testing , including shrinking.
+  (akin to Haskell's QuickCheck, Erlang's PropEr, Elixir's StreamData). This means
+  that your test are run many times with different, autogenerated inputs, and as soon
+  as a failing case is found, this input is simplified, in the end giving you back
+  the simplest input that made the test fail.
+email:
+- w-m@wmcode.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/prop_check.rb
+- lib/prop_check/generator.rb
+- lib/prop_check/generators.rb
+- lib/prop_check/helper.rb
+- lib/prop_check/lazy_tree.rb
+- lib/prop_check/property.rb
+- lib/prop_check/property/check_evaluator.rb
+- lib/prop_check/property/configuration.rb
+- lib/prop_check/rspec.rb
+- lib/prop_check/version.rb
+- prop_check.gemspec
+homepage: https://github.com/Qqwy/ruby-prop_check/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Qqwy/ruby-prop_check/
+  source_code_uri: https://github.com/Qqwy/ruby-prop_check/
+  changelog_uri: https://github.com/Qqwy/ruby-prop_check/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: PropCheck allows you to do property-based testing , including shrinking.
+  (akin to Haskell's QuickCheck, Erlang's PropEr, Elixir's StreamData)
+test_files: []