startback-jobs 0.13.0 → 0.14.0

data/spec/unit/support/operation_runner/test_around_run.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'singleton'
+module Startback
+  module Support
+    describe OperationRunner, "around_run" do
+
+      class OperationTest < Startback::Operation
+
+        def call
+          { seen_hello: hello }
+        end
+
+      end
+
+      let(:op) {
+        OperationTest.new
+      }
+
+      context 'the simplest contract' do
+        class RunnerTest1
+          include OperationRunner
+
+          def operation_world(op)
+            { hello: "world"}
+          end
+        end
+
+        it 'lets run an operation with world bound' do
+          expect(RunnerTest1.new.run(op)).to eql({
+            seen_hello: "world"
+          })
+        end
+      end
+
+      context 'the around feature' do
+        class RunnerTest2
+          include OperationRunner
+
+          def initialize
+            @arounds = []
+          end
+          attr_reader :arounds
+
+          around_run do |o, then_block|
+            raise unless o.is_a?(OperationTest)
+            arounds << "hello"
+            then_block.call
+          end
+
+          around_run do |_, then_block|
+            arounds << "world"
+            then_block.call
+          end
+
+          def operation_world(op)
+            { hello: "world" }
+          end
+        end
+
+        it 'calls the around before the operation itself' do
+          test = RunnerTest2.new
+          got = test.run(op)
+          expect(test.arounds).to eql(["hello", "world"])
+          expect(got).to eql({
+            seen_hello: "world"
+          })
+        end
+      end
+
+      context 'the around feature with a class' do
+        class SomeTransactionManager
+          include Singleton
+
+          def initialize
+            @called = false
+          end
+          attr_reader :called
+
+          def call(runner, op)
+            raise unless runner.is_a?(RunnerTest3)
+            raise unless op.is_a?(OperationTest)
+            @called = true
+            yield
+          end
+
+        end
+
+        class RunnerTest3
+          include OperationRunner
+          around_run SomeTransactionManager.instance
+
+          def operation_world(op)
+            { hello: "world" }
+          end
+        end
+
+        it 'calls the proc with expected parameters' do
+          test = RunnerTest3.new
+          got = test.run(op)
+          expect(SomeTransactionManager.instance.called).to eql(true)
+          expect(got).to eql({
+            seen_hello: "world"
+          })
+        end
+      end
+
+      context 'the around feature with a subclass' do
+        class RunnerTest4
+          include OperationRunner
+
+          def initialize
+            @called = false
+          end
+          attr_reader :called
+
+          around_run do |o,t|
+            raise unless o.is_a?(OperationTest)
+            @called = true
+            t.call
+          end
+        end
+
+        class RunnerTest5 < RunnerTest4
+
+          def initialize
+            super
+            @subcalled = false
+          end
+          attr_reader :subcalled
+
+          around_run do |o,t|
+            raise unless o.is_a?(OperationTest)
+            @subcalled = true
+            t.call
+          end
+
+          def operation_world(op)
+            { hello: "world" }
+          end
+        end
+
+        it 'executes all hooks' do
+          test = RunnerTest5.new
+          got = test.run(op)
+          expect(test.called).to be(true)
+          expect(test.subcalled).to be(true)
+          expect(got).to eql({
+            seen_hello: "world"
+          })
+        end
+
+      end
+
+    end # module OperationRunner
+  end # module Support
+end # module Startback

data/spec/unit/support/operation_runner/test_before_after_call.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'singleton'
+module Startback
+  module Support
+    describe OperationRunner, "before_call" do
+
+      class OperationTestBeforeCall < Operation
+
+        def initialize
+          before_called = false
+        end
+        attr_accessor :before_called
+
+        before_call do
+          self.before_called = true
+        end
+
+        def call
+          {
+            seen_hello: "world"
+          }
+        end
+
+      end
+
+      let(:op) {
+        OperationTestBeforeCall.new
+      }
+
+      class RunnerTest1
+        include OperationRunner
+
+        def operation_world(op)
+          { hello: "world" }
+        end
+      end
+
+      it 'runs before the around hooks' do
+        expect(RunnerTest1.new.run(op)).to eql({
+          seen_hello: "world"
+        })
+        expect(op.before_called).to eql(true)
+      end
+
+
+    end
+  end
+end

data/spec/unit/support/test_data_object.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module Startback
+  module Support
+    describe DataObject do
+
+      class FooDataObject
+        include DataObject
+      end
+
+      let(:data) do
+        {
+          :foo => 'bar',
+          'bar' => 'baz'
+        }
+      end
+
+      subject do
+        FooDataObject.new(data)
+      end
+
+      it 'lets create an instance with providing data' do
+        expect(subject).to be_a(FooDataObject)
+      end
+
+      it 'lets get the data back' do
+        expect(subject.to_data).to eql(data)
+        expect(subject.to_data).not_to be(data)
+      end
+
+      it 'lets to_json it' do
+        expect(subject.to_json).to eql(%Q{{"foo":"bar","bar":"baz"}})
+      end
+
+      describe "data helpers" do
+        it 'lets access data through methods' do
+          expect(subject.foo).to eql('bar')
+        end
+
+        it 'is indifferent to symbol vs. string' do
+          expect(subject.bar).to eql('baz')
+        end
+
+        it 'is indifferent to camel casing' do
+          expect(subject.bar).to eql('baz')
+        end
+
+        it 'raises a NoMethodError when not known' do
+          expect {
+            subject.no_such_one
+          }.to raise_error(NoMethodError)
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:foo)).to eql(true)
+          expect(subject.respond_to?(:bar)).to eql(true)
+          expect(subject.respond_to?(:no_such_one)).to eql(false)
+        end
+      end # data helpers
+
+      describe "? helpers" do
+        let(:data) do
+          {
+            'some' => 'thing',
+            'ready' => false,
+            'unready' => true,
+            'nothing' => nil
+          }
+        end
+
+        it 'works as expected' do
+          expect(subject.some?).to eql(true)
+          expect(subject.ready?).to eql(false)
+          expect(subject.unready?).to eql(true)
+          expect(subject.nothing?).to eql(false)
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:some?)).to eql(true)
+          expect(subject.respond_to?(:ready?)).to eql(true)
+          expect(subject.respond_to?(:unready?)).to eql(true)
+          expect(subject.respond_to?(:nothing?)).to eql(true)
+        end
+
+        it 'stays conservative' do
+          expect {
+            subject.no_such_one?
+          }.to raise_error(NoMethodError)
+          expect(subject.respond_to?(:no_such_one?)).to eql(false)
+        end
+      end
+
+      describe "case helpers" do
+        let(:data) do
+          {
+            'camelCase' => 'snake_case'
+          }
+        end
+
+        it 'lets use camelCase' do
+          expect(subject.camelCase).to eql('snake_case')
+        end
+
+        it 'lets use camel_case' do
+          expect(subject.camel_case).to eql('snake_case')
+        end
+
+        it 'implements respond_to? correctly' do
+          expect(subject.respond_to?(:camelCase)).to eql(true)
+          expect(subject.respond_to?(:camel_case)).to eql(true)
+        end
+
+        it 'is compatible with ? helpers' do
+          expect(subject.camelCase?).to eql(true)
+          expect(subject.camel_case?).to eql(true)
+        end
+
+        it 'stays conservative' do
+          expect {
+            subject.no_such_one
+          }.to raise_error(NoMethodError)
+          expect(subject.respond_to?(:no_such_one)).to eql(false)
+          expect(subject.respond_to?(:no_such_one?)).to eql(false)
+        end
+      end
+
+      describe '[]' do
+        let(:data) do
+          {
+            :foo => 'bar',
+            'bar' => 'baz',
+            'camelCase' => 'snake_case'
+          }
+        end
+
+        it 'lets access data' do
+          expect(subject[:foo]).to eql('bar')
+          expect(subject['bar']).to eql('baz')
+          expect(subject['camelCase']).to eql('snake_case')
+        end
+
+        it 'uses indifferent access' do
+          expect(subject['foo']).to eql('bar')
+          expect(subject[:bar]).to eql('baz')
+          expect(subject[:camelCase]).to eql('snake_case')
+        end
+
+        it 'has no other magic and returns nil in all other cases' do
+          expect(subject[:foo?]).to be_nil
+          expect(subject[:camel_case]).to be_nil
+          expect(subject[:camel_case?]).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/unit/support/test_env.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+module Startback
+  module Support
+    describe Env do
+      include Env
+
+      before do
+        ENV['FOO'] = 'BAR'
+        ENV['FOOL'] = ''
+        ENV['FOOLISH'] = ' BAR '
+      end
+
+      after do
+        ENV.delete('FOO')
+        ENV.delete('FOOL')
+      end
+
+      describe "env" do
+        it 'returns an env variable' do
+          expect(env('FOO')).to eql('BAR')
+        end
+
+        it 'returns nil otherwise' do
+          expect(env('BAR')).to be_nil
+        end
+
+        it 'strips the value' do
+          expect(env('FOOLISH')).to eql('BAR')
+        end
+
+        it 'yields the block if any' do
+          expect(env('FOO'){|x| x.downcase }).to eql('bar')
+        end
+
+        it 'support a default value' do
+          expect(env('BAR', 'BAZ')).to eql('BAZ')
+        end
+
+        it 'yields the block with the default if any' do
+          expect(env('BAR', 'BAZ'){|x| x.downcase }).to eql('baz')
+        end
+
+        it 'returns nil when empty' do
+          expect(env('FOOL')).to be_nil
+        end
+
+        it 'yields the block with the default if empty' do
+          expect(env('FOOL', 'BAZ'){|x| x.downcase }).to eql('baz')
+        end
+      end
+
+      describe "env!" do
+        it 'returns an env variable' do
+          expect(env!('FOO')).to eql('BAR')
+        end
+
+        it 'strips the value' do
+          expect(env!('FOOLISH')).to eql('BAR')
+        end
+
+        it 'raise otherwise' do
+          expect{ env!('BAR') }.to raise_error(Startback::Errors::Error, /BAR/)
+        end
+
+        it 'raise on empty' do
+          expect{ env!('FOOL') }.to raise_error(Startback::Errors::Error, /FOOL/)
+        end
+
+        it 'yields the block if any' do
+          expect(env('FOO'){|x| x.downcase }).to eql('bar')
+        end
+      end
+    end
+  end
+end

data/spec/unit/support/test_robusteness.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+module Startback
+  module Support
+    describe Robustness do
+
+      let(:the_logger) {
+        FakeLogger.new
+      }
+
+      let(:context_with_logger) {
+        Context.new.tap{|c| c.logger = the_logger }
+      }
+
+      describe "monitor" do
+        include Robustness
+
+        it 'works' do
+          x = monitor("test", context_with_logger) do
+            12
+          end
+          expect(x).to eql(12)
+          expect(the_logger.last_msg.keys).to eql([:op, :op_took])
+        end
+
+      end # monitor
+
+      describe "stop_errors" do
+        include Robustness
+
+        it 'works and logs the error' do
+          x = nil
+          expect {
+            x = stop_errors("test", context_with_logger) do
+              raise "Test"
+            end
+          }.not_to raise_error
+          expect(x).to be(nil)
+          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
+        end
+
+        it 'returns the result if no error' do
+          x = nil
+          expect {
+            x = stop_errors("test", context_with_logger) do
+              12
+            end
+          }.not_to raise_error
+          expect(x).to eql(12)
+          expect(the_logger.last_msg).to be_nil
+        end
+
+      end
+
+      describe "try_max_times" do
+        include Robustness
+
+        it 'fails if n errors are seen' do
+          seen = 0
+          expect {
+            try_max_times(2, "test", context_with_logger) do
+              seen += 1
+              raise "Test"
+            end
+          }.to raise_error("Test")
+          expect(seen).to eql(2)
+          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
+        end
+
+        it 'suceeds if an attemps succeeds' do
+          seen = 0
+          result = nil
+          expect {
+            result = try_max_times(2, "test", context_with_logger) do
+              seen += 1
+              raise "Test" if seen == 1
+              12
+            end
+          }.not_to raise_error
+          expect(result).to eql(12)
+          expect(seen).to eql(2)
+          expect(the_logger.last_msg.keys).to eql([:op, :op_took, :error])
+        end
+
+        it 'suceeds if first attemps succeeds' do
+          result = nil
+          expect {
+            result = try_max_times(2, "test", context_with_logger) do
+              12
+            end
+          }.not_to raise_error
+          expect(result).to eql(12)
+          expect(the_logger.last_msg).to be_nil
+        end
+
+      end
+
+      describe "parse_args" do
+        include Robustness::Tools
+
+        it 'works fine with full op and no context' do
+          log_msg_src = {
+            op: "AnOp",
+            op_data: { foo: "bar" }
+          }
+          log_msg, logger = parse_args(log_msg_src)
+          expect(log_msg).to eql(log_msg_src)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with an string and a method name' do
+          expected = {
+            op: "AClass#method"
+          }
+          log_msg, logger = parse_args("AClass", "method")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with an string, a method name, and a message' do
+          expected = {
+            op: "AClass#method",
+            op_data: { message: "Hello world" }
+          }
+          log_msg, logger = parse_args("AClass", "method", "Hello world")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with a string only' do
+          expected = {
+            op: "a message"
+          }
+          log_msg, logger = parse_args("a message")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with a Exception only' do
+          exception = StandardError.new('hello')
+          expected = {
+            error: exception
+          }
+          log_msg, logger = parse_args(exception)
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with a string and a context with logger' do
+          expected = {
+            op: "a message"
+          }
+          log_msg, logger = parse_args("a message", context_with_logger)
+          expect(log_msg).to eql(expected)
+          expect(logger).to be(the_logger)
+        end
+
+        it 'works fine with a string and an extra hash' do
+          expected = {
+            op: "a message",
+            op_took: 16
+          }
+          log_msg, logger = parse_args("a message", op_took: 16)
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with a module and method' do
+          expected = {
+            op: "Startback#foo"
+          }
+          log_msg, logger = parse_args(Startback, "foo")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with a class and method' do
+          expected = {
+            op: "Startback::Event#foo"
+          }
+          log_msg, logger = parse_args(Startback::Event, "foo")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'works fine with an instance and method' do
+          expected = {
+            op: "Startback::Event#foo"
+          }
+          log_msg, logger = parse_args(Startback::Event.new(nil, nil), "foo")
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+
+        it 'when a hash is passed as last arg' do
+          expected = {
+            op: "hello#foo",
+            op_took: 16
+          }
+          log_msg, logger = parse_args("hello", "foo", op_took: 16)
+          expect(log_msg).to eql(expected)
+          expect(logger).to be_a(::Logger)
+        end
+      end
+
+      describe "logger_for" do
+        include Robustness::Tools
+
+        it 'works on a logger' do
+          expect(logger_for(the_logger)).to be(the_logger)
+        end
+
+        it 'works on a Context responding to logger' do
+          expect(logger_for(context_with_logger)).to be(the_logger)
+        end
+
+        it 'works on an object having a Context responding to logger' do
+          x = OpenStruct.new(context: context_with_logger)
+          expect(logger_for(x)).to eql(the_logger)
+        end
+
+        it 'works on an object having a Context but no logger' do
+          x = OpenStruct.new(context: Context.new)
+          expect(logger_for(x)).to be_a(::Logger)
+        end
+      end
+
+    end
+  end
+end