zendesk_api 0.0.9

data/live/upload_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe ZendeskAPI::Upload, :not_findable do
+  def valid_attributes
+    { :file => "spec/fixtures/Argentina.gif" }
+  end
+
+  it_should_be_creatable :id => :token
+end

data/live/user_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe ZendeskAPI::User, :delete_after do
+  def valid_attributes
+    { :name => "Test U.", :email => "test@example.org" }
+  end
+
+  it_should_be_creatable
+  it_should_be_updatable :name
+  it_should_be_deletable :find => [:active?, false]
+  it_should_be_readable :users
+  it_should_be_readable organization, :users
+end

data/live/view_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe ZendeskAPI::View do
+  it_should_be_readable :views
+  it_should_be_readable :views, :active
+end

data/spec/association_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe ZendeskAPI::Association do
+  let(:instance) { ZendeskAPI::TestResource.new(client, :id => 1) }
+  let(:child) { ZendeskAPI::TestResource::TestChild.new(client, :id => 1, :test_resource_id => 2) }
+
+  describe "setting/getting" do
+    context "has" do
+      before do
+        ZendeskAPI::TestResource.associations.clear
+        ZendeskAPI::TestResource.has :child, :class => :test_child
+      end
+
+      it "should cache an set object" do
+        instance.child = child
+        instance.child.should == child
+      end
+
+      it "should set id on set if it was there" do
+        instance.child_id = nil
+        instance.child = child
+        instance.child_id.should == child.id
+      end
+
+      it "should not set id on set if it was not there" do
+        instance.child = child
+        instance.child_id.should == nil
+      end
+
+      it "should build a object set via hash" do
+        instance.child = {:id => 2}
+        instance.child.id.should == 2
+      end
+
+      it "should build a object set via id" do
+        instance.child = 2
+        instance.child.id.should == 2
+      end
+
+      it "should fetch a unknown object" do
+        stub_json_request(:get, %r{test_resources/1/child}, json(:test_child => {:id => 2}))
+        instance.child.id.should == 2
+      end
+
+      it "should fetch an object known by id" do
+        stub_json_request(:get, %r{test_resources/1/child/5}, json(:test_child => {:id => 5}))
+        instance.child_id = 5
+        instance.child.id.should == 5
+      end
+
+      it "should handle client errors" do
+        stub_request(:get, %r{test_resources/1/child/5}).to_return(:status => 500)
+        instance.child_id = 5
+        expect { silence_logger { instance.child } }.to_not raise_error
+      end
+
+      it "should handle resource not found errors" do
+        stub_request(:get, %r{test_resources/1/child/5}).to_return(:status => 404)
+        instance.child_id = 5
+        silence_logger{ instance.child.should be_nil }
+      end
+
+      it "is not used when not used" do
+        instance.child_used?.should == false
+      end
+
+      it "is used when used" do
+        instance.child = child
+        instance.child_used?.should == true
+      end
+    end
+
+    context "has_many" do
+      it "should cache a set object" do
+        instance.children = [child]
+        instance.children.map(&:id).should == [1]
+      end
+
+      it "should set ids" do
+        instance.children_ids = []
+        instance.children = [child]
+        instance.children_ids.should == [child.id]
+      end
+
+      it "should build and cache objects set via hash" do
+        instance.children = [{:id => 2}]
+        instance.children.map(&:id).should == [2]
+      end
+
+      it "should build a object set via id" do
+        instance.children = [2]
+        instance.children.map(&:id).should == [2]
+      end
+
+      it "should fetch unknown objects" do
+        stub_json_request(:get, %r{test_resources/1/children}, json(:test_children => [{:id => 2}, {:id => 3}]))
+        instance.children.map(&:id).should == [2,3]
+      end
+
+      it "is not used when not used" do
+        instance.children_used?.should == false
+      end
+
+      it "is used when used" do
+        instance.children = [child]
+        instance.children_used?.should == true
+      end
+    end
+  end
+
+  context "class only" do
+    subject { described_class.new(:class => ZendeskAPI::TestResource) }
+
+    it "should generate resource path" do
+      subject.generate_path.should == "test_resources"
+    end
+
+    context "with an instance" do
+      it "should generate a specific resource path" do
+        subject.generate_path(instance).should == "test_resources/1"
+      end
+
+      context "with_id => false" do
+        it "should generate general resource path" do
+          subject.generate_path(instance, :with_id => false).should == "test_resources"
+        end
+      end
+
+      context "with an instance that is a new record" do
+        it "should generate general resource path" do
+          subject.generate_path(ZendeskAPI::TestResource.new(client)).should == "test_resources"
+        end
+      end
+    end
+
+    context "with a specified path" do
+      before(:each) { subject.options[:path] = "blergh" }
+
+      it "should generate general resource path" do
+        subject.generate_path.should == "blergh"
+      end
+    end
+
+    context "with a passed in id" do
+      it "should generate specific resource path" do
+        opts = { :id => 1 }
+        subject.generate_path(opts).should == "test_resources/1"
+        opts.should be_empty
+      end
+    end
+  end
+
+  context "class with a specified parent" do
+    subject { described_class.new(:class => ZendeskAPI::TestResource::TestChild, :parent => instance) }
+
+    it "should generate nested resource path" do
+      subject.generate_path.should == "test_resources/1/children"
+    end
+
+    context "with an instance" do
+      it "should generate a specific nested resource path" do
+        subject.generate_path(child).should == "test_resources/1/children/1"
+      end
+
+      context "with_id => false" do
+        it "should generate nested resource path" do
+          subject.generate_path(child, :with_id => false).should == "test_resources/1/children"
+        end
+      end
+    end
+
+    context "with a specified path" do
+      before(:each) { subject.options[:path] = "blergh" }
+
+      it "should generate nested resource path" do
+        subject.generate_path.should == "test_resources/1/blergh"
+      end
+    end
+  end
+
+  context "class with a parent id" do
+    subject { described_class.new(:class => ZendeskAPI::TestResource::TestChild) }
+
+    it "should raise an error if not passed an instance or id" do
+      expect { subject.generate_path }.to raise_error(ArgumentError)
+    end
+
+    it "should generate specific nested resource path" do
+      subject.generate_path(child).should == "test_resources/2/children/1"
+    end
+
+    context "with parent id passed in" do
+      it "should generate nested resource path" do
+        opts = { :test_resource_id => 3 }
+        subject.generate_path(opts).should == "test_resources/3/children"
+        opts.should be_empty
+      end
+    end
+  end
+
+  context "with a singular resource" do
+    subject { described_class.new(:class => ZendeskAPI::SingularTestResource) }
+
+    context "with an instance" do
+      it "should not generate a specific resource path" do
+        subject.generate_path(ZendeskAPI::SingularTestResource.new(client, :id => 1)).should == "singular_test_resources"
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+class SimpleClient < ZendeskAPI::Client
+  def build_connection
+    "FOO"
+  end
+end
+
+describe ZendeskAPI::Client do
+  subject { client }
+
+  context "#initialize" do
+    it "should require a block" do
+      expect { ZendeskAPI::Client.new }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an exception when url isn't ssl" do
+      expect do
+        ZendeskAPI::Client.new do |config|
+          config.url = "http://www.google.com"
+        end
+      end.to raise_error(ArgumentError) 
+    end
+
+    it "should not raise an exception when url isn't ssl and allow_http is set to true" do
+      expect do
+        ZendeskAPI::Client.new do |config|
+          config.allow_http = true
+          config.url = "http://www.google.com/"
+        end
+      end.to_not raise_error
+    end
+
+    it "should handle valid url" do
+      expect do
+        ZendeskAPI::Client.new do |config|
+          config.url = "https://example.zendesk.com/"
+        end.to_not raise_error
+      end
+    end
+
+    context "#logger" do
+      before(:each) do
+        @client = ZendeskAPI::Client.new do |config| 
+          config.url = "https://example.zendesk.com/"
+          config.logger = subject
+        end
+
+        stub_request(:get, %r{/bs$}).to_return(:status => 200)
+      end
+
+      context "with true value" do
+        subject { true }
+
+        it "should log in faraday" do
+          @client.connection.builder.handlers.should include(Faraday::Response::Logger)
+        end
+
+        context "with a request" do
+          it "should log" do
+            client.config.logger.should_receive(:info).at_least(:once)
+            @client.connection.get('/bs')
+          end
+        end
+      end
+
+      context "with false value" do
+        subject { false }
+
+        it "should not log" do
+          @client.connection.builder.handlers.should_not include(Faraday::Response::Logger)
+        end
+      end
+
+      context "with a nil value" do
+        subject { nil }
+
+        it "should log" do
+          @client.connection.builder.handlers.should include(Faraday::Response::Logger)
+        end
+      end
+
+      context "with a logger" do
+        let(:out){ StringIO.new }
+        subject { Logger.new(out) }
+        
+        it "should log" do
+          @client.connection.builder.handlers.should include(Faraday::Response::Logger)
+        end
+
+        context "with a request" do
+          it "should log to the subject" do
+            out.should_receive(:write).at_least(:once)
+            @client.connection.get('/bs')
+          end
+        end
+      end
+    end
+  end
+
+  context "#current_user" do
+    before(:each) do
+      stub_json_request(:get, %r{users/me}, json("user" => {}))
+    end
+
+    it "should be a user instance" do
+      client.current_user.should be_instance_of(ZendeskAPI::User)
+    end
+  end
+
+  context "#connection" do
+    it "should initially be false" do
+      subject.instance_variable_get(:@connection).should be_false
+    end
+
+    it "connection should be initialized on first call to #connection" do
+      subject.connection.should be_instance_of(Faraday::Connection)
+    end
+  end
+
+  context "resources" do
+    it "should return an instance of ZendeskAPI::Collection if there is no method" do
+      subject.tickets.should be_instance_of(ZendeskAPI::Collection)
+      subject.instance_variable_defined?(:@tickets).should be_true
+    end
+  end
+
+  context "#play" do
+    # TODO may be able to be replaced by VCR
+    before(:each) do 
+      stub_request(:get, %r{play}).to_return do
+        { :status => 302 }
+      end
+    end
+
+    it "should return an instance of ZendeskAPI::Playlist" do
+      subject.play(1).should be_instance_of(ZendeskAPI::Playlist)
+    end
+  end
+
+  it "can be subclassed" do
+    client = SimpleClient.new do |config|
+      config.allow_http = true
+    end
+    client.config.allow_http.should == true
+    client.connection.should == "FOO"
+    client.connection.object_id.should == client.connection.object_id # it's cached
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper.rb'
+
+describe ZendeskAPI::Collection do
+  subject do
+    ZendeskAPI::Collection.new(client, ZendeskAPI::TestResource)
+  end
+
+  context "initialization" do
+    it "should set the resource class" do
+      subject.instance_variable_get(:@resource_class).should == ZendeskAPI::TestResource
+    end
+
+    it "should initially be empty" do
+      subject.instance_variable_defined?(:@resources).should 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
+      subject.instance_variable_get(:@options)[:ids].should == "1,2,3,4"
+    end
+  end
+
+  context "deferral" do
+    before(:each) do
+      stub_json_request(:any, %r{test_resources}, json(:test_resource => {}))
+    end
+
+    it "should defer #create to the resource class" do
+      subject.create
+    end
+
+    it "should defer #find to the resource class" do
+      subject.find(:id => 1)
+    end
+
+    it "should defer #destroy to the resource class" do
+      subject.destroy(:id => 1)
+    end
+
+    it "should defer #update to the resource class" do
+      subject.update(:id => 1)
+    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))
+      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
+          subject.last.association.should == association
+        end
+      end
+    end
+  end
+
+  context "pagination with no options and no data" do
+    it "should return an empty array on #next" do
+      subject.next.should be_empty
+    end
+
+    it "should return an empty array on #prev" do
+      subject.prev.should 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
+      subject.per_page(10).should == subject
+      subject.instance_variable_get(:@options)["per_page"].should == 10
+    end
+
+    it "should set page option" do
+      subject.page(10).should == subject
+      subject.instance_variable_get(:@options)["page"].should == 10
+    end
+
+    it "should increate page option" do
+      subject.next.should == 3
+    end
+
+    it "should decreate page option" do
+      subject.prev.should == 1
+    end
+  end
+
+  context "fetch" do
+    it "does not fetch if associated is a new record" do
+      ZendeskAPI::Category.new(client).forums.fetch.should == []
+      ZendeskAPI::Category.new(client).forums.to_a.should == []
+    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 { subject.fetch(true).should be_empty }
+      end
+    end
+
+    context "with unfetchable resource" do
+      subject { ZendeskAPI::Collection.new(client, ZendeskAPI::NilResource) }
+
+      it "should not call connection" do
+        client.connection.should_not_receive(:get)
+        subject.fetch(true).should 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) { mock('ZendeskAPI::TestResource', :changes => [:xxx]) }
+
+      it "should call create with those options" do
+        ZendeskAPI::TestResource.should_receive(:new).
+          with(client, options.merge(:association => subject.association)).
+          and_return(object)
+
+        subject << options
+
+        object.should_receive(:save)
+        subject.save
+
+        subject.should 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
+        object.should_receive(:save)
+        subject.save
+      end
+
+      it "should have object in collection" do
+        subject.should include(object)
+      end
+    end
+
+    context "with everything else" do
+      it "should pass to new, since this is how attachment handles it" do
+        attachment = mock(:changes => [:xxx])
+        ZendeskAPI::TestResource.should_receive(:new).with(client, "img.jpg").and_return attachment
+        subject << "img.jpg"
+
+        attachment.should_receive :save
+        subject.save
+      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
+
+        nxt.size.should == 1
+        nxt.should_not == current
+      end
+
+      it "should find the prev page by calling fetch" do
+        current = subject.to_a.dup
+        prev = subject.prev
+
+        prev.size.should == 1
+        prev.should_not == 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
+        subject.next.should == 3
+      end
+
+      it "should decrease page option and not call fetch" do
+        subject.prev.should == 1
+      end
+
+      context "with page == 1" do
+        before do
+          subject.page(1)
+          subject.clear_cache
+          subject.should_not_receive(:fetch)
+        end
+
+        it "should do nothing on #prev" do
+          subject.prev.should == []
+        end
+      end
+    end
+  end
+
+  context "method missing" do
+    before(:each) { subject.stub(:fetch).and_return([1, 2, nil, 3]) }
+
+    it "should pass all methods not defined to resources" do
+      subject.compact.should == [1, 2, 3]
+    end
+
+    it "should take a block" do
+      subject.map {|i| i.to_i + 1}.should == [2, 3, 1, 4]
+    end
+
+    it "should create a new collection if it isn't an array method" do
+      subject.recent.should be_instance_of(ZendeskAPI::Collection)
+    end
+
+    it "should pass the correct query_path to the new collection" do
+      subject.recent.instance_variable_get(:@collection_path).last.should == :recent
+    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
+  end
+end