endpoint-flux 1.1.4

data/lib/endpoint_flux/exceptions/unauthorized.rb

@@ -0,0 +1,12 @@
+module EndpointFlux
+  module Exceptions
+    class Unauthorized < EndpointFlux::Exceptions::Base
+      def to_hash
+        {
+          status: 401,
+          message: 'Unauthorized'
+        }
+      end
+    end
+  end
+end

data/lib/endpoint_flux/exceptions/validation.rb

@@ -0,0 +1,13 @@
+module EndpointFlux
+  module Exceptions
+    class Validation < EndpointFlux::Exceptions::Base
+      def to_hash
+        {
+          status: 422,
+          message: 'validation errors',
+          errors: @messages
+        }
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares.rb

@@ -0,0 +1,8 @@
+module Middlewares
+  require_relative 'middlewares/authenticator/skip'
+  require_relative 'middlewares/authorizator/skip'
+  require_relative 'middlewares/decorator/skip'
+  require_relative 'middlewares/decorator/add_status'
+  require_relative 'middlewares/policy/skip'
+  require_relative 'middlewares/validator/empty'
+end

data/lib/endpoint_flux/middlewares/authenticator/skip.rb

@@ -0,0 +1,11 @@
+module EndpointFlux
+  module Middlewares
+    module Authenticator
+      module Skip
+        def self.perform(*args, _options)
+          args
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares/authorizator/skip.rb

@@ -0,0 +1,11 @@
+module EndpointFlux
+  module Middlewares
+    module Authorizator
+      module Skip
+        def self.perform(*args, _opts)
+          args
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares/decorator/add_status.rb

@@ -0,0 +1,12 @@
+module EndpointFlux
+  module Middlewares
+    module Decorator
+      module AddStatus
+        def self.perform(request, response, status)
+          response.body[:status] = status
+          [request, response]
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares/decorator/skip.rb

@@ -0,0 +1,11 @@
+module EndpointFlux
+  module Middlewares
+    module Decorator
+      module Skip
+        def self.perform(*args, _options)
+          args
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares/policy/skip.rb

@@ -0,0 +1,11 @@
+module EndpointFlux
+  module Middlewares
+    module Policy
+      module Skip
+        def self.perform(*args, _options)
+          args
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/middlewares/validator/empty.rb

@@ -0,0 +1,12 @@
+module EndpointFlux
+  module Middlewares
+    module Validator
+      module Empty
+        def self.perform(request, response, _options)
+          request.params = {}
+          [request, response]
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/rails/concerns/endpoint_controller.rb

@@ -0,0 +1,43 @@
+module EndpointFlux
+  module Rails
+    module Concerns
+      module EndpointController
+        extend ActiveSupport::Concern
+
+        def present(namespace)
+          _, response = endpoint_for(namespace).perform(request_object)
+
+          headers.merge! response.headers
+          render json: response.body
+        end
+
+        def endpoint_for(namespace)
+          return namespace unless ::EndpointFlux.config.endpoints_namespace
+          (::EndpointFlux.config.endpoints_namespace + '/' + namespace).camelize.constantize
+        end
+
+        def request_object
+          ::EndpointFlux::Request.new(
+            headers: headers.merge('Authorization' => request.headers['authorization']),
+            remote_ip: remote_ip,
+            params: endpoint_params
+          )
+        end
+
+        def endpoint_params
+          params.permit!.except(:controller, :action, :format).to_h.deep_symbolize_keys
+        end
+
+        def remote_ip
+          ip = request.remote_ip.to_s
+
+          if ip == '127.0.0.1'
+            ip = request.env['HTTP_X_FORWARDED_FOR']
+          end
+
+          ip
+        end
+      end
+    end
+  end
+end

data/lib/endpoint_flux/request.rb

@@ -0,0 +1,17 @@
+module EndpointFlux
+  class Request
+    def initialize(headers: {}, remote_ip: '', params: {}, namespace: nil)
+      @headers = headers
+      @remote_ip = remote_ip
+      @params = params
+      @namespace = namespace
+    end
+
+    attr_accessor :params
+    attr_accessor :headers
+    attr_accessor :remote_ip
+    attr_accessor :namespace
+    attr_accessor :endpoint
+    attr_accessor :scope
+  end
+end

data/lib/endpoint_flux/response.rb

@@ -0,0 +1,30 @@
+module EndpointFlux
+  class Response
+    def initialize(headers: {}, body: {})
+      @body = body
+      @headers = headers
+    end
+
+    attr_accessor :body, :headers
+
+    def success?
+      body[:status] && body[:status].between?(200, 209)
+    end
+
+    def invalid?
+      body[:status] == 422
+    end
+
+    def forbidden?
+      body[:status] == 403
+    end
+
+    def unauthorized?
+      body[:status] == 401
+    end
+
+    def not_found?
+      body[:status] == 404
+    end
+  end
+end

data/lib/endpoint_flux/version.rb

@@ -0,0 +1,3 @@
+module EndpointFlux
+  VERSION = '1.1.4'.freeze
+end

data/spec/lib/class_loader_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::ClassLoader do
+  describe '#string_to_class_name' do
+    it 'converts string to class name' do
+      expect(subject.string_to_class_name('hey/bey/cey')).to eq('Hey::Bey::Cey')
+    end
+  end
+
+  describe '#load_class!' do
+    context 'when wrong params given' do
+      it 'fails if the class is not existing' do
+        expect { subject.load_class!('hey/bey') }
+          .to raise_error('The [hey/bey] should be a string representing a class')
+      end
+
+      it 'fails if the class name is invalid' do
+        expect { subject.load_class!('111/bey') }
+          .to raise_error('The [111/bey] should be a string representing a class')
+      end
+    end
+
+    context 'when valid params given' do
+      let(:sample_class) { stub_const 'SampleClass::SecondLevel', Class.new }
+
+      it 'returns the class back' do
+        expect(subject.load_class!(sample_class)).to be(sample_class)
+      end
+    end
+  end
+end

data/spec/lib/config/default_middlewares_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config do
+  describe '#default_middlewares' do
+    before do
+      stub_const('EndpointFlux::Middlewares::Authenticator::Sample', Class.new)
+      EndpointFlux::Middlewares::Authenticator::Sample.class_eval do
+        def self.perform(_, headers, response)
+          [{}, headers, response]
+        end
+      end
+
+      subject.default_middlewares :authenticator, 'sample'
+    end
+    let(:middleware) { subject.default_middlewares[:authenticator].first }
+
+    it 'sets default middleware' do
+      expect(middleware.klass).to be(EndpointFlux::Middlewares::Authenticator::Sample)
+    end
+  end
+end

data/spec/lib/config/endpoints_namespace_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config do
+  describe '#endpoints_namespace' do
+    it 'sets default endpoints namespace' do
+      stub_const 'Some::Sample', Class.new
+
+      subject.endpoints_namespace 'some/sample'
+
+      expect(subject.endpoints_namespace).to be == 'some/sample'
+    end
+  end
+end

data/spec/lib/config/flow_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config do
+  it 'sets flow' do
+    subject.flow %i[hey bey]
+    expect(subject.flow).to eq(%i[hey bey])
+  end
+end

data/spec/lib/config/interceptor_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config::Interceptor do
+  describe '#add' do
+    context 'when wrong params given' do
+      it 'fails when no block given' do
+        expect { subject.add() }.to raise_error('Block not given')
+      end
+    end
+
+    context 'when valid params given' do
+      let(:block) { proc {} }
+
+      it 'adds the handler' do
+        subject.add(&block)
+
+        expect(subject.handlers).to include(block)
+      end
+    end
+  end
+
+  describe '#run' do
+    let(:sample_exception) { stub_const 'SampleException', Class.new(Exception) }
+    let(:block) { proc { raise SampleException } }
+
+    context 'when valid params given' do
+      it 'runs the handler' do
+        subject.add(&block)
+        expect { subject.run('attrs') }
+          .to raise_error(sample_exception)
+      end
+    end
+  end
+end

data/spec/lib/config/middleware_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config::Middleware do
+  let(:block) { proc { raise BlockException, 'bla bla' } }
+  let(:options) { { option: :option } }
+
+  before do
+    stub_const 'BlockException', Class.new(Exception)
+    stub_const 'PerformException', Class.new(Exception)
+    stub_const 'MiddlewareSample', Class.new
+
+    MiddlewareSample.class_eval do
+      def self.perform(*)
+        raise PerformException, 'bla bla'
+      end
+    end
+  end
+
+  context 'when wrong params given' do
+    it 'fails when there is no params given' do
+      expect { described_class.new }.to raise_error('You must provide block or existing klass')
+    end
+
+    it 'fails when there is no perform method' do
+      stub_const 'NoPerformMiddlewareSample', Class.new
+
+      expect do
+        described_class.new(NoPerformMiddlewareSample)
+      end.to raise_error('The [NoPerformMiddlewareSample] class should define perform class method')
+    end
+  end
+
+  context 'when valid params given' do
+    let(:subject) { described_class.new(MiddlewareSample, options, &block) }
+
+    it 'creates middleware instance with class' do
+      expect(subject.klass).to be(MiddlewareSample)
+    end
+
+    it 'creates middleware instance with handler' do
+      expect(subject.handler).to be(block)
+    end
+
+    it 'creates middleware instance with options' do
+      expect(subject.options).to be(options)
+    end
+  end
+
+  describe '#run' do
+    it 'runs klass perform when it is given' do
+      middleware = described_class.new(MiddlewareSample)
+
+      expect { middleware.run({}) }.to raise_error(PerformException)
+    end
+
+    it 'runs klass handler when it is given' do
+      middleware = described_class.new(&block)
+
+      expect { middleware.run({}) }.to raise_error(BlockException)
+    end
+  end
+end

data/spec/lib/config/rescue_from_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Config::RescueFrom do
+  describe '#add' do
+    let(:sample_exception) { stub_const 'SampleException', Class.new(Exception) }
+
+    context 'when wrong params given' do
+      it 'fails when no block given' do
+        expect { subject.add(sample_exception) }.to raise_error('Block not given')
+      end
+    end
+
+    context 'when valid params given' do
+      let(:block) { proc {} }
+
+      it 'adds the exception handler' do
+        subject.add(sample_exception, &block)
+
+        expect(subject.exceptions).to include(sample_exception)
+        expect(subject.handlers.values).to include(block)
+      end
+    end
+  end
+
+  describe '#run' do
+    let(:sample_exception) { stub_const 'SampleException', Class.new(Exception) }
+    let(:block_exception) { stub_const 'BlockException', Class.new(Exception) }
+    let(:block) { proc { raise BlockException } }
+
+    context 'when wrong params given' do
+      it 'fails when handler not given' do
+        expect { subject.run('name', 'attrs', sample_exception.new) }
+          .to raise_error('No handler given')
+      end
+    end
+
+    context 'when valid params given' do
+      it 'runs the handler' do
+        subject.add(sample_exception, &block)
+        expect { subject.run('name', 'attrs', sample_exception.new) }
+          .to raise_error(block_exception)
+      end
+    end
+  end
+end

data/spec/lib/endpoint/flow_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Endpoint do
+  let(:klass) { stub_const 'Sample', Class.new }
+
+  before do
+    klass.include EndpointFlux::Endpoint
+  end
+
+  describe '#flow' do
+    let(:params) { { some: :val } }
+    let(:middleware_request) { EndpointFlux::Request.new(headers: {}, params: params) }
+    let(:middleware_response) { EndpointFlux::Response.new }
+
+    before do
+      stub_const('EndpointFlux::Middlewares::Validator::Sample', Class.new)
+      EndpointFlux::Middlewares::Validator::Sample.class_eval do
+        def self.perform(request, response, _)
+          request.params = {}
+          [request, response]
+        end
+      end
+
+      stub_const('EndpointFlux::Middlewares::Decorator::Sample', Class.new)
+      EndpointFlux::Middlewares::Decorator::Sample.class_eval do
+        def self.perform(request, _response, _)
+          [request, EndpointFlux::Response.new(headers: {}, body: {})]
+        end
+      end
+
+      klass.flow %i[validator decorator]
+
+      EndpointFlux.config.default_middlewares :validator, :sample
+      EndpointFlux.config.default_middlewares :decorator, 'sample'
+    end
+
+    it 'uses default middleware if not defined' do
+      request, response = klass.perform(middleware_request)
+      expect(request.params).to eq({})
+      expect(response.body).to eq({})
+    end
+  end
+end