wrong 0.5.6-java → 0.6.0-java

data/README.markdown

@@ -56,7 +56,7 @@ And a companion, 'deny':
 
 	deny{'abc'.include?('bc')}
 	 ==> Didn't expect "abc".include?("bc")
-	
+
 More examples are in the file `examples.rb` <http://github.com/alexch/wrong/blob/master/examples.rb>
 
 There's also a spreadsheet showing a translation from Test::Unit and RSpec to Wrong, with notes, at [this Google Doc](https://spreadsheets.google.com/pub?key=0AouPn6oLrimWdE0tZDVOWnFGMzVPZy0tWHZwdnhFYkE&hl=en&output=html). (Ask <alexch@gmail.com> if you want editing privileges.)
@@ -105,11 +105,34 @@ We also implement the most amazing debugging method ever, `d`, which gives you a
     x = 7
     d { x } # => prints "x is 7" to the console
     d { x * 2 } # => prints "(x * 2) is 14" to the console
+    d("math is hard") { 2 + 2 } #=> prints "math is hard: (2 + 2) is 4"
 
 `d` was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this version is a rewrite and homage. You may also enjoy [g](https://github.com/jugyo/g) by [jugyo](http://jugyo.org/).
 
 Remember, if you want `d` to work at runtime (e.g. in a webapp) then you must `include Wrong::D` inside your app, e.g. in your `environment.rb` file.
 
+### eventually
+
+If you care that something is going to be true *soon*, but maybe not *right* now, use `eventually`. It will keep executing the block, up to 4 times a second, until either
+
+  * the block returns true(ish)
+  * 5 seconds elapse
+
+If the block raises an exception, then `eventually` will treat that as a false and keep trying. The last time it fails, it'll raise that exception instead of a mere `AssertionFailedError`. That way, the following are all possible:
+
+    eventually { false }
+    eventually { assert { false } }
+    eventually { false.should be_true }  # in RSpec
+
+and you should get the expected failure after time expires.
+
+You can also send options to eventually as hash parameters.
+
+    eventually(:timeout => 10) { false } # keep trying for 10 sec
+    eventually(:delay => 1) { false }    # try every 1.0 sec, not every 0.25 sec
+
+(For now, `eventually` is in its own module, but you get it when you `include Wrong`. Maybe it should be in Helpers like the rest?)
+
 ## Test Framework Adapters ##
 
 Adapters for various test frameworks sit under wrong/adapters.
@@ -297,11 +320,11 @@ We hope this structure lets your eyes focus on the meaningful values and differe
 
 Wrong tries to maintain indentation to improve readability. If the inspected VALUE contains newlines, or is longer than will fit on your console, the succeeding lines will be indented to a pleasant level.
 
-Sometimes Wrong will not be able to evaluate a detail without raising an exception. This exception will be duly noted, which might be misleading. For example, 
+Sometimes Wrong will not be able to evaluate a detail without raising an exception. This exception will be duly noted, which might be misleading. For example,
 
 	a = [1,2,3,4]
 	assert { a.all? {|i| i<4} }
-	
+
 would fail, since on the final pass, `(i < 4)` is false. But the error message is a bit vague:
 
 	Wrong::Assert::AssertionFailedError: Expected a.all? { |i| (i < 4) }, but

data/lib/wrong/d.rb

@@ -37,7 +37,8 @@ module Wrong
         value = value.color(:magenta)
       end
 
-      puts [code, "is", value].join(" ")
+      message = args.compact.join(", ") + ":" unless args.empty?
+      puts [message, code, "is", value].compact.join(" ")
     end
 
     extend D # this allows you to call Wrong::D.d if you like

data/lib/wrong/eventually.rb

@@ -0,0 +1,24 @@
+module Wrong
+  module Eventually
+    NO_BLOCK_PASSED = "you must pass a block to the eventually method"
+    
+    def eventually options = {}, &block
+      raise NO_BLOCK_PASSED if block.nil?
+      timeout = options[:timeout] || 5
+      delay = options[:delay] || 0.25
+      last_error = nil
+      success = nil
+      begin_time = Time.now      
+      while (Time.now - begin_time) < timeout
+        begin
+          aver(:assert, &block)
+          return
+        rescue Exception => e
+          last_error = e
+          sleep delay
+        end
+      end
+      raise last_error
+    end
+  end
+end

data/lib/wrong/version.rb

@@ -1,3 +1,3 @@
 module Wrong
-  VERSION = "0.5.6" unless defined?(Wrong::VERSION)
+  VERSION = "0.6.0" unless defined?(Wrong::VERSION)
 end

data/lib/wrong.rb

@@ -12,12 +12,15 @@ require "wrong/irb"
 require "wrong/d"
 require "wrong/message/array_diff"
 require "wrong/message/string_comparison"
+require "wrong/eventually"
 
 module Wrong
   include Wrong::Assert
   extend Wrong::Assert
   include Wrong::Helpers
   extend Wrong::Helpers
+  include Wrong::Eventually
+  extend Wrong::Eventually
 end
 
 # this does some magic; if you don't like it...

data/test/chunk_test.rb

@@ -164,8 +164,8 @@ describe Chunk do
         assert { (x == 5) && (y == (z + 10)) }
       CODE
       code_parts = chunk.parts
-      assert code_parts == <<-PARTS.split("\n")
-((x == 5) and (y == (z + 10)))
+      assert code_parts == <<-PARTS.split("\n"), code_parts
+(x == 5) and (y == (z + 10))
 (x == 5)
 x
 5

data/test/d_test.rb

@@ -29,11 +29,11 @@ describe "d" do
       output = capturing do
         d { x }
       end
-      assert { output == 
-        "x is [\"aaaaaaaaaa\",\n \"bbbbbbbbbb\"]\n" 
+      assert { output ==
+        "x is [\"aaaaaaaaaa\",\n \"bbbbbbbbbb\"]\n"
       }
     ensure
-      Wrong::Chunk.terminal_width = nil    
+      Wrong::Chunk.terminal_width = nil
     end
   end
 
@@ -72,10 +72,24 @@ describe "d" do
 
   it "works when called on the D module" do
     x = 9
-    output = capturing { 
+    output = capturing {
       Wrong::D.d { x }
     }
     assert { output == "x is 9\n" }
   end
 
+  it "takes an optional message string" do
+    output = capturing {
+      Wrong::D.d("basic math") { 2 + 2 }
+    }
+    assert { output == "basic math: (2 + 2) is 4\n" }
+  end
+
+  it "takes a bunch of optional messages" do
+    output = capturing {
+      Wrong::D.d(2, "plus", :two) { 2 + 2 }
+    }
+    assert { output == "2, plus, two: (2 + 2) is 4\n" }
+  end
+
 end

data/test/eventually_test.rb

@@ -0,0 +1,191 @@
+# based on 
+# * https://gist.github.com/1228927
+# * https://github.com/pivotal/selenium/blob/master/lib/selenium/wait_for.rb
+# see
+# http://rubyforge.org/pipermail/rspec-users/2011-September/020575.html
+
+here = File.expand_path(File.dirname(__FILE__))
+
+require "#{here}/test_helper"
+require "wrong/assert"
+require "wrong/helpers"
+require "wrong/d"
+
+require "wrong/eventually"
+
+# todo: move this to a monkey patch file
+class Object
+  unless Object.method_defined? :singleton_class
+    def singleton_class
+       class << self
+         self
+       end
+    end
+  end
+end
+
+describe "eventually" do
+  include Wrong::Eventually
+  include Wrong::Assert
+  include Wrong::Helpers
+  include Wrong::D
+
+  # rolling our own mock clock and stubbing framework since we want these 
+  # tests to run in MiniTest or in any version of RSpec
+
+  class ::Time
+    class << self
+      alias_method :real_now, :now
+      def now
+        # puts "in new now; original_now = #{original_now}, @now = #{@now}"
+        @now ||= real_now
+      end
+      def now= new_now
+        @now = new_now
+      end
+    end    
+  end
+
+  def stub_it(receiver, method_name, &block)
+    receiver.singleton_class.send(:define_method, method_name, &block)
+  end
+  
+  def unstub_it(receiver, method_name)
+    receiver.singleton_class.send(:remove_method, method_name)
+  end
+
+  before do
+    stub_it(self, :sleep) do |secs| 
+      Time.now += secs
+    end
+  end
+  
+  after do
+    unstub_it(self, :sleep)
+  end
+    
+  it "requires a block" do
+    e = rescuing {
+      eventually
+    }
+    assert { e.message == Wrong::Eventually::NO_BLOCK_PASSED }
+    assert { e.message =~ /pass a block/ }
+  end
+
+  it "returns immediately if the block evaluates to true" do
+    original_now = Time.now
+    eventually { true }
+    assert { Time.now == original_now }
+  end
+
+  it "raises an exception after 5 seconds of being false" do
+    original_now = Time.now
+    e = rescuing do
+      eventually { false }
+    end
+    deny { e.nil? }
+    assert { Time.now == original_now + 5}
+  end
+  
+  it "calls the block every 0.25 seconds" do
+    original_now = Time.now            
+    called_at = []
+    rescuing {
+      eventually { 
+        called_at << (Time.now - original_now)
+        false
+      }
+    }
+    assert { called_at.uniq == [
+      0.0, 0.25, 0.5, 0.75, 
+      1.0, 1.25, 1.5, 1.75, 
+      2.0, 2.25, 2.5, 2.75, 
+      3.0, 3.25, 3.5, 3.75, 
+      4.0, 4.25, 4.5, 4.75, 
+    ] }
+  end
+  
+  it "puts the elapsed time in the exception message"
+  # assert { e.message =~ /\(after 5 sec\)$/}
+  
+  
+  it "returns after the condition is false for a while then true" do
+    original_now = Time.now
+    eventually {
+      # cleverly, I am asserting that time has passed
+      Time.now >= original_now + 2
+    }
+    assert {
+      Time.now == original_now + 2
+    }
+  end
+
+  it "raises a detailed Wrong exception if the result keeps being false" do
+    original_now = Time.now
+    e = rescuing do
+      eventually { false }
+    end
+    assert { e.message == "Expected false" }
+    
+    x = 1
+    e = rescuing do
+      eventually { x + 2 == 4 }
+    end
+    assert { e.message == "Expected ((x + 2) == 4), but\n    (x + 2) is 3\n    x is 1\n" }
+  end
+  
+  describe "if the block raises an exception" do
+    it "for 5 seconds, it raises that exception" do
+      original_now = Time.now
+      e = rescuing do
+        eventually { raise "nope" }
+      end
+      deny { e.nil? }
+      assert { Time.now == original_now + 5}
+      assert { e.is_a? RuntimeError }
+      assert { e.message == "nope" }
+    end
+
+    it "but then returns true, it succeeds silently" do
+      original_now = Time.now
+      eventually {
+         if Time.now < original_now + 2
+           raise "not yet"
+         else
+           true
+         end
+      }
+      assert {
+        Time.now == original_now + 2
+      }
+    end
+  end
+  
+  describe "passes a context hash to the block" do
+    it "that influences the error message"
+  end
+  
+  describe "takes an options hash" do
+    it "that can change the timeout" do
+      original_now = Time.now      
+      rescuing {
+        eventually(:timeout => 2) { false }
+      }
+      assert {
+        Time.now == original_now + 2        
+      }
+    end
+    
+    it "that can change the delay" do
+      original_now = Time.now            
+      called_at = []
+      rescuing {
+        eventually(:delay => 1.5) { 
+          called_at << (Time.now - original_now)
+          false
+        }
+      }
+      assert { called_at.uniq == [0.0, 1.5, 3.0, 4.5] }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wrong
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.0
   prerelease: 
 platform: java
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-24 00:00:00.000000000Z
+date: 2011-10-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicated
-  requirement: &70166290574900 !ruby/object:Gem::Requirement
+  requirement: &70263619821900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: 0.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *70166290574900
+  version_requirements: *70263619821900
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &70166290568940 !ruby/object:Gem::Requirement
+  requirement: &70263619821400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 2.0.4
   type: :runtime
   prerelease: false
-  version_requirements: *70166290568940
+  version_requirements: *70263619821400
 - !ruby/object:Gem::Dependency
   name: ruby2ruby
-  requirement: &70166290567620 !ruby/object:Gem::Requirement
+  requirement: &70263619820940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: '1.2'
   type: :runtime
   prerelease: false
-  version_requirements: *70166290567620
+  version_requirements: *70263619820940
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &70166290566340 !ruby/object:Gem::Requirement
+  requirement: &70263619820480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70166290566340
+  version_requirements: *70263619820480
 - !ruby/object:Gem::Dependency
   name: diff-lcs
-  requirement: &70166290565100 !ruby/object:Gem::Requirement
+  requirement: &70263619820020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,7 +66,7 @@ dependencies:
         version: 1.1.2
   type: :runtime
   prerelease: false
-  version_requirements: *70166290565100
+  version_requirements: *70263619820020
 description: ! 'Wrong provides a general assert method that takes a predicate block.
   Assertion failure
 
@@ -96,6 +96,7 @@ files:
 - lib/wrong/close_to.rb
 - lib/wrong/config.rb
 - lib/wrong/d.rb
+- lib/wrong/eventually.rb
 - lib/wrong/failure_message.rb
 - lib/wrong/helpers.rb
 - lib/wrong/irb.rb
@@ -139,6 +140,7 @@ files:
 - test/close_to_test.rb
 - test/config_test.rb
 - test/d_test.rb
+- test/eventually_test.rb
 - test/failure_message_test.rb
 - test/failures_test.rb
 - test/message/array_diff_test.rb
@@ -164,7 +166,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3347829710092711523
+      hash: -4300453348468624126
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -210,6 +212,7 @@ test_files:
 - test/close_to_test.rb
 - test/config_test.rb
 - test/d_test.rb
+- test/eventually_test.rb
 - test/failure_message_test.rb
 - test/failures_test.rb
 - test/message/array_diff_test.rb