zendesk_api 1.13.1 → 1.13.2

data/spec/core/collection_spec.rb

@@ -1,901 +0,0 @@
-require 'core/spec_helper'
-
-describe ZendeskAPI::Collection do
-  subject do
-    ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource)
-  end
-
-  context "initialization" do
-    it "should set the resource class" do
-      expect(subject.instance_variable_get(:@resource_class)).to eq(ZendeskAPI::TestResource)
-    end
-
-    it "should initially be empty" do
-      expect(subject.instance_variable_defined?(:@resources)).to be(false)
-    end
-  end
-
-  context "with array option passed in" do
-    subject { ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource, :ids => [1, 2, 3, 4]) }
-
-    it "should join array with commas" do
-      expect(subject.instance_variable_get(:@options)[:ids]).to eq("1,2,3,4")
-    end
-  end
-
-  context "deferral" do
-    it "should defer #create_many! to the resource class" do
-      collection = ZendeskAPI::Collection.new(client, ZendeskAPI::BulkTestResource)
-      stub_json_request(:post, %r{bulk_test_resources/create_many$}, json(:job_status => {}))
-      collection.create_many!([{:name => 'Mick'}, {:name => 'Steven'}])
-      assert_requested(:post, %r{bulk_test_resources/create_many$},
-        :body => {
-          :bulk_test_resources => [{:name => 'Mick'}, {:name => 'Steven'}]
-        }
-      )
-    end
-
-    it "should defer #destroy_many! to the resource class" do
-      collection = ZendeskAPI::Collection.new(client, ZendeskAPI::BulkTestResource)
-      stub_json_request(:delete, %r{bulk_test_resources/destroy_many\?}, json(:job_status => {}))
-      collection.destroy_many!([1,2,3])
-      assert_requested(:delete, %r{bulk_test_resources/destroy_many\?ids=1,2,3$})
-    end
-
-    it "should defer #update_many! to the resource class" do
-      collection = ZendeskAPI::Collection.new(client, ZendeskAPI::BulkTestResource)
-      stub_json_request(:put, %r{bulk_test_resources/update_many\?}, json(:job_status => {}))
-      collection.update_many!([1,2,3], {:name => 'Mick'})
-      assert_requested(:put, %r{bulk_test_resources/update_many\?ids=1,2,3$})
-    end
-
-    it "should defer #create to the resource class" do
-      stub_json_request(:post, %r{test_resources$}, json(:test_resource => {}))
-      subject.create
-    end
-
-    it "should defer #find to the resource class" do
-      stub_json_request(:get, %r{test_resources/1$}, json(:test_resource => {}))
-      subject.find(:id => 1)
-    end
-
-    it "should defer #destroy to the resource class" do
-      stub_json_request(:delete, %r{test_resources/1$}, json(:test_resource => {}))
-      subject.destroy(:id => 1)
-    end
-
-    it "should defer #update to the resource class" do
-      stub_json_request(:put, %r{test_resources/1$}, json(:test_resource => {}))
-      subject.update(:id => 1)
-    end
-
-    context "when class doesn't have method" do
-      subject do
-        ZendeskAPI::Collection.new(client, ZendeskAPI::NilDataResource)
-      end
-
-      it "should raise NoMethodError" do
-        expect { subject.create }.to raise_error(NoMethodError)
-      end
-
-      it "should raise NoMethodError" do
-        expect { subject.create! }.to raise_error(NoMethodError)
-      end
-    end
-
-    context "with a class with a parent" do
-      let(:association) do
-        ZendeskAPI::Association.new(:class => ZendeskAPI::TestResource::TestChild,
-          :parent => ZendeskAPI::TestResource.new(client, :id => 1), :name => :children)
-      end
-
-      subject do
-        ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource::TestChild,
-          :association => association)
-      end
-
-      before(:each) do
-        stub_json_request(:any, %r{/test_resources/\d+/child}, json("test_child" => {}))
-      end
-
-      it "should defer #create to the resource class with the parent id" do
-        subject.create
-      end
-
-      it "should defer #destroy the resource class with the parent id" do
-        subject.destroy(:id => 1)
-      end
-
-      it "should defer #find to the resource class with the parent id" do
-        subject.find(:id => 1)
-      end
-
-      it "should defer #update to the resource class with the parent id" do
-        subject.update(:id => 1)
-      end
-
-      context "on object push" do
-        before(:each) do
-          stub_json_request(:get, %r{test_resources/\d+/children}, json(:test_children => []))
-          subject << { :id => 1 }
-        end
-
-        it "should pass association" do
-          expect(subject.last.association).to eq(association)
-        end
-
-        it "should #build a resource and add it" do
-          resource = subject.build
-          expect(subject).to include(resource)
-          expect(resource.association).to eq(subject.association)
-        end
-
-        it "should #build! a resource and add it" do
-          resource = subject.build!
-          expect(subject).to include(resource)
-          expect(resource.association).to eq(subject.association)
-        end
-      end
-    end
-  end
-
-  context "pagination with data" do
-    before(:each) do
-      stub_json_request(:get, %r{test_resources}, json(
-        :test_resources => [{ :id => 1 }]
-      ))
-      subject.fetch(true)
-    end
-
-    context "on #page" do
-      context "with nil" do
-        before(:each) { subject.page(nil) }
-
-        it "should not empty the cache" do
-          expect(subject.instance_variable_get(:@resources)).to_not be_empty
-        end
-      end
-
-      context "with a number" do
-        before(:each) { subject.page(3) }
-
-        it "should empty the cache" do
-          expect(subject.instance_variable_get(:@resources)).to be_nil
-        end
-      end
-    end
-
-    context "on #per_page" do
-      context "with nil" do
-        before(:each) { subject.per_page(nil) }
-
-        it "should not empty the cache" do
-          expect(subject.instance_variable_get(:@resources)).to_not be_empty
-        end
-      end
-
-      context "with a number" do
-        before(:each) { subject.per_page(20) }
-
-        it "should empty the cache" do
-          expect(subject.instance_variable_get(:@resources)).to be_nil
-        end
-      end
-    end
-  end
-
-  context "pagination with no options and no data" do
-    it "should return an empty array on #next" do
-      expect(subject.next).to be_empty
-    end
-
-    it "should return an empty array on #prev" do
-      expect(subject.prev).to be_empty
-    end
-  end
-
-  context "pagination with options and no data" do
-    before(:each) { subject.per_page(5).page(2) }
-
-    it "should set per_page option" do
-      expect(subject.per_page(10)).to eq(subject)
-      expect(subject.instance_variable_get(:@options)["per_page"]).to eq(10)
-    end
-
-    it "should set page option" do
-      expect(subject.page(10)).to eq(subject)
-      expect(subject.instance_variable_get(:@options)["page"]).to eq(10)
-    end
-
-    it "should increate page option" do
-      expect(subject.next).to eq(3)
-    end
-
-    it "should decreate page option" do
-      expect(subject.prev).to eq(1)
-    end
-  end
-
-  context "all" do
-    context "Faraday errors" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources$}, json(
-          :test_resources => [{:id => 1}], :next_page => "/test_resources?page=2"
-        ))
-
-        stub_request(:get, %r{test_resources\?page=2}).to_return(:status => 500).then.to_return(
-          :headers => { :content_type => "application/json" }, :status => 200,
-          :body => json(:test_resources => [{:id => 2}], :next_page => "/test_resources?page=3"))
-
-        stub_request(:get, %r{test_resources\?page=3}).to_return(:status => 404)
-      end
-
-      it "should retry from the same page" do
-        class SearchError < Exception; end
-
-        expect do |b|
-          client.insert_callback do |env|
-            if env[:status] == 500 && env[:url].request_uri =~ /test_resources/
-              raise SearchError
-            end
-          end
-
-          begin
-            silence_logger { subject.all(&b) }
-          rescue SearchError
-            retry
-          end
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 2]
-        )
-      end
-
-      it "should retry from the same page!" do
-        expect do |b|
-          begin
-            subject.all!(&b)
-          rescue ZendeskAPI::Error::NetworkError
-            retry
-          rescue ZendeskAPI::Error::ClientError
-          end
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 2]
-        )
-      end
-
-      it "raises an ArgumentError without a block (all)" do
-        expect do |b|
-          subject.all
-        end.to raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError without a block (all!)" do
-        expect do |b|
-          subject.all!
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context "requests with no next_page" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources$}, json(
-          :test_resources => [{:id => 1}],
-          :next_page => "/test_resources?page=2"
-        ))
-
-        stub_json_request(:get, %r{test_resources\?page=2}, json(
-          :test_resources => [{:id => 2}]
-        ))
-      end
-
-      it "should yield resource and page" do
-        expect do |b|
-          silence_logger { subject.all(&b) }
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 2]
-        )
-      end
-    end
-
-    context "incremental requests" do
-      subject do
-        ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource, :path => 'exports/test_resources?start_time=0')
-      end
-
-      before(:each) do
-        stub_json_request(:get, %r{exports/test_resources\?start_time=0$}, json(
-          :test_resources => [{:id => 1}],
-          :next_page => "/exports/test_resources?start_time=200"
-        ))
-
-        stub_json_request(:get, %r{exports/test_resources\?start_time=200$}, json(
-          :test_resources => [{:id => 2}],
-          :next_page => "/exports/test_resources?start_time=200"
-        ))
-      end
-
-      it "should yield resource and page (and not infinitely loop)" do
-        expect do |b|
-          Timeout.timeout(5) do
-            silence_logger { subject.all(&b) }
-          end
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 1] # page defaults to 1
-        )
-      end
-    end
-
-    context "infinite loops" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources$}, json(
-          :test_resources => [{:id => 1}],
-          :next_page => "/test_resources?page=2"
-        ))
-
-        stub_json_request(:get, %r{/test_resources\?page=2$}, json(
-          :test_resources => [{:id => 2}],
-          :next_page => "/test_resources?page=2"
-        ))
-      end
-
-      xit "should yield resource and page (and not infinitely loop)" do
-        expect do |b|
-          Timeout.timeout(5) do
-            silence_logger { subject.all(&b) }
-          end
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 2]
-        )
-      end
-    end
-
-    context "successful requests" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources$}, json(
-          :test_resources => [{:id => 1}],
-          :next_page => "/test_resources?page=2"
-        ))
-
-        stub_json_request(:get, %r{test_resources\?page=2}, json(
-          :test_resources => [{:id => 2}],
-          :next_page => "/test_resources?page=3"
-        ))
-
-        stub_request(:get, %r{test_resources\?page=3}).to_return(:status => 404)
-      end
-
-      it "should yield resource if arity == 1" do
-        expect do |block|
-          # Needed to make sure the arity == 1
-          block.instance_eval do
-            def to_proc
-              @used = true
-
-              probe = self
-              Proc.new do |arg|
-                probe.num_yields += 1
-                probe.yielded_args << [arg]
-              end
-            end
-          end
-
-          silence_logger { subject.all(&block) }
-        end.to yield_successive_args(
-          ZendeskAPI::TestResource.new(client, :id => 1),
-          ZendeskAPI::TestResource.new(client, :id => 2)
-        )
-      end
-
-      it "should yield resource and page" do
-        expect do |b|
-          silence_logger { subject.all(&b) }
-        end.to yield_successive_args(
-          [ZendeskAPI::TestResource.new(client, :id => 1), 1],
-          [ZendeskAPI::TestResource.new(client, :id => 2), 2]
-        )
-      end
-
-      context "afterwards" do
-        before(:each) do
-          silence_logger { subject.all {|_|} }
-        end
-
-        it "should reset the collection" do
-          expect(subject.first_page?).to be(true)
-          expect(subject.fetch).to eq([ZendeskAPI::TestResource.new(client, :id => 1)])
-        end
-      end
-    end
-  end
-
-  context "fetch" do
-    context "grabbing the current page" do
-      context "from next_page" do
-        before(:each) do
-          stub_json_request(:get, %r{test_resources}, json(
-            :test_resources => [{:id => 2}],
-            :next_page => "/test_resources?page=2"
-          ))
-
-          subject.fetch(true)
-          @page = subject.instance_variable_get(:@options)["page"]
-        end
-
-        it "should set the page to 1" do
-          expect(@page).to eq(1)
-        end
-      end
-
-      context "from prev_page" do
-        before(:each) do
-          stub_json_request(:get, %r{test_resources}, json(
-            :test_resources => [{:id => 2}],
-            :previous_page => "/test_resources?page=1"
-          ))
-
-          subject.fetch(true)
-          @page = subject.instance_variable_get(:@options)["page"]
-        end
-
-        it "should set the page to 2" do
-          expect(@page).to eq(2)
-        end
-      end
-
-      context "with nothing" do
-        before(:each) do
-          stub_json_request(:get, %r{test_resources}, json(:test_resources => [{:id => 2}]))
-          subject.fetch(true)
-          @page = subject.instance_variable_get(:@options)["page"]
-        end
-
-        it "should not set the page" do
-          expect(@page).to be_nil
-        end
-      end
-    end
-
-    it "does not fetch if associated is a new record" do
-      expect(ZendeskAPI::Category.new(client).forums.fetch).to eq([])
-      expect(ZendeskAPI::Category.new(client).forums.to_a).to eq([])
-    end
-
-    context "with client error" do
-      before(:each) do
-        stub_request(:get, %r{test_resources}).to_return(:status => 500)
-      end
-
-      it "should properly be handled" do
-        silence_logger { expect(subject.fetch(true)).to be_empty }
-      end
-    end
-
-    context "with an invalid model key expectation" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources}, json(
-          :test_resource_stuff => [{:id => 2}],
-          :next_page => "/test_resources?page=2"
-        ))
-      end
-
-      it "should properly be handled" do
-        expect(subject.fetch(true)).to be_empty
-      end
-    end
-
-    context "with nil body" do
-      before(:each) do
-        stub_request(:get, %r{test_resources}).to_return(:status => 200)
-      end
-
-      it "should properly be handled" do
-        silence_logger { expect(subject.fetch(true)).to be_empty }
-      end
-    end
-
-    context "with unfetchable resource" do
-      subject { ZendeskAPI::Collection.new(client, ZendeskAPI::NilResource) }
-
-      it "should not call connection" do
-        expect(client.connection).to_not receive(:get)
-        expect(subject.fetch(true)).to be_empty
-      end
-    end
-  end
-
-  context "save" do
-    let(:options) { { :abc => 1 } }
-    before(:each) do
-      stub_json_request(:get, %r{test_resources}, json(:test_resources => []))
-      subject.clear_cache
-    end
-
-    context "with a hash" do
-      let(:object) { double('ZendeskAPI::TestResource', :changes => [:xxx], :changed? => true, :destroyed? => false) }
-
-      it "should call create with those options" do
-        expect(ZendeskAPI::TestResource).to receive(:new).
-          with(client, options.merge(:association => subject.association)).
-          and_return(object)
-
-        subject << options
-
-        expect(object).to receive(:save)
-        subject.save
-
-        expect(subject).to include(object)
-      end
-    end
-
-    context "with a new object" do
-      let(:object) { ZendeskAPI::TestResource.new(client, options) }
-      before(:each) do
-        subject << object
-      end
-
-      it "should save object" do
-        expect(object).to receive(:save)
-        subject.save
-      end
-
-      it "should have object in collection" do
-        expect(subject).to include(object)
-      end
-    end
-
-    context "with everything else" do
-      it "should pass to new, since this is how attachment handles it" do
-        attachment = double(:changes => [:xxx], :changed? => true, :destroyed? => false)
-        expect(ZendeskAPI::TestResource).to receive(:new).
-          with(client, :id => "img.jpg", :association => instance_of(ZendeskAPI::Association)).
-          and_return attachment
-
-        subject << "img.jpg"
-
-        expect(attachment).to receive(:save)
-        subject.save
-      end
-    end
-
-    context "with a destroyed object" do
-      let(:object) { ZendeskAPI::TestResource.new(client, options) }
-
-      before(:each) do
-        subject << object
-      end
-
-      it "should not save object" do
-        expect(object).to receive(:destroyed?).and_return(true)
-        expect(object).to_not receive(:save)
-
-        subject.save
-      end
-
-      it "should have object in collection" do
-        expect(subject).to include(object)
-      end
-    end
-  end
-
-  context "without real data" do
-    subject do
-      ZendeskAPI::Collection.new(client, ZendeskAPI::User)
-    end
-
-    before(:each) do
-      stub_json_request(:get, %r{users\?page=2}, json(
-        :users => [{:id => 2}],
-        :next_page => "/users?page=3&per_page=1",
-        :previous_page => "/users?page=1&per_page=1"
-      ))
-
-      subject.per_page(1).page(2)
-      subject.fetch(true)
-    end
-
-    context "pagination with no options" do
-      before(:each) do
-        stub_json_request(:get, %r{users\?page=(1|3)}, json(:users => [{:id => 3}]))
-
-        subject.per_page(nil).page(nil)
-      end
-
-      it "should find the next page by calling fetch" do
-        current = subject.to_a.dup
-        nxt = subject.next
-
-        expect(nxt.size).to eq(1)
-        expect(nxt).to_not eq(current)
-      end
-
-      it "should find the prev page by calling fetch" do
-        current = subject.to_a.dup
-        prev = subject.prev
-
-        expect(prev.size).to eq(1)
-        expect(prev).to_not eq(current)
-      end
-    end
-
-    context "pagination with options", :vcr do
-      before(:each) { subject.per_page(1).page(2) }
-
-      it "should increase page option and not call fetch" do
-        expect(subject.next).to eq(3)
-      end
-
-      it "should decrease page option and not call fetch" do
-        expect(subject.prev).to eq(1)
-      end
-
-      context "with page == 1" do
-        before do
-          subject.page(1)
-          subject.clear_cache
-          expect(subject).to_not receive(:fetch)
-        end
-
-        it "should do nothing on #prev" do
-          expect(subject.prev).to eq([])
-        end
-      end
-    end
-  end
-
-  context "side loading" do
-    before(:each) do
-      subject.include(:nil_resources)
-    end
-
-    context "singular id on resource" do
-      before(:each) do
-        ZendeskAPI::TestResource.has ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1, :nil_resource_id => 4 }],
-          :nil_resources => [{ :id => 1, :name => :bye }, { :id => 4, :name => :hi }]
-        ))
-
-        subject.fetch(true)
-
-        @resource = subject.detect {|res| res.id == 1}
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resource).to_not be_nil
-      end
-
-      it "should side load the correct nil_resource" do
-        expect(@resource.nil_resource.name).to eq("hi")
-      end
-    end
-
-
-    context "multiple resources" do
-      before(:each) do
-        ZendeskAPI::TestResource.has ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1, :nil_resource_id => 4 }, { :id => 2, :nil_resource_id => 1 }],
-          :nil_resources => [{ :id => 1, :name => :bye }, { :id => 4, :name => :hi }]
-        ))
-
-        subject.fetch(true)
-
-      end
-
-      context "first resource" do
-        before(:each) { @resource = subject.detect {|res| res.id == 1} }
-
-        it "should side load nil_resources" do
-          expect(@resource.nil_resource).to_not be_nil
-        end
-
-        it "should side load the correct nil_resource" do
-          expect(@resource.nil_resource.name).to eq("hi")
-        end
-      end
-
-      context "second resource" do
-        before(:each) { @resource = subject.detect {|res| res.id == 2} }
-
-        it "should side load nil_resources" do
-          expect(@resource.nil_resource).to_not be_nil
-        end
-
-        it "should side load the correct nil_resource" do
-          expect(@resource.nil_resource.name).to eq("bye")
-        end
-      end
-    end
-
-    context "plural ids on resource" do
-      before(:each) do
-        ZendeskAPI::TestResource.has_many ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1, :nil_resource_ids => [1, 4] }],
-          :nil_resources => [{ :id => 1, :name => :hi }, { :id => 4, :name => :hello }, { :id => 5, :name => :goodbye }]
-        ))
-
-        subject.fetch(true)
-
-        @resource = subject.detect {|res| res.id == 1}
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resources).to_not be_empty
-      end
-
-      it "should side load the correct nil_resources" do
-        expect(@resource.nil_resources.map(&:name)).to eq(%w{hi hello})
-      end
-    end
-
-    context "ids in side load" do
-      before(:each) do
-        ZendeskAPI::TestResource.has_many ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1 }],
-          :nil_resources => [{ :id => 1, :test_resource_id => 2 }, { :id => 2, :test_resource_id => 1 }, { :id => 4, :test_resource_id => 1 }]
-        ))
-
-        subject.fetch(true)
-        @resource = subject.detect {|res| res.id == 1}
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resources).to_not be_empty
-      end
-
-      it "should side load the correct nil_resources" do
-        expect(@resource.nil_resources.map(&:id)).to eq([2, 4])
-      end
-    end
-
-    context "id in side load" do
-      before(:each) do
-        ZendeskAPI::TestResource.has ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1 }],
-          :nil_resources => [{ :id => 1, :test_resource_id => 2 }, { :id => 2, :test_resource_id => 1 }]
-        ))
-
-        subject.fetch(true)
-        @resource = subject.detect {|res| res.id == 1}
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resource).to_not be_nil
-      end
-
-      it "should side load the correct nil_resources" do
-        expect(@resource.nil_resource.id).to eq(2)
-      end
-    end
-
-    context "with name as key" do
-      before(:each) do
-        ZendeskAPI::TestResource.has ZendeskAPI::NilResource, :include_key => :name
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1, :nil_resource_id => 4 }],
-          :nil_resources => [{ :name => 1 }, { :name => 4 }]
-        ))
-
-        subject.fetch(true)
-
-        @resource = subject.detect {|res| res.id == 1}
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resource).to_not be_nil
-      end
-
-      it "should side load the correct nil_resource" do
-        expect(@resource.nil_resource.name).to eq(4)
-      end
-    end
-
-    context "sub-loading" do
-      before(:each) do
-        ZendeskAPI::TestResource.has ZendeskAPI::TestResource::TestChild
-        ZendeskAPI::TestResource::TestChild.has ZendeskAPI::NilResource
-
-        stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
-          :test_resources => [{ :id => 1, :test_child => { :nil_resource_id => 4 } }],
-          :nil_resources => [{ :id => 1 }, { :id => 4 }]
-        ))
-
-        subject.fetch(true)
-
-        @resource = subject.detect {|res| res.id == 1}.test_child
-      end
-
-      it "should side load nil_resources" do
-        expect(@resource.nil_resource).to_not be_nil
-      end
-
-      it "should side load the correct nil_resource" do
-        expect(@resource.nil_resource.id).to eq(4)
-      end
-    end
-  end
-
-  context "method missing" do
-    before(:each) { allow(subject).to receive(:fetch).and_return([1, 2, nil, 3]) }
-
-    context "with an class method on the resource class" do
-      it "should pass methods to class if defined" do
-        expect(subject.test).to eq("hi")
-      end
-    end
-
-    it "should pass all methods not defined to resources" do
-      expect(subject.compact).to eq([1, 2, 3])
-    end
-
-    it "should take a block" do
-      expect(subject.map {|i| i.to_i + 1}).to eq([2, 3, 1, 4])
-    end
-
-    it "should create a new collection if it isn't an array method" do
-      expect(subject.recent).to be_instance_of(ZendeskAPI::Collection)
-    end
-
-    it "should pass the correct query_path to the new collection" do
-      expect(subject.recent.instance_variable_get(:@collection_path).last).to eq(:recent)
-    end
-  end
-
-  context "with a module (Search)" do
-    subject { ZendeskAPI::Collection.new(client, ZendeskAPI::Search, :query => "hello") }
-
-    before(:each) do
-      stub_json_request(:get, %r{search\?query=hello}, json(:results => []))
-    end
-
-    it "should not blow up" do
-      expect(subject.to_a).to eq([])
-    end
-  end
-
-  context "with different path" do
-    subject do
-      ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource, :collection_path => ["test_resources", "active"])
-    end
-
-    before(:each) do
-      stub_json_request(:post, %r{test_resources/active})
-    end
-
-    context "deferral" do
-      it "should defer #create to the resource class with proper path" do
-        subject.create
-      end
-    end
-
-    context "resources" do
-      before(:each) do
-        stub_json_request(:get, %r{test_resources/active},
-          json(:test_resources => [{ :id => 1 }]))
-
-        subject.fetch
-
-        stub_json_request(:put, %r{test_resources/1})
-      end
-
-      it "should not save using the collection path" do
-        resource = subject.first
-        resource.save
-      end
-    end
-  end
-end