startback-jobs 0.14.0 → 0.14.1

data/spec/unit/event/bus/memory/test_async.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-module Startback
-  class Event
-    describe Bus::Memory do
-
-      subject{
-        Bus::Memory::Async.new
-      }
-
-      it 'allows emiting an receiving' do
-        seen = nil
-        subject.listen("user_changed") do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new("user_changed", {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'allows mixin Symbol vs. String for event type' do
-        seen = nil
-        subject.listen(:user_changed) do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new(:user_changed, {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'does not raise errors synchronously' do
-        subject.listen("user_changed") do |evt|
-          raise "An error occured"
-        end
-        expect {
-          subject.emit(Event.new("user_changed", {id: 12}))
-        }.not_to raise_error
-      end
-
-    end
-  end
-end

data/spec/unit/event/bus/memory/test_sync.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-module Startback
-  class Event
-    describe Bus::Memory do
-
-      subject{
-        Bus::Memory::Sync.new
-      }
-
-      it 'allows emiting an receiving' do
-        seen = nil
-        subject.listen("user_changed") do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new("user_changed", {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'allows mixin Symbol vs. String for event type' do
-        seen = nil
-        subject.listen(:user_changed) do |evt|
-          seen = evt
-        end
-        subject.emit(Event.new(:user_changed, {id: 12}))
-        expect(seen).to be_a(Event)
-        expect(seen.type).to eql("user_changed")
-        expect(seen.data.to_h).to eql({id: 12})
-      end
-
-      it 'raises emit errors synchronously' do
-        subject.listen("user_changed") do |evt|
-          raise "An error occured"
-        end
-        expect {
-          subject.emit(Event.new("user_changed", {id: 12}))
-        }.to raise_error("An error occured")
-      end
-
-    end
-  end
-end

data/spec/unit/support/hooks/test_after_hook.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe Hooks, "after_xxx" do
-
-      class AfterHooked
-        include Hooks.new(:xxx)
-
-        def initialize
-          super
-          @after_called = false
-        end
-        attr_accessor :after_called
-
-        after_xxx do
-          self.after_called = true
-        end
-
-      end
-
-      class SubAfterHooked < AfterHooked
-
-        def initialize
-          super
-          @subafter_called = false
-        end
-        attr_accessor :subafter_called
-
-        after_xxx do
-          self.subafter_called = true
-        end
-
-      end
-
-      it 'works as expected' do
-        h = AfterHooked.new
-        expect(h.after_called).to eql(false)
-        h.after_xxx
-        expect(h.after_called).to eql(true)
-      end
-
-      it 'works as expected on subclass' do
-        h = SubAfterHooked.new
-        expect(h.after_called).to eql(false)
-        expect(h.subafter_called).to eql(false)
-        h.after_xxx
-        expect(h.after_called).to eql(true)
-        expect(h.subafter_called).to eql(true)
-      end
-
-    end
-  end
-end

data/spec/unit/support/hooks/test_before_hook.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'singleton'
-module Startback
-  module Support
-    describe Hooks, "before_xxx" do
-
-      class BeforeHooked
-        include Hooks.new(:xxx)
-
-        def initialize
-          super
-          @before_called = false
-        end
-        attr_accessor :before_called
-
-        before_xxx do
-          self.before_called = true
-        end
-
-      end
-
-      class SubBeforeHooked < BeforeHooked
-
-        def initialize
-          super
-          @subbefore_called = false
-        end
-        attr_accessor :subbefore_called
-
-        before_xxx do
-          self.subbefore_called = true
-        end
-
-      end
-
-      it 'works as expected' do
-        h = BeforeHooked.new
-        expect(h.before_called).to eql(false)
-        h.before_xxx
-        expect(h.before_called).to eql(true)
-      end
-
-      it 'works as expected on subclass' do
-        h = SubBeforeHooked.new
-        expect(h.before_called).to eql(false)
-        expect(h.subbefore_called).to eql(false)
-        h.before_xxx
-        expect(h.before_called).to eql(true)
-        expect(h.subbefore_called).to eql(true)
-      end
-
-    end
-  end
-end

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

@@ -1,156 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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