hypothesis-specs 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 748dfd8fb0c05573aecd17da1fb658a3d3add0ae731e16dc8f3f9274cd5db006
-  data.tar.gz: ffd23f44bd8fa7eaca616cc00bc497033d6c9557761c8ffacdc756d3b6bad080
+  metadata.gz: b61a06e5e23722e55967de84342fb6baa43247b7900e0d3e0e45e02c5efa71ab
+  data.tar.gz: 509ee84bbbb29624d1c94b696e3b60cdcf0a458c94f6f0a5463cadfaef514261
 SHA512:
-  metadata.gz: a1e26c552c6baaf4fcf3fa1ef3784ad911c5a06c1582b3153daf09b6f618900656ac08f2377c9fba834e5a1ecd2a2ae90d6f33a542b457fb23db30760265b058
-  data.tar.gz: 2fd4b38d077f32f978010612c72a613b4692f6299b4d5b66885afffe6b22180a4f834d5769f456b29f00a7eb3dc2b31246cae7a7410e2532d183aa61c5651b02
+  metadata.gz: 91b0c4bd91e31ef524b27f0b85137caec78978216c684cbf3b92aa9ebe788d598b98e8362e3960c52563e31ffd005279539349606ad4c7bb689ae7d1cf972e71
+  data.tar.gz: 958a99a260e866c32eaa8faa9e1d57aa4c479a02dfd7e4f966f2b3d790e473beacf93d9127164ee20fc8edcecb8b32ff5675efeec5b1edf0053d9254958b21e1

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# Hypothesis for Ruby 0.5.0 (2021-01-25)
+
+Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. [hypothesis-python](https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful. While `hypothesis-ruby` does not have the concept of other "Phases" yet, we can still start off the API by using this concept.
+
+Usage:
+
+```
+hypothesis(phases: Phase.excluding(:shrink)) do
+  # Failures here will be displayed directly and shrinking will be avoided
+end
+```
+
 # Hypothesis for Ruby 0.4.0 (2021-01-12)
 
 This removes hypothesis-ruby's dependence on RSpec. Now, it can be used with any Ruby test runner.

data/lib/hypothesis.rb

@@ -7,6 +7,28 @@ require_relative 'hypothesis/testcase'
 require_relative 'hypothesis/engine'
 require_relative 'hypothesis/world'
 
+module Phase
+  SHRINK = :shrink
+
+  module_function
+
+  def all
+    [SHRINK]
+  end
+
+  def excluding(*phases)
+    unknown_phases = phases.reject { |phase| Phase.all.include?(phase) }
+    unless unknown_phases.empty?
+      raise(
+        ArgumentError,
+        "Attempting to exclude unknown phases: #{unknown_phases}"
+      )
+    end
+
+    all - phases
+  end
+end
+
 # This is the main module for using Hypothesis.
 # It is expected that you will include this in your
 # tests, but its methods are also available on the
@@ -201,7 +223,12 @@ module Hypothesis
   #   should store previously failing test cases. If it is nil, Hypothesis
   #   will use a default of .hypothesis/examples in the current directory.
   #   May also be set to false to disable the database functionality.
-  def hypothesis(max_valid_test_cases: 200, database: nil, &block)
+  def hypothesis(
+    max_valid_test_cases: 200,
+    phases: Phase.all,
+    database: nil,
+    &block
+  )
     unless World.current_engine.nil?
       raise UsageError, 'Cannot nest hypothesis calls'
     end
@@ -210,6 +237,7 @@ module Hypothesis
       World.current_engine = Engine.new(
         hypothesis_stable_identifier,
         max_examples: max_valid_test_cases,
+        phases: phases,
         database: database
       )
       World.current_engine.run(&block)

data/lib/hypothesis/engine.rb

@@ -19,7 +19,11 @@ module Hypothesis
       database = nil if database == false
 
       @core_engine = HypothesisCoreEngine.new(
-        name, database, seed, options.fetch(:max_examples)
+        name,
+        database,
+        seed,
+        options.fetch(:max_examples),
+        options.fetch(:phases)
       )
 
       @exceptions_to_tags = Hash.new { |h, k| h[k] = h.size }

data/src/lib.rs

@@ -4,15 +4,19 @@ extern crate rutie;
 extern crate lazy_static;
 extern crate conjecture;
 
+use std::convert::TryFrom;
 use std::mem;
 
-use rutie::{AnyException, AnyObject, Boolean, Class, Float, Integer, NilClass, Object, RString, VM};
+use rutie::{
+    AnyException, AnyObject, Array, Boolean, Class, Exception, Float, Integer, NilClass, Object,
+    RString, Symbol, VM,
+};
 
 use conjecture::data::{DataSource, Status, TestResult};
 use conjecture::database::{BoxedDatabase, DirectoryDatabase, NoDatabase};
 use conjecture::distributions;
 use conjecture::distributions::Repeat;
-use conjecture::engine::Engine;
+use conjecture::engine::{Engine, Phase};
 
 pub struct HypothesisCoreDataSourceStruct {
     source: Option<DataSource>,
@@ -77,6 +81,7 @@ impl HypothesisCoreEngineStruct {
         database_path: Option<String>,
         seed: u64,
         max_examples: u64,
+        phases: Vec<Phase>,
     ) -> HypothesisCoreEngineStruct {
         let xs: [u32; 2] = [seed as u32, (seed >> 32) as u32];
         let db: BoxedDatabase = match database_path {
@@ -85,7 +90,7 @@ impl HypothesisCoreEngineStruct {
         };
 
         HypothesisCoreEngineStruct {
-            engine: Engine::new(name, max_examples, &xs, db),
+            engine: Engine::new(name, max_examples, phases, &xs, db),
             pending: None,
             interesting_examples: Vec::new(),
         }
@@ -151,13 +156,26 @@ methods!(
         name: RString,
         database_path: RString,
         seed: Integer,
-        max_example: Integer
+        max_example: Integer,
+        phases: Array
     ) -> AnyObject {
+        let rust_phases = safe_access(phases)
+            .into_iter()
+            .map(|ruby_phase| {
+                let phase_sym = safe_access(ruby_phase.try_convert_to::<Symbol>());
+                let phase = Phase::try_from(phase_sym.to_str())
+                    .map_err(|e| AnyException::new("ArgumentError", Some(&e)));
+
+                safe_access(phase)
+            })
+            .collect();
+
         let core_engine = HypothesisCoreEngineStruct::new(
             safe_access(name).to_string(),
             database_path.ok().map(|p| p.to_string()),
             safe_access(seed).to_u64(),
             safe_access(max_example).to_u64(),
+            rust_phases,
         );
 
         Class::from_existing("HypothesisCoreEngine")
@@ -465,5 +483,5 @@ fn mark_child_status(
 }
 
 fn safe_access<T>(value: Result<T, AnyException>) -> T {
-  value.map_err(VM::raise_ex).unwrap()
+    value.map_err(VM::raise_ex).unwrap()
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hypothesis-specs
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - David R. Maciver
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-12 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rutie
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
+rubygems_version: 3.2.6
 signing_key: 
 specification_version: 4
 summary: Hypothesis is a powerful, flexible, and easy to use library for property-based