endpoint-flux 1.1.4

data/spec/lib/endpoint/middlewares_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Endpoint do
+  let(:klass) { class_double('Sample') }
+
+  before do
+    EndpointFlux.config EndpointFlux::Config.new
+
+    klass.include EndpointFlux::Endpoint
+  end
+
+  context 'with exceptions' do
+    it 'fails with wrong string' do
+      klass.flow [:validator]
+
+      expect do
+        klass.validator 'some_not_existing_class'
+      end.to raise_error('You must provide block or existing klass')
+    end
+
+    it 'fails whit wrong class passed' do
+      stub_const 'EndpointFlux::Middlewares::Validator::SampleMiddleware', Class.new
+
+      klass.flow [:validator]
+
+      expect { klass.validator 'sample_middleware' }.to raise_error(
+        'The [EndpointFlux::Middlewares::Validator::SampleMiddleware] '\
+        'class should define perform class method'
+      )
+    end
+
+    context 'when wrong param passed' do
+      it do
+        klass.flow [:validator]
+
+        expect { klass.validator 1334 }.to raise_error(
+          'You must provide block or existing klass'
+        )
+      end
+
+      it do
+        stub_const 'SampleMiddleware', Class.new
+
+        klass.flow [:validator]
+
+        expect { klass.validator SampleMiddleware }.to raise_error(
+          'You must provide block or existing klass'
+        )
+      end
+    end
+  end
+
+  describe 'middlewares' do
+    before do
+      stub_const 'SomeNamespace::MiddlewareName::SampleMiddleware', Class.new
+      SomeNamespace::MiddlewareName::SampleMiddleware.class_eval do
+        def self.perform(*args)
+          args
+        end
+      end
+
+      EndpointFlux.config.middlewares_namespaces << 'some_namespace'
+    end
+
+    before do
+      klass.flow [:middleware_name]
+    end
+
+    let(:middleware) { klass.middleware_name.first }
+
+    it 'sets middleware with options' do
+      klass.middleware_name 'sample_middleware', some: :option
+
+      expect(middleware.klass).to be(SomeNamespace::MiddlewareName::SampleMiddleware)
+      expect(middleware.options).to eq(some: :option)
+    end
+
+    it 'sets middleware' do
+      klass.middleware_name 'sample_middleware'
+
+      expect(middleware.klass).to be(SomeNamespace::MiddlewareName::SampleMiddleware)
+    end
+
+    it 'does not add twice' do
+      klass.middleware_name 'sample_middleware'
+      klass.middleware_name 'sample_middleware'
+
+      middleware = klass.middleware_name.first
+
+      expect(middleware.klass).to be(SomeNamespace::MiddlewareName::SampleMiddleware)
+    end
+
+    context 'block' do
+      let(:block) { proc {} }
+
+      it 'sets middleware' do
+        klass.middleware_name(&block)
+
+        expect(middleware.handler).to be == block
+      end
+
+      it 'does not adds twice' do
+        klass.middleware_name(&block)
+        klass.middleware_name(&block)
+
+        expect(middleware.handler).to be == block
+      end
+    end
+  end
+end

data/spec/lib/endpoint/perform_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Endpoint do
+  let(:klass) { stub_const 'Sample', Class.new }
+  let(:middleware_request) { EndpointFlux::Request.new(headers: {}, params: params) }
+  let(:middleware_response) { EndpointFlux::Response.new }
+
+  before do
+    EndpointFlux.config EndpointFlux::Config.new
+
+    klass.include EndpointFlux::Endpoint
+  end
+
+  describe '#perform' do
+    before do
+      stub_const 'EndpointFlux::Middlewares::Validator::SampleValidator', Class.new
+      EndpointFlux::Middlewares::Validator::SampleValidator.class_eval do
+        def self.perform(request, response, _)
+          request.params = {}
+          [request, response, {}]
+        end
+      end
+    end
+
+    let(:params) { { some: :val } }
+
+    it 'checks if middleware exists' do
+      klass.flow [:validator]
+
+      expect { klass.perform(middleware_request) }
+        .to raise_error('No middleware registred for [:validator]')
+    end
+
+    context 'middleware passed as string' do
+      it 'runs middleware passed as string' do
+        klass.flow [:validator]
+        klass.validator 'sample_validator'
+
+        request, response = klass.perform(middleware_request)
+
+        expect(request.params).to eq({})
+        expect(response.body).to eq({})
+      end
+    end
+
+    context 'default middleware' do
+      before do
+        klass.flow [:validator]
+
+        EndpointFlux.config.default_middlewares :validator, 'sample_validator'
+      end
+
+      it 'uses default if not defined' do
+        request, response = klass.perform(middleware_request)
+
+        expect(request.params).to eq({})
+        expect(response.body).to eq({})
+      end
+    end
+  end
+end

data/spec/lib/endpoint/rescue_from_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Endpoint do
+  let(:klass) { stub_const 'Sample', Class.new }
+  let(:middleware_request) { EndpointFlux::Request.new(headers: {}, params: {}) }
+  let(:middleware_response) { EndpointFlux::Response.new }
+
+  before do
+    EndpointFlux.config EndpointFlux::Config.new
+
+    klass.include EndpointFlux::Endpoint
+  end
+
+  describe '#rescue_from' do
+    let(:sample_exception) { stub_const 'SampleException', Class.new(Exception) }
+    let!(:sample_validator) do
+      stub_const 'EndpointFlux::Middlewares::Validator::Sample', Class.new
+      EndpointFlux::Middlewares::Validator::Sample.class_eval do
+        def self.perform(*)
+          raise SampleException, 'bla bla'
+        end
+      end
+      EndpointFlux::Middlewares::Validator::Sample
+    end
+    let!(:sample_decorator) do
+      stub_const 'EndpointFlux::Middlewares::Decorator::Sample', Class.new
+      EndpointFlux::Middlewares::Decorator::Sample.class_eval do
+        def self.perform(request, response, options)
+          response.body[:decorator] = true
+          [request, response, options]
+        end
+      end
+      EndpointFlux::Middlewares::Decorator::Sample
+    end
+
+    it 'fails if exception not found' do
+      expect do
+        EndpointFlux.config.rescue_from 'NonExsistingClasss' do |_, attrs|
+          # code
+        end
+      end.to raise_error('The [NonExsistingClasss] should be a string representing a class')
+    end
+
+    context 'default middleware' do
+      before do
+        klass.flow %i[validator decorator]
+        klass.validator 'sample'
+        klass.decorator 'sample'
+
+        EndpointFlux.config.rescue_from sample_exception do |_, attrs|
+          [attrs[0], attrs[1], { status: false }]
+        end
+      end
+
+      it 'uses default if not defined' do
+        _, response = klass.perform(middleware_request)
+        expect(response.body[:status]).to be_falsey
+      end
+    end
+  end
+end

data/spec/lib/endpoint_flux/rails/concerns/endpoint_controller_spec.rb

@@ -0,0 +1,75 @@
+module ActiveSupport
+  module Concern ; end
+end
+
+require 'spec_helper'
+require 'endpoint_flux/rails/concerns/endpoint_controller'
+require 'ostruct'
+
+class RemoteIpDummyClass
+  include EndpointFlux::Rails::Concerns::EndpointController
+
+  def headers
+    {}
+  end
+
+  def request
+    OpenStruct.new(
+      headers: { 'authorization' => 'authorization header' },
+      remote_ip: '172.18.0.1',
+      env: { 'HTTP_X_FORWARDED_FOR' => '172.18.0.2' }
+    )
+  end
+end
+
+class LocalIpDummyClass
+  include EndpointFlux::Rails::Concerns::EndpointController
+
+  def headers
+    {}
+  end
+
+  def request
+    OpenStruct.new(
+      headers: { 'authorization' => 'authorization header' },
+      remote_ip: '127.0.0.1',
+      env: { 'HTTP_X_FORWARDED_FOR' => '172.18.0.2' }
+    )
+  end
+end
+
+RSpec.describe EndpointFlux::Rails::Concerns::EndpointController do
+  describe '#request_object' do
+    before do
+      allow(subject).to receive(:endpoint_params).and_return({})
+    end
+
+    context 'remote ip' do
+      subject { RemoteIpDummyClass.new }
+
+      it 'sets property as remote_ip' do
+        expect(
+          ::EndpointFlux::Request
+        ).to receive(:new).with(headers: { 'Authorization' => 'authorization header' },
+                                params: subject.endpoint_params,
+                                remote_ip: subject.request.remote_ip)
+
+        subject.request_object
+      end
+    end
+
+    context 'local ip' do
+      subject { LocalIpDummyClass.new }
+
+      it 'sets property as HTTP_X_FORWARDED_FOR' do
+        expect(
+          ::EndpointFlux::Request
+        ).to receive(:new).with(headers: { 'Authorization' => 'authorization header' },
+                                params: subject.endpoint_params,
+                                remote_ip: subject.request.env['HTTP_X_FORWARDED_FOR'])
+
+        subject.request_object
+      end
+    end
+  end
+end

data/spec/lib/endpoint_flux/request_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Request do
+  it { should respond_to :headers }
+  it { should respond_to :remote_ip }
+  it { should respond_to :params }
+  it { should respond_to :namespace }
+  it { should respond_to :endpoint }
+  it { should respond_to :scope }
+
+  describe '#initialize' do
+    context 'when all params specified' do
+      let(:params) { { param: :val } }
+      let(:headers) { { header: :val } }
+      let(:remote_ip) { '127.0.0.1' }
+      let(:namespace) { 'namespace' }
+
+      it 'should set args' do
+        request = EndpointFlux::Request.new(
+          params: params,
+          headers: headers,
+          remote_ip: remote_ip,
+          namespace: namespace
+        )
+
+        expect(request.params).to eq params
+        expect(request.headers).to eq headers
+        expect(request.remote_ip).to eq remote_ip
+        expect(request.namespace).to eq namespace
+      end
+
+      context 'when params missed' do
+        it 'should set default values' do
+          request = EndpointFlux::Request.new
+
+          expect(request.params).to be_empty
+          expect(request.headers).to be_empty
+          expect(request.remote_ip).to eq ''
+          expect(request.namespace).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/lib/exceptions/forbidden_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Exceptions::Forbidden do
+  describe '#to_hash' do
+    it 'returns correct hash' do
+      expect(subject.to_hash).to eq(
+        status: 403,
+        message: 'Forbidden'
+      )
+    end
+  end
+end

data/spec/lib/exceptions/not_found_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Exceptions::NotFound do
+  describe '#to_hash' do
+    it 'returns correct hash' do
+      expect(subject.to_hash).to eq(
+        status: 404,
+        message: 'not found'
+      )
+    end
+  end
+end

data/spec/lib/exceptions/service_unavailable_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Exceptions::ServiceUnavailable do
+  describe '#to_hash' do
+    it 'returns correct hash' do
+      expect(subject.to_hash).to eq(
+        status: 503,
+        message: 'service unavailable'
+      )
+    end
+  end
+end

data/spec/lib/exceptions/unauthorized_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Exceptions::Unauthorized do
+  describe '#to_hash' do
+    it 'returns correct hash' do
+      expect(subject.to_hash).to eq(
+        status: 401,
+        message: 'Unauthorized'
+      )
+    end
+  end
+end

data/spec/lib/exceptions/validation_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Exceptions::Validation do
+  describe '#to_hash' do
+    let(:messages) { {name: 'not valid'} }
+    it 'returns correct hash' do
+      expect(EndpointFlux::Exceptions::Validation.new(messages).to_hash).to eq(
+        status: 422,
+        message: 'validation errors',
+        errors: messages
+      )
+    end
+  end
+end

data/spec/lib/middlewares/authenticator/skip_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../middlewares/shared_examples'
+
+RSpec.describe EndpointFlux::Middlewares::Authenticator::Skip do
+  include_examples 'perform does not change the params'
+end

data/spec/lib/middlewares/authorizator/skip_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../middlewares/shared_examples'
+
+RSpec.describe EndpointFlux::Middlewares::Authorizator::Skip do
+  include_examples 'perform does not change the params'
+end

data/spec/lib/middlewares/decorator/add_status_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe EndpointFlux::Middlewares::Decorator::AddStatus do
+  describe '#perform' do
+    let(:params) { { some: 'value' } }
+    let(:body) { { status: 200 } }
+    let(:request) { EndpointFlux::Request.new(headers: {}, params: params) }
+    let(:response) { EndpointFlux::Response.new(headers: {}, body: body) }
+
+    it 'returns response with status in body' do
+      middleware_request, middleware_response = subject.perform(request, response, {})
+
+      expect(middleware_request.headers).to eq({})
+      expect(middleware_request.params).to eq(params)
+      expect(middleware_response.headers).to eq({})
+      expect(middleware_response.body).to eq(body)
+    end
+  end
+end