startback-jobs 0.14.0 → 0.14.1

data/lib/startback/web/shield.rb

@@ -1,58 +0,0 @@
-module Startback
-  module Web
-    #
-    # This Rack middleware catches all known exceptions raised by sublayers
-    # in the Rack chain. Those exceptions are converted to proper HTTP error
-    # codes and friendly error messages encoded in json.
-    #
-    # Please check the Errors module about status codes used for each Startback
-    # error.
-    #
-    # This class aims at being used as top level of a Rack chain.
-    #
-    # Examples:
-    #
-    #     Rack::Builder.new do
-    #       use Startback::Web::Shield
-    #     end
-    #
-    class Shield < Rack::Robustness
-      include Errors
-
-      self.no_catch_all
-      self.content_type 'application/json'
-
-      # Decoding errors from json and csv are considered user's fault
-      self.on(Finitio::TypeError){ 400 }
-      self.on(::NotImplementedError){ 501 }
-
-      # Various other codes for the framework specific error classes
-      self.on(Startback::Errors::Error) {|ex|
-        ex.class.status
-      }
-
-      # A bit of logic to choose the best error message for the user
-      # according to the error class
-      self.body{|ex|
-        body_for(ex).to_json
-      }
-
-      def body_for(ex)
-        ex = ex.root_cause if ex.is_a?(Finitio::TypeError)
-        body = { code: ex.class.name, description: ex.message }
-        return body unless ex.is_a?(Startback::Errors::Error)
-        return body unless ex.has_causes?
-
-        body[:causes] = ex.causes
-          .filter{|cause|
-            cause.is_a?(Startback::Errors::Error)
-          }
-          .map{|cause|
-            body_for(cause)
-          }
-        body
-      end
-
-    end # class Shield
-  end # module Web
-end # module Startback

data/lib/startback.rb

@@ -1,43 +0,0 @@
-require 'sinatra'
-require 'rack/robustness'
-require 'finitio'
-require 'logger'
-require 'path'
-require 'ostruct'
-require 'benchmark'
-
-# Provides a reusable backend framework for backend components written
-# in ruby.
-#
-# The framework installs conventions regarding:
-#
-# - The exposition of web service APIs (Framework::Api, on top of Sinatra)
-# - Operations (Framework::Operation)
-# - Error handling (Framework::Errors) and their handling in web APIs
-#   (based on Rack::Robustness)
-# - General code support (Framework::Support modules & classes).
-#
-# Please refer to the documentation of those main abstractions for details.
-#
-module Startback
-
-  # Simply checks that a path exists of raise an error
-  def self._!(path)
-    Path(path).tap do |p|
-      raise "Missing #{p.basename}." unless p.exists?
-    end
-  end
-
-  require_relative 'startback/version'
-  require_relative 'startback/ext'
-  require_relative 'startback/errors'
-  require_relative 'startback/support'
-  require_relative 'startback/model'
-  require_relative 'startback/context'
-  require_relative 'startback/operation'
-  require_relative 'startback/services'
-
-  # Logger instance to use for the application
-  LOGGER = ::Startback::Support::Logger.new
-
-end # module Startback

data/spec/unit/audit/test_prometheus.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'startback/audit'
-module Startback
-  module Audit
-    describe Prometheus do
-
-      EXPORTER = Prometheus.new({
-        prefix: "hello",
-        labels: {
-          app_version: "1.0"
-        }
-      })
-
-      class Runner
-        include Startback::Support::OperationRunner
-
-        class IdealOp < Startback::Operation
-          def call
-            42
-          end
-        end
-
-        class ExceptionalOp < Startback::Operation
-          def call
-            raise "Oops"
-          end
-        end
-
-        around_run(EXPORTER)
-        def test
-          run IdealOp.new
-        end
-        def test_exp
-          run ExceptionalOp.new
-        end
-      end
-
-      describe 'The ideal case' do
-        before do
-          expect(EXPORTER.calls).to receive(:observe).with(
-            kind_of(Numeric),
-            hash_including(labels: {
-              operation: "Startback::Audit::Runner::IdealOp",
-              startback_version: Startback::VERSION,
-              app_version: "1.0"
-            }))
-          expect(EXPORTER.errors).not_to receive(:increment)
-        end
-        it 'runs the operation' do
-          expect(Runner.new.test).to eql(42)
-        end
-      end
-
-      describe 'The exceptional case' do
-        before do
-          expect(EXPORTER.errors).to receive(:increment).with(
-            hash_including(labels: {
-              operation: "Startback::Audit::Runner::ExceptionalOp",
-              startback_version: Startback::VERSION,
-              app_version: "1.0"
-            })
-          )
-          expect(EXPORTER.calls).not_to receive(:observe)
-        end
-        it 'let errors bubble up' do
-          expect { Runner.new.test_exp }.to raise_error(/Oops/)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/audit/test_trailer.rb

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

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

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

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

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

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

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

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

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