ddy_remote_resource 0.4.2

data/lib/remote_resource/rest.rb

@@ -0,0 +1,29 @@
+module RemoteResource
+  module REST
+    extend ActiveSupport::Concern
+
+    ACTIONS = [:get, :put, :patch, :post]
+
+    module ClassMethods
+
+      RemoteResource::REST::ACTIONS.each do |action|
+        define_method action do |*args|
+          attributes         = args[0] || {}
+          connection_options = args[1] || {}
+
+          RemoteResource::Request.new(self, action, attributes, connection_options).perform
+        end
+      end
+    end
+
+    RemoteResource::REST::ACTIONS.each do |action|
+      define_method action do |*args|
+        attributes         = args[0] || {}
+        connection_options = args[1] || {}
+
+        RemoteResource::Request.new(self, action, attributes, connection_options).perform
+      end
+    end
+
+  end
+end

data/lib/remote_resource/url_naming.rb

@@ -0,0 +1,34 @@
+module RemoteResource
+  module UrlNaming
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :site, :version, :path_prefix, :path_postfix, :collection, :collection_name, instance_accessor: false
+
+      self.collection = false
+    end
+
+    module ClassMethods
+
+      def app_host(app, env = 'development')
+        CONFIG[env.to_sym][:apps][app.to_sym]
+      end
+
+      def base_url
+        determined_url_naming.base_url
+      end
+
+      def use_relative_model_naming?
+        true
+      end
+
+      private
+
+      def determined_url_naming
+        RemoteResource::UrlNamingDetermination.new self
+      end
+
+    end
+
+  end
+end

data/lib/remote_resource/url_naming_determination.rb

@@ -0,0 +1,39 @@
+module RemoteResource
+  class UrlNamingDetermination
+
+    attr_reader :resource_klass, :connection_options
+
+    def initialize(resource_klass, connection_options = {})
+      @resource_klass     = resource_klass
+      @connection_options = connection_options
+    end
+
+    def base_url(id = nil)
+      site         = connection_options.fetch(:site, resource_klass.site)
+      version      = connection_options.fetch(:version, resource_klass.version)
+      path_prefix  = connection_options.fetch(:path_prefix, resource_klass.path_prefix)
+      path_postfix = connection_options.fetch(:path_postfix, resource_klass.path_postfix)
+
+      id           = "/#{id}" if id.present?
+
+      "#{site}#{version.presence}#{path_prefix.presence}/#{url_safe_relative_name}#{id}#{path_postfix.presence}"
+    end
+
+    def url_safe_relative_name
+      collection = connection_options.fetch(:collection, resource_klass.collection)
+
+      if collection
+        relative_name.underscore.downcase.pluralize
+      else
+        relative_name.underscore.downcase
+      end
+    end
+
+    def relative_name
+      collection_name = connection_options.fetch(:collection_name, resource_klass.collection_name)
+
+      collection_name.to_s.presence || resource_klass.name.to_s.demodulize
+    end
+
+  end
+end

data/lib/remote_resource/version.rb

@@ -0,0 +1,3 @@
+module RemoteResource
+  VERSION = '0.4.2'
+end

data/remote_resource.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'remote_resource/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ddy_remote_resource'
+  spec.version       = RemoteResource::VERSION
+  spec.authors       = ["Jan van der Pas"]
+  spec.email         = ["jvanderpas@digidentity.eu"]
+  spec.summary       = %q{RemoteResource, a gem to use resources with REST services.}
+  spec.description   = %q{RemoteResource, a gem to use resources with REST services. A replacement for ActiveResource gem.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'activemodel'
+  spec.add_runtime_dependency 'virtus'
+  spec.add_runtime_dependency 'mime-types', '>= 1.16'
+  spec.add_runtime_dependency 'ethon', '~> 0.7.1'
+  spec.add_runtime_dependency 'typhoeus'
+end

data/spec/lib/extensions/ethon/easy/queryable_spec.rb

@@ -0,0 +1,135 @@
+require 'ethon'
+require_relative '../../../../../lib/extensions/ethon/easy/queryable'
+
+describe Ethon::Easy::Queryable do
+
+  let(:hash)    { {} }
+  let!(:easy)   { Ethon::Easy.new }
+  let(:params)  { Ethon::Easy::Params.new(easy, hash) }
+
+  describe "#build_query_pairs" do
+    let(:pairs) { params.method(:build_query_pairs).call(hash) }
+
+    context "when params is empty" do
+      it "returns empty array" do
+        expect(pairs).to eq([])
+      end
+    end
+
+    context "when params is string" do
+      let(:hash) { "{a: 1}" }
+
+      it "wraps it in an array" do
+        expect(pairs).to eq([hash])
+      end
+    end
+
+    context "when params is simple hash" do
+      let(:hash) { {:a => 1, :b => 2} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include([:b, 2])
+      end
+    end
+
+    context "when params is a nested hash" do
+      let(:hash) { {:a => 1, :b => {:c => 2}} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include(["b[c]", 2])
+      end
+    end
+
+    context "when params contains an array" do
+      let(:hash) { {:a => 1, :b => [2, 3]} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include(["b[]", 2])
+        expect(pairs).to include(["b[]", 3])
+      end
+    end
+
+    context "when params contains something nested in an array" do
+      context "when string" do
+        let(:hash) { {:a => {:b => ["hello", "world"]}} }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][]", "hello"], ["a[b][]", "world"]])
+        end
+      end
+
+      context "when hash" do
+        let(:hash) { {:a => {:b => [{:c =>1}, {:d => 2}]}} }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][][c]", 1], ["a[b][][d]", 2]])
+        end
+      end
+
+      context "when file" do
+        let(:file) { File.open("spec/spec_helper.rb") }
+        let(:file_info) { params.method(:file_info).call(file) }
+        let(:hash) { {:a => {:b => [file]}} }
+        let(:mime_type) { file_info[1] }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][]", file_info]])
+        end
+
+        context "when MIME" do
+          context "when mime type" do
+            it "sets mime type to text" do
+              expect(mime_type).to eq("application/x-ruby")
+            end
+          end
+
+          context "when no mime type" do
+            let(:file) { Tempfile.new("fubar") }
+
+            it "sets mime type to default application/octet-stream" do
+              Object.send(:remove_const, :MIME)
+              expect(mime_type).to eq("application/octet-stream")
+            end
+          end
+        end
+
+        context "when no MIME" do
+          it "sets mime type to default application/octet-stream" do
+            expect(mime_type).to eq("application/octet-stream")
+          end
+        end
+      end
+    end
+
+
+    context "when params contains file" do
+      let(:file) { Tempfile.new("fubar") }
+      let(:file_info) { params.method(:file_info).call(file) }
+      let(:hash) { {:a => 1, :b => file} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include([:b, file_info])
+      end
+    end
+
+    context "when params key contains a null byte" do
+      let(:hash) { {:a => "1\0" } }
+
+      it "preserves" do
+        expect(pairs).to eq([[:a, "1\0"]])
+      end
+    end
+
+    context "when params value contains a null byte" do
+      let(:hash) { {"a\0" => 1 } }
+
+      it "preserves" do
+        expect(pairs).to eq([["a\0", 1]])
+      end
+    end
+  end
+end

data/spec/lib/remote_resource/base_spec.rb

@@ -0,0 +1,388 @@
+require 'spec_helper'
+
+describe RemoteResource::Base do
+
+  module RemoteResource
+    class Dummy
+      include RemoteResource::Base
+
+      self.site = 'https://foobar.com'
+
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::Dummy }
+  let(:dummy)       { dummy_class.new }
+
+  specify { expect(described_class.const_defined?('RemoteResource::Builder')).to be_truthy }
+  specify { expect(described_class.const_defined?('RemoteResource::UrlNaming')).to be_truthy }
+  specify { expect(described_class.const_defined?('RemoteResource::Connection')).to be_truthy }
+  specify { expect(described_class.const_defined?('RemoteResource::REST')).to be_truthy }
+
+  specify { expect(described_class.const_defined?('RemoteResource::Querying::FinderMethods')).to be_truthy }
+  specify { expect(described_class.const_defined?('RemoteResource::Querying::PersistenceMethods')).to be_truthy }
+
+  describe 'OPTIONS' do
+    let(:options) { [:base_url, :site, :headers, :version, :path_prefix, :path_postfix, :content_type, :collection, :collection_name, :root_element] }
+
+    specify { expect(described_class::OPTIONS).to eql options }
+  end
+
+  describe 'attributes' do
+    it '#id' do
+      expect(dummy.attributes).to have_key :id
+    end
+  end
+
+  describe '.global_headers=' do
+    let(:global_headers) do
+      {
+        'X-Locale' => 'en',
+        'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
+      }
+    end
+
+    after { described_class.global_headers = nil }
+
+    it 'sets the global headers Thread variable' do
+      expect{ described_class.global_headers = global_headers }.to change{ Thread.current[:global_headers] }.from(nil).to global_headers
+    end
+  end
+
+  describe '.global_headers' do
+    let(:global_headers) do
+      {
+        'X-Locale' => 'en',
+        'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
+      }
+    end
+
+    before { described_class.global_headers = global_headers }
+    after  { described_class.global_headers = nil }
+
+    it 'returns the global headers Thread variable' do
+      expect(described_class.global_headers).to eql global_headers
+    end
+  end
+
+  describe '.connection_options' do
+    it 'instantiates as a RemoteResource::ConnectionOptions' do
+      expect(dummy_class.connection_options).to be_a RemoteResource::ConnectionOptions
+    end
+
+    it 'uses the implemented class as base_class' do
+      expect(dummy_class.connection_options.base_class).to be RemoteResource::Dummy
+    end
+
+    it 'sets the name of Thread variable with the implemented class' do
+      expect(dummy_class.connection_options).to eql Thread.current['remote_resource.dummy.connection_options']
+    end
+  end
+
+  describe '.threaded_connection_options' do
+    it 'instantiates as a Hash' do
+      expect(dummy_class.threaded_connection_options).to be_a Hash
+    end
+
+    it 'sets the name of Thread variable with the implemented class' do
+      expect(dummy_class.threaded_connection_options).to eql Thread.current['remote_resource.dummy.threaded_connection_options']
+    end
+  end
+
+  describe '.with_connection_options' do
+    let(:connection_options) { {} }
+
+    let(:block_with_connection_options) do
+      dummy_class.with_connection_options(connection_options) do
+        dummy_class.find_by({ username: 'foobar' }, { content_type: '.json' })
+        dummy_class.create({ username: 'bazbar' }, { content_type: '.xml' })
+      end
+    end
+
+    before { allow_any_instance_of(Typhoeus::Request).to receive(:run) { double.as_null_object } }
+
+    it 'yields the block' do
+      expect(dummy_class).to receive(:find_by).with({ username: 'foobar' }, { content_type: '.json' }).and_call_original
+      expect(dummy_class).to receive(:create).with({ username: 'bazbar' }, { content_type: '.xml' }).and_call_original
+      block_with_connection_options
+    end
+
+    it 'ensures to set the threaded_connection_options Thread variable to nil' do
+      dummy_class.threaded_connection_options
+
+      expect{ block_with_connection_options }.to change{ Thread.current['remote_resource.dummy.threaded_connection_options'] }.from(an_instance_of(Hash)).to nil
+    end
+
+    context 'when the given connection_options contain headers' do
+      let(:connection_options) do
+        {
+          headers: { "Foo" => "Bar" }
+        }
+      end
+
+      it 'uses the headers of the given connection_options' do
+        expect(Typhoeus::Request).to receive(:get).with('https://foobar.com/dummy.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json", "Foo" => "Bar" }).and_call_original
+        expect(Typhoeus::Request).to receive(:post).with('https://foobar.com/dummy.xml', body: { username: 'bazbar' }, headers: { "Accept" => "application/json", "Foo" => "Bar" }).and_call_original
+        block_with_connection_options
+      end
+    end
+
+    context 'when the given connection_options contain base_url' do
+      let(:connection_options) do
+        {
+          base_url: 'https://api.foobar.eu/dummy'
+        }
+      end
+
+      it 'uses the base_url of the given connection_options' do
+        expect(Typhoeus::Request).to receive(:get).with('https://api.foobar.eu/dummy.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json" }).and_call_original
+        expect(Typhoeus::Request).to receive(:post).with('https://api.foobar.eu/dummy.xml', body: { username: 'bazbar' }, headers: { "Accept" => "application/json" }).and_call_original
+        block_with_connection_options
+      end
+    end
+
+    context 'when the given connection_options contain something else' do
+      let(:connection_options) do
+        {
+          collection: true,
+          path_prefix: '/api',
+          root_element: :bazbar
+        }
+      end
+
+      it 'uses the given connection_options' do
+        expect(Typhoeus::Request).to receive(:get).with('https://foobar.com/api/dummies.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json" }).and_call_original
+        expect(Typhoeus::Request).to receive(:post).with('https://foobar.com/api/dummies.xml', body:  { 'bazbar' => { username: 'bazbar' } }, headers: { "Accept" => "application/json" }).and_call_original
+        block_with_connection_options
+      end
+    end
+  end
+
+  describe '#connection_options' do
+    it 'instanties as a RemoteResource::ConnectionOptions' do
+      expect(dummy.connection_options).to be_a RemoteResource::ConnectionOptions
+    end
+
+    it 'uses the implemented class as base_class' do
+      expect(dummy.connection_options.base_class).to be RemoteResource::Dummy
+    end
+  end
+
+  describe '#empty?' do
+    before { allow(dummy).to receive(:_response) { response } }
+
+    context 'when the response is present' do
+      let(:response) { instance_double(RemoteResource::Response, sanitized_response_body: sanitized_response_body) }
+
+      context 'and the #sanitized_response_body is present' do
+        let(:sanitized_response_body) do
+          { name: 'Mies' }
+        end
+
+        it 'returns false' do
+          expect(dummy.empty?).to eql false
+        end
+      end
+
+      context 'and the #sanitized_response_body is blank' do
+        let(:sanitized_response_body) do
+          {}
+        end
+
+        it 'returns true' do
+          expect(dummy.empty?).to eql true
+        end
+      end
+
+      context 'and the #sanitized_response_body is NOT present' do
+        let(:sanitized_response_body) { nil }
+
+        it 'returns true' do
+          expect(dummy.empty?).to eql true
+        end
+      end
+    end
+
+    context 'when the response is NOT present' do
+      let(:response) { nil }
+
+      it 'returns true' do
+        expect(dummy.empty?).to eql true
+      end
+    end
+  end
+
+  describe '#persisted?' do
+    context 'when id is present' do
+      it 'returns true' do
+        dummy.id = 10
+        expect(dummy.persisted?).to eql true
+      end
+    end
+
+    context 'when is is NOT present' do
+      it 'returns false' do
+        expect(dummy.persisted?).to eql false
+      end
+    end
+  end
+
+  describe '#new_record?' do
+    context 'when instance persisted' do
+      it 'returns false' do
+        allow(dummy).to receive(:persisted?) { true }
+
+        expect(dummy.new_record?).to eql false
+      end
+    end
+
+    context 'when instance does NOT persist' do
+      it 'returns true' do
+        allow(dummy).to receive(:persisted?) { false }
+
+        expect(dummy.new_record?).to eql true
+      end
+    end
+  end
+
+  describe '#success?' do
+    let(:response) { instance_double(RemoteResource::Response) }
+
+    before { allow(dummy).to receive(:_response) { response } }
+
+    context 'when response is successful' do
+      before { allow(response).to receive(:success?) { true } }
+
+      context 'and the resource has NO errors present' do
+        it 'returns true' do
+          expect(dummy.success?).to eql true
+        end
+      end
+
+      context 'and the resource has errors present' do
+        it 'returns false' do
+          dummy.errors.add :id, 'must be present'
+
+          expect(dummy.success?).to eql false
+        end
+      end
+    end
+
+    context 'when response is NOT successful' do
+      before { allow(response).to receive(:success?) { false } }
+
+      it 'returns false' do
+        expect(dummy.success?).to eql false
+      end
+    end
+  end
+
+  describe '#errors?' do
+    context 'when resource has errors present' do
+      it 'returns true' do
+        dummy.errors.add :id, 'must be present'
+
+        expect(dummy.errors?).to eql true
+      end
+    end
+
+    context 'when resource has NO errors present' do
+      it 'returns false' do
+        expect(dummy.errors?).to eql false
+      end
+    end
+  end
+
+  describe '#handle_response' do
+    let(:response) { instance_double(RemoteResource::Response) }
+
+    before { allow(dummy).to receive(:rebuild_resource_from_response) { dummy } }
+
+    context 'when the response is a unprocessable_entity' do
+      before do
+        allow(response).to receive(:unprocessable_entity?) { true }
+
+        allow(dummy).to receive(:assign_errors_from_response)
+      end
+
+      it 'rebuilds the resource from the response' do
+        expect(dummy).to receive(:rebuild_resource_from_response).with response
+        dummy.handle_response response
+      end
+
+      it 'assigns the errors from the response to the resource' do
+        expect(dummy).to receive(:assign_errors_from_response).with response
+        dummy.handle_response response
+      end
+    end
+
+    context 'when the response is NOT a unprocessable_entity' do
+      before { allow(response).to receive(:unprocessable_entity?) { false } }
+
+      it 'rebuilds the resource from the response' do
+        expect(dummy).to receive(:rebuild_resource_from_response).with response
+        dummy.handle_response response
+      end
+    end
+  end
+
+  describe '#assign_response' do
+    let(:response) { instance_double(RemoteResource::Response) }
+
+    it 'assigns the #_response' do
+      expect{ dummy.assign_response response }.to change{ dummy._response }.from(nil).to response
+    end
+  end
+
+  describe '#assign_errors_from_response' do
+    let(:response)                      { instance_double(RemoteResource::Response) }
+    let(:error_messages_response_body)  { double('error_messages_response_body') }
+
+    it 'calls the #assign_errors method with the #error_messages_response_body of the response' do
+      allow(response).to receive(:error_messages_response_body) { error_messages_response_body }
+
+      expect(dummy).to receive(:assign_errors).with error_messages_response_body
+      dummy.assign_errors_from_response response
+    end
+  end
+
+  describe '#assign_errors' do
+    context 'with errors in the error_messages' do
+      let(:error_messages) do
+        {
+          "foo" => ["is required"],
+          "bar" => ["must be greater than 5"]
+        }
+      end
+
+      it 'assigns the error_messages as errors' do
+        dummy.send :assign_errors, error_messages
+        expect(dummy.errors.messages).to eql foo: ["is required"], bar: ["must be greater than 5"]
+      end
+    end
+
+    context 'with an empty Hash in the error_messages' do
+      let(:error_messages) do
+        {}
+      end
+
+      it 'does NOT assign the error_messages as errors' do
+        dummy.send :assign_errors, error_messages
+        expect(dummy.errors.messages).to eql({})
+      end
+    end
+
+    context 'with a String in the error_messages' do
+      let(:error_messages) do
+        "unauthorized"
+      end
+
+      it 'does NOT assign the error_messages as errors' do
+        dummy.send :assign_errors, error_messages
+        expect(dummy.errors.messages).to eql({})
+      end
+    end
+  end
+
+end
+