party_resource 0.0.1

data/spec/integration/integration_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
+require 'fixtures/test_base_class'
+require 'fixtures/other_class'
+require 'fixtures/test_class'
+
+describe TestClass do
+
+  let(:object) {TestClass.new(:foo)}
+
+  describe 'class level call' do
+    it 'raises an argument error when called with the wrong number of arguments' do
+      lambda { TestClass.find }.should raise_error(ArgumentError)
+    end
+
+    it 'finds an object' do
+      stub_request(:get, "http://fred:pass@myserver/path/find/99.ext").to_return(:body => 'some data')
+      TestClass.find(99).should == TestClass.new('some data')
+    end
+
+    it 'finds an object with extra options' do
+      stub_request(:get, "http://fred:pass@myserver/path/find/99.ext?extra=options").to_return(:body => 'some data')
+      TestClass.find(99, :extra => 'options').should == TestClass.new('some data')
+    end
+
+    it 'uses other connectors' do
+      stub_request(:get, 'http://otherserver/url').to_return(:body => 'from the otherserver')
+      OtherPartyClass.test.should == 'from the otherserver'
+    end
+  end
+
+  describe 'instance level call' do
+    it 'gets the result' do
+      stub_request(:put, "http://fred:pass@myserver/path/update/99.ext").to_return(:body => 'updated data')
+      TestClass.new(:var => 99).update
+    end
+  end
+
+  describe 'building connected objects' do
+    it 'build the requested response object' do
+        stub_request(:put, "http://fred:pass@myserver/path/update/99.ext").to_return(:body => 'updated data')
+        TestClass.new(:var => 99).update.should == OtherClass.new('updated data')
+    end
+
+    it 'passes the raw result back when requested' do
+      stub_request(:post, "http://fred:pass@myserver/path/save/file").with(:body => "data=somedata").to_return(:body => 'saved data')
+      TestClass.save('somedata').should == 'saved data'
+    end
+
+    it 'builds the result using the specified method' do
+      stub_request(:delete, "http://fred:pass@myserver/path/delete").to_return(:body => 'deleted OK')
+      TestClass.destroy.should be_true
+    end
+
+    it 'builds the result using the specified proc' do
+      stub_request(:get, "http://fred:pass@myserver/path/foo?value=908").to_return(:body => 'foo data')
+      TestClass.foo(908).should == 'New foo data Improved'
+    end
+
+    it 'builds each value in an array individually' do
+      stub_request(:get, "http://fred:pass@myserver/path/foo?value=908").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '[foo,data]')
+      TestClass.foo(908).should == ['New foo Improved', 'New data Improved']
+    end
+
+    it 'passes "included" variables to the new object' do
+      v2 = mock(:v2)
+      stub_request(:get, "http://fred:pass@myserver/path/include").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{}')
+      test = TestClass.from_json(:value2 => v2)
+      test.include.should == OtherClass.new(:thing => v2)
+    end
+
+    context 'error cases' do
+      it 'raises ResourceNotFound' do
+        stub_request(:delete, "http://fred:pass@myserver/path/delete").to_return(:status => 404)
+        lambda { TestClass.destroy }.should raise_error(PartyResource::ResourceNotFound)
+      end
+
+      it 'raises ResourceInvalid' do
+        stub_request(:delete, "http://fred:pass@myserver/path/delete").to_return(:status => 422)
+        lambda { TestClass.destroy }.should raise_error(PartyResource::ResourceInvalid)
+      end
+
+      it 'raises ClientError' do
+        stub_request(:delete, "http://fred:pass@myserver/path/delete").to_return(:status => 405)
+        lambda { TestClass.destroy }.should raise_error(PartyResource::ClientError)
+      end
+
+      it 'raises ServerError' do
+        stub_request(:delete, "http://fred:pass@myserver/path/delete").to_return(:status => 501)
+        lambda { TestClass.destroy }.should raise_error(PartyResource::ServerError)
+      end
+
+      it 'rescues exceptions' do
+        stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:status => 404)
+        TestClass.fetch_json.should be_nil
+      end
+
+    end
+  end
+
+  describe 'populating properties' do
+    it 'populates result values' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{value2:"value2", value4:"ignored"}')
+      result = TestClass.fetch_json
+      result.value2.should == 'value2'
+      result.value3.should == nil
+      result.should_not be_respond_to(:value4)
+    end
+
+    it 'populates renamed values' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{input_name:"value"}')
+      result = TestClass.fetch_json
+      result.value.should == 'value'
+    end
+
+    it 'populates nested values' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{block:{var:"value"}}')
+      result = TestClass.fetch_json
+      result.nested_value.should == 'value'
+    end
+
+    it 'falls back to populating based on the property name if from is not found' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{value:"value"}')
+      result = TestClass.fetch_json
+      result.value.should == 'value'
+    end
+
+    it 'populates a property as another class' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{other: "value"}')
+      result = TestClass.fetch_json
+      result.other.should == OtherClass.new('value')
+    end
+
+    it 'populates a property with a proc' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{processed: "value"}')
+      result = TestClass.fetch_json
+      result.processed.should == "Processed: value"
+    end
+
+    it 'does not build null data' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{processed: null}')
+      result = TestClass.fetch_json
+      result.processed.should == nil
+    end
+
+    it 'builds each value when populating an array' do
+      stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{processed: [1,2,3,4]}')
+      result = TestClass.fetch_json
+      result.processed.should == ['Processed: 1','Processed: 2','Processed: 3','Processed: 4']
+    end
+
+    context 'and inherited class' do
+      it 'self refers to the child class' do
+        stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{value2:"value2", child_property:"child"}')
+        result = InheritedTestClass.fetch_json
+        result.should be_a(InheritedTestClass)
+      end
+
+      it 'all local and inherited properties are available' do
+        stub_request(:get, "http://fred:pass@myserver/path/big_data").to_return(:headers => {'Content-Type' => 'text/json'}, :body => '{value2:"value2", child_property:"child"}')
+        result = InheritedTestClass.fetch_json
+        result.child_property.should == 'child'
+        result.value2.should == 'value2'
+      end
+    end
+  end
+
+  describe '#to_property_hash' do
+    it 'converts an object to external hash representation' do
+      obj = TestClass.from_json(:value => 'v1', :value2 => 'v2', :nested_value => 'nv', :processed => 'Milk', :child => {:thing => 'Happiness'})
+      obj.to_properties_hash.should == {:input_name => 'v1', :value2 => 'v2', :block => {:var => 'nv'}, :output_name => 'Processed: Milk', :child => {:thing => 'Happiness'}}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'party_resource'
+require 'spec'
+require 'spec/autorun'
+require 'webmock/rspec'
+
+include WebMock
+
+module LetMock
+  def let_mock(name, options = {})
+    let(name) { mock(name, options) }
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.extend(LetMock)
+end
+

data/spec/unit/connector/base_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(__FILE__, '..', '..', '..', 'spec_helper'))
+
+describe PartyResource::Connector::Base do
+  describe "creation" do
+    subject { PartyResource::Connector::Base.new(:test, options) }
+
+    let_mock(:username)
+    let_mock(:password)
+    let_mock(:normalized_uri)
+    let_mock(:original_uri)
+
+    before do
+      HTTParty.stub(:normalize_base_uri => normalized_uri)
+    end
+
+    context "with a base_uri" do
+      let(:options) { { :base_uri => original_uri } }
+
+      it 'normalizes the base_uri' do
+        HTTParty.should_receive(:normalize_base_uri).with(original_uri)
+        subject.options.should == {:base_uri => normalized_uri }
+      end
+    end
+
+    context 'with username' do
+      let(:options) { { :username => username } }
+
+      it 'stores the username' do
+        subject.options.should == {:basic_auth => {:username => username, :password => nil} }
+      end
+    end
+
+    context 'with password' do
+      let(:options) { { :password => password } }
+
+      it 'stores the password' do
+        subject.options.should == {:basic_auth => {:password => password, :username => nil} }
+      end
+    end
+
+    context 'with all options' do
+      let(:options) { { :base_uri => original_uri, :username => username, :password => password } }
+
+      it 'stores the options' do
+        subject.options.should == {:base_uri => normalized_uri, 
+                                   :basic_auth => {:password => password, :username => username } }
+      end
+    end
+  end
+
+  describe '#fetch' do
+    let(:options) { {:base_uri => 'http://myserver.test/path'} }
+    let_mock(:data, :empty? => false)
+    let_mock(:path)
+    let_mock(:return_data, :code => 200)
+    let(:request) { mock(:request, :path => path, :verb => verb, :http_data => data) }
+
+    subject { PartyResource::Connector::Base.new(:test, options) }
+
+    [:put, :post, :delete, :get].each do |http_verb|
+      context "for #{http_verb} requests" do
+        let(:verb) { http_verb }
+        it "fetches the request using HTTParty" do
+          HTTParty.should_receive(verb).with(path, data).and_return(return_data)
+          subject.fetch(request).should == return_data
+        end
+
+      end
+    end
+
+    context 'error cases' do
+      let(:request) { mock(:request, :path => mock(:path), :verb => :get, :http_data => mock(:data)) }
+
+      it 'raises an exception' do
+        return_data = mock(:data, :code => 404)
+        HTTParty.should_receive(:get).and_return(return_data)
+        lambda{ subject.fetch(request) }.should raise_error(PartyResource::ConnectionError)
+      end
+    end
+
+  end
+
+end

data/spec/unit/connector_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(__FILE__, '..', '..', 'spec_helper'))
+
+describe PartyResource::Connector do
+  describe '#lookup' do
+
+    let(:test_connector) { mock(:connector) }
+    let(:default_connector) { mock(:connector) }
+    let(:connectors) { { :test => test_connector, :other => default_connector } }
+
+    before do
+      PartyResource::Connector.repository.stub(:connectors => connectors)
+    end
+
+    it "returns the named connectors" do
+      PartyResource::Connector.lookup(:test).should == test_connector
+    end
+
+    it "returns the default connector for nil name" do
+      PartyResource::Connector.repository.stub(:default => :other)
+
+      PartyResource::Connector.lookup(nil).should == default_connector
+    end
+
+    it 'raises a NoConnector error it the connector could not be found' do
+      lambda { PartyResource::Connector.lookup(:missing_name) }.should raise_error(PartyResource::NoConnector)
+    end
+  end
+
+  describe '#default=' do
+    it 'sets the default connector name' do
+      name = mock(:name)
+      PartyResource::Connector.default = name
+      PartyResource::Connector.repository.default.should == name
+    end
+  end
+
+  describe '#new' do
+    let_mock(:name)
+    let_mock(:options)
+    let_mock(:connector)
+
+    before do
+      @repository = PartyResource::Connector::Repository.new
+      PartyResource::Connector.stub(:repository => @repository)
+      PartyResource::Connector::Base.stub(:new => connector)
+      options.stub(:[]).with(:default).and_return(false)
+    end
+
+    it 'creates a new connector' do
+      PartyResource::Connector::Base.should_receive(:new).with(name, options).and_return(connector)
+      PartyResource::Connector.add(name, options)
+      PartyResource::Connector(name).should == connector
+    end
+
+    it 'sets the default if it is currently unset' do
+      name2 = mock(:name2)
+      PartyResource::Connector.add(name, options)
+      PartyResource::Connector.repository.default.should == name
+
+      PartyResource::Connector.add(name2, options)
+      PartyResource::Connector.repository.default.should == name
+    end
+
+    it 'sets the default if the default option is set' do
+      name2 = mock(:name2)
+      PartyResource::Connector.add(name, options)
+      PartyResource::Connector.repository.default.should == name
+
+      options.stub(:[]).with(:default).and_return(true)
+      PartyResource::Connector.add(name2, options)
+      PartyResource::Connector.repository.default.should == name2
+    end
+  end
+end
+

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'Exceptions' do
+
+  describe PartyResource::ConnectionError do
+    subject { PartyResource::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::ResourceNotFound)
+      end
+
+      it 'builds ResourceInvalid' do
+        data.stub(:code => 422)
+        built.should be_a(PartyResource::ResourceInvalid)
+      end
+
+      it 'builds ClientError' do
+        data.stub(:code => 400)
+        built.should be_a(PartyResource::ClientError)
+      end
+
+      it 'builds ServerError' do
+        data.stub(:code => 500)
+        built.should be_a(PartyResource::ServerError)
+      end
+    end
+  end
+
+end

data/spec/unit/party_resource_spec.rb

@@ -0,0 +1,227 @@
+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 '.Connector' do
+    context 'with name == nil' do
+      it 'returns the default connector' do
+        connector = mock(:connector)
+        PartyResource::Connector.should_receive(:lookup).with(nil).and_return(connector)
+        PartyResource::Connector(nil).should == connector
+      end
+    end
+
+    context 'with a name given' do
+      it 'returns the requested connector' do
+        connector = mock(:connector)
+        name = mock(:name)
+        PartyResource::Connector.should_receive(:lookup).with(name).and_return(connector)
+        PartyResource::Connector(name).should == connector
+      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::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
+