wait_until 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7de9f2648acd119acf6be1818db422565693cf99
-  data.tar.gz: 9fbebbe283132d1b03df299a37cb2f1d097b856c
+  metadata.gz: a5c68a76d714894ee9485a1b5ac4912796483a0f
+  data.tar.gz: 0e2f8e3181b35e07be9db356b98fff21bc48cc1a
 SHA512:
-  metadata.gz: e4dbbb3806f5b26b61660227f1429471d43e0a42673f222647d62f79bdad6f2fb9115161a747d5473e8bdb115c1fc5b82ae5df3d4ab2e6995bb13f43fa7cdc59
-  data.tar.gz: 11244dcf7441bca457c2cb5eb5cb009b7b5be9cf229745bb49ff8ebb514bc532c97c653dc116f765839332b5e81391d9bd5602300edb0e15c7ecafe8c6ef82f0
+  metadata.gz: 206d00e29b59bda409e945970a93d7ba81b84337297c40f0e4adbd956830cf79615e1ff3dd00fdfeb4590b84e1120c3e3bdb3ea237e7263e5043045e843d68ac
+  data.tar.gz: d49ed27c88ae9885dbfa8d0689d9696ce37a2647980dfe5ef6633422e64848bd6479764b06f2a81562711a18fe13f74dc8c2d1c1824e5e965c18ac0deaaf2082

data/lib/wait_until/operation.rb

@@ -2,10 +2,11 @@ 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]
+    def initialize(args)
+      @timeout_in_seconds = args[:timeout_in_seconds] || ::WaitUntil::Wait.default_timeout_in_seconds
+      @description        = args[:description]
+      @failure_message    = args[:failure_message]
+      @on_failure         = args[:on_failure]
     end
 
     def eventually_true?(&block)
@@ -17,8 +18,10 @@ module WaitUntil
     end
 
     def failure_message
-      message = "Timed-out waiting until '#{@description}'"
-      message << ".  Last observed exception: #{@last_error}" if @last_error
+      message = @failure_message
+      message ||= "Timed-out waiting until '#{@description}'"  if @description
+      message ||= "Timed-out waiting until operation completed"
+      message << "\nLast observed exception: #{@last_error}" if @last_error
       message
     end
 

data/lib/wait_until/version.rb

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

data/lib/wait_until/wait.rb

@@ -6,17 +6,17 @@ module WaitUntil
 
       attr_accessor :default_timeout_in_seconds
 
-      def until_true!(description, options={}, &block)
-        operation = WaitUntil::Operation.new(description, options)
+      def until_true!(args={}, &block)
+        operation = WaitUntil::Operation.new(args)
         raise operation.failure_message unless operation.eventually_true?(&block)
       end
 
-      def until_false!(description, options={}, &block)
-        until_true!(description, options) { !block.call }
+      def until_false!(args={}, &block)
+        until_true!(args) { !block.call }
       end
 
-      def until!(description, options={}, &block)
-        until_true!(description, options) do
+      def until!(args={}, &block)
+        until_true!(args) do
           block.call
           true
         end

data/spec/lib/wait_until/operation_spec.rb

@@ -8,10 +8,9 @@ describe WaitUntil::Operation do
 
   end
 
-  let(:description) { "some operations description" }
-  let(:options)     { {} }
+  let(:args) { {} }
 
-  let(:operation) { described_class.new(description, options) }
+  let(:operation) { described_class.new(args) }
 
   before(:example) { InvocationData.counter = 0 }
 
@@ -53,7 +52,7 @@ describe WaitUntil::Operation do
       context "and a timeout is provided" do
 
         let(:timeout_in_seconds) { 2 }
-        let(:options)            { { timeout_in_seconds: timeout_in_seconds } }
+        let(:args)               { { timeout_in_seconds: timeout_in_seconds } }
 
         it "waits until at least that period of time before returning false" do
           start_time = Time.now
@@ -69,7 +68,7 @@ describe WaitUntil::Operation do
       context "and a failure callback is provided" do
 
         let(:on_failure_callback) { lambda { InvocationData.counter += 1 } }
-        let(:options)             { { on_failure: on_failure_callback } }
+        let(:args)                { { on_failure: on_failure_callback } }
 
         it "executes the callback once" do
           subject
@@ -106,12 +105,53 @@ describe WaitUntil::Operation do
 
     shared_examples_for "a standard failure message" do
 
-      it "indicates a time-out occurred" do
-        expect(subject).to include("Timed-out")
+      context "and a custom failure message was provided" do
+
+        let(:failure_message) { "some failure message" }
+        let(:args)            { { failure_message: failure_message } }
+
+        it "contains the failure message" do
+          expect(subject).to include(failure_message)
+        end
+
+        context "and an operation description was provided" do
+
+          let(:description) { "some operation description" }
+          let(:args)        { { failure_message: failure_message, description: description } }
+
+          it "contains the failure message" do
+            expect(subject).to include(failure_message)
+          end
+
+          it "excludes the description" do
+            expect(subject).to_not include(description)
+          end
+
+        end
+
       end
 
-      it "contains the operations description" do
-        expect(subject).to include(description)
+      context "and an operation description was provided" do
+
+        let(:description) { "some operation description" }
+        let(:args)        { { description: description } }
+
+        it "indicates a time-out occurred" do
+          expect(subject).to include("Timed-out")
+        end
+
+        it "contains the description" do
+          expect(subject).to include(description)
+        end
+
+      end
+
+      context "and no failure message or description was provided" do
+
+        it "indicates a time-out occurred" do
+          expect(subject).to include("Timed-out")
+        end
+
       end
 
     end

data/spec/lib/wait_until/wait_spec.rb

@@ -1,26 +1,46 @@
 describe WaitUntil::Wait do
 
-  let(:description) { "some operations description" }
-  let(:options)     { {} }
+  let(:block) { lambda { "some block" } }
+  let(:args)  { {} }
 
-  shared_examples_for "a wait method that times-out" do
+  shared_examples_for "a wait method that uses an operation to determine if it eventually succeeds" do
 
-    it "raises an error indicating the operation timed-out" do
-      expect(subject).to raise_error(/Timed-out waiting until '#{description}'/i)
+    let(:eventually_true_flag) { true }
+    let(:failure_message)      { "some failure message" }
+    let(:operation)            do
+      instance_double(WaitUntil::Operation, eventually_true?: eventually_true_flag, failure_message: failure_message)
     end
 
-    context "and a timeout is provided" do
+    before(:example) { allow(WaitUntil::Operation).to receive(:new).and_return(operation) }
 
-      let(:timeout_in_seconds) { 2 }
-      let(:options)            { { timeout_in_seconds: timeout_in_seconds } }
+    it "creates an operation representing the call" do
+      expect(WaitUntil::Operation).to receive(:new).with(args)
 
-      it "waits until at least that period of time before raising an error" do
-        start_time = Time.now
+      subject
+    end
+
+    it "determines if the operation eventually returns true" do
+      expect(operation).to receive(:eventually_true?)
+
+      subject
+    end
+
+    context "when the operation is eventually true" do
 
-        subject.call rescue nil
+      let(:eventually_true_flag) { true }
 
-        period_of_time_waited = (Time.now - start_time)
-        expect(period_of_time_waited).to be >= timeout_in_seconds
+      it "executes without error" do
+        expect(lambda { subject }).to_not raise_error
+      end
+
+    end
+
+    context "when the operation is never eventually true" do
+
+      let(:eventually_true_flag) { false }
+
+      it "raises an error with the operations failure message" do
+        expect(lambda { subject }).to raise_error(failure_message)
       end
 
     end
@@ -29,38 +49,26 @@ describe WaitUntil::Wait do
 
   describe "::until_true!" do
 
-    subject { lambda { described_class.until_true!(description, options, &block) } }
+    subject { described_class.until_true!(args, &block) }
+
+    it_behaves_like "a wait method that uses an operation to determine if it eventually succeeds"
 
     context "when the block returns true" do
 
       let(:block) { lambda { true } }
 
       it "executes without error" do
-        expect(subject).to_not raise_error
+        expect(lambda { subject }).to_not raise_error
       end
 
     end
 
-    context "when the blocks always returns false" do
+    context "when the block returns false" do
 
       let(:block) { lambda { false } }
 
-      it_behaves_like "a wait method that times-out"
-
-    end
-
-    context "when the block eventually returns true" do
-
-      let(:block) do
-        invocation_count = 0
-        lambda do
-          invocation_count += 1
-          invocation_count == 3
-        end
-      end
-
-      it "executes without error" do
-        expect(subject).to_not raise_error
+      it "raises an error" do
+        expect(lambda { subject }).to raise_error(/timed-out/i)
       end
 
     end
@@ -69,38 +77,26 @@ describe WaitUntil::Wait do
 
   describe "::until_false!" do
 
-    subject { lambda { described_class.until_false!(description, options, &block) } }
+    subject { described_class.until_false!(args, &block) }
+
+    it_behaves_like "a wait method that uses an operation to determine if it eventually succeeds"
 
     context "when the block returns false" do
 
       let(:block) { lambda { false } }
 
       it "executes without error" do
-        expect(subject).to_not raise_error
+        expect(lambda { subject }).to_not raise_error
       end
 
     end
 
-    context "when the blocks always returns true" do
+    context "when the block returns true" do
 
       let(:block) { lambda { true } }
 
-      it_behaves_like "a wait method that times-out"
-
-    end
-
-    context "when the block eventually returns false" do
-
-      let(:block) do
-        invocation_count = 0
-        lambda do
-          invocation_count += 1
-          invocation_count < 3
-        end
-      end
-
-      it "executes without error" do
-        expect(subject).to_not raise_error
+      it "raises an error" do
+        expect(lambda { subject }).to raise_error(/timed-out/i)
       end
 
     end
@@ -109,38 +105,26 @@ describe WaitUntil::Wait do
 
   describe "::until!" do
 
-    subject { lambda { described_class.until!(description, options, &block) } }
+    subject { described_class.until!(args, &block) }
+
+    it_behaves_like "a wait method that uses an operation to determine if it eventually succeeds"
 
     context "when the block executes without error" do
 
-      let(:block) { lambda { nil } }
+      let(:block) { lambda { "does not raise an error" } }
 
       it "executes without error" do
-        expect(subject).to_not raise_error
+        expect(lambda { subject }).to_not raise_error
       end
 
     end
 
-    context "when the block raises an error indefinitely" do
-
-      let(:block) { lambda { raise "Forced Error" } }
+    context "when the block raises an error" do
 
-      it_behaves_like "a wait method that times-out"
-
-    end
+      let(:block) { lambda { raise "forced error" } }
 
-    context "when the block eventually executes without error" do
-
-      let(:block) do
-        invocation_count = 0
-        lambda do
-          invocation_count += 1
-          raise "Forced Error" if invocation_count < 3
-        end
-      end
-
-      it "executes without error" do
-        expect(subject).to_not raise_error
+      it "raises an error" do
+        expect(lambda { subject }).to raise_error(/timed-out/i)
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wait_until
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Matthew Ueckerman