wait_until 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fda8f4fcee46c7d2d20f75ac05ad27aa74092d55
-  data.tar.gz: 9411470c6fefa44fabb608fdd856869813d3459e
+  metadata.gz: 7de9f2648acd119acf6be1818db422565693cf99
+  data.tar.gz: 9fbebbe283132d1b03df299a37cb2f1d097b856c
 SHA512:
-  metadata.gz: 0016e0f6c78d14283024120000a1d4dfb3b9cebc9a78ddef2c70aa60397fbb8ac915b698ec639246843062548fdaddaf5a7c46522b6c618d31faec771903e307
-  data.tar.gz: 024e70bc0f3e21b7f5c7ac2ac49d66919b7ce9f92a2b3b3093e4f2c6924f9ce0388782bb11f5f3f161d77b32cec89bc357c6f1e110795628df2c3034812bb1c1
+  metadata.gz: e4dbbb3806f5b26b61660227f1429471d43e0a42673f222647d62f79bdad6f2fb9115161a747d5473e8bdb115c1fc5b82ae5df3d4ab2e6995bb13f43fa7cdc59
+  data.tar.gz: 11244dcf7441bca457c2cb5eb5cb009b7b5be9cf229745bb49ff8ebb514bc532c97c653dc116f765839332b5e81391d9bd5602300edb0e15c7ecafe8c6ef82f0

data/lib/wait_until.rb

@@ -1,3 +1,4 @@
+require_relative "wait_until/operation"
 require_relative "wait_until/wait"
 
-Wait = WaitUntil::Wait
+::Wait = WaitUntil::Wait

data/lib/wait_until/operation.rb

@@ -0,0 +1,45 @@
+module WaitUntil
+
+  class Operation
+
+    def initialize(description, options)
+      @description        = description
+      @timeout_in_seconds = options[:timeout_in_seconds] || ::WaitUntil::Wait.default_timeout_in_seconds
+      @on_failure         = options[:on_failure]
+    end
+
+    def eventually_true?(&block)
+      @start_time = Time.now
+      loop do
+        return true if true?(&block)
+        return false if timed_out?
+      end
+    end
+
+    def failure_message
+      message = "Timed-out waiting until '#{@description}'"
+      message << ".  Last observed exception: #{@last_error}" if @last_error
+      message
+    end
+
+    private
+
+    def true?(&block)
+      begin
+        !!block.call
+      rescue => error
+        @last_error = error
+        false
+      end
+    end
+
+    def timed_out?
+      elapsed_time = Time.now - @start_time
+      is_timed_out = elapsed_time >= @timeout_in_seconds
+      @on_failure.call if @on_failure if is_timed_out
+      is_timed_out
+    end
+
+  end
+
+end

data/lib/wait_until/version.rb

@@ -1,3 +1,3 @@
 module WaitUntil
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/wait_until/wait.rb

@@ -1,4 +1,5 @@
 module WaitUntil
+
   class Wait
 
     class << self
@@ -6,22 +7,8 @@ module WaitUntil
       attr_accessor :default_timeout_in_seconds
 
       def until_true!(description, options={}, &block)
-        timeout_in_seconds = options[:timeout_in_seconds] || self.default_timeout_in_seconds
-        start_time = Time.now
-        last_exc = nil
-        loop do
-          begin
-            return if block.call
-          rescue => exc
-            last_exc = exc
-          end
-          elapsed_time = Time.now - start_time
-          if elapsed_time >= timeout_in_seconds
-            failure_message = "Timed-out waiting until '#{description}'"
-            failure_message << ".  Last observed exception: #{last_exc}" if last_exc
-            raise failure_message
-          end
-        end
+        operation = WaitUntil::Operation.new(description, options)
+        raise operation.failure_message unless operation.eventually_true?(&block)
       end
 
       def until_false!(description, options={}, &block)
@@ -40,4 +27,5 @@ module WaitUntil
     self.default_timeout_in_seconds = ENV["timeout"] ? ENV["timeout"].to_i : 20
 
   end
+
 end

data/spec/lib/wait_until/operation_spec.rb

@@ -0,0 +1,146 @@
+describe WaitUntil::Operation do
+
+  class InvocationData
+
+    class << self
+      attr_accessor :counter
+    end
+
+  end
+
+  let(:description) { "some operations description" }
+  let(:options)     { {} }
+
+  let(:operation) { described_class.new(description, options) }
+
+  before(:example) { InvocationData.counter = 0 }
+
+  describe "#eventually_true?" do
+
+    subject { operation.eventually_true?(&block) }
+
+    context "when the block returns true" do
+
+      let(:block) { lambda { true } }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when the blocks always returns false" do
+
+      let(:block) { lambda { false } }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+      context "and no timeout is provided" do
+
+        it "waits until at least the default period of time before returning false" do
+          start_time = Time.now
+
+          subject
+
+          period_of_time_waited = (Time.now - start_time)
+          expect(period_of_time_waited).to be >= WaitUntil::Wait.default_timeout_in_seconds
+        end
+
+      end
+
+      context "and a timeout is provided" do
+
+        let(:timeout_in_seconds) { 2 }
+        let(:options)            { { timeout_in_seconds: timeout_in_seconds } }
+
+        it "waits until at least that period of time before returning false" do
+          start_time = Time.now
+
+          subject
+
+          period_of_time_waited = (Time.now - start_time)
+          expect(period_of_time_waited).to be >= timeout_in_seconds
+        end
+
+      end
+
+      context "and a failure callback is provided" do
+
+        let(:on_failure_callback) { lambda { InvocationData.counter += 1 } }
+        let(:options)             { { on_failure: on_failure_callback } }
+
+        it "executes the callback once" do
+          subject
+
+          expect(InvocationData.counter).to eql(1)
+        end
+
+      end
+
+    end
+
+    context "when the block eventually returns true" do
+
+      let(:block) do
+        lambda do
+          InvocationData.counter += 1
+          InvocationData.counter == 3
+        end
+      end
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+  end
+
+  describe "#failure_message" do
+
+    subject { operation.failure_message }
+
+    before(:example) { operation.eventually_true?(&block) }
+
+    shared_examples_for "a standard failure message" do
+
+      it "indicates a time-out occurred" do
+        expect(subject).to include("Timed-out")
+      end
+
+      it "contains the operations description" do
+        expect(subject).to include(description)
+      end
+
+    end
+
+    context "when no exception occurred evaluating the operation" do
+
+      let(:block) { lambda { false } }
+
+      it_behaves_like "a standard failure message"
+
+    end
+
+    context "when an exception occurred evaluating the operation" do
+
+      let(:block) do
+        lambda do
+          InvocationData.counter += 1
+          raise "Forced error #{InvocationData.counter}"
+        end
+      end
+
+      it_behaves_like "a standard failure message"
+
+      it "includes the last error" do
+        expect(subject).to include("Forced error #{InvocationData.counter}")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/wait_until/wait_spec.rb

@@ -1,188 +1,146 @@
 describe WaitUntil::Wait do
 
-  before(:all) do
-    @initial_default_timeout = WaitUntil::Wait.default_timeout_in_seconds
-    WaitUntil::Wait.default_timeout_in_seconds = 1
-  end
+  let(:description) { "some operations description" }
+  let(:options)     { {} }
 
-  after(:all) { WaitUntil::Wait.default_timeout_in_seconds = @initial_default_timeout }
+  shared_examples_for "a wait method that times-out" do
 
-  describe ".until_true!" do
+    it "raises an error indicating the operation timed-out" do
+      expect(subject).to raise_error(/Timed-out waiting until '#{description}'/i)
+    end
 
-    context "when the block returns true" do
+    context "and a timeout is provided" do
 
-      let(:block) do
-        lambda { WaitUntil::Wait.until_true!("some operation") { true } }
-      end
+      let(:timeout_in_seconds) { 2 }
+      let(:options)            { { timeout_in_seconds: timeout_in_seconds } }
 
-      it "executes without error" do
-        expect(block).to_not raise_error
+      it "waits until at least that period of time before raising an error" do
+        start_time = Time.now
+
+        subject.call rescue nil
+
+        period_of_time_waited = (Time.now - start_time)
+        expect(period_of_time_waited).to be >= timeout_in_seconds
       end
 
     end
 
-    context "when the blocks always returns false" do
+  end
 
-      let(:timeout_in_seconds) { nil }
-      let(:block) do
-        lambda do
-          WaitUntil::Wait.until_true!("another operation finishes", timeout_in_seconds: timeout_in_seconds) { false }
-        end
-      end
+  describe "::until_true!" do
 
-      it "raises an error indicating the operation timed-out" do
-        expect(block).to raise_error(/Timed-out waiting until 'another operation finishes'/i)
-      end
+    subject { lambda { described_class.until_true!(description, options, &block) } }
+
+    context "when the block returns true" do
 
-      context "and a timeout is provided" do
+      let(:block) { lambda { true } }
 
-        let(:timeout_in_seconds) { 2 }
+      it "executes without error" do
+        expect(subject).to_not raise_error
+      end
 
-        it "waits until at least a period of time matching the timeout before raising an error" do
-          start_time = Time.now
+    end
 
-          expect(block).to raise_error
+    context "when the blocks always returns false" do
 
-          period_of_time_waited = (Time.now - start_time)
-          expect(period_of_time_waited).to be >= timeout_in_seconds
-        end
+      let(:block) { lambda { false } }
 
-      end
+      it_behaves_like "a wait method that times-out"
 
     end
 
     context "when the block eventually returns true" do
 
-      it "executes without error" do
+      let(:block) do
         invocation_count = 0
-        expect(lambda do
-          WaitUntil::Wait.until_true!("some operation") do
-            invocation_count += 1
-            invocation_count == 3
-          end
-        end).to_not raise_error
+        lambda do
+          invocation_count += 1
+          invocation_count == 3
+        end
+      end
+
+      it "executes without error" do
+        expect(subject).to_not raise_error
       end
 
     end
 
   end
 
-  describe ".until_false!" do
+  describe "::until_false!" do
+
+    subject { lambda { described_class.until_false!(description, options, &block) } }
 
     context "when the block returns false" do
 
-      let(:block) do
-        lambda { WaitUntil::Wait.until_false!("some operation") { false } }
-      end
+      let(:block) { lambda { false } }
 
       it "executes without error" do
-        expect(block).to_not raise_error
+        expect(subject).to_not raise_error
       end
 
     end
 
     context "when the blocks always returns true" do
 
-      let(:timeout_in_seconds) { nil }
-      let(:block) do
-        lambda do
-          WaitUntil::Wait.until_false!("another operation finishes", timeout_in_seconds: timeout_in_seconds) { true }
-        end
-      end
-
-      it "raises an error indicating the operation timed-out" do
-        expect(block).to raise_error(/Timed-out waiting until 'another operation finishes'/i)
-      end
+      let(:block) { lambda { true } }
 
-      context "and a timeout is provided" do
+      it_behaves_like "a wait method that times-out"
 
-        let(:timeout_in_seconds) { 2 }
-
-        it "waits until at least a period of time matching the timeout before raising an error" do
-          start_time = Time.now
+    end
 
-          expect(block).to raise_error
+    context "when the block eventually returns false" do
 
-          period_of_time_waited = (Time.now - start_time)
-          expect(period_of_time_waited).to be >= timeout_in_seconds
+      let(:block) do
+        invocation_count = 0
+        lambda do
+          invocation_count += 1
+          invocation_count < 3
         end
-
       end
 
-    end
-
-    context "when the block eventually returns false" do
-
       it "executes without error" do
-        invocation_count = 0
-        expect(lambda do
-          WaitUntil::Wait.until_false!("some operation") do
-            invocation_count += 1
-            invocation_count < 3
-          end
-        end).to_not raise_error
+        expect(subject).to_not raise_error
       end
 
     end
 
   end
 
-  describe ".until!" do
+  describe "::until!" do
+
+    subject { lambda { described_class.until!(description, options, &block) } }
 
     context "when the block executes without error" do
 
-      let(:block) do
-        lambda { WaitUntil::Wait.until!("some operation") { } }
-      end
+      let(:block) { lambda { nil } }
 
       it "executes without error" do
-        expect(block).to_not raise_error
+        expect(subject).to_not raise_error
       end
 
     end
 
     context "when the block raises an error indefinitely" do
 
-      let(:timeout_in_seconds) { nil }
-      let(:block) do
-        lambda do
-          WaitUntil::Wait.until!("some operation finishes", timeout_in_seconds: timeout_in_seconds) do
-            raise "forced error"
-          end
-        end
-      end
+      let(:block) { lambda { raise "Forced Error" } }
 
-      it "raises an error indicating the operation timed-out" do
-        expect(block).to raise_error(/Timed-out waiting until 'some operation finishes'/i)
-      end
+      it_behaves_like "a wait method that times-out"
 
-      context "and a timeout is provided" do
-
-        let(:timeout_in_seconds) { 2 }
-
-        it "waits until at least a period of time matching the timeout before raising an error" do
-          start_time = Time.now
+    end
 
-          expect(block).to raise_error
+    context "when the block eventually executes without error" do
 
-          period_of_time_waited = (Time.now - start_time)
-          expect(period_of_time_waited).to be >= timeout_in_seconds
+      let(:block) do
+        invocation_count = 0
+        lambda do
+          invocation_count += 1
+          raise "Forced Error" if invocation_count < 3
         end
-
       end
 
-    end
-
-    context "when the block eventually executes without error" do
-
       it "executes without error" do
-        invocation_count = 0
-        expect(lambda do
-          WaitUntil::Wait.until!("some operation") do
-            invocation_count += 1
-            raise "forced error" if invocation_count < 3
-          end
-        end).to_not raise_error
+        expect(subject).to_not raise_error
       end
 
     end

data/spec/spec_helper.rb

@@ -11,3 +11,16 @@ end if ENV["coverage"]
 require_relative "../lib/wait_until"
 
 Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |file| require file }
+
+RSpec.configure do |config|
+
+  config.before(:example) do
+    @initial_default_timeout = WaitUntil::Wait.default_timeout_in_seconds
+    WaitUntil::Wait.default_timeout_in_seconds = 1
+  end
+
+  config.after(:example) do
+    WaitUntil::Wait.default_timeout_in_seconds = @initial_default_timeout
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wait_until
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Matthew Ueckerman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-23 00:00:00.000000000 Z
+date: 2016-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: travis-lint
@@ -24,62 +24,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: metric_fu
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.11'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.11'
 description: Suspends execution until state changes via ::Wait.until! methods, timing-out
   after a configured period of time
 email: matthew.ueckerman@myob.com
@@ -88,8 +74,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./lib/wait_until.rb"
+- "./lib/wait_until/operation.rb"
 - "./lib/wait_until/version.rb"
 - "./lib/wait_until/wait.rb"
+- "./spec/lib/wait_until/operation_spec.rb"
 - "./spec/lib/wait_until/wait_spec.rb"
 - "./spec/lib/wait_until/wait_until_spec.rb"
 - "./spec/spec_helper.rb"
@@ -113,11 +101,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: wait_until
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Suspends execution until state changes via ::Wait.until! methods
 test_files:
+- "./spec/lib/wait_until/operation_spec.rb"
 - "./spec/lib/wait_until/wait_spec.rb"
 - "./spec/lib/wait_until/wait_until_spec.rb"
 - "./spec/spec_helper.rb"