fear 1.0.0 → 1.1.0

data/spec/fear/future_spec.rb

@@ -1,66 +1,166 @@
-RSpec.describe Fear::Future do
-  let(:value) { 5 }
-  let(:error) { StandardError.new('something went wrong') }
-
-  def future(&block)
-    described_class.new(executor: Concurrent::ImmediateExecutor.new, &block)
-  end
+# frozen_string_literal: true
 
-  context '#on_complete' do
-    it 'run callback with value' do
+RSpec.describe Fear::Future do
+  context "#on_complete" do
+    it "run callback with value" do
       expect do |callback|
-        future { value }.on_complete(&callback)
-      end.to yield_with_args(Fear.success(value))
+        Fear::Future.successful(5).on_complete(&callback)
+      end.to yield_with_args(Fear.success(5))
     end
 
-    it 'run callback with error' do
+    let(:error) { StandardError.new }
+
+    it "run callback with error" do
       expect do |callback|
-        future { raise error }.on_complete(&callback)
+        Fear::Future.failed(error).on_complete(&callback)
       end.to yield_with_args(Fear.failure(error))
     end
   end
 
-  context '#on_success' do
-    it 'run callback if no error' do
-      expect do |callback|
-        future { value }.on_success(&callback)
-      end.to yield_with_args(value)
+  context "#on_complete_match" do
+    context "successful covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.successful(5).on_complete_match do |m|
+            m.success(&callback)
+          end
+        end
+      end
+
+      it { is_expected.to yield_with_args(5) }
     end
 
-    it 'do not run callback if error occurred' do
-      expect do |callback|
-        future { raise error }.on_success(&callback)
-      end.not_to yield_with_args
+    context "successful not covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.successful(5).on_complete_match do |m|
+            m.failure(&callback)
+          end
+        end
+      end
+
+      it { is_expected.not_to yield_control }
     end
 
-    specify 'call all registered callbacks' do
-      expect do |second|
-        expect do |first|
-          future { value }
-            .on_success(&first)
-            .on_success(&second)
-        end.to yield_with_args(value)
-      end.to yield_with_args(value)
+    context "failed" do
+      subject do
+        proc do |callback|
+          Fear::Future.failed(error).on_complete_match do |m|
+            m.failure(&callback)
+          end
+        end
+      end
+      let(:error) { StandardError.new }
+
+      it { is_expected.to yield_with_args(error) }
+    end
+
+    context "failed not covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.failed(error).on_complete_match do |m|
+            m.success(&callback)
+          end
+        end
+      end
+      let(:error) { StandardError.new }
+
+      it { is_expected.not_to yield_control }
     end
   end
 
-  context '#on_failure' do
-    it 'do not run callback if no error' do
+  shared_examples :on_success do |method_name|
+    context "##{method_name}" do
+      context "successful" do
+        subject do
+          proc do |callback|
+            Fear::Future.successful(5).__send__(method_name, &callback)
+          end
+        end
+
+        it { is_expected.to yield_with_args(5) }
+      end
+
+      context "failed" do
+        subject do
+          proc do |callback|
+            Fear::Future.failed(StandardError.new).__send__(method_name, &callback)
+          end
+        end
+
+        it { is_expected.not_to yield_control }
+      end
+
+      specify "call all registered callbacks" do
+        expect do |second|
+          expect do |first|
+            Fear::Future.successful(5)
+              .__send__(method_name, &first)
+              .__send__(method_name, &second)
+          end.to yield_with_args(5)
+        end.to yield_with_args(5)
+      end
+    end
+  end
+
+  include_examples :on_success, :on_success
+  include_examples :on_success, :each
+
+  context "#on_success_match" do
+    context "successful covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.successful(5).on_success_match do |m|
+            m.case(5, &callback)
+          end
+        end
+      end
+
+      it { is_expected.to yield_with_args(5) }
+    end
+
+    context "successful not covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.successful(5).on_success_match do |m|
+            m.case(0, &callback)
+          end
+        end
+      end
+
+      it { is_expected.not_to yield_control }
+    end
+
+    context "failed" do
+      subject do
+        proc do |callback|
+          Fear::Future.failed(StandardError.new).on_success_match(&callback)
+        end
+      end
+
+      it { is_expected.not_to yield_control }
+    end
+  end
+
+  context "#on_failure" do
+    let(:error) { StandardError.new }
+
+    it "do not run callback if no error" do
       expect do |callback|
-        future { value }.on_failure(&callback)
+        Fear::Future.successful(5).on_failure(&callback)
       end.not_to yield_with_args
     end
 
-    it 'run callback if error occurred' do
+    it "run callback if error occurred" do
       expect do |callback|
-        future { raise error }.on_failure(&callback)
+        Fear::Future.failed(error).on_failure(&callback)
       end.to yield_with_args(error)
     end
 
-    specify 'call all registered callbacks' do
+    specify "call all registered callbacks" do
       expect do |second|
         expect do |first|
-          future { raise error }
+          Fear::Future.failed(error)
             .on_failure(&first)
             .on_failure(&second)
         end.to yield_with_args(error)
@@ -68,315 +168,373 @@ RSpec.describe Fear::Future do
     end
   end
 
-  context '#completed?' do
-    it 'completed with value' do
-      completed_future = future { value }
-
-      expect(completed_future).to be_completed
-    end
-
-    it 'completed with error' do
-      completed_future = future { raise error }
+  context "#on_failure_match" do
+    context "failure covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.failed(error).on_failure_match do |m|
+            m.case(StandardError, &callback)
+          end
+        end
+      end
+      let(:error) { StandardError.new }
 
-      expect(completed_future).to be_completed
+      it { is_expected.to yield_with_args(error) }
     end
 
-    it 'not completed with value' do
-      not_completed_future =
-        Fear.future do
-          sleep 1
-          value
+    context "failure not covered" do
+      subject do
+        proc do |callback|
+          Fear::Future.failed(error).on_failure_match do |m|
+            m.case(RuntimeError, &callback)
+          end
         end
+      end
+      let(:error) { StandardError.new }
 
-      expect(not_completed_future).not_to be_completed
+      it { is_expected.not_to yield_control }
     end
 
-    it 'not completed with error' do
-      not_completed_future =
-        Fear.future do
-          sleep 1
-          raise error
+    context "successful" do
+      subject do
+        proc do |callback|
+          Fear::Future.successful(5).on_failure_match(&callback)
         end
+      end
 
-      expect(not_completed_future).not_to be_completed
+      it { is_expected.not_to yield_control }
     end
   end
 
-  context '#value' do
-    it 'None if not completed' do
-      not_completed_future =
+  context "#completed?" do
+    context "not completed" do
+      subject do
         Fear.future do
-          sleep 1
+          sleep 0.1
           value
         end
+      end
 
-      future_value = not_completed_future.value
-
-      expect(future_value).to eq(Fear.none)
+      it { is_expected.not_to be_completed }
     end
 
-    it 'Some of Success if completed with result' do
-      future_value = future { value }.value
+    context "completed with error" do
+      subject { Fear::Await.ready(Fear.future { raise StandardError }, 1) }
 
-      expect(future_value).to eq Fear.some(Fear.success(value))
+      it { is_expected.to be_completed }
     end
 
-    it 'Some of Failure if completed with error' do
-      value = future { raise error }.value
+    context "completed with value" do
+      subject { Fear::Await.ready(Fear.future { 5 }, 0.5) }
 
-      expect(value).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to be_completed }
     end
   end
 
-  context '#transform' do
-    let(:failure) { ->(e) { e.message } }
-    let(:success) { ->(v) { v * 2 } }
+  context "#value" do
+    subject { future.value }
 
-    it 'call first callback if successful' do
-      value = future { 2 }.transform(success, failure).value
+    context "future returns nil" do
+      let(:future) { Fear::Future.successful(nil) }
 
-      expect(value).to eq Fear.some(Fear.success(4))
+      it { is_expected.to eq(Fear.some(Fear.success(nil))) }
     end
 
-    it 'call second callback if failed' do
-      value = future { raise error }.transform(success, failure).value
+    context "not completed" do
+      let(:future) do
+        Fear.future do
+          sleep 0.1
+          value
+        end
+      end
 
-      expect(value).to eq Fear.some(Fear.failure('something went wrong'))
+      it { is_expected.to eq(Fear.none) }
     end
-  end
 
-  context '#map' do
-    it 'successful result' do
-      result = future { value }.map { |r| r * 2 }.value
+    context "completed with success" do
+      let(:future) { Fear::Future.successful(5) }
 
-      expect(result).to eq Fear.some(Fear.success(10))
+      it { is_expected.to eq(Fear.some(Fear.success(5))) }
     end
 
-    it 'failed result' do
-      result = future { raise error }.map { |r| r * 2 }.value
+    context "completed with failure" do
+      let(:future) { Fear::Future.failed(error) }
+      let(:error) { StandardError.new }
 
-      expect(result).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to eq(Fear.some(Fear.failure(error))) }
     end
   end
 
-  context '#flat_map' do
-    it 'successful result' do
-      result = future { value }.flat_map { |r| future { r * 2 } }.value
+  context "#transform" do
+    context "successful" do
+      subject { Fear::Await.result(future, 1) }
+
+      let(:future) { Fear.future { 2 }.transform(->(v) { v * 2 }, :itself.to_proc) }
 
-      expect(result).to eq Fear.some(Fear.success(10))
+      it { is_expected.to eq(Fear.success(4)) }
     end
 
-    it 'failed result' do
-      result = future { raise error }.flat_map { |r| future { r * 2 } }.value
+    context "failed" do
+      subject { Fear::Await.result(future, 1) }
 
-      expect(result).to eq Fear.some(Fear.failure(error))
+      let(:future) { Fear.future { raise error }.transform(:itself.to_proc, :message.to_proc) }
+      let!(:error) { StandardError.new("fooo") }
+
+      it { is_expected.to eq(Fear.failure("fooo")) }
     end
+  end
+
+  context "#map" do
+    subject { Fear::Await.result(future.map { |x| x * 2 }, 1) }
 
-    it 'failed callback future' do
-      result = future { value }.flat_map { future { raise error } }.value
+    context "successful" do
+      let(:future) { Fear.future { 5 } }
 
-      expect(result).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to eq(Fear.success(10)) }
     end
 
-    it 'failured callback' do
-      result = future { value }.flat_map { raise error }.value
+    context "failed" do
+      let(:future) { Fear.future { raise error } }
+      let!(:error) { StandardError.new("foo") }
 
-      expect(result).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to eq(Fear.failure(error)) }
     end
   end
 
-  context '#each' do
-    it 'successful result' do
-      expect do |callback|
-        future { value }.each(&callback)
-      end.to yield_with_args(value)
-    end
+  context "#flat_map" do
+    subject { Fear::Await.result(future, 1) }
 
-    it 'failed result' do
-      expect do |callback|
-        future { raise error }.each(&callback)
-      end.not_to yield_with_args
+    context "successful" do
+      let(:future) { Fear.future { 5 }.flat_map { |r| Fear.future { r * 2 } } }
+
+      it { is_expected.to eq(Fear.success(10)) }
     end
-  end
 
-  context '#select' do
-    it 'satisfy predicate' do
-      value = future { 2 }.select(&:even?).value
+    context "failed" do
+      let(:future) { Fear.future { raise error }.flat_map { |r| Fear.future { r * 2 } } }
+      let!(:error) { StandardError.new("foo") }
 
-      expect(value).to eq Fear.some(Fear.success(2))
+      it { is_expected.to eq(Fear.failure(error)) }
     end
 
-    it 'does not satisfy predicate' do
-      value = future { 3 }.select(&:even?).value
+    context "failed callback future" do
+      let(:future) { Fear.future { 5 }.flat_map { Fear.future { raise error } } }
+      let!(:error) { StandardError.new("foo") }
 
-      expect(value.get.exception).to be_kind_of(Fear::NoSuchElementError)
+      it { is_expected.to eq(Fear.failure(error)) }
     end
 
-    it 'failure' do
-      value = future { raise error }.select(&:even?).value
+    context "failed callback" do
+      let(:future) { Fear.future { 5 }.flat_map { raise error } }
+      let!(:error) { StandardError.new("foo") }
 
-      expect(value.get.exception).to eq error
+      it { is_expected.to eq(Fear.failure(error)) }
     end
   end
 
-  context '#recover' do
-    it 'success' do
-      value = future { 2 / 1 }.recover do |m|
-        m.case { 0 }
-      end.value
+  context "#select" do
+    context "successful and satisfies predicate" do
+      subject { Fear::Await.result(future, 1) }
 
-      expect(value).to eq Fear.some(Fear.success(2))
+      let(:future) { Fear.future { 2 }.select(&:even?) }
+
+      it { is_expected.to eq(Fear.success(2)) }
     end
 
-    it 'failure and error case covered by pattern match' do
-      value = future { 2 / 0 }.recover do |m|
-        m.case(RuntimeError, &:message)
-        m.case(ZeroDivisionError) { 0 }
-      end.value
+    context "successful and does not satisfy predicate" do
+      subject { Fear::Await.result(future, 1).exception }
+
+      let(:future) { Fear.future { 3 }.select(&:even?) }
 
-      expect(value).to eq Fear.some(Fear.success(0))
+      it { is_expected.to be_kind_of(Fear::NoSuchElementError) }
     end
 
-    it 'failure and error case not covered by pattern match' do
-      value = future { 2 / 0 }.recover do |m|
-        m.case(RuntimeError, &:message)
-      end.value
+    context "failure" do
+      subject { Fear::Await.result(future, 1).exception }
+
+      let(:future) { Fear.future { raise error }.select(&:even?) }
+      let!(:error) { StandardError.new }
 
-      expect(value.get).to be_kind_of(Fear::Failure)
-      expect(value.get.exception).to be_kind_of(ZeroDivisionError)
+      it { is_expected.to eq(error) }
     end
   end
 
-  context '#zip' do
-    it 'success' do
-      this = future { 1 }
-      that = future { 2 }
+  context "#recover" do
+    subject { Fear::Await.result(future, 1) }
 
-      value = this.zip(that).value
+    context "successful" do
+      let(:future) do
+        Fear.future { 2 }.recover do |m|
+          m.case { 0 }
+        end
+      end
 
-      expect(value).to eq Fear.some(Fear.success([1, 2]))
+      it { is_expected.to eq(Fear.success(2)) }
     end
 
-    it 'self fails' do
-      this = future { raise error }
-      that = future { 2 }
+    context "failure and managed to recover" do
+      let(:future) do
+        Fear.future { 2 / 0 }.recover do |m|
+          m.case(RuntimeError, &:message)
+          m.case(ZeroDivisionError) { Float::INFINITY }
+        end
+      end
 
-      value = this.zip(that).value
+      it { is_expected.to eq(Fear.success(Float::INFINITY)) }
+    end
 
-      expect(value).to eq Fear.some(Fear.failure(error))
+    context "failure and error case not covered by pattern match" do
+      let(:future) do
+        Fear.future { 2 / 0 }.recover do |m|
+          m.case(RuntimeError, &:message)
+        end
+      end
+
+      it { is_expected.to match(Fear.failure(be_kind_of(ZeroDivisionError))) }
     end
+  end
 
-    it 'other fails' do
-      this = future { 1 }
-      that = future { raise error }
+  context "#zip" do
+    subject { Fear::Await.result(future, 1) }
 
-      value = this.zip(that).value
+    context "successful" do
+      let(:future) { this.zip(that) }
+      let!(:this) { Fear.future { 1 } }
+      let!(:that) { Fear.future { 2 } }
 
-      expect(value).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to eq(Fear.success([1, 2])) }
     end
 
-    it 'both fail' do
-      this = future { raise error }
-      that = future { raise ArgumentError }
+    context "first failed" do
+      let(:future) { this.zip(that) }
+      let!(:error) { StandardError.new }
+      let!(:this) { Fear.future { raise error } }
+      let!(:that) { Fear.future { 2 } }
 
-      value = this.zip(that).value
+      it { is_expected.to eq(Fear.failure(error)) }
+    end
 
-      expect(value).to eq Fear.some(Fear.failure(error))
+    context "second failed" do
+      let(:future) { this.zip(that) }
+      let!(:error) { StandardError.new }
+      let!(:this) { Fear.future { 1 } }
+      let!(:that) { Fear.future { raise error } }
+
+      it { is_expected.to eq(Fear.failure(error)) }
     end
   end
 
-  context '#fallback_to' do
-    it 'success' do
-      fallback = future { 42 }
-      value = future { 2 }.fallback_to(fallback).value
+  context "#fallback_to" do
+    subject { Fear::Await.result(future, 1) }
 
-      expect(value).to eq Fear.some(Fear.success(2))
+    context "successful" do
+      let(:future) { Fear.future { 2 }.fallback_to(fallback) }
+      let!(:fallback) { Fear.future { 42 } }
+
+      it { is_expected.to eq(Fear.success(2)) }
     end
 
-    it 'failure' do
-      fallback = future { 42 }
-      value = future { raise error }.fallback_to(fallback).value
+    context "failed" do
+      let(:future) { Fear.future { raise error }.fallback_to(fallback) }
+      let!(:fallback) { Fear.future { 42 } }
+      let!(:error) { StandardError.new }
 
-      expect(value).to eq Fear.some(Fear.success(42))
+      it { is_expected.to eq(Fear.success(42)) }
     end
 
-    it 'failure with failed fallback' do
-      fallback = future { raise ArumentError }
-      value = future { raise error }.fallback_to(fallback).value
+    context "fallback failed" do
+      let(:future) { Fear.future { raise error }.fallback_to(fallback) }
+      let!(:fallback) { Fear.future { raise } }
+      let!(:error) { StandardError.new }
 
-      expect(value).to eq Fear.some(Fear.failure(error))
+      it { is_expected.to eq(Fear.failure(error)) }
     end
   end
 
-  context '#and_then' do
-    context 'single callback' do
-      context 'callback is called' do
-        it 'returns result of future' do
+  context "#and_then" do
+    context "single callback" do
+      context "callback is called" do
+        it "calls callback" do
           expect do |callback|
-            future { 5 }.and_then do |m|
+            Fear::Future.successful(5).and_then do |m|
               m.success(&callback)
             end
           end.to yield_with_args(5)
         end
       end
 
-      context 'future with Success' do
-        context 'callback is not failing' do
-          it 'returns result of future' do
-            value = future { 5 }.and_then {}.value
+      context "future with Success" do
+        subject { Fear::Await.result(future, 1) }
 
-            expect(value).to eq Fear.some(Fear.success(5))
+        context "callback is not failing" do
+          let(:future) do
+            Fear.future { 5 }
+              .and_then { |m| m.success { |x| x * 2 } }
+          end
+
+          it "returns the same future" do
+            is_expected.to eq(Fear.success(5))
           end
         end
 
-        context 'callback is failing' do
-          it 'returns result of future' do
-            value = future { 5 }.and_then { raise error }.value
+        context "callback is failing" do
+          let(:future) { Fear.future { 5 }.and_then { |m| m.success { raise "foo" } } }
 
-            expect(value).to eq Fear.some(Fear.success(5))
-          end
+          it { is_expected.to eq(Fear.success(5)) }
         end
       end
 
-      context 'future with Failure' do
-        it 'ensure callback is called' do
+      context "future with Failure" do
+        let(:error) { StandardError.new }
+
+        it "ensure callback is called" do
           expect do |callback|
-            future { raise error }.and_then do |m|
+            Fear::Future.failed(error).and_then do |m|
               m.failure(&callback)
             end
           end.to yield_with_args(error)
         end
 
-        context 'callback is not failing' do
-          it 'returns result of future' do
-            value = future { raise error }.and_then {}.value
+        context "callback is not failing" do
+          subject { Fear::Await.result(future, 1) }
+
+          let(:future) { Fear.future { raise error }.and_then {} }
+          let!(:error) { StandardError.new }
 
-            expect(value).to eq Fear.some(Fear.failure(error))
+          it "returns result of future" do
+            is_expected.to eq(Fear.failure(error))
           end
         end
 
-        context 'callback is failing' do
-          it 'returns result of future' do
-            value = future { raise error }.and_then { raise ArgumentError }.value
+        context "callback is failing" do
+          subject { Fear::Await.result(future, 1) }
 
-            expect(value).to eq Fear.some(Fear.failure(error))
+          let(:future) do
+            Fear.future { raise error }
+              .and_then { raise ArgumentError }
+          end
+          let!(:error) { StandardError.new }
+
+          it "returns result of future" do
+            is_expected.to eq(Fear.failure(error))
           end
         end
       end
     end
 
-    context 'multiple callbacks' do
-      context 'on Future with Success' do
-        it 'ensure callbacks are called' do
+    context "multiple callbacks" do
+      context "on Future with Success" do
+        it "ensure callbacks are called" do
           expect do |first|
             expect do |second|
-              future { 5 }.and_then { |m| m.success(&first) }.and_then { |m| m.success(&second) }
+              Fear::Future.successful(5)
+                .and_then { |m| m.success(&first) }
+                .and_then { |m| m.success(&second) }
             end.to yield_with_args(5)
           end.to yield_with_args(5)
         end
 
-        # rubocop: disable Style/MultilineBlockChain
-        it 'ensure callbacks called in specified order' do
+        it "ensure callbacks called in specified order" do
           # REVIEW: could not write failing test
           last_called = nil
           Fear.future { 5 }.and_then do
@@ -385,7 +543,7 @@ RSpec.describe Fear::Future do
             last_called = :first
           end.and_then do
             expect(last_called).to(
-              eq(:first), 'second callback called before first'
+              eq(:first), "second callback called before first"
             )
             last_called = :second
           end
@@ -394,73 +552,131 @@ RSpec.describe Fear::Future do
 
           expect(last_called).to eq(:second)
         end
-        # rubocop: enable Style/MultilineBlockChain
 
-        context 'first callback is not failing' do
-          context 'and second callback is not failing' do
-            it 'returns result of the Future' do
-              value = future { 5 }.and_then {}.and_then {}.value
+        context "first callback is not failing" do
+          context "and second callback is not failing" do
+            subject { Fear::Await.result(future, 1) }
 
-              expect(value).to eq Fear.some(Fear.success(5))
+            let(:future) do
+              Fear.future { 5 }
+                .and_then {}
+                .and_then {}
             end
+
+            it { is_expected.to eq(Fear.success(5)) }
           end
 
-          context 'and second callback is failing' do
-            it 'returns result of the Future' do
-              value = future { 5 }.and_then {}.and_then do
-                raise ArgumentError
-              end.value
+          context "and second callback is failing" do
+            subject { Fear::Await.result(future, 1) }
 
-              expect(value).to eq Fear.some(Fear.success(5))
+            let(:future) do
+              Fear.future { 5 }
+                .and_then {}
+                .and_then { raise }
             end
+
+            it { is_expected.to eq(Fear.success(5)) }
           end
         end
 
-        context 'first callback is failing' do
-          it 'calls second callback' do
+        context "first callback is failing" do
+          it "calls second callback" do
             expect do |callback|
-              future { 5 }.and_then { raise error }.and_then { |m| m.success(&callback) }
+              Fear::Future.successful(5).and_then { raise error }.and_then { |m| m.success(&callback) }
             end.to yield_with_args(5)
           end
 
-          context 'and second callback is not failing' do
-            it 'returns result of the Future' do
-              value = future { 5 }.and_then { raise error }.and_then {}.value
+          context "and second callback is not failing" do
+            subject { Fear::Await.result(future, 1) }
 
-              expect(value).to eq Fear.some(Fear.success(5))
+            let(:future) do
+              Fear.future { 5 }
+                .and_then { raise }
+                .and_then {}
             end
+
+            it { is_expected.to eq(Fear.success(5)) }
           end
 
-          context 'and second callback is failing' do
-            it 'returns result of the Future' do
-              value = future { 5 }
-                .and_then { raise error }
-                .and_then { raise ArgumentError }
-                .value
+          context "and second callback is failing" do
+            subject { Fear::Await.result(future, 1) }
 
-              expect(value).to eq Fear.some(Fear.success(5))
+            let(:future) do
+              Fear.future { 5 }
+                .and_then { raise }
+                .and_then { raise ArgumentError }
             end
+
+            it { is_expected.to eq(Fear.success(5)) }
           end
         end
       end
     end
   end
 
-  context '.successful' do
-    it 'returns already succeed Future' do
-      future = described_class.successful(value)
+  context ".successful" do
+    it "returns already succeed Future" do
+      future = described_class.successful(5)
 
       future_value = future.value
 
-      expect(future_value).to eq Fear.some(Fear.success(value))
+      expect(future_value).to eq Fear.some(Fear.success(5))
     end
   end
 
-  context '.failed' do
-    it 'returns already failed Future' do
+  context ".failed" do
+    let(:error) { StandardError.new }
+
+    it "returns already failed Future" do
       value = described_class.failed(error).value
 
       expect(value).to eq Fear.some(Fear.failure(error))
     end
   end
+
+  describe Fear::Awaitable do
+    describe "#result" do
+      context "managed to complete within timeout" do
+        subject { Fear::Await.result(Fear.future { 5 }, 0.01) }
+
+        it { is_expected.to eq(Fear.success(5)) }
+      end
+
+      context "managed to complete within timeout with error" do
+        subject { Fear::Await.result(Fear.future { raise error }, 0.01) }
+
+        let!(:error) { StandardError.new }
+
+        it { is_expected.to eq(Fear.failure(error)) }
+      end
+
+      context "did not manage to complete within timeout" do
+        subject do
+          proc do
+            Fear::Await.result(Fear.future { sleep(1) }, 0.01)
+          end
+        end
+
+        it { is_expected.to raise_error(Timeout::Error) }
+      end
+    end
+
+    describe "#ready" do
+      context "managed to complete within timeout" do
+        subject { Fear::Await.ready(Fear.future { 5 }, 0.01).value }
+
+        it { is_expected.to eq(Fear.some(Fear.success(5))) }
+      end
+
+      context "did not manage to complete within timeout" do
+        subject do
+          proc do
+            Fear::Await.ready(Fear.future { sleep(1) }, 0.01)
+          end
+        end
+
+        it { is_expected.to raise_error(Timeout::Error) }
+      end
+    end
+  end
 end