startback-jobs 0.13.0 → 0.14.0

data/spec/unit/audit/test_trailer.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'startback/audit'
+module Startback
+  module Audit
+    describe Trailer do
+
+      let(:trailer) {
+        Trailer.new("/tmp/trail.log")
+      }
+
+      describe "op_name" do
+
+        def op_name(op, trailer = self.trailer)
+          trailer.send(:op_name, op)
+        end
+
+        it 'uses op_name in priority if provided' do
+          op = OpenStruct.new(op_name: "foo")
+          expect(op_name(op)).to eql("foo")
+        end
+      end
+
+      describe "op_data" do
+
+        def op_data(op, trailer = self.trailer)
+          trailer.send(:op_data, op)
+        end
+
+        it 'uses op_data in priority if provided' do
+          op = OpenStruct.new(op_data: { foo: "bar" }, input: 12, request: 13)
+          expect(op_data(op)).to eql({ foo: "bar" })
+        end
+
+        it 'uses to_trail then' do
+          op = OpenStruct.new(to_trail: { foo: "bar" }, input: 12, request: 13)
+          expect(op_data(op)).to eql({ foo: "bar" })
+        end
+
+        it 'uses input then' do
+          op = OpenStruct.new(input: { foo: "bar" }, request: 13)
+          expect(op_data(op)).to eql({ foo: "bar" })
+        end
+
+        it 'uses request then' do
+          op = OpenStruct.new(request: { foo: "bar" })
+          expect(op_data(op)).to eql({ foo: "bar" })
+        end
+
+        it 'applies default blacklists for security reasons' do
+          op = OpenStruct.new(input: {
+            token: "will not be dumped",
+            a_token: "will not be dumped",
+            AToken: "will not be dumped",
+            password: "will not be dumped",
+            secret: "will not be dumped",
+            credentials: "will not be dumped",
+            foo: "bar"
+          })
+          expect(op_data(op)).to eql({
+            foo: "bar"
+          })
+        end
+
+        it 'applies default blacklists to data arrays too' do
+          op = OpenStruct.new(input: [{
+            token: "will not be dumped",
+            a_token: "will not be dumped",
+            AToken: "will not be dumped",
+            password: "will not be dumped",
+            secret: "will not be dumped",
+            credentials: "will not be dumped",
+            foo: "bar"
+          }])
+          expect(op_data(op)).to eql([{
+            foo: "bar"
+          }])
+        end
+
+        it 'uses the stop words provided at construction' do
+          t = Trailer.new("/tmp/trail.log", blacklist: "hello and     world")
+          op = OpenStruct.new(request: { Hello: "bar", World: "foo", foo: "bar" })
+          expect(op_data(op, t)).to eql({ foo: "bar" })
+        end
+
+      end
+
+      describe "op_context" do
+
+        def op_context(op, trailer = self.trailer)
+          trailer.send(:op_context, op)
+        end
+
+        it 'applies default blacklists for security reasons' do
+          op = OpenStruct.new(context: {
+            token: "will not be dumped",
+            foo: "bar"
+          })
+          expect(op_context(op)).to eql({ foo: "bar" })
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/caching/test_entity_cache.rb

@@ -0,0 +1,136 @@
+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 primary_key(ckey)
+          case ckey
+          when Integer then "a key"
+          when String then ckey
+          else
+            raise "Invalid key `#{ckey}`"
+          end
+        end
+
+        # We use the deprecated methods below to test
+        # backward compatibility with 0.5.0.
+
+        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 "primary_key" do
+
+        subject{
+          cache.get(12)
+        }
+
+        it 'allows using candidate keys' 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, "factor" 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/context/test_dup.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "dup" do
+
+    let(:context) {
+      SubContext.new.tap{|s| s.foo = "bar" }
+    }
+
+    class ContextRelatedAbstraction
+
+      def initialize(context)
+        @context = context
+      end
+      attr_reader :context
+
+    end
+
+    it 'yields a dup of the original context' do
+      seen = false
+      got = context.dup{|x|
+        seen = x
+        expect(x).not_to be(context)
+      }
+      expect(seen).to be(got)
+      expect(got).to be_a(SubContext)
+      expect(got).not_to be(context)
+      expect(got.foo).to eql("bar")
+    end
+
+    it 'cleans all factored cache' do
+      cra = context.factor(ContextRelatedAbstraction)
+      expect(cra).to be_a(ContextRelatedAbstraction)
+      cra2 = context.factor(ContextRelatedAbstraction)
+      expect(cra2).to be(cra)
+      cra3 = context.dup.factor(ContextRelatedAbstraction)
+      expect(cra3).not_to be(cra)
+      expect(cra3).not_to be(cra2)
+    end
+
+  end
+end

data/spec/unit/context/test_fork.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "fork" do
+
+    it 'is a simple dup without args' do
+      context = SubContext.new
+      context.foo = ['hello']
+
+      forked = context.fork
+      expect(forked).not_to be(context)
+      expect(forked.foo).to eql(['hello'])
+      expect(forked.foo).to be(context.foo)
+    end
+
+    it 'yields the context if a block is provided' do
+      context = SubContext.new
+
+      seen = false
+      context.fork({ 'foo' => 'hello' }) do |forked|
+        expect(forked).not_to be(context)
+        expect(forked.foo).to eql('hello')
+        seen = true
+      end
+      expect(seen).to eql(true)
+    end
+
+    it 'uses the factory on the hash provided' do
+      context = SubContext.new
+
+      forked = context.fork({ 'foo' => 'hello' })
+      expect(forked).not_to be(context)
+      expect(forked.foo).to eql('hello')
+    end
+
+  end
+end

data/spec/unit/context/test_h_factory.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "h information contract" do
+
+    it "has a to_json that dumps it" do
+      expect(Context.new.to_json).to eql("{}")
+    end
+
+    it 'allows installing factories' do
+      expect(Context.h_factories).to be_empty
+      expect(SubContext.h_factories.size).to eql(2)
+    end
+
+    it 'has a `to_h` information contract that works as expected' do
+      context = SubContext.new.tap{|c|
+        c.foo = "Hello"
+        c.bar = "World"
+      }
+      expect(context.to_h).to eql({ "foo" => "Hello", "bar" => "World" })
+    end
+
+    it 'has a `h` information contract that works as expected' do
+      context = SubContext.h({ "foo" => "Hello", "bar" => "World" })
+      expect(context).to be_a(SubContext)
+      expect(context.foo).to eql("Hello")
+      expect(context.bar).to eql("World")
+    end
+
+  end
+end

data/spec/unit/context/test_middleware.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Startback
+  class Context
+
+    class MyContextSubClass < Context
+    end
+
+    describe Middleware do
+      include Rack::Test::Methods
+
+      def app
+        build_args = self.build_args
+        Rack::Builder.new do
+          use Middleware, *build_args
+          run ->(env){
+            ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
+            [200, {}, ctx.class.to_s]
+          }
+        end
+      end
+
+      context 'when used without context' do
+        let(:build_args){ [] }
+
+        it 'sets the default context class' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Startback::Context")
+        end
+      end
+
+      context 'when specifying the context class' do
+        let(:build_args){ [MyContextSubClass.new] }
+
+        it 'sets the default context class' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Startback::Context::MyContextSubClass")
+        end
+      end
+
+    end
+  end # module Web
+end # module Startback

data/spec/unit/context/test_with_world.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "with_world" do
+
+    let(:who) do
+      Object.new
+    end
+
+    let(:context) do
+      SubContext.new.with_world(hello: who)
+    end
+
+    it 'works as expected' do
+      got = context.world.hello
+      expect(got).to be(who)
+    end
+
+  end
+end

data/spec/unit/context/test_world.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "world" do
+
+    let(:context) do
+      SubContext.new
+    end
+
+    it 'works as expected' do
+      got = context.world.partner
+      expect(got).not_to be_nil
+      expect(context.world.partner).to be(got)
+    end
+
+  end
+end

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

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

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

@@ -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