gracefully 0.0.1 → 0.1.0

data/spec/degradable_spec.rb

@@ -0,0 +1,49 @@
+require 'gracefully/degradable'
+
+RSpec.describe Gracefully::Degradable do
+  describe 'an object included the Gracefully module' do
+    subject {
+      klass.new
+    }
+
+    context 'with the first method constantly failing' do
+      let(:klass) {
+        Class.new do
+          include Gracefully::Degradable
+
+          def foo
+            raise 'simulated error'
+          end
+
+          def bar
+            "bar"
+          end
+
+          gracefully_degrade :foo, fallback: [:bar]
+        end
+      }
+
+      specify { expect(subject.foo).to eq('bar') }
+    end
+
+    context 'with the first method timing out' do
+      let(:klass) {
+        Class.new do
+          include Gracefully::Degradable
+
+          def foo
+            sleep 1
+          end
+
+          def baz
+            "baz"
+          end
+
+          gracefully_degrade :foo, timeout: 0.1, fallback: [:baz]
+        end
+      }
+
+      specify { expect(subject.foo).to eq('baz') }
+    end
+  end
+end

data/spec/gracefully_spec.rb

@@ -1,11 +1,22 @@
 require 'gracefully'
 
+RSpec.shared_context 'successful fallback' do
+  let(:fallback_to) {
+    -> arg1 { 'fallback:arg1:' + arg1 }
+  }
+end
+
+RSpec.shared_context 'failing fallback' do
+  let(:fallback_to) {
+    -> arg1 { raise 'simulated error of fallback' }
+  }
+end
+
 RSpec.describe Gracefully do
-  describe "feature call result" do
+  describe "command call result" do
     subject {
       Gracefully.
-        degrade(feature_name).
-        usually(&usually).
+        degradable_command(&usually).
         fallback_to(&fallback_to).
         call input1
     }
@@ -14,15 +25,13 @@ RSpec.describe Gracefully do
       'input1'
     }
 
-    let(:fallback_to) {
-      -> arg1 { 'fallback:arg1:' + arg1 }
-    }
-
-    context 'when the feature is defined for the name' do
-      let(:feature_name) {
-        :the_feature
+    context 'when the command is defined for the name' do
+      let(:command_name) {
+        :the_command
       }
 
+      include_context 'successful fallback'
+
       context 'when the usually block succeeds without any error' do
         let(:usually) {
           -> arg1 { 'usually:arg1:' + arg1 }
@@ -39,5 +48,122 @@ RSpec.describe Gracefully do
         it { is_expected.to eq('fallback:arg1:input1') }
       end
     end
+
+    context 'when both the usual block and the fallback block fail' do
+      let(:command_name) {
+        :the_command
+      }
+
+      include_context 'failing fallback'
+
+      let(:usually) {
+        -> arg1 { raise 'simulated error' }
+      }
+
+      specify { expect { subject }.to raise_error(/Tried to get the value of a failure/) }
+    end
+  end
+
+  describe 'the command' do
+    let(:allowed_failures) { 1 }
+
+    let (:command) {
+      described_class.command(
+        timeout: 0.1,
+        retries: 1,
+        allowed_failures: allowed_failures,
+        run_only_if: run_only_if,
+        counter: -> { Gracefully::InMemoryCounter.new },
+        &body
+      )
+    }
+
+    subject {
+      command.call
+    }
+
+    context 'which is enabled' do
+      let(:run_only_if) {
+        -> { true }
+      }
+
+      context 'which is successful' do
+        let(:body) {
+          -> { 'ok' }
+        }
+
+        it { is_expected.to eq('ok') }
+      end
+
+      context 'which fails at first and then succeeds' do
+        let(:body) {
+          count = 0
+          -> {
+            count += 1
+            if count == 1
+              raise 'simulated error'
+            else
+              'ok'
+            end
+          }
+        }
+
+        it { is_expected.to eq('ok') }
+      end
+
+      context 'which is failing' do
+        let(:body) {
+          -> { raise 'simulated error' }
+        }
+
+        context 'after failures more than allowed' do
+          before do
+            (allowed_failures + 1).times do
+              expect { subject }.to raise_error(Gracefully::Error, 'simulated error')
+            end
+          end
+
+          specify {
+            expect { subject }.to raise_error(Gracefully::CircuitBreaker::CurrentlyOpenError)
+          }
+        end
+      end
+
+      context 'which is timing out' do
+        let(:body) {
+          -> { sleep 1 }
+        }
+
+        specify {
+          expect { subject }.to raise_error(Gracefully::Error, 'execution expired')
+        }
+
+        context 'after failures more than allowed' do
+          before do
+            (allowed_failures + 1).times do
+              expect { subject }.to raise_error(Gracefully::Error, 'execution expired')
+            end
+          end
+
+          specify {
+            expect { subject }.to raise_error(Gracefully::CircuitBreaker::CurrentlyOpenError)
+          }
+        end
+      end
+    end
+
+    context 'which is disabled' do
+      let(:run_only_if) {
+        -> { false }
+      }
+
+      let(:body) {
+        -> { 'ok' }
+      }
+
+      specify {
+        expect { subject }.to raise_error(Gracefully::CommandDisabledError)
+      }
+    end
   end
 end

data/spec/mutex_based_synchronized_counter_spec.rb

@@ -0,0 +1,50 @@
+require 'gracefully/mutex_based_synchronized_counter'
+
+RSpec.describe Gracefully::MutexBasedSynchronizedCounter do
+  subject {
+    counter.count
+  }
+
+  let(:counter) {
+    described_class.new(Gracefully::InMemoryCounter.new)
+  }
+
+  before do
+    @threads = 10.times.map do
+      Thread.abort_on_exception = true
+      Thread.start do
+        counter.increment!
+      end
+    end
+  end
+
+  specify {
+    expect(subject).to be_between(0, 10)
+  }
+
+  context 'after all the threads have finished' do
+    before do
+      @threads.each(&:join)
+    end
+
+    it { is_expected.to eq(10) }
+
+    context 'and then reset' do
+      before do
+        @thread = Thread.start do
+          counter.reset!
+        end
+      end
+
+      it { is_expected.to eq(10).or eq(0) }
+
+      context 'eventually' do
+        before do
+          @thread.join
+        end
+
+        it { is_expected.to eq(0) }
+      end
+    end
+  end
+end

data/spec/retried_command_spec.rb

@@ -0,0 +1,93 @@
+require 'gracefully'
+require 'gracefully/command'
+require 'gracefully/retried_command'
+
+RSpec.shared_examples "a retried command" do
+  let(:input1) {
+    'input1'
+  }
+
+  let(:callable) {
+    Gracefully::Command.new(&usually)
+  }
+
+  context 'when the block given to the command succeeds without any error' do
+    let(:usually) {
+      -> arg1 { 'usually:arg1:' + arg1 }
+    }
+
+    it { is_expected.to eq('usually:arg1:input1') }
+  end
+
+  context 'when the usually block fails with an error' do
+    let(:usually) {
+      -> arg1 { raise 'simulated error' }
+    }
+
+    specify { expect { subject }.to raise_error('simulated error') }
+  end
+
+  context 'when the usually block fails' do
+    let(:usually) {
+      num_trials = 0
+      -> arg1 {
+        num_trials += 1
+        if num_trials == 1
+          raise 'simulated error'
+        else
+          'usually:arg1:' + arg1
+        end
+      }
+    }
+
+    specify {
+      expect(subject).to eq('usually:arg1:input1')
+    }
+  end
+end
+
+RSpec.describe Gracefully::RetriedCommand do
+  context "command creation with invalid number of arguments" do
+    subject {
+      described_class.new(1, 2, 3)
+    }
+
+    specify { expect { subject }.to raise_error(/Invalid number of arguments: 3/) }
+  end
+
+  describe 'with 0 retries' do
+    context 'made of a callable object' do
+      subject {
+        described_class.new(usually, retries: 0).call input1
+      }
+
+      it_behaves_like 'a command'
+    end
+  end
+
+  describe "with more than 1 retries" do
+    context 'made of a callable object' do
+      subject {
+        described_class.new(usually, retries: 1).call input1
+      }
+
+      it_behaves_like 'a retried command'
+    end
+
+    context 'made of a command' do
+      subject {
+        described_class.new(callable, retries: 1).call input1
+      }
+
+      it_behaves_like 'a retried command'
+    end
+
+    context 'made of a block' do
+      subject {
+        described_class.new(retries: 1, &usually).call input1
+      }
+
+      it_behaves_like 'a retried command'
+    end
+  end
+end

data/spec/short_circuited_command_spec.rb

@@ -0,0 +1,136 @@
+require 'gracefully'
+require 'gracefully/short_circuited_command'
+
+RSpec.shared_examples "a short-circuited command" do
+  let(:input1) {
+    'input1'
+  }
+
+  let(:callable) {
+    Gracefully::Command.new(&usually)
+  }
+
+  context 'when the block given to the command succeeds without any error' do
+    let(:usually) {
+      -> arg1 { 'usually:arg1:' + arg1 }
+    }
+
+    it { is_expected.to eq('usually:arg1:input1') }
+  end
+
+  context 'when the usually block fails with an error' do
+    let(:usually) {
+      -> arg1 { raise 'simulated error' }
+    }
+
+    specify { expect { subject }.to raise_error('simulated error') }
+
+    context 'more than allowed times' do
+      let(:failed_at) {
+        Time.now
+      }
+
+      before do
+        Timecop.freeze(failed_at) do
+          2.times do
+            expect { subject }.to raise_error('simulated error')
+          end
+        end
+      end
+
+      around do |ex|
+        Timecop.freeze(failed_at + passed_seconds) { ex.run }
+      end
+
+      context '0 seconds passed' do
+        let(:passed_seconds) { 0 }
+
+        specify {
+          expect { subject }.to raise_error(Gracefully::CircuitBreaker::CurrentlyOpenError)
+        }
+      end
+
+      context 'try_close_after seconds passed' do
+        let(:passed_seconds) { try_close_after }
+
+        specify {
+          expect { subject }.to raise_error(Gracefully::CircuitBreaker::CurrentlyOpenError)
+        }
+      end
+
+      context 'try_close_after + 1 seconds passed' do
+        let(:passed_seconds) { try_close_after + 1 }
+
+        specify {
+          expect { subject }.to raise_error('simulated error')
+        }
+      end
+    end
+  end
+end
+
+RSpec.describe Gracefully::ShortCircuitedCommand do
+  context "command creation with invalid number of arguments" do
+    subject {
+      described_class.new(1, 2, 3)
+    }
+
+    specify { expect { subject }.to raise_error(/Invalid number of arguments: 3/) }
+  end
+
+  let(:try_close_after) {
+    3
+  }
+
+  describe 'with 0 allowed failures' do
+    context 'made of a callable object' do
+      subject {
+        described_class.new(usually, allowed_failures: 0).call input1
+      }
+
+      it_behaves_like 'a command'
+    end
+  end
+
+  describe "with more than 1 allowed failures" do
+    subject {
+      command.call input1
+    }
+
+    let(:allowed_failures) {
+      1
+    }
+
+    let(:options) {
+      {
+        allowed_failures: allowed_failures,
+        try_close_after: try_close_after,
+        counter: -> { Gracefully::InMemoryCounter.new }
+      }
+    }
+
+    context 'made of a callable object' do
+      let(:command) {
+        described_class.new(usually, options)
+      }
+
+      it_behaves_like 'a short-circuited command'
+    end
+
+    context 'made of a command' do
+      let(:command) {
+        described_class.new(callable, options)
+      }
+
+      it_behaves_like 'a short-circuited command'
+    end
+
+    context 'made of a block' do
+      let(:command) {
+        described_class.new(options, &usually)
+      }
+
+      it_behaves_like 'a short-circuited command'
+    end
+  end
+end