startback-websocket 0.14.0 → 0.14.1

data/lib/startback/web/magic_assets.rb

@@ -1,98 +0,0 @@
-require 'sprockets'
-module Startback
-  module Web
-    #
-    # Rack application & middleware that can be used to simplify javascript
-    # and css assets management, using Sprockets.
-    #
-    # Example:
-    #
-    #     # Used as rack app, typically under a path
-    #     Rack::Builder.new do
-    #       map '/assets' do
-    #         run Startback::Web::MagicAssets.new({
-    #           folder: "/path/to/assets/src"
-    #         })
-    #       end
-    #       run MyApp
-    #     end
-    #
-    #     # Used as a rack middleware, e.g. in a Sinatra application
-    #     use Startback::Web::MagicAssets, {
-    #       folder: "/path/to/assets/src",
-    #       path: "/assets"
-    #     }
-    #
-    # Sprocket configuration can be done through the `:sprocket` option:
-    #
-    #     use Startback::Web::MagicAssets, {
-    #       sprockets: {
-    #         :css_compressor => :scss
-    #       }
-    #     }
-    #
-    class MagicAssets
-
-      DEFAULT_OPTIONS = {
-        sprockets: {},
-        plugins: {}
-      }
-
-      def initialize(app, options = {})
-        app, options = nil, app if app.is_a?(Hash)
-        @app = app
-        @options = DEFAULT_OPTIONS.merge(options)
-        @sprockets = build_sprockets
-      end
-      attr_reader :sprockets
-
-      def call(env)
-        if new_env = is_match?(env)
-          @sprockets.call(new_env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def [](*args, &bl)
-        @sprockets.[](*args, &bl)
-      end
-
-    private
-
-      def path
-        @options[:path]
-      end
-
-      def is_match?(env)
-        if @app.nil?
-          # Not used as a middleware, use this env and match
-          env
-        elsif env['PATH_INFO'].start_with?(path)
-          # Used as a middleware, and PATH_INFO starts with the
-          # assets path => strip it for sprockets
-          env.merge("PATH_INFO" => env["PATH_INFO"].sub(path, ""))
-        else
-          # No match, let @app execute with the untouched environment
-          nil
-        end
-      end
-
-      def build_sprockets
-        Sprockets::Environment.new.tap{|s|
-          Array(@options[:folder]).each do |folder|
-            s.append_path(folder)
-          end
-          @options[:sprockets].each_pair do |k,v|
-            s.public_send(:"#{k}=", v)
-          end
-          @options[:plugins].each do |p|
-            p.install(s)
-          end
-        }
-      end
-
-    end # class MagicAssets
-  end # module Web
-end # module Startback
-require_relative 'magic_assets/rake_tasks'

data/lib/startback/web/middleware.rb

@@ -1,13 +0,0 @@
-module Startback
-  module Web
-    module Middleware
-
-    protected
-
-      def context(env = @env)
-        ::Startback::Context::Middleware.context(env) || Errors.server_error!("Unable to find context!!")
-      end
-
-    end # module Middleware
-  end # module Web
-end # module Startback

data/lib/startback/web/prometheus.rb

@@ -1,16 +0,0 @@
-require 'prometheus/middleware/exporter'
-module Startback
-  module Web
-    #
-    # Can be used to expose the prometheus metrics inside a Startback
-    # application.
-    #
-    # Example:
-    #
-    #     use Startback::Web::Prometheus
-    #
-    class Prometheus < Prometheus::Middleware::Exporter
-
-    end # class Prometheus
-  end # module Web
-end # module Startback

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