callapi 0.8

data/lib/callapi/routes/metadata.rb

@@ -0,0 +1,72 @@
+class Callapi::Routes::Metadata
+  extend Memoist
+
+  def initialize(http_method_namespace, *args)
+    @http_method_namespace = http_method_namespace
+    @call_name, @call_options = args.shift, *args
+
+    call_name_with_all_namespaces.size.times do |i|
+      metadata = create_metadata(i)
+      Callapi::Routes.send(:save_class, metadata) if metadata
+    end
+  end
+
+  private
+
+  def create_metadata(i)
+    new_class_name = call_name_with_all_namespaces[i + 1]
+
+    return unless new_class_name
+
+    is_call_class = new_class_name.eql? call_name_with_all_namespaces.last
+
+    OpenStruct.new.tap do |data|
+      data.class_name = full_class_name(i)
+      data.call_class = is_call_class
+      data.http_method_namespace = @http_method_namespace
+      if is_call_class
+        data.class_options = @call_options
+        data.call_name_with_namespaces = call_name_with_namespaces
+      end
+    end
+  end
+
+  def full_class_name(i)
+    call_name_with_all_namespaces[0..i + 1].join('::')
+  end
+
+  def call_name_with_namespaces
+    namespaces.push(@call_name).map do |class_name|
+      if class_name_with_param_key?(class_name)
+        class_name_to_class_name_with_param_key(class_name)
+      else
+        class_name
+      end.camelize
+    end
+  end
+  memoize :call_name_with_namespaces
+
+  def call_name_with_all_namespaces
+    [@http_method_namespace.to_s] + call_name_with_namespaces
+  end
+  memoize :call_name_with_all_namespaces
+
+  def namespaces
+    Callapi::Routes.send(:namespaces).dup
+  end
+  memoize :namespaces
+
+  def class_name_with_param_key?(class_name)
+    class_name[0] == ':' || class_name.match('/:')
+  end
+
+  def class_name_to_class_name_with_param_key(class_name)
+    class_name.scan(/(:\w+)\/?/).map(&:first).each do |pattern|
+      replacement = pattern.dup
+      replacement[0] = ''
+      replacement << '_param'
+      class_name.sub!(pattern, replacement)
+    end
+    class_name
+  end
+end

data/lib/callapi/version.rb

@@ -0,0 +1,3 @@
+module Callapi
+  VERSION = '0.8'
+end

data/lib/ext/deep_struct.rb

@@ -0,0 +1,25 @@
+class DeepStruct < OpenStruct
+  def initialize(hash = nil)
+    @table = {}
+    @hash_table = {}
+
+    if hash
+      hash.each do |key, value|
+        @table[key.to_sym] = process_value(value)
+        @hash_table[key.to_sym] = value
+
+        new_ostruct_member(key)
+      end
+    end
+  end
+
+  def process_value(value)
+    if value.is_a?(Hash)
+      self.class.new(value)
+    elsif value.is_a?(Array)
+      value.map { |element| process_value(element) }
+    else
+      value
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'webmock/rspec'
+
+require_relative '../lib/callapi'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    Get = Module.new
+    Get::Users = Class.new(Callapi::Call::Base)
+
+    Callapi::Config.configure do |config|
+      config.log_level = :off
+    end
+  end
+end

data/spec/unit/call/base_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Callapi::Call::Base do
+  let(:config) { Callapi::Config }
+  let(:call) { described_class.new }
+
+  context '#initialize' do
+    it 'should take params as an argument' do
+      expect(described_class.new(some_param: :some_value).params).to eql(some_param: :some_value)
+    end
+  end
+
+  context '#strategy' do
+    before { allow(config).to receive(:request_strategy).and_return(Callapi::Call::Request::Api) }
+
+    it 'should be taken from config' do
+      expect(subject.strategy).to eql(Callapi::Call::Request::Api)
+    end
+  end
+
+  context '.strategy' do
+    before { described_class.strategy = Callapi::Call::Request::Mock }
+
+    it 'should overwrite default strategy for each instance' do
+      expect(subject.strategy).to eql(Callapi::Call::Request::Mock)
+    end
+  end
+
+  context '#response_parser' do
+    subject { call.response_parser }
+
+    before { call.with_response_parser(Callapi::Call::Parser::Json::AsObject) }
+
+    it 'should be accessible' do
+      expect(subject).to eql(Callapi::Call::Parser::Json::AsObject)
+    end
+  end
+end

data/spec/unit/call/request/api_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Callapi::Call::Request::Api do
+  context '#host' do
+    subject { described_class.new(nil).host }
+    let(:config) { Callapi::Config }
+
+    context 'when API host is not set' do
+      it 'should raise ApiHostNotSet error' do
+        expect { subject }.to raise_error { Callapi::ApiHostNotSetError }
+      end
+    end
+
+    context 'when API host is set' do
+      before { allow(config).to receive(:api_host).and_return('http://api.org') }
+
+      it 'should take API host from config' do
+        expect( subject ).to eql 'http://api.org'
+      end
+    end
+  end
+
+  context '#response' do
+    before do
+      config = Callapi::Config
+      allow(config).to receive(:request_strategy).and_return(described_class)
+      allow(config).to receive(:api_host).and_return('http://api.org')
+      stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '')
+
+      call_class = Get::Users
+      @call = call_class.new
+    end
+
+    subject { described_class.new(@call).response }
+
+    it 'should get response from server' do
+      expect( subject.body ).to eql(nil)
+      expect( subject.code ).to eql('200')
+    end
+  end
+end

data/spec/unit/call/request/mock_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Callapi::Call::Request::Mock do
+  context '#response' do
+    before do
+      call_class = Get::Users
+      @call = call_class.new
+    end
+
+    subject { described_class.new(@call).response }
+
+    context 'when there is no file with mocked response' do
+      it 'should raise CouldNotFoundRequestMockFile error' do
+        expect{ subject }.to raise_error { Callapi::CouldNotFoundMockRequestFileError }
+      end
+    end
+
+    context '#body' do
+      subject { described_class.new(@call).response.body }
+
+      before do
+        allow(File).to receive(:read).and_return('body from file')
+      end
+
+      it 'should be taken from file' do
+        expect(subject).to eql('body from file')
+      end
+    end
+
+    context '#filepath' do
+      subject { described_class.new(@call).send(:file_path) }
+
+      it 'should be created based on call HTTP method, request path and response format ' do
+        expect(subject).to eql 'mocked_calls/get/users.json'
+      end
+    end
+  end
+end

data/spec/unit/call/request_metadata_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Callapi::Call::RequestMetadata do
+  before(:all) do
+    Get::Users::Details = Class.new(Callapi::Call::Base)
+    Get::Users::IdParam = Class.new(Callapi::Call::Base)
+    Get::Users::IdParam::Posts = Class.new(Callapi::Call::Base)
+    Get::Users::IdParam::Posts::PostIdParam = Class.new(Callapi::Call::Base)
+    ClassWithoutHttpNamespace = Class.new(Callapi::Call::Base)
+  end
+
+  let(:metadata) { described_class.new(@call_class.new) }
+
+  context '#request_method' do
+    subject { metadata.request_method }
+
+    context 'when call class has namespace equal to some HTTP method' do
+      let(:metadata) { described_class.new(Get::Users.new) }
+
+      it 'should take HTTP method from this namespace' do
+        expect(subject).to eql(:get)
+      end
+    end
+
+    context 'when call class does not have namespace equal to some HTTP method' do
+      let(:metadata) { described_class.new(ClassWithoutHttpNamespace.new) }
+
+      it 'should raise UnknownHttpMethod error' do
+        expect{ subject }.to raise_error { Callapi::UnknownHttpMethodError }
+      end
+    end
+  end
+
+  context '#request_path' do
+    subject { metadata.request_path }
+    let(:metadata) { described_class.new(Get::Users::Details.new) }
+
+    it 'should be equal to underscored class name with its namespaces' do
+      expect(subject).to eql('/users/details')
+    end
+
+    context 'when class name contain "Param" string' do
+      let(:metadata) { described_class.new(Get::Users::IdParam::Posts::PostIdParam.new(id: 123, post_id: 456)) }
+
+      it 'should use this param value to create path' do
+        expect(subject).to eql('/users/123/posts/456')
+      end
+
+      context 'but required param is not provided' do
+        let(:metadata) { described_class.new(Get::Users::IdParam::Posts::PostIdParam.new(post_id: 456)) }
+
+        it 'should raise MissingParam error' do
+          expect{ subject }.to raise_error{Callapi::MissingParamError}
+        end
+      end
+    end
+  end
+end

data/spec/unit/call/response/json/as_object_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Callapi::Call::Parser::Json::AsObject do
+  context '#data' do
+    before do
+      config = Callapi::Config
+      allow(config).to receive(:api_host).and_return('http://api.org')
+      allow(config).to receive(:default_response_parser).and_return(described_class)
+
+      @call = Get::Users.new
+    end
+
+    subject { @call.response.data }
+
+    context 'when request body is "{"valid": true, "score": 59}"' do
+      before { stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '{"valid": true, "score": 59}') }
+
+      it 'should return object with #valid and #score methods' do
+        expect(subject.valid).to eq (true)
+        expect(subject.score).to eq (59)
+      end
+    end
+
+    context 'when request body is "[{"score": 59}, {"score": 60}]"' do
+      before { stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '[{"score": 59}, {"score": 60}]') }
+
+      it 'should return array of objects with #score method' do
+        expect(subject[0].score).to eq (59)
+        expect(subject[1].score).to eq (60)
+      end
+    end
+
+    context '#keys_excluded_from_parsing' do
+      context 'when set to ["translations"]' do
+        before { described_class.keys_excluded_from_parsing = ['translations'] }
+
+        context 'and request body is "{"valid": true, "translations": {"a": "A"}}"' do
+          before { stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '{"valid": true, "translations": {"a": "A"}}') }
+
+          it 'should should not create object from #translations' do
+            expect(subject.valid).to eq (true)
+            expect(subject.translations).to eq ({'a' => 'A'})
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/call/response/json_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Callapi::Call::Parser::Json do
+  context '#data' do
+    before do
+      config = Callapi::Config
+      allow(config).to receive(:api_host).and_return('http://api.org')
+
+      call_class = Get::Users
+      @call = call_class.new
+    end
+
+    subject { @call.response.data }
+
+    context 'when request body is "{"valid": true, "score": 59}"' do
+      before { stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '{"valid": true, "score": 59}') }
+
+      it { expect(subject).to eq ({'valid' => true, 'score' => 59}) }
+    end
+  end
+end

data/spec/unit/call/response/plain_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Callapi::Call::Parser::Plain do
+  context '#data' do
+    before do
+      Callapi::Config.configure do |config|
+        config.api_host = 'http://api.org'
+      end
+
+      Callapi::Routes.draw do
+        get 'plain', parser: Callapi::Call::Parser::Plain
+      end
+
+      stub_request(:get, 'http://api.org/plain').to_return(status: 200, body: 'some response')
+    end
+
+    subject { get_plain_call.response.data }
+
+    it 'should return response body' do
+      expect(subject).to eql ( 'some response' )
+    end
+  end
+end

data/spec/unit/call/response_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Callapi::Call::Parser do
+  before do
+    config = Callapi::Config
+    allow(config).to receive(:api_host).and_return('http://api.org')
+
+    @call = Get::Users.new
+  end
+
+  context 'caching response' do
+    before do
+      stub_request(:get, 'http://api.org/users').to_return(status: 200, body: '{"json": true}')
+    end
+
+    it 'should not parse response twice unless call is reloaded' do
+      cached_response = {'json' => true}
+      expect(@call.response.data).to eql cached_response
+      @call.response_parser = Callapi::Call::Parser::Plain
+      expect(@call.response.data).to eql cached_response
+      @call.reload
+      expect(@call.response.data).to eql '{"json": true}'
+    end
+
+  end
+
+  context '#data' do
+    subject { @call.response.data }
+
+    context 'when API returned 5xx' do
+      before do
+        stub_request(:get, 'http://api.org/users').to_return(status: 500)
+      end
+
+      it 'should raise ServerError error' do
+        expect{ subject }.to raise_error { Callapi::ServerError }
+      end
+    end
+
+    context 'when API returned 4xx' do
+      before do
+        stub_request(:get, 'http://api.org/users').to_return(status: 400)
+      end
+
+      it 'should raise ClientError error' do
+        expect{ subject }.to raise_error { Callapi::ClientError }
+      end
+    end
+
+    context 'when API returned 401' do
+      before do
+        stub_request(:get, 'http://api.org/users').to_return(status: 401)
+      end
+
+      it 'should raise NotAuthorized error' do
+        expect{ subject }.to raise_error { Callapi::NotAuthorizedError }
+      end
+    end
+
+  end
+end