startback 0.4.5 → 0.5.0

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Startback
+  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

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Startback
+  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

data/spec/unit/caching/test_entity_cache.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'startback/caching/entity_cache'
+require 'startback/caching/store'
+module Startback
+  module Caching
+    describe EntityCache do
+
+      class BaseCache < EntityCache
+
+        def initialize(context = nil)
+          super(Store.new, context)
+          @called = 0
+          @last_key = nil
+        end
+        attr_reader :called, :last_key
+
+      protected
+
+        def full_key(key)
+          { k: key }
+        end
+
+        def load_raw_data(key)
+          @called += 1
+          @last_key = key
+          "a value"
+        end
+
+      end
+
+      class ShortCache < BaseCache
+        self.default_ttl = 1
+      end
+
+      class InvalidatingCache < BaseCache
+
+      protected
+
+        def valid?(key, value)
+          false
+        end
+
+      end
+
+      let(:cache) {
+        BaseCache.new
+      }
+
+      describe "default_ttl" do
+
+        it 'has a default ttl of one hour' do
+          expect(BaseCache.default_ttl).to eql(3600)
+        end
+
+        it 'allows overriding it' do
+          expect(ShortCache.default_ttl).to eql(1)
+        end
+
+        it 'is accessible as default_caching_options on the instance' do
+          expect(cache.send(:default_caching_options)).to eql({ttl: 3600})
+        end
+
+      end
+
+      describe "get" do
+
+        subject{
+          cache.get("a key")
+        }
+
+        it 'yields to load_raw_data only once with the short key' do
+          expect(subject).to eql("a value")
+          expect(subject).to eql("a value")
+          expect(cache.called).to eql(1)
+          expect(cache.last_key).to eql("a key")
+        end
+
+      end
+
+      describe "invalidate" do
+
+        it 'strips the key on the store, yielding a cache miss' do
+          expect(cache.get("a key")).to eql("a value")
+          cache.invalidate("a key")
+          expect(cache.get("a key")).to eql("a value")
+          expect(cache.called).to eql(2)
+          expect(cache.last_key).to eql("a key")
+        end
+
+      end
+
+      describe "valid? override" do
+
+        let(:cache) {
+          InvalidatingCache.new
+        }
+
+        it 'yields to load_raw_data only once with the extend key' do
+          expect(cache.get("a key")).to eql("a value")
+          expect(cache.get("a key")).to eql("a value")
+          expect(cache.called).to eql(2)
+          expect(cache.last_key).to eql("a key")
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/context/test_abstraction_factory.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module Startback
+  describe Context do
+
+    let(:context) {
+      Context.new
+    }
+
+    class ContextRelatedAbstraction
+
+      def initialize(context)
+        @context = context
+      end
+      attr_reader :context
+
+    end
+
+    class ContextRelatedAbstractionWithArgs
+
+      def initialize(arg1, arg2, context)
+        @arg1 = arg1
+        @arg2 = arg2
+        @context = context
+      end
+      attr_reader :arg1, :arg2, :context
+
+    end
+
+    it 'is a factory for other context-related abstractions' do
+      got = context.factor(ContextRelatedAbstraction)
+      expect(got).to be_a(ContextRelatedAbstraction)
+      expect(got.context).to be(context)
+
+      got2 = context.factor(ContextRelatedAbstraction)
+      expect(got2).to be(got)
+    end
+
+    it 'is takes cares of abstraction arguments' do
+      got = context.factor(ContextRelatedAbstractionWithArgs, 12, 14)
+      expect(got).to be_a(ContextRelatedAbstractionWithArgs)
+      expect(got.context).to be(context)
+      expect(got.arg1).to eql(12)
+      expect(got.arg2).to eql(14)
+    end
+
+    it 'is caches even in presence ofabstraction arguments' do
+      got = context.factor(ContextRelatedAbstractionWithArgs, 12, 14)
+      expect(got).to be_a(ContextRelatedAbstractionWithArgs)
+
+      got2 = context.factor(ContextRelatedAbstractionWithArgs, 12, 14)
+      expect(got2).to be(got)
+    end
+
+    it 'is distinguishes different abstraction arguments' do
+      got = context.factor(ContextRelatedAbstractionWithArgs, 12, 14)
+      expect(got).to be_a(ContextRelatedAbstractionWithArgs)
+
+      got2 = context.factor(ContextRelatedAbstractionWithArgs, 17, 14)
+      expect(got2).not_to be(got)
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,157 @@
+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 TransactionManager
+          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 TransactionManager.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(TransactionManager.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