startback-jobs 0.13.0 → 0.14.0

data/spec/unit/support/test_transaction_manager.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+module Startback
+  module Support
+    describe TransactionManager do
+      subject do
+        TransactionManager.new(db).call(nil, op) do
+          op.call
+        end
+      end
+
+      class FakeDatabase
+        def initialize
+          @called = false
+        end
+        attr_reader :called
+
+        def transaction
+          @called = true
+          yield
+        end
+      end
+
+      let(:db) do
+        FakeDatabase.new
+      end
+
+      context 'when called with a default operation' do
+        class OperationNotManagingTransactions < Startback::Operation
+          def call
+            12
+          end
+        end
+
+        let(:op) do
+          OperationNotManagingTransactions.new
+        end
+
+        it 'calls db.transaction' do
+          expect(subject).to eql(12)
+          expect(db.called).to eql(true)
+        end
+      end
+
+      context 'when called with an operation that manages the transactions itself' do
+        class OperationManagingTransactions < Startback::Operation
+          self.transaction_policy = :within_call
+
+          def call
+            12
+          end
+        end
+
+        let(:op) do
+          OperationManagingTransactions.new
+        end
+
+        it 'calls db.transaction' do
+          expect(subject).to eql(12)
+          expect(db.called).to eql(false)
+        end
+      end
+    end
+  end
+end

data/spec/unit/support/test_world.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Startback
+  module Support
+    describe World do
+
+      let(:world) do
+        World.new
+      end
+
+      describe 'with' do
+        subject do
+          world.with(foo: :bar, bar: :baz)
+        end
+
+        it 'returns a new world instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'gives access to those variables' do
+          expect(subject.foo).to eql(:bar)
+          expect(subject[:bar]).to eql(:baz)
+        end
+      end
+
+      describe 'dup' do
+        let(:world) do
+          World.new(foo: :bar)
+        end
+
+        subject do
+          world.dup
+        end
+
+        it 'returns another instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'keeps variables' do
+          expect(subject.foo).to eql(:bar)
+        end
+      end
+
+      describe 'class factory' do
+        subject do
+          world.factory(:foo) do
+            hello
+          end
+        end
+
+        def hello
+          OpenStruct.new(bar: 12)
+        end
+
+        it 'returns a world instance' do
+          expect(subject).to be_a(World)
+          expect(subject).not_to be(world)
+        end
+
+        it 'installs the factory' do
+          bound = subject.with_scope(self)
+          got = bound.foo
+          expect(got).to be_a(OpenStruct)
+          expect(got.bar).to eql(12)
+          expect(bound.foo).to be(got)
+        end
+      end
+    end
+  end
+end

data/spec/unit/test_event.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Startback
+  describe Event do
+
+    subject{
+      Event.new("User::Changed", { "foo" => "bar" })
+    }
+
+    it 'presents an ostruct on top of its data' do
+      expect(subject.data.foo).to eql("bar")
+    end
+
+    describe "the json information contract" do
+
+      JSON_SRC = <<-JSON.gsub(/\s+/, "")
+        {
+          "type": "User::Changed",
+          "data": {
+            "foo": "bar"
+          }
+        }
+      JSON
+
+      it 'has a to_json method that works as expected' do
+        expect(subject.to_json).to eql(JSON_SRC)
+      end
+
+      it 'has a to_json that dumps the context if any' do
+        evt = Event.new("User::Changed", { "foo" => "bar" }, { "baz": "context" })
+        expect(evt.to_json).to eql(<<-JSON.gsub(/\s+/, ""))
+          {
+            "type": "User::Changed",
+            "data": {
+              "foo": "bar"
+            },
+            "context": {
+              "baz": "context"
+            }
+          }
+        JSON
+      end
+
+
+      it 'has a json class method that works as expected' do
+        evt = Event.json(JSON_SRC, nil)
+        expect(evt).to be_a(Event)
+        expect(evt.type).to eql("User::Changed")
+        expect(evt.data).to eql(subject.data)
+      end
+
+      it 'accepts an explicit context as second argument' do
+        c = SubContext.new.tap{|x| x.foo = 'hello' }
+        evt = Event.json(JSON_SRC, c)
+        expect(evt.context).not_to be(c)
+        expect(evt.context).to be_a(SubContext)
+        expect(evt.context.foo).to eql('hello')
+      end
+    end
+
+  end
+end # module Startback

data/spec/unit/test_operation.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Startback
+  describe Operation do
+
+    class FooOp < Operation
+
+      def initialize(foo = :bar)
+        @foo = foo
+      end
+      attr_accessor :foo
+
+      def call
+        @foo
+      end
+
+    end
+
+    it 'can be bound, which returns a new operation' do
+      foo1 = FooOp.new
+      foo1.foo = :bar1
+
+      foo2 = foo1.bind({ db: :bar })
+      expect(foo2.foo).to eql(:bar1)
+      expect(foo2.db).to eql(:bar)
+    end
+
+  end
+
+  describe Operation::MultiOperation do
+
+    it 'lets chain with +' do
+      mop = Operation::MultiOperation.new
+      mop2 = (mop + FooOp.new)
+
+      expect(mop == mop2).to eql(false)
+      expect(mop.size).to eql(0)
+      expect(mop2.size).to eql(1)
+    end
+
+    it 'calls and collects the result on call' do
+      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
+      expect(mop.call).to eql([:hello, :world])
+    end
+
+    it 'binds every sub operation recursively' do
+      mop = Operation::MultiOperation.new + FooOp.new(:hello) + FooOp.new(:world)
+      mop2 = mop.bind({requester: :bar})
+
+      expect(mop == mop2).to eql(false)
+      expect(mop2.ops.all?{|op| op.requester == :bar })        
+    end
+
+  end
+end # module Startback

data/spec/unit/test_support.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Startback
+  describe Support do
+    include Support
+
+    describe "deep_merge" do
+
+      it 'works as expected' do
+        h1 = {
+          :foo => "bar",
+          :bar => "unchanged",
+          :baz => {
+            "hello" => "world",
+            "changed" => "yes"
+          }
+        }
+        h2 = {
+          :foo => "baz",
+          :baz => {
+            "eloy" => "tom",
+            "changed" => "no"
+          }
+        }
+        expected = {
+          :foo => "baz",
+          :bar => "unchanged",
+          :baz => {
+            "hello" => "world",
+            "eloy" => "tom",
+            "changed" => "no"
+          }
+        }
+        expect(deep_merge(h1, h2)).to eql(expected)
+      end
+
+    end
+
+  end
+end

data/spec/unit/web/fixtures/assets/app/hello.es6

@@ -0,0 +1,4 @@
+let test = (x) => {
+  console.log("Hello " + x)
+}
+test("world")

data/spec/unit/web/fixtures/assets/app/hello.html

@@ -0,0 +1 @@
+<p>Hello {{who}}</p>

data/spec/unit/web/fixtures/assets/index.es6

@@ -0,0 +1 @@
+//= require_tree ./app

data/spec/unit/web/test_api.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'startback/web/api'
+
+module Startback
+  module Web
+    describe Api do
+      include Rack::Test::Methods
+
+      class JsonDto
+        def to(accept, content_type)
+          ["application/json", %Q{{"foo":"bar"}}]
+        end
+      end
+
+      class PathDto
+        def to(accept, content_type)
+          ["text/plain", Path.file]
+        end
+      end
+
+      class DtoAble
+        def initialize(dto)
+          @dto = dto
+        end
+        def to_dto(context)
+          @dto
+        end
+      end
+
+      class TestedApi < ::Startback::Web::Api
+        get '/no-such-one' do
+          serve("Something", nil)
+        end
+
+        get '/entity' do
+          serve('Entity', {foo: "bar"})
+        end
+
+        get '/path' do
+          serve('Path', Path.file)
+        end
+
+        get '/dto-able' do
+          serve('DTO', DtoAble.new(JsonDto.new))
+        end
+
+        get '/dto-path' do
+          serve('DTO', DtoAble.new(PathDto.new))
+        end
+      end
+
+      let(:app) {
+        TestedApi
+      }
+
+      it 'convert nil to 404' do
+        get '/no-such-one'
+        expect(last_response.status).to eql(404)
+      end
+
+      it 'supports serving entities' do
+        get '/entity'
+        expect(last_response.body).to eql(%Q{{"foo":"bar"}})
+      end
+
+      it 'supports serving paths' do
+        get '/path'
+        expect(last_response.body).to eql(Path.file.read)
+      end
+
+      it 'supports serving DTO-able objects' do
+        get '/dto-able'
+        expect(last_response.body).to eql(%Q{{"foo":"bar"}})
+      end
+
+      it 'supports serving DTO-able objects eventually returning paths' do
+        get '/dto-path'
+        expect(last_response.body).to eql(Path.file.read)
+      end
+    end
+  end # module Web
+end # module Startback

data/spec/unit/web/test_auto_caching.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'startback/web/auto_caching'
+
+module Startback
+  module Web
+    describe AutoCaching do
+      include Rack::Test::Methods
+
+      context 'when used without options' do
+        def app
+          Rack::Builder.new do
+            use AutoCaching
+            run ->(env){ [200, {}, ["Hello error"]] }
+          end
+        end
+
+        it 'sets the development Cache-Control since this is a test' do
+          get '/'
+          expect(last_response['Cache-Control']). to eql("no-cache, no-store, max-age=0, must-revalidate")
+        end
+      end
+
+      context 'when forcing production' do
+        def app
+          Rack::Builder.new do
+            use AutoCaching, false
+            run ->(env){ [200, {}, ["Hello error"]] }
+          end
+        end
+
+        it 'sets the production Cache-Control' do
+          get '/'
+          expect(last_response['Cache-Control']). to eql("public, must-revalidate, max-age=3600, s-max-age=3600")
+        end
+      end
+
+      context 'when forcing development headers' do
+        def app
+          Rack::Builder.new do
+            use AutoCaching, development: { "Cache-Control" => "no-cache" }
+            run ->(env){ [200, {}, ["Hello error"]] }
+          end
+        end
+
+        it 'sets the production Cache-Control' do
+          get '/'
+          expect(last_response['Cache-Control']). to eql("no-cache")
+        end
+      end
+
+      context 'when setting the Cache-Control header only' do
+        def app
+          Rack::Builder.new do
+            use AutoCaching, development: "no-cache"
+            run ->(env){ [200, {}, ["Hello error"]] }
+          end
+        end
+
+        it 'sets the production Cache-Control' do
+          get '/'
+          expect(last_response['Cache-Control']). to eql("no-cache")
+        end
+      end
+
+      context 'when a Cache-Control header is already set by the app' do
+        def app
+          Rack::Builder.new do
+            use AutoCaching
+            run ->(env){ [200, {"Cache-Control" => "priority"}, ["Hello error"]] }
+          end
+        end
+
+        it 'sets the production Cache-Control' do
+          get '/'
+          expect(last_response['Cache-Control']). to eql("priority")
+        end
+      end
+
+    end # CatchAll
+  end # module Web
+end # module Startback

data/spec/unit/web/test_catch_all.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'singleton'
+require 'startback/web/catch_all'
+
+module Startback
+  module Web
+    describe CatchAll do
+      include Rack::Test::Methods
+
+      context 'when used without context' do
+        def app
+          Rack::Builder.new do
+            use CatchAll
+            run ->(env){ raise "Hello error" }
+          end
+        end
+
+        it 'returns a 500 with json explanation' do
+          get '/'
+          expect(last_response.status).to eql(500)
+          expect(last_response.content_type).to eql("application/json")
+          result = JSON.parse(last_response.body)
+          expect(result).to eql({
+            "code" => "Startback::Errors::InternalServerError",
+            "description" => "An error occured, sorry"
+          })
+        end
+      end
+
+      context 'when used with a context providing an error handler' do
+
+        class AnError < StandardError
+        end
+
+        class ErrorHandler
+          include Singleton
+
+          attr_reader :ex
+
+          def fatal(ex)
+            @ex = ex
+          end
+
+        end
+
+        class MyContextWithErrorHandler < Startback::Context
+
+          def error_handler
+            ErrorHandler.instance
+          end
+
+        end
+
+        def app
+          Rack::Builder.new do
+            use Context::Middleware, MyContextWithErrorHandler.new
+            use CatchAll
+            run ->(env){ raise AnError, "Hello error" }
+          end
+        end
+
+        it 'returns a 500 with json explanation' do
+          get '/'
+          expect(last_response.status).to eql(500)
+          expect(last_response.content_type).to eql("application/json")
+          result = JSON.parse(last_response.body)
+          expect(result).to eql({
+            "code" => "Startback::Errors::InternalServerError",
+            "description" => "An error occured, sorry"
+          })
+          expect(ErrorHandler.instance.ex).to be_a(AnError)
+        end
+      end
+
+    end # CatchAll
+  end # module Web
+end # module Startback

data/spec/unit/web/test_cors_headers.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'startback/web/cors_headers'
+
+module Startback
+  module Web
+    describe CorsHeaders do
+      include Rack::Test::Methods
+
+      context 'when used without options' do
+        def app
+          Rack::Builder.new do
+            use CorsHeaders
+            run ->(env){ [200, {}, ["Hello world"]] }
+          end
+        end
+
+        it 'sets the CORS headers to default values' do
+          header('Origin', "https://test.com")
+          get '/'
+          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
+          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
+          expect(last_response.body).to eql("Hello world")
+        end
+
+        it 'strips everything when option' do
+          header('Origin', "https://test.com")
+          options '/'
+          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
+          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
+          expect(last_response.status).to eql(204)
+          expect(last_response.body).to eql("")
+        end
+      end
+
+      context 'when used with the :bounce option' do
+        def app
+          Rack::Builder.new do
+            use CorsHeaders, bounce: true
+            run ->(env){ [200, {}, ["Hello world"]] }
+          end
+        end
+
+        it 'sets the CORS Origin header to the caller' do
+          header('Origin', "https://test.com")
+          get '/'
+          expect(last_response['Access-Control-Allow-Origin']). to eql("https://test.com")
+          expect(last_response['Access-Control-Allow-Methods']). to eql("OPTIONS, HEAD, GET, POST, PUT, PATCH, DELETE")
+          expect(last_response.body).to eql("Hello world")
+        end
+      end
+
+      context 'when overriding a header' do
+        def app
+          Rack::Builder.new do
+            use CorsHeaders, headers: { 'Access-Control-Allow-Methods' => "POST" }
+            run ->(env){ [200, {}, ["Hello world"]] }
+          end
+        end
+
+        it 'sets the CORS Origin header to the caller' do
+          header('Origin', "https://test.com")
+          get '/'
+          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
+          expect(last_response['Access-Control-Allow-Methods']). to eql("POST")
+          expect(last_response.body).to eql("Hello world")
+        end
+      end
+
+      context 'when the app sets specific headers' do
+        def app
+          Rack::Builder.new do
+            use CorsHeaders
+            run ->(env){ [200, {'Access-Control-Allow-Methods' => "POST"}, ["Hello world"]] }
+          end
+        end
+
+        it 'does not override them' do
+          header('Origin', "https://test.com")
+          get '/'
+          expect(last_response['Access-Control-Allow-Origin']). to eql("*")
+          expect(last_response['Access-Control-Allow-Methods']). to eql("POST")
+          expect(last_response.body).to eql("Hello world")
+        end
+      end
+
+    end # CatchAll
+  end # module Web
+end # module Startback

data/spec/unit/web/test_healthcheck.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'startback/web/health_check'
+
+module Startback
+  module Web
+    describe HealthCheck do
+      include Rack::Test::Methods
+
+      context 'when used without a block and no failure' do
+        def app
+          HealthCheck.new
+        end
+
+        it 'returns a 204 when ok' do
+          get '/'
+          expect(last_response.status).to eql(204)
+          expect(last_response.body).to be_empty
+        end
+      end
+
+      context 'when used without a block a failure' do
+        def app
+          app = HealthCheck.new
+          def app.check!(env)
+            raise "Hello error"
+          end
+          app
+        end
+
+        it 'raises when ko' do
+          expect(->(){ get '/' }).to raise_error("Hello error")
+        end
+      end
+
+      context 'when used with a block returning a debug message' do
+        def app
+          HealthCheck.new{ "Hello world" }
+        end
+
+        it 'returns a 200 with plain text message' do
+          get '/'
+          expect(last_response.status).to eql(200)
+          expect(last_response.body).to eql("Hello world")
+        end
+      end
+
+      context 'when used with a block raising an exception' do
+        def app
+          HealthCheck.new{ raise("Hello error") }
+        end
+
+        it 're-raises it' do
+          expect(->(){ get '/' }).to raise_error("Hello error")
+        end
+      end
+
+    end
+  end # module Web
+end # module Startback