daylight 0.9.0.rc1

data/spec/lib/daylight/associations_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+
+describe Daylight::Associations do
+
+  class RelatedTestClass < Daylight::API
+    self.password = nil
+    self.include_format_in_path = false
+  end
+
+  class AssociationsTestClass < Daylight::API
+    self.password = nil
+    self.include_format_in_path = false
+
+    has_many   :related_test_classes, through: :associated
+    has_many   :things,        class_name: 'RelatedTestClass', through: :associated
+    belongs_to :parent,        class_name: 'RelatedTestClass'
+    has_one    :grandparent,   class_name: 'RelatedTestClass', through: :parent
+    has_one    :associate,     class_name: 'RelatedTestClass'
+    remote     :remote_stuff,  class_name: 'RelatedTestClass'
+
+    def id;        123; end
+    def parent_id; 456; end
+  end
+
+  describe :has_many do
+
+    before do
+      data = [{name: 'one'}, {name: 'two'}]
+      [RelatedTestClass, AssociationsTestClass].each do |clazz|
+        stub_request(:get, %r{#{clazz.site}}).to_return(body: data.to_json)
+      end
+    end
+
+
+    it "fetches the results out of the attributes if they exist" do
+      object = AssociationsTestClass.first
+      object.attributes['related_test_classes_attributes'] = ['yay']
+      collection = object.related_test_classes
+      collection.should be_instance_of(Array)
+      collection.first.should == 'yay'
+    end
+
+    describe "with new resource" do
+      let(:new_resource) { AssociationsTestClass.new }
+
+
+      it "caches the results of the association" do
+        collection = new_resource.related_test_classes
+        new_resource.related_test_classes.should == collection
+      end
+
+      it "creates a method that construts an Array for the collection" do
+        collection = new_resource.related_test_classes
+
+        collection.should be_a Array
+      end
+
+      it "sets the associations directly the attributes hash" do
+        new_resource.related_test_classes = ["associated instances"]
+
+        new_resource.attributes['related_test_classes_attributes'].should == ["associated instances"]
+      end
+
+      it "fetches the stored associations out of the attributes when they are set" do
+        new_resource.related_test_classes = ["associated instances"]
+
+        new_resource.related_test_classes.should == ["associated instances"]
+      end
+    end
+
+
+    describe "with existing resource" do
+      let(:existing_resource) { AssociationsTestClass.first }
+
+      it "creates a method that construts an ResourceProxy for the association" do
+        proxy = existing_resource.related_test_classes
+
+        proxy.should be_a Daylight::ResourceProxy
+        proxy.resource_class.should == RelatedTestClass
+      end
+
+      it "creates a method that construts an ResourceProxy with context about the association" do
+        proxy = existing_resource.related_test_classes
+
+        proxy.association_name.should == :related_test_classes
+        proxy.association_resource.should == existing_resource
+      end
+
+      it "hits the association api endpoint" do
+        existing_resource.related_test_classes.load
+
+        a_request(:get, "http://daylight.test/v1/associations_test_classes/123/related_test_classes.json").should have_been_made
+      end
+
+      it "caches the results of the association" do
+        proxy = existing_resource.related_test_classes
+        existing_resource.related_test_classes.should == proxy
+      end
+
+      it "supports the :class_name option" do ## THIS ONE
+        proxy = existing_resource.things
+        proxy.resource_class.should == RelatedTestClass
+      end
+
+      it "chains using the proxy class for the associated model" do
+        proxy = existing_resource.related_test_classes.where(wibble: 'wobble')
+
+        proxy.resource_class.should == RelatedTestClass
+        proxy.to_params[:filters].should == {wibble: 'wobble'}
+      end
+
+      it "sets the associations directly the attributes hash" do
+        existing_resource.related_test_classes = ["associated instances"]
+
+        existing_resource.attributes['related_test_classes_attributes'].should == ["associated instances"]
+      end
+
+      it "fetches the stored associations out of the attributes when they exist" do
+        existing_resource.related_test_classes = ["associated instances"]
+
+        existing_resource.related_test_classes.should == ["associated instances"]
+      end
+    end
+  end
+
+  describe :belongs_to do
+
+    before do
+      data = { parent: {name: 'three'}}
+      [RelatedTestClass, AssociationsTestClass].each do |clazz|
+        stub_request(:get, %r{#{clazz.site}}).to_return(body: data.to_json)
+      end
+    end
+
+    it 'still fetches the parent object' do
+      resource = AssociationsTestClass.find(1)
+
+      resource.parent.should_not be_nil
+      resource.parent.name.should == 'three'
+    end
+
+    it 'sets the parent to a new object' do
+      resource = AssociationsTestClass.find(1)
+      resource.parent = RelatedTestClass.new(name: 'new parent')
+
+      resource.parent.name.should == 'new parent'
+    end
+
+    it 'sets the parent foreign key' do
+      resource = AssociationsTestClass.find(1)
+      resource.parent = RelatedTestClass.new(id: 789, name: 'new parent')
+
+      resource.attributes['parent_id'].should == 789
+    end
+
+    it 'sets the parent directly in the nested attributes hash' do
+      resource = AssociationsTestClass.find(1)
+      resource.parent = RelatedTestClass.new(id: 789, name: 'new parent')
+
+      resource.attributes['parent_attributes'].should == resource.parent
+    end
+  end
+
+  describe :belongs_to_through do
+
+    before do
+      association_data = { through: {
+          id: 1,
+          parent_id: 456, # ignored because of parent_id method
+          parent_attributes: {
+            id: 456,
+            grandparent_id: 3
+          }
+        }
+      }
+
+      embedded_data = { through: {
+          id: 2,
+          parent_id: 456, # ignored because of parent_id method
+          parent_attributes: {
+            id: 456,
+            grandparent: { id: 4, name: 'embed' }
+          }
+        }
+      }
+
+      related_data = {id: nil, name: 'related'}
+
+      stub_request(:get, %r{#{AssociationsTestClass.element_path(1)}}).to_return(body: association_data.to_json)
+      stub_request(:get, %r{#{AssociationsTestClass.element_path(2)}}).to_return(body: embedded_data.to_json)
+      stub_request(:get, %r{#{RelatedTestClass.element_path(456)}}).to_return(body: related_data.merge(id: 456).to_json)
+      stub_request(:get, %r{#{RelatedTestClass.element_path(3)}}).to_return(body: related_data.merge(id: 3).to_json)
+    end
+
+    it 'still fetches the parent object' do
+      resource = AssociationsTestClass.find(1)
+
+      resource.parent.should_not be_nil
+      resource.parent.id.should   == 456
+      resource.parent.name.should == 'related'
+    end
+
+    it 'fetches the "through" object' do
+      resource = AssociationsTestClass.find(1)
+
+      resource.grandparent.should_not be_nil
+      resource.grandparent.id.should   == 3
+      resource.grandparent.name.should == 'related'
+    end
+
+    it 'fetches embedded "through" object' do
+      resource = AssociationsTestClass.find(2)
+
+      resource.grandparent.should be_kind_of(ActiveResource::Base)
+      resource.grandparent.id.should   == 4
+      resource.grandparent.name.should == 'embed'
+    end
+
+    it 'sets the "through" object foreign key' do
+      resource = AssociationsTestClass.find(1)
+      resource.grandparent = RelatedTestClass.new(id: 789, name: 'new grandparent')
+
+      resource.attributes['parent_attributes']['grandparent_id'].should == 789
+    end
+
+    it 'sets the through object directly in the nested attributes hash' do
+      resource = AssociationsTestClass.find(1)
+      resource.grandparent = RelatedTestClass.new(id: 789, name: 'new grandparent')
+
+      resource.attributes['parent_attributes']['grandparent_attributes'].should == resource.grandparent
+    end
+  end
+
+  describe :has_one do
+    before do
+      associated = { id: nil, name: 'Hardy', associate_attributes: { id: 100 } }
+      related    = { id: 100, name: 'Laurel' }
+      stub_request(:get, %r{#{AssociationsTestClass.element_path(1)}}).to_return(body: associated.to_json)
+      # It uses the filter method instead of default ActiveResource behavior
+      # http://daylight.test/v1/related_test_classes?filters%5Bassociations_test_class_id%5D=123&limit=1
+      stub_request(:get, %r{filters%5Bassociations_test_class_id%5D=123}).to_return(body: [related].to_json)
+    end
+
+    it 'still fetches the associate object' do
+      resource = AssociationsTestClass.find(1)
+
+      resource.associate.should_not be_nil
+      resource.associate.id.should == 100
+      resource.associate.name.should == 'Laurel'
+    end
+
+    it 'sets the associate to a new object' do
+      resource = AssociationsTestClass.find(1)
+      resource.associate = RelatedTestClass.new(name: 'Rik Mayall')
+
+      resource.associate.name.should == 'Rik Mayall'
+    end
+
+    it 'sets the associate foreign key' do
+      resource = AssociationsTestClass.find(1)
+      resource.associate = RelatedTestClass.new(id: 333, name: 'Rik Mayall')
+
+      resource.associate.associations_test_class_id.should == resource.id
+    end
+
+    it 'sets the associate directly in the nested attributes hash' do
+      resource = AssociationsTestClass.find(1)
+      resource.associate = RelatedTestClass.new(id: 333, name: 'Rik Mayall')
+
+      resource.attributes['associate_attributes'].should == resource.associate
+    end
+  end
+
+  describe :remote do
+
+    def respond_with(data)
+      stub_request(:get, %r{#{AssociationsTestClass.site}}).to_return(body: data.to_json)
+    end
+
+    let(:subject) { AssociationsTestClass.new }
+
+    it "loads data from the remote" do
+      respond_with({remote_stuff: {id: 2, foo: 'bar'}})
+
+      subject.remote_stuff.foo.should == 'bar'
+    end
+
+    it "handles collections" do
+      respond_with({remote_stuff: [{id: 2, foo: 'first'}, {id: 3, foo: 'second'}]})
+
+      subject.remote_stuff.first.foo.should == 'first'
+      subject.remote_stuff.last.foo.should == 'second'
+    end
+
+    it "caches the data" do
+      respond_with({remote_stuff: {cache: 'cachey cache'}})
+
+      subject.should_receive(:get).once.and_call_original
+
+      subject.remote_stuff.cache.should == 'cachey cache'
+      subject.remote_stuff.cache.should == 'cachey cache'
+    end
+
+    it "handles metadata with an object" do
+      respond_with({remote_stuff: {id: 2, foo: 'bar'}, meta: {}})
+
+      subject.remote_stuff.foo.should == 'bar'
+    end
+
+    it "handles metadata with a collection" do
+      respond_with({remote_stuff: [{id: 2, foo: 'first'}, {id: 3, foo: 'second'}], meta: {}})
+
+      subject.remote_stuff.first.foo.should == 'first'
+      subject.remote_stuff.last.foo.should == 'second'
+    end
+
+    it "returns data from the attributes if that already exists" do
+      subject.attributes[:remote_stuff] = 'wibble'
+
+      subject.remote_stuff.should == 'wibble'
+    end
+
+  end
+
+end

data/spec/lib/daylight/collection_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe Daylight::Collection do
+
+  class CollectionTestClass < Daylight::API
+    self.password = nil
+
+    scopes :foo, :bar
+  end
+
+  before do
+    stub_request(:get, %r{#{CollectionTestClass.site}}).to_return(body: [].to_json)
+  end
+
+  describe :metadata do
+    before do
+      data = { collection: [{name: 'one'}, {name: 'two'}], meta: {data: 'baz'} }
+      stub_request(:get, %r{#{CollectionTestClass.site}}).to_return(body: data.to_json)
+    end
+
+    it 'is retrieved before parsing' do
+      collection = CollectionTestClass.all
+
+      collection.metadata.should == {'data' => 'baz'}
+    end
+
+    it 'is passed to child elements' do
+      collection = CollectionTestClass.all
+      collection.each do |child|
+        child.metadata.should ==  {'data' => 'baz'}
+      end
+    end
+  end
+
+  describe :first_or_initialize do
+
+    describe 'with results' do
+      before do
+        data = [{name: 'one'}, {name: 'two'}]
+        stub_request(:get, %r{#{CollectionTestClass.site}}).to_return(body: data.to_json)
+      end
+
+      it 'returns the first result' do
+        result = CollectionTestClass.where(name: 'one').first_or_initialize
+        result.should be_kind_of(CollectionTestClass)
+        result.name.should == 'one'
+      end
+    end
+
+    it 'reraises NoMethodErrors on initialize' do
+      CollectionTestClass.stub(:new).and_raise(NoMethodError)
+
+      expect { CollectionTestClass.where(name: 'one').first_or_initialize }.to \
+        raise_error(StandardError, 'Cannot create resource from resource type: CollectionTestClass')
+    end
+
+    it 'returns an unsaved instance' do
+      result = CollectionTestClass.where(name: 'two').first_or_initialize
+
+      result.should be_kind_of(CollectionTestClass)
+      result.should_not be_persisted
+    end
+
+    it 'adds known parameter values to attributes' do
+      result = CollectionTestClass.where(name: 'two').first_or_initialize
+
+      result.should be_kind_of(CollectionTestClass)
+      result.should_not be_persisted
+
+      result.name.should == 'two'
+    end
+
+    it 'adds query parameter to prefix_options' do
+      result = CollectionTestClass.foo.bar.where(name: 'two').first_or_initialize
+
+      result.should be_kind_of(CollectionTestClass)
+      result.should_not be_persisted
+
+      result.prefix_options.should == {scopes: [:foo, :bar]}
+    end
+
+    it 'keeps collection parameters from being merged into attributes' do
+      result = CollectionTestClass.where(name: 'two').limit(10).offset(100).order(name: 'asc').first_or_initialize
+
+      result.should be_kind_of(CollectionTestClass)
+      result.should_not be_persisted
+
+      result.attributes[:limit].should be_nil
+      result.attributes[:offset].should be_nil
+      result.attributes[:order].should be_nil
+    end
+
+    it 'leaves unknown paramters so they are merged into attributes' do
+      result = CollectionTestClass.find(:all, params: {a: 1, b: 2}).first_or_initialize
+
+      result.should be_kind_of(CollectionTestClass)
+      result.should_not be_persisted
+
+      result.a.should == 1
+      result.b.should == 2
+    end
+  end
+
+  describe :first_or_create do
+
+    describe 'with results' do
+      before do
+        data = [{name: 'one'}, {name: 'two'}]
+        stub_request(:get, %r{#{CollectionTestClass.site}}).to_return(body: data.to_json)
+      end
+
+      it 'returns the first result' do
+        result = CollectionTestClass.where(name: 'one').first_or_create
+        result.should be_kind_of(CollectionTestClass)
+        result.name.should == 'one'
+      end
+    end
+
+    describe 'with errors' do
+      before do
+        errors = {errors: {status: ["can't be blank", "is not included in the list"]} }
+        stub_request(:post, %r{#{CollectionTestClass.site}}).to_return(body: errors.to_json, status: 422)
+      end
+
+      it 'returns an unsaved instance with errors' do
+        result = CollectionTestClass.where(name: 'one').first_or_create
+        result.should be_kind_of(CollectionTestClass)
+        result.should_not be_persisted
+
+        result.name.should == 'one'
+        result.errors.full_messages.should == ["Status can't be blank", "Status is not included in the list"]
+      end
+
+      it 'reraises NoMethodErrors on initialize' do
+        CollectionTestClass.stub(:new).and_raise(NoMethodError)
+
+        expect { CollectionTestClass.where(name: 'one').first_or_create }.to \
+          raise_error(StandardError, 'Cannot build resource from resource type: CollectionTestClass')
+      end
+    end
+
+    describe 'with create' do
+      before do
+        resource = {id: 1, name: 'one'}
+        stub_request(:post, %r{#{CollectionTestClass.site}}).to_return(body: resource.to_json, status: 201)
+      end
+
+      it 'returns a saved instance' do
+        result = CollectionTestClass.where(name: 'one').first_or_create
+
+        result.should be_kind_of(CollectionTestClass)
+        result.should be_persisted
+
+        result.id.should == 1
+      end
+
+      it 'adds known parameter values to attributes' do
+        result = CollectionTestClass.where(name: 'two').first_or_create
+
+        result.should be_kind_of(CollectionTestClass)
+        result.should be_persisted
+
+        result.name.should == 'one'
+      end
+
+      describe 'before save' do
+        before do
+          CollectionTestClass.any_instance.stub(save: true)
+        end
+
+        it 'adds query parameter to prefix_options before save' do
+          result = CollectionTestClass.foo.bar.where(name: 'two').first_or_initialize
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should_not be_persisted
+
+          result.prefix_options.should == {scopes: [:foo, :bar]}
+        end
+
+        it 'keeps collection parameters from being merged into attributes' do
+          result = CollectionTestClass.where(name: 'two').limit(10).offset(100).order(name: 'asc').first_or_create
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should_not be_persisted
+
+          result.attributes[:limit].should be_nil
+          result.attributes[:offset].should be_nil
+          result.attributes[:order].should be_nil
+        end
+
+        it 'keeps unknown paramters so they are merged into attributes' do
+          result = CollectionTestClass.find(:all, params: {a: 1, b: 2}).first_or_create
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should_not be_persisted
+
+          result.a.should == 1
+          result.b.should == 2
+        end
+      end
+
+      describe 'after save' do
+        it 'has no prefix_options' do
+          result = CollectionTestClass.foo.bar.where(name: 'two').first_or_create
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should be_persisted
+
+          result.prefix_options.should == {}
+        end
+
+        it 'has no collection parameters' do
+          result = CollectionTestClass.where(name: 'two').limit(10).offset(100).order(name: 'asc').first_or_create
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should be_persisted
+
+          result.attributes[:limit].should be_nil
+          result.attributes[:offset].should be_nil
+          result.attributes[:order].should be_nil
+        end
+
+        it 'keeps unknown paramters' do
+          result = CollectionTestClass.find(:all, params: {a: 1, b: 2}).first_or_create
+
+          result.should be_kind_of(CollectionTestClass)
+          result.should be_persisted
+
+          result.a.should == 1
+          result.b.should == 2
+        end
+      end
+    end
+  end
+end

data/spec/lib/daylight/errors_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Daylight::Errors do
+
+  class BaseErrorTest < StandardError
+    def initialize resposne, message=nill
+      @message = 'base'
+    end
+
+    def to_s
+      @message.dup
+    end
+  end
+
+  class ErrorTest < BaseErrorTest
+    include Daylight::Errors
+  end
+
+  def mock_response headers, body
+    double(header: headers, body: body)
+  end
+
+  it 'ignores parsing with no body and content-type' do
+    error = ErrorTest.new(mock_response({}, nil))
+
+    error.messages.should == []
+    error.to_s.should == 'base'
+  end
+
+  it 'sets no message for unknown content-type' do
+    error = ErrorTest.new(mock_response({'content-type' => 'application/foo'}, 'bar error, no drink'))
+
+    error.messages.should == []
+    error.to_s.should == 'base'
+  end
+
+
+  describe :xml do
+    let(:xml_error)    { '<errors><error>message</error></errors>' }
+    let(:xml_errors)   { '<errors><error>problem 1</error><error>problem 2</error></errors>' }
+
+    def xml_response body=nil
+      mock_response({'content-type' => 'application/xml; charset=utf-8'}, body)
+    end
+
+    it 'parses no error' do
+      error = ErrorTest.new(xml_response)
+
+      error.messages.should == []
+      error.to_s.should == 'base'
+    end
+
+    it 'parses one error' do
+      error = ErrorTest.new(xml_response(xml_error))
+
+      error.messages.should == ['message']
+      error.to_s.should == 'base  Root Cause = message'
+    end
+
+    it 'parses multiple errors' do
+      error = ErrorTest.new(xml_response(xml_errors))
+
+      error.messages.should == ['problem 1', 'problem 2']
+      error.to_s.should == 'base  Root Cause = problem 1, problem 2'
+    end
+
+    it 'handles decode errors and sets no messages' do
+      error = ErrorTest.new(xml_response('bad data'))
+
+      error.messages.should == []
+      error.to_s.should == 'base'
+    end
+  end
+
+  describe :json do
+    let(:json_error)    { { errors: 'message'}.to_json }
+    let(:json_errors)   { { errors: ['problem 1', 'problem 2'] }.to_json }
+
+    def json_response body=nil
+      mock_response({'content-type' => 'application/json; charset=utf-8'}, body)
+    end
+
+    it 'parses no error' do
+      error = ErrorTest.new(json_response)
+
+      error.messages.should == []
+      error.to_s.should == 'base'
+    end
+
+    it 'parses one error' do
+      error = ErrorTest.new(json_response(json_error))
+
+      error.messages.should == ['message']
+      error.to_s.should == 'base  Root Cause = message'
+    end
+
+    it 'parses multiple errors' do
+      error = ErrorTest.new(json_response(json_errors))
+
+      error.messages.should == ['problem 1', 'problem 2']
+      error.to_s.should == 'base  Root Cause = problem 1, problem 2'
+    end
+
+    it 'handles decode errors and sets no messages' do
+      error = ErrorTest.new(json_response('<bad data>'))
+
+      error.messages.should == []
+      error.to_s.should == 'base'
+    end
+  end
+end