resource_set 1.0.0

data/spec/integration/resource_actions_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+class DummyResourceActions < ResourceSet::Resource
+  resources do
+    action :dummy, 'GET /dummy' do
+      handler(200) { |resp| resp.body.upcase }
+    end
+
+    action :headered, 'GET /headered' do
+      before_request { |req| req.headers['Added-Header'] = self.value }
+    end
+  end
+
+  def value
+    scope.value
+  end
+end
+
+RSpec.describe 'Resource Actions' do
+  let(:connection) { Faraday.new { |b| b.adapter :test, stubs } }
+  let(:scoped) { double('scope', value: 'bunk') }
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/dummy') { |env| [200, {}, 'dummies'] }
+      stub.get('/headered') { |env| [200, {}, env[:request_headers]['Added-Header']] }
+    end
+  end
+
+  it 'Retrieving /dummy returns the body as uppercased' do
+    resource = DummyResourceActions.new(connection: connection, scope: scoped)
+    response = resource.dummy
+    expect(response).to eq('DUMMIES')
+  end
+
+  it 'adds the header before the request happens' do
+    resource = DummyResourceActions.new(connection: connection, scope: scoped)
+    response = resource.headered
+
+    expect(response).to eq(scoped.value)
+  end
+end

data/spec/lib/resource_set/action_invoker_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+RSpec.describe ResourceSet::ActionInvoker do
+  let(:connection) { Faraday.new { |b| b.adapter :test, stubs } }
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/users') { |env| [200, {}, 'all users'] }
+      stub.get('/users/bad_page') { |env| [404, {}, 'not found'] }
+      stub.get('/users/12') { |env| [200, {}, 'user 12'] }
+      stub.post('/users') { |env| [200, {}, env[:body]] }
+      stub.get('/paged') { |env| [200, {}, env[:url].to_s] }
+      stub.get('/before_hooks') { |env| [200, {}, env[:request_headers]['Owner-Id']] }
+      stub.get('/block_based') { |env| [200, {}, 'block based path'] }
+    end
+  end
+  let(:action) { ResourceSet::Action.new(:find) }
+  let(:resource) { double('resource instance', connection: connection) }
+
+  describe '.call' do
+    it 'performs a request to the specfied URL' do
+      action.verb :get
+      action.path '/users'
+
+      result = ResourceSet::ActionInvoker.call(action, resource)
+
+      expect(result).to eq('all users')
+    end
+
+    it 'performs a request to the correct url when using a block for path' do
+      action.path { '/block_based' }
+      result = ResourceSet::ActionInvoker.call(action, resource)
+
+      expect(result).to eq('block based path')
+    end
+
+    it 'substitues params on call' do
+      action.verb :get
+      action.path '/users/:id'
+
+      result = ResourceSet::ActionInvoker.call(action, resource, id: 12)
+      expect(result).to eq('user 12')
+    end
+
+    context 'when an action has a handler' do
+      it 'returns the handler block' do
+        action.verb :get
+        action.path '/users'
+        action.handler(200) { |response| 'changed' }
+
+        result = ResourceSet::ActionInvoker.call(action, resource)
+
+        expect(result).to eq('changed')
+      end
+
+      it 'passes the initial object' do
+        action.verb :get
+        action.path '/users'
+        action.handler(200) { |response, hash| hash }
+
+        target_hash = Hash.new
+        result = ResourceSet::ActionInvoker.call(action, resource, target_hash)
+
+        expect(result).to be target_hash
+      end
+
+      it 'uses the correct handler on status codes' do
+        action.verb :get
+        action.path '/users/bad_page'
+        action.handler(404) { |response| '404ed' }
+
+        result = ResourceSet::ActionInvoker.call(action, resource)
+        expect(result).to eq('404ed')
+      end
+
+      it 'uses a default handler if provided' do
+        action.verb :get
+        action.path '/users'
+        action.handler { |response| 'Something unexpected happened.' }
+
+        result = ResourceSet::ActionInvoker.call(action, resource)
+        expect(result).to eq('Something unexpected happened.')
+      end
+    end
+
+    context 'for requests with bodies' do
+      it 'uses the body handler when present' do
+        action.verb :post
+        action.path '/users'
+        action.body { |object| 'i am a banana' }
+
+        result = ResourceSet::ActionInvoker.call(action, resource, 'echo me')
+        expect(result).to eq('i am a banana')
+      end
+
+      it 'uses the body handler with multiple arity when present' do
+        action.verb :post
+        action.path '/users'
+        action.body { |first, second| first + second }
+
+        result = ResourceSet::ActionInvoker.call(action, resource, 'echo me', ' another')
+        expect(result).to eq('echo me another')
+      end
+    end
+
+    context 'for requests with query params' do
+      it 'appends the query parameters to the endpoint' do
+        action.query_keys :per_page, :page
+        action.path '/paged'
+
+        result = ResourceSet::ActionInvoker.call(action, resource, page: 3, per_page: 300)
+        addressed = Addressable::URI.parse(result)
+
+        expect(addressed.query_values).to include('per_page' => '300', 'page' => '3')
+      end
+    end
+
+    context 'for actions that have before request hooks' do
+      it 'calls the before request with the request object' do
+        action.path '/before_hooks'
+        action.verb :get
+        action.before_request { |req| req.headers['Owner-Id'] = 'bojangles' }
+
+        result = ResourceSet::ActionInvoker.call(action, resource)
+        expect(result).to eq('bojangles')
+      end
+
+      it 'calls the before request with the request object and arguments' do
+        action.path '/before_hooks'
+        action.verb :get
+        action.before_request { |one, two, req| req.headers['Owner-Id'] = "#{one} #{two}" }
+
+        result = ResourceSet::ActionInvoker.call(action, resource, 'one', 'two')
+        expect(result).to eq('one two')
+      end
+
+      context 'for passing a symbol' do
+        it 'calls the method on the context of the action' do
+          def resource.kickit(request)
+            request.headers['Owner-Id'] = 'btabes'
+          end
+
+          action.path '/before_hooks'
+          action.verb :get
+          action.before_request(:kickit)
+
+          invoker = ResourceSet::ActionInvoker.new(action, resource)
+
+          expect(invoker.handle_response).to eq('btabes')
+        end
+
+        it 'calls the action with arguments passed' do
+          def resource.kickit(one, two, request)
+            request.headers['Owner-Id'] = "#{one} #{two}"
+          end
+
+          action.path '/before_hooks'
+          action.verb :get
+          action.before_request(:kickit)
+
+          invoker = ResourceSet::ActionInvoker.new(action, resource, 'bobby', 'tables')
+
+          expect(invoker.handle_response).to eq('bobby tables')
+        end
+      end
+    end
+  end
+end

data/spec/lib/resource_set/action_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+RSpec.describe ResourceSet::Action do
+  subject(:action) { ResourceSet::Action.new(:bunk) }
+
+  describe '#initialize' do
+    it 'initializes with a name' do
+      instance = ResourceSet::Action.new(:all)
+      expect(instance.name).to eq(:all)
+    end
+  end
+
+  describe '#verb' do
+    it 'sets the verb' do
+      action = described_class.new(:find)
+      action.verb :get
+      expect(action.verb).to be(:get)
+    end
+  end
+
+  describe '#path' do
+    it 'sets the path' do
+      action = described_class.new(:find)
+      action.path '/something/sammy'
+      expect(action.path).to eq('/something/sammy')
+    end
+
+    it 'sets the path to a block when passed' do
+      action = described_class.new(:find)
+      proc = Proc.new { '/users/:id/comments' }
+      action.path(&proc)
+
+      expect(action.path).to be(proc)
+    end
+  end
+
+  describe '#handler' do
+    it 'adds a handler to the handlers' do
+      expect { action.handler(202) { } }.to change(action.handlers, :size).from(0).to(1)
+    end
+
+    it 'adds the correct status code when using a symbol' do
+      action.handler(:ok) {}
+      expect(action.handlers).to have_key(200)
+    end
+  end
+
+  describe '#handlers' do
+    it 'returns a handler collection object' do
+      collection = action.handlers
+      expect(collection).to be_kind_of(Hash)
+    end
+  end
+
+  describe '#body' do
+    it 'stores a proc for handling requests with bodies' do
+      handler = Proc.new { |object| 'whut whut' }
+      action.body(&handler)
+
+      expect(action.body).to be(handler)
+    end
+  end
+
+  describe '#query_keys' do
+    it 'allows setting known query parameters that we should append to the URL' do
+      action.query_keys :per_page, :page
+      expect(action.query_keys).to include(:per_page, :page)
+    end
+  end
+
+  describe '#before_request' do
+    context 'with a block' do
+      it 'sets a block to happen before the request happens' do
+        proc = Proc.new {}
+        action.before_request(&proc)
+        expect(action.hooks[:before]).to include(proc)
+      end
+    end
+
+    context 'with a symbol' do
+      it 'adds the symbol to the before hooks' do
+        action.before_request(:foo)
+        expect(action.hooks[:before]).to include(:foo)
+      end
+    end
+  end
+end

data/spec/lib/resource_set/endpoint_resolver_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe ResourceSet::EndpointResolver do
+  describe '#initialize' do
+    it 'initializes with pieces of a URL' do
+      options = { path: '/users', namespace: '/v2', query_param_keys: ['per_page', 'page'] }
+      instance = ResourceSet::EndpointResolver.new(options)
+
+      expect(instance.path).to eq(options[:path])
+      expect(instance.query_param_keys).to eq(options[:query_param_keys])
+    end
+  end
+
+  describe '#resolve' do
+    let(:path) { '/users' }
+    let(:query_param_keys) { [] }
+    let(:options) { { path: path, query_param_keys: query_param_keys } }
+
+    subject(:resolver) { ResourceSet::EndpointResolver.new(options) }
+
+    context 'simple resolve' do
+      it 'creates a populated URL from passed values' do
+        endpoint = resolver.resolve()
+        expect(endpoint).to eq('/users')
+      end
+    end
+
+    context 'substituted paths' do
+      let(:path) { '/users/:id' }
+
+      it 'creates a populated URL from passed values' do
+        endpoint = resolver.resolve(id: 1066)
+        expect(endpoint).to eq('/users/1066')
+      end
+    end
+
+    context 'with query parameters' do
+      let(:query_param_keys) { [:per_page, :page] }
+
+      it 'generates a URL with query parameters set correctly' do
+        endpoint = resolver.resolve(per_page: 2, page: 3)
+
+        uri = Addressable::URI.parse(endpoint)
+        expect(uri.query_values).to eq("per_page" => '2', "page" => '3')
+      end
+    end
+
+    context 'with query parameters already appended' do
+      let(:path) { '/:something/users?foo=bar' }
+      let(:query_param_keys) { [:per_page, :page] }
+
+      it 'appends the query params to the url that already has some' do
+        endpoint = resolver.resolve(something: 'testing', per_page: 2, page: 3)
+
+        uri = Addressable::URI.parse(endpoint)
+        expect(uri.query_values).to eq("foo" => 'bar', "per_page" => '2', "page" => '3')
+      end
+    end
+  end
+end

data/spec/lib/resource_set/inheritable_attribute_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ResourceSet::InheritableAttribute do
+  subject do
+    Class.new(Object) do
+      extend ResourceSet::InheritableAttribute
+
+      inheritable_attr :_resources
+    end
+  end
+
+  it 'provides a reader with an empty inherited attribute' do
+    expect(subject._resources).to be_nil
+  end
+
+  it 'provides a reader with empty inherited attributes in a derived class' do
+    expect(Class.new(subject)._resources).to be_nil
+
+    # subject._resouces = true
+    # Class.new(subject)._resources # TODO: crashes.
+  end
+
+  it 'provides an attribute copy in subclasses' do
+    subject._resources = []
+    expect(subject._resources.object_id).not_to eq Class.new(subject)._resources.object_id
+  end
+
+  it 'provides a writer' do
+    subject._resources = [:resource]
+    expect(subject._resources).to eq [:resource]
+  end
+
+  it 'inherits attributes' do
+    subject._resources = [:resource]
+
+    subclass_a = Class.new(subject)
+    subclass_a._resources << :another_resource
+
+    subclass_b = Class.new(subject)
+    subclass_b._resources << :different_resource
+
+    expect(subject._resources).to eq [:resource]
+    expect(subclass_a._resources).to eq [:resource, :another_resource]
+    expect(subclass_b._resources).to eq [:resource, :different_resource]
+  end
+
+  it 'does not inherit attributes if we set explicitely' do
+    subject._resources = [:resource]
+    subclass = Class.new(subject)
+
+    subclass._resources = [:another_resource]
+    expect(subclass._resources).to eq [:another_resource]
+  end
+end

data/spec/lib/resource_set/method_factory_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe ResourceSet::MethodFactory do
+  let(:collection) { ResourceSet::ResourceCollection.new }
+  let(:klass) { Class.new { attr_accessor :connection } }
+
+  describe '.construct' do
+    before do
+      collection.action :find
+      collection.action :all
+    end
+
+    it 'adds the methods from the resource collection to the passed object' do
+      ResourceSet::MethodFactory.construct(klass, collection)
+      instance = klass.new
+      expect(instance).to respond_to(:find, :all)
+    end
+
+    it 'bails when the method is already defined' do
+      collection.action :all
+
+      expect {
+        ResourceSet::MethodFactory.construct(klass, collection)
+      }.to raise_exception(ArgumentError).with_message("Action 'all' is already defined on `#{klass}`")
+    end
+
+    it 'adds the correct interface for the action' do
+      ResourceSet::MethodFactory.construct(klass, collection)
+      method_sig = klass.instance_method(:all).parameters
+
+      expect(method_sig).to eq([[:rest, :args]])
+    end
+
+  end
+
+  describe 'Calling the method' do
+    it 'calls the invoker passed with the arguments and action' do
+      action = ResourceSet::Action.new(:bunk)
+      collection << action
+      invoker = double('invoker', call: true)
+
+      ResourceSet::MethodFactory.construct(klass, collection, invoker)
+
+      instance = klass.new
+      instance.connection = double('connection')
+      instance.bunk('something', 'something else')
+      expect(invoker).to have_received(:call).with(action, instance, 'something', 'something else')
+    end
+  end
+end