party_resource 0.0.3 → 0.0.4

data/spec/unit/exceptions_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe 'Exceptions' do
-
-  describe PartyResource::Exceptions::ConnectionError do
-    subject { PartyResource::Exceptions::ConnectionError }
-
-    describe 'build' do
-      let(:built) { subject.build(data) }
-      let_mock(:data)
-
-      it 'builds ResourceNotFound' do
-        data.stub(:code => 404)
-        built.should be_a(PartyResource::Exceptions::ResourceNotFound)
-      end
-
-      it 'builds ResourceInvalid' do
-        data.stub(:code => 422)
-        built.should be_a(PartyResource::Exceptions::ResourceInvalid)
-      end
-
-      it 'builds ClientError' do
-        data.stub(:code => 400)
-        built.should be_a(PartyResource::Exceptions::ClientError)
-      end
-
-      it 'builds ServerError' do
-        data.stub(:code => 500)
-        built.should be_a(PartyResource::Exceptions::ServerError)
-      end
-    end
-  end
-
-end

data/spec/unit/party_resource_spec.rb

@@ -1,208 +0,0 @@
-require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
-
-describe "PartyResource" do
-
-  subject do
-    Class.new().send(:include, PartyResource)
-  end
-  let(:object) { subject.new }
-
-  describe '.connect' do
-
-    let(:route) { mock(:route) }
-    let_mock(:other_options)
-
-    before do
-      PartyResource::Route.stub(:new => route)
-    end
-
-    context 'for a class level route' do
-      let_mock(:klass)
-
-      it "creates a class method matching the name" do
-        subject.connect :new_resource_method
-        should respond_to(:new_resource_method)
-      end
-
-      it "creates a new route" do
-        options = {:values => other_options, :as => klass}
-        PartyResource::Route.should_receive(:new).with({:values => other_options, :connector => nil, :as => klass})
-        subject.connect :new_resource_method, options
-      end
-
-      context 'the created method' do
-
-        before { subject.connect :new_resource_method }
-
-        it 'calls the route with the class and the arguments' do
-          args = [mock(:arg), mock(:arg)]
-          route.should_receive(:call).with(subject, *args)
-
-          subject.new_resource_method args[0], args[1]
-        end
-
-      end
-
-      context 'with a connector set' do
-        before do
-          subject.party_connector :foo
-        end
-
-        it 'passes the connector name to the route' do
-          PartyResource::Route.should_receive(:new).with(hash_including(:connector => :foo))
-          subject.connect :new_resource_method, {}
-        end
-      end
-    end
-
-    context 'for an instance level route' do
-
-      it "creates an instance method matching the name" do
-        subject.connect :new_resource_method, :on => :instance
-        subject.new.should respond_to(:new_resource_method)
-      end
-
-      it "creates a new route" do
-        options = {:on => :instance, :others => other_options}
-        PartyResource::Route.should_receive(:new).with({:others => other_options, :connector => nil, :as => :self})
-        subject.connect :new_resource_method, options
-      end
-
-      context 'the created method' do
-
-        before { subject.connect :new_resource_method, :on => :instance }
-
-        it 'calls the route with the class and the arguments' do
-          args = [mock(:arg), mock(:arg)]
-          object = subject.new
-          route.should_receive(:call).with(object, *args)
-
-          object.new_resource_method args[0], args[1]
-        end
-
-      end
-    end
-  end
-
-  describe '.parameter_values' do
-    let_mock(:v1)
-    let_mock(:v2)
-    let_mock(:v3)
-    it 'returns internal values for requested variables' do
-      subject.stub(:v1 => v1, :v2 => v2, :v3 => v3)
-      subject.parameter_values([:v1, :v3]).should == {:v1 => v1, :v3 => v3}
-    end
-
-    it 'raises a MissingParameter error' do
-      subject.stub(:v1 => v1)
-      lambda { subject.parameter_values([:v1, :vx]) }.should raise_error(PartyResource::Exceptions::MissingParameter)
-    end
-  end
-
-  describe 'properties' do
-    let_mock(:v1)
-    let_mock(:v2)
-    it 'populates property values from hash' do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1, :name2 => v2)
-      object.name.should == v1
-      object.name2.should == v2
-    end
-
-    it 'renames properties from passed data' do
-      subject.property :name, :from => :input_name
-      object.send(:populate_properties, :input_name => v1, :name => v2)
-      object.name.should == v1
-    end
-
-    it 'reaches inside nested values' do
-      subject.property :name, :from => [:parent, :input_name]
-      object.send(:populate_properties, :parent => { :input_name => v1 }, :input_name => v2)
-      object.name.should == v1
-    end
-
-    it 'falls back to populating based on the property name if from is not found' do
-      subject.property :name, :from => :input_name
-      object.send(:populate_properties, :name => v2)
-      object.name.should == v2
-    end
-
-    it 'does not try to build nil values' do
-      klass = Class.new
-      subject.property :name, :as => klass
-      klass.should_not_receive(:new)
-      object.send(:populate_properties, :name => nil)
-      object.name.should == nil
-    end
-
-    it "doesn't set properties to nil if they aren't in the data hash" do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1)
-      object.name.should == v1
-      object.name2.should == nil
-      object.send(:populate_properties,:name2 => v2)
-      object.name.should == v1
-      object.name2.should == v2
-    end
-
-    it 'returns a hash representation of properties' do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1, :name2 => v2)
-      object.to_properties_hash.should == {:name => v1, :name2 => v2}
-    end
-
-    it 'does not include nil values in the properties hash' do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1)
-      object.to_properties_hash.should == {:name => v1}
-    end
-
-    it 'translates propery names to input names' do
-      subject.property :name, :from => :input_name
-      object.send(:populate_properties, :name => v1)
-      object.to_properties_hash.should == {:input_name => v1}
-    end
-
-    it 'translates propery names to nested input names' do
-      subject.property :name, :from => [:block, :input_name]
-      object.send(:populate_properties, :name => v1)
-      object.to_properties_hash.should == {:block => {:input_name => v1}}
-    end
-
-    it 'translates property names to their required output names' do
-      subject.property :name, :to => :output_name
-      subject.property :name2, :to => [:block, :output_name]
-      object.send(:populate_properties, :name => v1, :name2 => v2)
-      object.to_properties_hash.should == {:output_name => v1, :block => {:output_name => v2}}
-    end
-  end
-
-  describe '#properties_equal?' do
-    let_mock(:v1)
-    let(:object2) { subject.new }
-
-    before do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1, :name2 => nil)
-    end
-
-    it 'returns true if all properties are equal' do
-      subject.property :name, :name2
-      object.send(:populate_properties, :name => v1, :name2 => nil)
-      object2.send(:populate_properties, :name => v1)
-      object.should be_properties_equal(object2)
-    end
-
-    it 'returns false if all properties are not equal' do
-      object2.send(:populate_properties, :name => v1, :name2 => v1)
-      object.should_not be_properties_equal(object2)
-    end
-
-    it 'returns false if the other object does not respond to all required properties' do
-      object.should_not be_properties_equal(Object.new)
-    end
-  end
-
-
-end
-

data/spec/unit/request_spec.rb

@@ -1,103 +0,0 @@
-require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
-
-describe PartyResource::Request do
-
-  subject { PartyResource::Request.new(verb, path, context, args, params) }
-  let_mock(:context, :parameter_values => {})
-  let_mock(:verb)
-  let_mock(:value)
-  let(:params) { {} }
-  let(:path) { '/path' }
-
-  context 'with static path' do
-    let(:path) { 'mypath/file.json' }
-    let(:args) { {} }
-
-    its(:verb) { should == verb }
-    its(:path) { should == path }
-    its(:data) { should == {} }
-
-    it "should merge http_data with passed options" do
-      subject.http_data(:foo => :bar).should == { :foo => :bar }
-    end
-  end
-
-  context 'with a parameter' do
-    let(:path) { 'mypath/file.json' }
-    let(:args) { {:param => value} }
-
-    its(:verb) { should == verb }
-    its(:path) { should == path }
-    its(:data) { should == args }
-  end
-
-  context 'with a parameter referenced in the path' do
-    let(:path) { 'mypath/:param.json' }
-    let(:args) { {:param => 'THE_VALUE', :second => value} }
-
-    its(:verb) { should == verb }
-    its(:path) { should == 'mypath/THE_VALUE.json' }
-    its(:data) { should == {:second => value } }
-  end
-
-  context 'with an object variable referenced in the path' do
-    let_mock(:context, :parameter_values => {:var => 'THE_VALUE'})
-    let(:path) { 'mypath/:param/:var.json' }
-    let(:args) { {:param => 'PARAM_VALUE', :second => value} }
-
-    its(:verb) { should == verb }
-    its(:path) { should == 'mypath/PARAM_VALUE/THE_VALUE.json' }
-    its(:data) { should == { :second => value } }
-    it 'asks the context object for required data values' do
-      context.should_receive(:parameter_values).with([:var])
-      subject.path
-    end
-  end
-
-  context 'with extra parameters' do
-    let(:path) { '/path/:id' }
-    let_mock(:p1)
-    let_mock(:p2)
-    let_mock(:a1)
-    let_mock(:a2)
-    let(:params) { {:id => mock(:id2), :param => p1, :param2 => p2} }
-    let(:args) { {:id => 'THE_ID', :param => a1, :arg2 => a2} }
-    it 'merges them into the request data' do
-      subject.path.should == '/path/THE_ID'
-      subject.data.should == {:param => a1, :param2 => p2, :arg2 => a2}
-    end
-  end
-
-  context 'for a GET request' do
-    let(:verb) { :get }
-    let_mock(:args)
-    its(:http_data) { { :query => args } }
-
-    context 'with no data' do
-      let(:args) { {} }
-      its(:http_data) { should == {} }
-    end
-  end
-
-  [:post, :put, :delete].each do |http_verb|
-    context "for a #{http_verb} request" do
-      let(:verb) { http_verb }
-      let(:args) { {:param => value} }
-      its(:http_data) { should == { :body => args } }
-    end
-
-    context 'with no data' do
-      let(:args) { {} }
-      its(:http_data) { should == {} }
-    end
-  end
-
-  context 'encoding the path' do
-    let(:args) { {} }
-    let(:path) { '/path needing encoding' }
-    it 'encodes the path' do
-      subject.path.should == '/path%20needing%20encoding'
-    end
-  end
-
-end

data/spec/unit/route_spec.rb

@@ -1,118 +0,0 @@
-require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
-
-describe PartyResource::Route do
-
-  subject { PartyResource::Route.new options }
-
-  let_mock(:path)
-  let_mock(:object)
-  let_mock(:raw_result)
-  let(:connector) { mock(:connector, :fetch => raw_result) }
-  let(:klass) { Class.new {def initialize(data); end} }
-  let(:options) { { :get => path, :as => klass } }
-
-  before do
-    PartyResource::Connector.stub(:lookup => connector)
-  end
-
-  describe ".call" do
-
-    [:get, :put, :post, :delete].each do |verb|
-
-      context "for a #{verb} request" do
-        let(:options) { { verb => path, :as => klass } }
-
-        it "performs a #{verb} request to the path with the connector" do
-          request = mock(:request)
-          PartyResource::Request.should_receive(:new).with(verb, path, object, anything, anything).and_return(request)
-          connector.should_receive(:fetch).with(request)
-          subject.call(object)
-        end
-      end
-    end
-
-    context 'with more than one verb passed' do
-      let(:options) { { :post => path, :get => path } }
-
-      it "raises an argument error" do
-        lambda{ subject.call(object) }.should raise_error(ArgumentError)
-      end
-    end
-
-    context "with no variables" do
-      let(:options) { { :get => path, :as => klass } }
-
-      it "builds the request path" do
-        PartyResource::Request.should_receive(:new).with(:get, path, object, {}, anything)
-        subject.call(object)
-      end
-
-    end
-
-    context "with some variables" do
-      let(:options) { { :get => path, :with => [:a, :b, :c], :as => klass } }
-
-      it "builds the request path" do
-        PartyResource::Request.should_receive(:new).with(:get, path, object, {:a => 1, :b => 2, :c => 3}, anything)
-        subject.call(object, 1, 2, 3)
-      end
-
-      it "raises an ArgumentError for the wrong number of arguments" do
-        lambda { subject.call(object, 1, 2, 3, 4) }.should raise_error(ArgumentError)
-        lambda { subject.call(object) }.should raise_error(ArgumentError)
-      end
-    end
-
-    context 'when returning as class' do
-      let_mock(:result_object)
-
-      it 'builds an object from the data returned' do
-        klass.should_receive(:new).with(raw_result).and_return(result_object)
-        subject.call(object).should == result_object
-      end
-    end
-
-    context 'when returning as :raw' do
-      let(:options) { { :get => path, :as => :raw } }
-      it 'builds an object from the data returned' do
-        klass.should_not_receive(:new)
-        subject.call(object).should == raw_result
-      end
-    end
-
-    context 'when returning as class with builder method' do
-      let_mock(:result_object)
-      let(:options) { { :get => path, :as => [klass, :builder] } }
-
-      it 'builds an object from the data returned' do
-        klass.should_receive(:builder).with(raw_result).and_return(result_object)
-        subject.call(object).should == result_object
-      end
-    end
-
-    context 'when returning as proc' do
-      let_mock(:result_object)
-      let(:options) { { :get => path, :as => lambda {|data| data.morph } } }
-
-      it 'builds an object from the data returned' do
-        raw_result.should_receive(:morph).and_return(result_object)
-        subject.call(object).should == result_object
-      end
-    end
-
-    context 'when returning an array' do
-      let(:raw_result) { [1, 2] }
-      let(:options) { { :get => path, :as => lambda {|data| "X#{data}" } } }
-      it 'builds each value individually' do
-        subject.call(object).should == %w{ X1 X2 }
-      end
-    end
-
-    context 'with an extra params hash' do
-      it '' do
-        lambda { subject.call(object, {:params => :data}) }.should_not raise_error
-      end
-    end
-
-  end
-end