apitizer 0.0.1

data/spec/apitizer/connection/dispatcher_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+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
+
+  def create_request(action, address)
+    double(action: action, address: address, parameters: {})
+  end
+
+  describe '#process' do
+    restful_actions.each do |action|
+      method = rest_http_dictionary[action]
+
+      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
+
+        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!' ])
+        end
+      end
+    end
+  end
+end

data/spec/apitizer/helper_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Apitizer::Helper do
+  extend ResourceHelper
+
+  let(:subject_module) { Apitizer::Helper }
+
+  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
+      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
+      end
+    end
+
+    it 'raises exceptions when encounters unknown actions' do
+      expect { subject_module.member_action?(:rock) }.to \
+        raise_error(subject_module::Error, /Unknown action/i)
+    end
+  end
+
+  describe '.deep_merge' do
+    it 'merges two hashes taking into account nested hashes' do
+      one = { a: 1, b: { c: 2, d: 3 } }
+      two = { a: 4, b: { c: 5, e: 6 } }
+      expect(subject_module.deep_merge(one, two)).to \
+        eq(a: 4, b: { c: 5, d: 3, e: 6 })
+    end
+  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'
+      ]
+      query = subject_module.build_query(
+        title: 'Meaning of Life', author: 'Random Number Generator')
+      expect(queries).to include(query)
+    end
+
+    it 'handles parameters whose values are ordinary lists' 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'
+      ]
+      query = subject_module.build_query(
+        genres: { 0 => { name: 'Comedy' }, 1 => { name: 'Fiction' } })
+      expect(queries).to include(query)
+    end
+
+    it 'converts integers to decimal strings' do
+      query = subject_module.build_query(page: 42)
+      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'
+      ]
+      query = subject_module.build_query(
+        primes: { 0 => { value: 2 }, 1 => { value: 3 } })
+      expect(queries).to include(query)
+    end
+
+    it 'converts the logical true to the string true' do
+      query = subject_module.build_query(published: true)
+      expect(query).to eq('published=true')
+    end
+
+    it 'converts the logical false to the string false' do
+      query = subject_module.build_query(published: false)
+      expect(query).to eq('published=false')
+    end
+  end
+end

data/spec/apitizer/processing/parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Apitizer::Processing::Parser do
+  let(:parent_module) { Apitizer::Processing }
+  let(:subject_class) { parent_module::Parser }
+
+  it 'supports JSON' do
+    subject = subject_class.build(:json)
+    result = subject.process('{ "articles": [] }')
+    expect(result).to eq("articles" => [])
+  end
+
+  it 'supports YAML' do
+    subject = subject_class.build(:yaml)
+    result = subject.process("---\narticles: []")
+    expect(result).to eq("articles" => [])
+  end
+
+  it 'does not support XML' do
+    expect { subject_class.build(:xml) }.to \
+      raise_error(parent_module::Error, /Unknown format/i)
+  end
+end

data/spec/apitizer/result_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Apitizer::Result do
+  let(:path) { double('Path') }
+  let(:request) { double('Request', path: path) }
+  let(:response) { double('Response', code: 200) }
+  let(:content) { double('Content') }
+
+  subject do
+    Apitizer::Result.new(request: request, response: response, content: content)
+  end
+
+  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 }
+end

data/spec/apitizer/routing/mapper_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Apitizer::Routing::Mapper do
+  extend ResourceHelper
+
+  let(:subject_class) { Apitizer::Routing::Mapper }
+
+  def create_path
+    double(:<< => nil, :advance => nil, :permitted? => true)
+  end
+
+  def expect_steps(steps, path = create_path)
+    Array(steps).each do |step|
+      expect(path).to receive(:<<).once.ordered.with(step)
+    end
+    path
+  end
+
+  def expect_trace(mapper, steps, scope = [])
+    mapper.trace(:arbitrary, steps, expect_steps(scope + steps))
+  end
+
+  describe '#define' do
+    it 'declares the root address' do
+      subject.define do
+        address('https://service.com/api')
+        resources(:articles)
+      end
+      expect_trace(subject, [ :articles, 'xxx' ], [ 'https://service.com/api' ])
+    end
+
+    it 'declares plain resources' do
+      subject.define { resources(:articles) }
+      expect_trace(subject, [ :articles ])
+    end
+
+    it 'declares nested resources' do
+      subject.define { resources(:articles) { resources(:sections) } }
+      expect_trace(subject, [ :articles, 'xxx', :sections, 'yyy' ])
+    end
+
+    it 'declares scoped resources' do
+      subject.define do
+        scope 'https://service.com/api' do
+          scope [ 'v1', :json ] do
+            resources(:articles) { resources(:sections) }
+          end
+        end
+      end
+      expect_trace(subject, [ :articles, 'xxx', :sections, 'yyy' ],
+       [ 'https://service.com/api', 'v1', :json ])
+    end
+
+    restful_member_actions.each do |action|
+      it "declares custom #{ action } operations on members" do
+        subject.define do
+          resources(:articles) { send(action, :shred, on: :member) }
+        end
+        expect_trace(subject, [ :articles, 'xxx', :shred ])
+      end
+
+      it 'declares custom operations with variable names' do
+        subject.define do
+          resources(:articles) { send(action, ':paragraph', on: :member) }
+        end
+        expect_trace(subject, [ :articles, 'xxx', 'zzz' ])
+      end
+    end
+
+    it 'does not support reopening of resource declarations' do
+      subject.define do
+        resources(:articles)
+        resources(:articles) { resources(:sections) }
+      end
+      expect do
+        subject.trace(:arbitrary, [ :articles, 'xxx', :sections, 'yyy' ])
+      end.to raise_error(Apitizer::Routing::Error, /Not found/i)
+    end
+  end
+end

data/spec/apitizer/routing/node_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Apitizer::Routing::Node do
+  extend ResourceHelper
+  include FactoryHelper
+
+  shared_examples 'an adequate pathfinder' do
+    let(:path) { double(:<< => nil, :advance => nil) }
+
+    it 'gradually builds up Paths' do
+      steps.each do |step|
+        expect(path).to receive(:<<).once.ordered.with(step)
+      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) }
+      end
+      root.trace(steps, path)
+    end
+  end
+
+  describe '::Base#trace' do
+    context 'when working with plain collections' do
+      let(:root) { create_tree(:articles) }
+
+      context 'when looking for collections' do
+        let(:steps) { [ :articles ] }
+        it_behaves_like 'an adequate pathfinder'
+      end
+
+      context 'when looking for members' do
+        let(:steps) { [ :articles, 'xxx' ] }
+        it_behaves_like 'an adequate pathfinder'
+      end
+    end
+
+    context 'when working with nested collections' do
+      let(:root) { create_tree(:articles, :sections) }
+
+      context 'when looking for collections' do
+        let(:steps) { [ :articles, 'xxx', :sections ] }
+        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'
+      end
+    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
+    end
+  end
+end

data/spec/apitizer/routing/path_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Apitizer::Routing::Path do
+  extend ResourceHelper
+  include FactoryHelper
+
+  describe '#<<' do
+    it 'builds up addresses' do
+      [ :articles, 'xxx', :sections, 'yyy' ].each { |step| subject << step }
+      expect(subject.address).to eq('articles/xxx/sections/yyy')
+    end
+  end
+
+  describe '#advance' do
+    it 'keeps track of destinations' do
+      nodes = [ double('articles'), double('sections') ]
+      nodes.each { |node| subject.advance(node) }
+      expect(subject.node).to be(nodes.last)
+    end
+  end
+
+  an_adequate_guard = Proc.new do |only_actions = restful_actions|
+    (restful_collection_actions & only_actions).each do |action|
+      it "is true for #{ action } collection action" do
+        path = root.trace(steps)
+        expect(path.permitted?(action)).to be_true
+      end
+    end
+
+    (restful_member_actions & only_actions).each do |action|
+      it "is true for #{ action } member actions" do
+        path = root.trace([ *steps, 'xxx' ])
+        expect(path.permitted?(action)).to be_true
+      end
+    end
+
+    (restful_collection_actions - only_actions).each do |action|
+      it "is false for #{ action } collection action" do
+        path = root.trace(steps)
+        expect(path.permitted?(action)).to be_false
+      end
+    end
+
+    (restful_member_actions - only_actions).each do |action|
+      it "is false for #{ action } member actions" do
+        path = root.trace([ *steps, 'xxx' ])
+        expect(path.permitted?(action)).to be_false
+      end
+    end
+
+    restful_member_actions.each do |action|
+      it "is false for #{ action } actions to collections" do
+        path = root.trace(steps)
+        expect(path.permitted?(action)).to be_false
+      end
+    end
+
+    restful_collection_actions.each do |action|
+      it "is false for #{ action } actions to members" do
+        path = root.trace([ *steps, 'xxx' ])
+        expect(path.permitted?(action)).to be_false
+      end
+    end
+  end
+
+  describe '#permitted?' do
+    context 'when working with plain collections' do
+      let(:root) { create_tree(:articles) }
+      let(:steps) { [ :articles ] }
+
+      instance_exec(&an_adequate_guard)
+    end
+
+    context 'when working with nested collections' do
+      let(:root) { create_tree(:articles, :sections) }
+      let(:steps) { [ :articles, 'yyy', :sections ] }
+
+      instance_exec(&an_adequate_guard)
+    end
+
+    context 'when working with collections restricted to index and show' do
+      let(:root) { create_tree([ :articles, [ :index, :show ] ]) }
+      let(:steps) { [ :articles ] }
+
+      instance_exec([ :index, :show ], &an_adequate_guard)
+    end
+
+    restful_member_actions.each do |action|
+      it "is true for custom #{ action } operations on members" do
+        root = create_tree(:articles, shred: action)
+        path = root.trace([ :articles, 'xxx', :shred ])
+        expect(path.permitted?(action)).to be_true
+      end
+
+      it "is true for custom #{ action } operations with variable names" do
+        root = create_tree(:articles, ':paragraph' => action)
+        path = root.trace([ :articles, 'xxx', 'zzz' ])
+        expect(path.permitted?(action)).to be_true
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'support/resource_helper'
+require 'support/factory_helper'
+require 'webmock/rspec'
+require 'apitizer'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/factory_helper.rb

@@ -0,0 +1,23 @@
+module FactoryHelper
+  def create_tree(*names)
+    operations = names.last.is_a?(Hash) ? names.pop : {}
+    root = Apitizer::Routing::Node::Root.new
+    leaf = names.inject(root) do |parent, object|
+      if object.is_a?(Array)
+        name, only = *object
+        node = Apitizer::Routing::Node::Collection.new(name, only: only)
+      else
+        name = object
+        node = Apitizer::Routing::Node::Collection.new(name)
+      end
+      parent.append(node)
+      node
+    end
+    operations.each do |name, action|
+      operation = Apitizer::Routing::Node::Operation.new(
+        name, action: action, on: :member)
+      leaf.append(operation)
+    end
+    root
+  end
+end