apitizer 0.0.1 → 0.0.2

data/spec/apitizer/connection/adaptor_spec.rb

@@ -1,21 +1,97 @@
 require 'spec_helper'
 
-describe Apitizer::Connection::Adaptor do
+RSpec.describe Apitizer::Connection::Adaptor do
   let(:parent_module) { Apitizer::Connection }
-  let(:address) { 'https://service.com/api/v1/json/articles' }
+  let(:address) { 'https://service.com/api/articles' }
 
-  [ 'Standard' ].each do |adaptor|
-    subject { parent_module::Adaptor.const_get(adaptor).new }
+  shared_examples 'a proper postman' do |method:|
+    it 'takes into account headers' do
+      headers = { 'Secret-Token' => 'arbitrary' }
+      stub = stub_http_request(method, address).with(headers: headers)
+      subject.process(method, address, {}, headers)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  shared_examples '#call of a Rack app' do |method:|
+    let(:code) { 200 }
+    let(:headers) { { 'a' => [ 'b' ] } }
+    let(:body) { 'Hej!' }
+
+    before(:each) do
+      stub_http_request(method, address).to_return(
+        code: code, headers: headers, body: body)
+    end
+
+    let(:response) { subject.process(method, address) }
+
+    it 'returns an array with three elements' do
+      expect(response.length).to eq(3)
+    end
+
+    it 'returns the code as the first element' do
+      expect(response[0]).to eq(code)
+    end
+
+    it 'returns the code as an integer' do
+      expect(response[0]).to be_kind_of(Integer)
+    end
+
+    it 'returns the headers as the second element' do
+      expect(response[1]).to eq(headers)
+    end
+
+    it 'returns the headers as a hash' do
+      expect(response[1]).to be_kind_of(Hash)
+    end
+
+    it 'returns the body as the third element' do
+      expect(response[2]).to eq([ body ])
+    end
+
+    it 'returns the body as an object responding to #each' do
+      expect(response[2]).to respond_to(:each)
+    end
+  end
+
+  describe '::Standard' do
+    subject { parent_module::Adaptor::Standard.new }
+
+    describe '#process' do
+      [ :get ].each do |method|
+        context "when sending #{ method } requests" do
+          it_behaves_like '#call of a Rack app', method: method
+          it_behaves_like 'a proper postman', method: method
+
+          it 'encodes parameters into the URI' do
+            stub = stub_http_request(method, address).with(query: { life: 42 })
+            subject.process(method, address, life: 42)
+            expect(stub).to have_been_requested
+          end
+        end
+      end
+
+      [ :post, :put, :patch, :delete ].each do |method|
+        context "when sending #{ method } requests" do
+          it_behaves_like '#call of a Rack app', method: method
+          it_behaves_like 'a proper postman', method: method
+
+          it 'encodes parameters into the body' do
+            stub = stub_http_request(method, address).with(body: 'life=42')
+            response = subject.process(method, address, life: 42)
+            expect(stub).to have_been_requested
+          end
 
-    describe "#{ adaptor }.process" do
-      it 'returns the code, headers, and body of the response' do
-        stub_http_request(:get, address).to_return(
-          code: '200', body: 'Hej!', headers: { 'a' => 'b' } )
-        response = subject.process(:get, address)
-        expect(response).to eq([ '200', { 'a' => [ 'b' ] }, 'Hej!' ])
+          it 'sets the charset parameter to UTF-8' do
+            stub = stub_http_request(method, address).with(
+              headers: { 'Content-Type' => /charset=UTF-8/ })
+            response = subject.process(method, address, life: 42)
+            expect(stub).to have_been_requested
+          end
+        end
       end
 
-      it 'raises exceptions when encounters unknown methods' do
+      it 'raises exceptions for unknown methods' do
         expect { subject.process(:smile, address) }.to \
           raise_error(parent_module::Error, /Invalid method/i)
       end

data/spec/apitizer/connection/dispatcher_spec.rb

@@ -1,37 +1,35 @@
 require 'spec_helper'
 
-describe Apitizer::Connection::Dispatcher do
+RSpec.describe Apitizer::Connection::Dispatcher do
   extend ResourceHelper
   include ResourceHelper
 
-  let(:headers) { { 'Secret-Token' => 'arbitrary' } }
-  let(:address) { 'https://service.com/api/v1/json/articles' }
-  let(:subject) do
-    Apitizer::Connection::Dispatcher.new(
-      dictionary: rest_http_dictionary, headers: headers)
-  end
+  let(:address) { 'https://service.com/api/articles' }
 
-  def create_request(action, address)
-    double(action: action, address: address, parameters: {})
+  def create_request(method)
+    double(method: method, address: address, parameters: {})
   end
 
   describe '#process' do
-    restful_actions.each do |action|
-      method = rest_http_dictionary[action]
+    { :json => '{}', :yaml => '---' }.each do |format, sample|
+      context "when interacting in #{ format }" do
+        let(:subject) { Apitizer::Connection::Dispatcher.new(format: format) }
 
-      context "when sending #{ action } Requests" do
-        it 'sets the token header' do
-          stub = stub_http_request(method, address)
-          response = subject.process(create_request(action, address))
-          expect(stub).to \
-            have_requested(method, address).with(headers: headers)
-        end
+        http_methods.each do |method|
+          context "when performing #{ method } operations" do
+            it 'uses propoer HTTP methods' do
+              stub = stub_http_request(method, address).to_return(body: sample)
+              response = subject.process(create_request(method))
+              expect(stub).to have_been_requested
+            end
 
-        it 'returns Responses' do
-          stub_http_request(method, address).
-            to_return(code: '200', body: 'Hej!')
-          response = subject.process(create_request(action, address))
-          expect([ response.code, response.body ]).to eq([ 200, 'Hej!' ])
+            it 'sets proper headers' do
+              stub = stub_http_request(method, address).to_return(body: sample).
+                with(headers: { 'Accept' => mime_type_dictionary[format] })
+              response = subject.process(create_request(method))
+              expect(stub).to have_been_requested
+            end
+          end
         end
       end
     end

data/spec/apitizer/connection/format_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe Apitizer::Connection::Format do
+  let(:subject_class) { Apitizer::Connection::Format }
+
+  { :json => '{ "articles": [] }',
+    :yaml => "---\narticles: []" }.each do |format, sample|
+
+    it "supports #{ format }" do
+      subject = subject_class.build(format)
+      result = subject.process(sample)
+      expect(result).to eq('articles' => [])
+    end
+  end
+end

data/spec/apitizer/helper_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Apitizer::Helper do
+RSpec.describe Apitizer::Helper do
   extend ResourceHelper
 
   let(:subject_module) { Apitizer::Helper }
@@ -8,13 +8,13 @@ describe Apitizer::Helper do
   describe '.member_action?' do
     restful_member_actions.each do |action|
       it "returns true for the #{ action } member action" do
-        expect(subject_module.member_action?(action)).to be_true
+        expect(subject_module.member_action?(action)).to be true
       end
     end
 
     restful_collection_actions.each do |action|
       it "returns false for the #{ action } collection action" do
-        expect(subject_module.member_action?(action)).to be_false
+        expect(subject_module.member_action?(action)).to be false
       end
     end
 
@@ -34,29 +34,39 @@ describe Apitizer::Helper do
   end
 
   describe '.build_query' do
-    it 'handels ordinary parameters' do
-      queries = [
-        'title=Meaning+of+Life&author=Random+Number+Generator',
-        'author=Random+Number+Generator&title=Meaning+of+Life'
-      ]
+    it 'handles ordinary parameters' do
       query = subject_module.build_query(
         title: 'Meaning of Life', author: 'Random Number Generator')
-      expect(queries).to include(query)
+      expect(query).to \
+        eq('title=Meaning+of+Life&author=Random+Number+Generator')
     end
 
-    it 'handles parameters whose values are ordinary lists' do
+    it 'handles parameters whose values are ordinary arrays' do
       query = subject_module.build_query(keywords: [ 'hitchhiker', 'galaxy' ])
       expect(query).to eq('keywords[]=hitchhiker&keywords[]=galaxy')
     end
 
-    it 'handles parameters whose values are object lists' do
-      queries = [
-        'genres[0][name]=Comedy&genres[1][name]=Fiction',
-        'genres[1][name]=Fiction&genres[0][name]=Comedy'
-      ]
+    it 'handles parameters whose values are object arrays' do
       query = subject_module.build_query(
-        genres: { 0 => { name: 'Comedy' }, 1 => { name: 'Fiction' } })
-      expect(queries).to include(query)
+        genres: [ { name: 'Comedy' }, { name: 'Fiction' } ])
+      expect(query).to \
+        eq('genres[0][name]=Comedy&genres[1][name]=Fiction')
+    end
+
+    it 'ignores parameters whose values are empty ordinary arrays' do
+      query = subject_module.build_query(title: 'Pulp Fiction', keywords: [])
+      expect(query).to eq('title=Pulp+Fiction')
+    end
+
+    it 'ignores parameters whose values are empty object arrays' do
+      query = subject_module.build_query(title: 'Pulp Fiction', genres: {})
+      expect(query).to eq('title=Pulp+Fiction')
+    end
+
+    it 'ignores deeply nested empty structures' do
+      query = subject_module.build_query(title: 'Pulp Fiction',
+        genres: [ { :name => { :language => [ nil, nil, [], {} ] } } ])
+      expect(query).to eq('title=Pulp+Fiction')
     end
 
     it 'converts integers to decimal strings' do
@@ -64,14 +74,11 @@ describe Apitizer::Helper do
       expect(query).to eq('page=42')
     end
 
-    it 'converts integers in object lists to decimal strings' do
-      queries = [
-        'primes[0][value]=2&primes[1][value]=3',
-        'primes[1][value]=3&primes[0][value]=2'
-      ]
+    it 'converts integers in object arrays to decimal strings' do
       query = subject_module.build_query(
-        primes: { 0 => { value: 2 }, 1 => { value: 3 } })
-      expect(queries).to include(query)
+        primes: [ { value: 2 }, { value: 3 } ])
+      expect(query).to \
+        eq('primes[0][value]=2&primes[1][value]=3')
     end
 
     it 'converts the logical true to the string true' do
@@ -83,5 +90,27 @@ describe Apitizer::Helper do
       query = subject_module.build_query(published: false)
       expect(query).to eq('published=false')
     end
+
+    it 'handles an arbitrary object that responds to #to_a' do
+      object = double(to_a: [ 'one', 'two' ])
+      query = subject_module.build_query(digits: object)
+      expect(query).to eq('digits[]=one&digits[]=two')
+    end
+
+    it 'handles an arbitrary object that responds to #to_h' do
+      object = double(to_h: { one: 1, two: 2 })
+      query = subject_module.build_query(digits: object)
+      expect(query).to eq('digits[one]=1&digits[two]=2')
+    end
+
+    it 'raises an exception for an unknown objects without #to_a and #to_h' do
+      expect { subject_module.build_query(a: { b: Class.new.new }) }.to \
+        raise_error(ArgumentError)
+    end
+
+    it 'returns a string encoded in UTF-8' do
+      query = subject_module.build_query(alpha: 'omega')
+      expect(query.encoding.to_s).to match(/^UTF-8$/i)
+    end
   end
 end

data/spec/apitizer/result_spec.rb

@@ -1,19 +1,17 @@
 require 'spec_helper'
 
-describe Apitizer::Result do
+RSpec.describe Apitizer::Result do
   let(:path) { double('Path') }
   let(:request) { double('Request', path: path) }
-  let(:response) { double('Response', code: 200) }
   let(:content) { double('Content') }
+  let(:response) { double('Response', code: 200, content: content) }
 
-  subject do
-    Apitizer::Result.new(request: request, response: response, content: content)
-  end
+  subject { Apitizer::Result.new(request: request, response: response) }
 
   it { should == content }
   it { should be_a(content.class) }
   it { should be_kind_of(content.class) }
   it { should be_instance_of(content.class) }
-  its(:path) { should == path }
-  its(:code) { should == 200 }
+  it { expect(subject.path).to eq(path) }
+  it { expect(subject.code).to eq(200) }
 end

data/spec/apitizer/routing/map_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+RSpec.describe Apitizer::Routing::Map do
+  extend ResourceHelper
+
+  describe '#define' do
+    it 'declares plain resources' do
+      subject.define { resources(:articles) }
+      path = subject.trace(:index, [ :articles ])
+      expect(path.address).to eq('articles')
+    end
+
+    it 'declares nested resources' do
+      subject.define { resources(:articles) { resources(:sections) } }
+      path = subject.trace(:show, [ :articles, 'xxx', :sections, 'yyy' ])
+      expect(path.address).to eq('articles/xxx/sections/yyy')
+    end
+
+    it 'declares the root address' do
+      subject.define do
+        address('https://service.com/api')
+        resources(:articles)
+      end
+      path = subject.trace(:show, [ :articles, 'xxx' ])
+      expect(path.address).to eq('https://service.com/api/articles/xxx')
+    end
+
+    restful_actions.each do |action|
+      it "declares #{ action } operations on members" do
+        subject.define do
+          resources(:articles) { send(action, :shred, on: :member) }
+        end
+        path = subject.trace(action, [ :articles, 'xxx', :shred ])
+        expect(path.address).to eq('articles/xxx/shred')
+      end
+
+      it "declares #{ action } operations on members with variable names" do
+        subject.define do
+          resources(:articles) { send(action, ':paragraph', on: :member) }
+        end
+        path = subject.trace(action, [ :articles, 'xxx', 'zzz' ])
+        expect(path.address).to eq('articles/xxx/zzz')
+      end
+
+      it "declares #{ action } operations on collections" do
+        subject.define do
+          resources(:articles) { send(action, :shred, on: :collection) }
+        end
+        path = subject.trace(action, [ :articles, :shred ])
+        expect(path.address).to eq('articles/shred')
+      end
+
+      it "declares #{ action } operations on collections with variable names" do
+        subject.define do
+          resources(:articles) { send(action, ':paragraph', on: :collection) }
+        end
+        path = subject.trace(action, [ :articles, 'zzz' ])
+        expect(path.address).to eq('articles/zzz')
+      end
+    end
+
+    it 'supports reopening of resource declarations' do
+      subject.define do
+        resources(:articles)
+        resources(:articles) { resources(:sections) }
+      end
+      path = subject.trace(:show, [ :articles, 'xxx', :sections, 'yyy' ])
+      expect(path.address).to eq('articles/xxx/sections/yyy')
+    end
+  end
+end

data/spec/apitizer/routing/node_spec.rb

@@ -1,63 +1,135 @@
 require 'spec_helper'
 
-describe Apitizer::Routing::Node do
+RSpec.describe Apitizer::Routing::Node do
   extend ResourceHelper
   include FactoryHelper
 
   shared_examples 'an adequate pathfinder' do
-    let(:path) { double(:<< => nil, :advance => nil) }
+    it 'finds final destinations' do
+      expect(root.trace(steps)).to be_kind_of(Apitizer::Routing::Path)
+    end
+  end
+
+  shared_examples 'an adequate collection guard' do |only: restful_actions|
+    (restful_collection_actions & only).each do |action|
+      it "permits #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_truthy
+      end
+    end
 
-    it 'gradually builds up Paths' do
-      steps.each do |step|
-        expect(path).to receive(:<<).once.ordered.with(step)
+    (restful_collection_actions - only).each do |action|
+      it "does not permit #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_falsy
       end
-      root.trace(steps, path)
     end
 
-    it 'gradually advances Paths' do
-      steps.select { |step| step.is_a?(Symbol) }.each do |name|
-        expect(path).to receive(:advance).once.ordered.
-          with { |n| n.match(name) }
+    restful_member_actions.each do |action|
+      it "does not permit #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_falsy
       end
-      root.trace(steps, path)
     end
   end
 
-  describe '::Base#trace' do
-    context 'when working with plain collections' do
-      let(:root) { create_tree(:articles) }
+  shared_examples 'an adequate member guard' do |only: restful_actions|
+    (restful_member_actions & only).each do |action|
+      it "permites #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_truthy
+      end
+    end
 
-      context 'when looking for collections' do
-        let(:steps) { [ :articles ] }
-        it_behaves_like 'an adequate pathfinder'
+    (restful_member_actions - only).each do |action|
+      it "does not permit #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_falsy
       end
+    end
 
-      context 'when looking for members' do
-        let(:steps) { [ :articles, 'xxx' ] }
-        it_behaves_like 'an adequate pathfinder'
+    restful_collection_actions.each do |action|
+      it "does not permit #{ action } actions" do
+        path = root.trace(steps)
+        expect(path.permit?(action)).to be_falsy
       end
     end
+  end
+
+  context 'when defining plain collections' do
+    let(:root) { create_tree(:articles) }
+
+    context 'when looking for collections' do
+      let(:steps) { [ :articles ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate collection guard'
+    end
 
-    context 'when working with nested collections' do
-      let(:root) { create_tree(:articles, :sections) }
+    context 'when looking for members' do
+      let(:steps) { [ :articles, 'xxx' ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate member guard'
+    end
+  end
 
-      context 'when looking for collections' do
-        let(:steps) { [ :articles, 'xxx', :sections ] }
-        it_behaves_like 'an adequate pathfinder'
-      end
+  context 'when defining nested collections' do
+    let(:root) { create_tree(:articles, :sections) }
+    let(:steps) { [ :articles, 'yyy', :sections ] }
 
-      context 'when looking for members' do
-        let(:steps) { [ :articles, 'xxx', :sections, 'yyy' ] }
-        it_behaves_like 'an adequate pathfinder'
-      end
+    context 'when looking for collections' do
+      let(:steps) { [ :articles, 'xxx', :sections ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate collection guard'
     end
 
-    restful_actions.each do |action|
-      context "when working with custom #{ action } actions" do
-        let(:root) { create_tree(:articles, shred: action) }
-        let(:steps) { [ :articles, 'xxx', :shred ] }
-        it_behaves_like 'an adequate pathfinder'
-      end
+    context 'when looking for members' do
+      let(:steps) { [ :articles, 'xxx', :sections, 'yyy' ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate member guard'
+    end
+  end
+
+  only = [ :index, :show ]
+  context "when defining collections restricted to #{ only.join(', ') }" do
+    let(:root) { create_tree([ :articles, only ]) }
+
+    context 'when looking for collections' do
+      let(:steps) { [ :articles ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate collection guard', only: only
+    end
+
+    context 'when looking for members' do
+      let(:steps) { [ :articles, 'xxx' ] }
+      it_behaves_like 'an adequate pathfinder'
+      it_behaves_like 'an adequate member guard', only: only
+    end
+  end
+
+  restful_actions.each do |action|
+    context "when defining #{ action } operations" do
+      let(:root) { create_tree(:articles, shred: action) }
+      let(:steps) { [ :articles, 'xxx', :shred ] }
+
+      it_behaves_like 'an adequate pathfinder'
+    end
+  end
+
+  restful_collection_actions.each do |action|
+    context "when defining #{ action } operations with varible names" do
+      let(:root) { create_tree(:articles, ':paragraph' => action) }
+      let(:steps) { [ :articles, 'zzz' ] }
+
+      it_behaves_like 'an adequate pathfinder'
+    end
+  end
+
+  restful_member_actions.each do |action|
+    context "when defining #{ action } operations with varible names" do
+      let(:root) { create_tree(:articles, ':paragraph' => action) }
+      let(:steps) { [ :articles, 'xxx', 'zzz' ] }
+
+      it_behaves_like 'an adequate pathfinder'
     end
   end
 end