endpoint-flux2 1.1.6

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

@@ -0,0 +1,158 @@
+module ActiveSupport
+  module Concern; end
+end
+
+module Endpoints
+  module Test; end
+end
+
+class String
+  def camelize(uppercase_first_letter = true)
+    string = self
+    if uppercase_first_letter
+      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+    else
+      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+    end
+    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
+  end
+
+  def constantize(camel_cased_word =nil)
+    camel_cased_word ||= self
+    names = camel_cased_word.split("::".freeze)
+
+    # Trigger a built-in NameError exception including the ill-formed constant in the message.
+    Object.const_get(camel_cased_word) if names.empty?
+
+    # Remove the first blank element in case of '::ClassName' notation.
+    names.shift if names.size > 1 && names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      if constant == Object
+        constant.const_get(name)
+      else
+        candidate = constant.const_get(name)
+        next candidate if constant.const_defined?(name, false)
+        next candidate unless Object.const_defined?(name)
+
+        # Go down the ancestors to check if it is owned directly. The check
+        # stops when we reach Object or the end of ancestors tree.
+        constant = constant.ancestors.inject(constant) do |const, ancestor|
+          break const    if ancestor == Object
+          break ancestor if ancestor.const_defined?(name, false)
+          const
+        end
+
+        # owner is in Object, so raise
+        constant.const_get(name, false)
+      end
+    end
+  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
+
+  def params; 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
+
+  describe '#endpoint_params' do
+    before do
+      allow(subject).to receive_message_chain(:params, :permit!, :except, :to_h, :deep_symbolize_keys)
+                            .and_return({test: 'test'})
+    end
+
+    context 'request' do
+      subject { LocalIpDummyClass.new }
+
+      it 'permits and excepts params' do
+        expect(subject.endpoint_params).to match({test: 'test'})
+      end
+    end
+
+  end
+
+  describe '#endpoint_for' do
+    context 'with namespace' do
+      subject { LocalIpDummyClass.new }
+      it 'return namespace' do
+        expect(subject.endpoint_for('test')).to eq(Endpoints::Test)
+      end
+    end
+
+  end
+
+  describe '#present' do
+
+  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

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

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

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

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

data/spec/lib/middlewares/shared_examples.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+RSpec.shared_context 'perform does not change the params', shared_context: :metadata do
+  describe '#perform' do
+    let(:params) { { some: 'value' } }
+    let(:headers) { { 'Authorization' => 'valid' } }
+    let(:request) { EndpointFlux::Request.new(headers: headers, params: params) }
+    let(:response) { EndpointFlux::Response.new(headers: {}, body: {}) }
+    
+    it 'returns not changed params' do
+      middleware_request, middleware_response = subject.perform(request, response, {})
+      
+      expect(middleware_request.params).to eq(params)
+      expect(middleware_request.headers).to eq(headers)
+      expect(middleware_response.headers).to eq({})
+      expect(middleware_response.body).to eq({})
+    end
+  end
+end

data/spec/lib/middlewares/validator/empty_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe EndpointFlux::Middlewares::Validator::Empty do
+  describe '#perform' do
+    let(:params) { { some: 'value' } }
+    let(:request) { EndpointFlux::Request.new(headers: {}, params: params) }
+    let(:response) { EndpointFlux::Response.new }
+
+    it 'returns empty params' do
+      middleware_request, middleware_response = subject.perform(request, response, {})
+
+      expect(middleware_request.params).to eq({})
+      expect(middleware_response.headers).to eq({})
+      expect(middleware_response.body).to eq({})
+    end
+  end
+end

data/spec/lib/response_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+RSpec.describe EndpointFlux::Response do
+  subject { EndpointFlux::Response.new(params) }
+  let(:empty_subject) { EndpointFlux::Response.new() }
+  
+  describe '#success?' do
+    context 'when valid params given' do
+      Array(200..209).each do |status|
+        let(:params) { { headers: {}, body: {status: status}  } }
+        it "returns true for status #{status}" do
+          expect(subject.success?).to be_truthy
+        end
+      end
+    end
+
+    context 'when wrong params given' do
+      let(:status) { 400 }
+      let(:params) { { headers: {}, body: {status: status}  } }
+      it 'returns false for not a success status' do
+        expect(subject.success?).to be_falsey
+      end
+      
+      describe 'when Response initialized without params' do
+        it 'returns false for not a success status' do
+          expect(empty_subject.success?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#invalid?' do
+    let(:params) { { headers: {}, body: {status: status}  } }
+    context 'when valid params given' do
+      let(:status) { 422 }
+      
+      it 'returns true for status 422' do
+        expect(subject.invalid?).to be_truthy
+      end
+    end
+  
+    context 'when wrong params given' do
+      let(:status) { 400 }
+      
+      it 'returns false for not an invalid status' do
+        expect(subject.invalid?).to be_falsey
+      end
+    
+      describe 'when Response initialized without params' do
+        it 'returns false for not an invalid status' do
+          expect(empty_subject.invalid?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#forbidden?' do
+    let(:params) { { headers: {}, body: {status: status}  } }
+    context 'when valid params given' do
+      let(:status) { 403 }
+    
+      it 'returns true for status 403' do
+        expect(subject.forbidden?).to be_truthy
+      end
+    end
+  
+    context 'when wrong params given' do
+      let(:status) { 400 }
+    
+      it 'returns false for not a forbidden status' do
+        expect(subject.forbidden?).to be_falsey
+      end
+    
+      describe 'when Response initialized without params' do
+        it 'returns false for not a forbidden status' do
+          expect(empty_subject.forbidden?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#unauthorized?' do
+    let(:params) { { headers: {}, body: {status: status}  } }
+    context 'when valid params given' do
+      let(:status) { 401 }
+    
+      it 'returns true for status 401' do
+        expect(subject.unauthorized?).to be_truthy
+      end
+    end
+  
+    context 'when wrong params given' do
+      let(:status) { 400 }
+    
+      it 'returns false for not a unauthorized status' do
+        expect(subject.unauthorized?).to be_falsey
+      end
+    
+      describe 'when Response initialized without params' do
+        it 'returns false for not a unauthorized status' do
+          expect(empty_subject.unauthorized?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#unauthorized?' do
+    let(:params) { { headers: {}, body: {status: status}  } }
+    context 'when valid params given' do
+      let(:status) { 404 }
+    
+      it 'returns true for status 404' do
+        expect(subject.not_found?).to be_truthy
+      end
+    end
+  
+    context 'when wrong params given' do
+      let(:status) { 400 }
+    
+      it 'returns false for not a not_found status' do
+        expect(subject.not_found?).to be_falsey
+      end
+    
+      describe 'when Response initialized without params' do
+        it 'returns false for not a not_found status' do
+          expect(empty_subject.not_found?).to be_falsey
+        end
+      end
+    end
+  end
+end