party_resource 0.0.3 → 0.0.4

data/spec/fixtures/other_class.rb

@@ -1,19 +0,0 @@
-class OtherClass < TestBaseClass
-  def self.make_boolean(data)
-    data =~ /OK/
-  end
-end
-
-
-class OtherPartyClass
-  include PartyResource
-  party_connector :other_connector
-
-  connect :test, :get => '/url', :as => :raw
-
-  property :thing
-
-  def initialize(args)
-    populate_properties(args)
-  end
-end

data/spec/fixtures/test_base_class.rb

@@ -1,17 +0,0 @@
-class TestBaseClass
-  attr :args
-
-  def initialize(args={})
-    @args = args
-  end
-
-  def method_missing(name, *params)
-    return args[name] if params.empty? && args.has_key?(name)
-    super
-  end
-
-  def ==(other)
-    self.class == other.class && args == other.args
-  end
-end
-

data/spec/fixtures/test_class.rb

@@ -1,44 +0,0 @@
-PartyResource::Connector.add(:other_connector, {:base_uri => 'http://otherserver/'})
-PartyResource::Connector.add(:my_connector, {:base_uri => 'http://myserver/path', :username => 'fred', :password => 'pass', :default => true})
-
-class TestClass < TestBaseClass
-  include PartyResource
-
-  connect :find, :get => '/find/:id.ext', :with => :id, :on => :class
-
-  connect :update, :put => '/update/:var.ext', :on => :instance, :as => OtherClass
-
-  connect :save, :post => '/save/file', :with => :data, :as => :raw
-
-  connect :destroy, :delete => '/delete', :as => [OtherClass, :make_boolean]
-
-  connect :foo, :get => '/foo', :with => :value, :as => lambda {|data| "New #{data} Improved" }
-
-  connect :fetch_json, :get => '/big_data', :as => [:self, :from_json], :rescue => {'ResourceNotFound' => nil}
-
-  connect :include, :get => '/include', :on => :instance, :as => OtherClass, :including => {:thing => :value2}
-
-  property :value, :from => :input_name
-
-  property :value2, :value3
-
-  property :nested_value, :from => [:block, :var]
-
-  property :other, :as => OtherClass
-
-  property :processed, :as => lambda { |data| "Processed: #{data}" }, :to => :output_name
-
-  property :child, :as => OtherPartyClass
-
-  def self.from_json(args)
-    obj = self.new
-    obj.send(:populate_properties, args)
-    obj
-  end
-
-end
-
-class InheritedTestClass < TestClass
-  property :child_property
-end
-

data/spec/integration/integration_spec.rb

@@ -1,213 +0,0 @@
-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)}
-
-  after do
-    PartyResource.logger = nil
-  end
-
-  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::Exceptions::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::Exceptions::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::Exceptions::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::Exceptions::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
-
-  describe 'logging' do
-    context 'with no logger' do
-      it 'does not fail' do
-        stub_request(:get, "http://fred:pass@myserver/path/find/99.ext").to_return(:body => 'some data')
-        TestClass.find(99)
-      end
-    end
-
-    context 'with a logger object' do
-      before do
-        @logger = mock(:logger)
-        PartyResource.logger = @logger
-      end
-
-      it 'logs all api calls to debug' do
-        stub_request(:get, "http://fred:pass@myserver/path/find/99.ext").to_return(:body => 'some data')
-        @logger.should_receive(:debug).with('** PartyResource GET call to /find/99.ext with {:basic_auth=>{:username=>"fred", :password=>"pass"}, :base_uri=>"http://myserver/path"}')
-        TestClass.find(99)
-      end
-    end
-
-    context 'with a logger lambda' do
-      before do
-        @logger = mock(:logger)
-        PartyResource.logger = lambda {|message| @logger.log(message) }
-      end
-
-      it 'logs all api calls to debug' do
-        stub_request(:get, "http://fred:pass@myserver/path/find/99.ext").to_return(:body => 'some data')
-        @logger.should_receive(:log).with('** PartyResource GET call to /find/99.ext with {:basic_auth=>{:username=>"fred", :password=>"pass"}, :base_uri=>"http://myserver/path"}')
-        TestClass.find(99)
-      end
-    end
-
-  end
-end

data/spec/spec_helper.rb

@@ -1,20 +0,0 @@
-$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

@@ -1,83 +0,0 @@
-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::Exceptions::ConnectionError)
-      end
-    end
-
-  end
-
-end

data/spec/unit/connector_spec.rb

@@ -1,67 +0,0 @@
-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.send(: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.send(: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::Exceptions::NoConnector)
-    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.lookup(name).should == connector
-    end
-
-    it 'sets the default if it is currently unset' do
-      name2 = mock(:name2)
-      PartyResource::Connector.add(name, options)
-      PartyResource::Connector.send(:repository).default.should == name
-
-      PartyResource::Connector.add(name2, options)
-      PartyResource::Connector.send(: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
-