zendesk_api 1.3.9 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29e998ef5ac29f169434e9f790efadefacb2643f
-  data.tar.gz: 4c04948d4dbe97717235756b3d966f90de072b5a
+  metadata.gz: 1d07ce370fb28464897785ae66e33e426fc65b1f
+  data.tar.gz: df2e6e5fed6d5bb977b0707b7f46e7396a3c8c70
 SHA512:
-  metadata.gz: 1ff31fb5fc88df8a3eba6d624fc838a6e2a339184dbd66749cefe7a097a6e01877524a95215f75bb8d7cb5625c43719aaf247a2df61df23dc2bc99368b364824
-  data.tar.gz: 9a02b1a2563b332facca8b17a3a2469e3765a406c46ae1f5a39110b8a3cb206cd39417f5764903f48dd23626f4e0dcf81c64e06e25e2ee9cc5a8b10cb63363aa
+  metadata.gz: 789311dcc288abb846bd53a6301df3f1c60988aefec37949272d260e58a85d2fa3faca796f50814578fc377acf813b159fccbe67328a334405b81f596f58fbd6
+  data.tar.gz: 19fc5162ac0a2956a4d6a70cfe082d39dcfdc87d56f81e3c5a53c11442882a507485e5a61529f350700ffbc9d0b32da38f6fb825111b72c6212ba3f1aaf756c6

data/.rspec

@@ -1,2 +1,2 @@
 --color
---format nested
+--format documentation

data/Gemfile

@@ -4,6 +4,7 @@ gem "simplecov", :platforms => :ruby_19, :group => :test
 gem "jruby-openssl", :platforms => :jruby
 
 group :test do
+  gem "byebug", :platform => [:ruby_20, :ruby_21]
   gem "json", :platform => :ruby_18
 
   # only used for uploads testing

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zendesk_api (1.3.9)
+    zendesk_api (1.4.0)
       faraday (~> 0.9)
       hashie (>= 1.2)
       inflection
@@ -12,9 +12,9 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (3.2.18)
-      activemodel (= 3.2.18)
-      activesupport (= 3.2.18)
+    actionpack (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
       builder (~> 3.0.0)
       erubis (~> 2.7.0)
       journey (~> 1.0.4)
@@ -22,30 +22,35 @@ GEM
       rack-cache (~> 1.2)
       rack-test (~> 0.6.1)
       sprockets (~> 2.2.1)
-    activemodel (3.2.18)
-      activesupport (= 3.2.18)
+    activemodel (3.2.19)
+      activesupport (= 3.2.19)
       builder (~> 3.0.0)
-    activesupport (3.2.18)
+    activesupport (3.2.19)
       i18n (~> 0.6, >= 0.6.4)
       multi_json (~> 1.0)
     addressable (2.3.6)
     builder (3.0.4)
     bump (0.5.0)
+    byebug (3.1.2)
+      columnize (~> 0.8)
+      debugger-linecache (~> 1.2)
+    columnize (0.8.9)
     crack (0.4.2)
       safe_yaml (~> 1.0.0)
+    debugger-linecache (1.2.0)
     diff-lcs (1.2.5)
-    docile (1.1.3)
+    docile (1.1.5)
     erubis (2.7.0)
     faraday (0.9.0)
       multipart-post (>= 1.2, < 3)
-    hashie (3.0.0)
+    hashie (3.2.0)
     hike (1.2.3)
-    i18n (0.6.9)
+    i18n (0.6.11)
     inflection (1.0.0)
     journey (1.0.4)
     json (1.8.1)
     mime-types (1.25.1)
-    multi_json (1.10.0)
+    multi_json (1.10.1)
     multipart-post (2.0.0)
     rack (1.4.5)
     rack-cache (1.2)
@@ -53,16 +58,20 @@ GEM
     rack-test (0.6.2)
       rack (>= 1.0)
     rake (10.3.2)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.2)
     safe_yaml (1.0.3)
-    simplecov (0.8.2)
+    simplecov (0.9.0)
       docile (~> 1.1.0)
       multi_json
       simplecov-html (~> 0.8.0)
@@ -73,7 +82,7 @@ GEM
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
     tilt (1.4.1)
-    vcr (2.9.0)
+    vcr (2.9.2)
     webmock (1.18.0)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
@@ -85,6 +94,7 @@ PLATFORMS
 DEPENDENCIES
   actionpack (~> 3.2)
   bump
+  byebug
   jruby-openssl
   json
   rake

data/lib/zendesk_api/collection.rb

@@ -263,6 +263,10 @@ module ZendeskAPI
     # @private
     def to_ary; nil; end
 
+    def respond_to?(name)
+      super || Array.new.respond_to?(name)
+    end
+
     # Sends methods to underlying array of resources.
     def method_missing(name, *args, &block)
       if resource_methods.include?(name)
@@ -324,6 +328,9 @@ module ZendeskAPI
 
         self.next
       end
+
+      page(nil)
+      clear_cache
     end
 
     def _save(method = :save)

data/lib/zendesk_api/version.rb

@@ -1,3 +1,3 @@
 module ZendeskAPI
-  VERSION = "1.3.9"
+  VERSION = "1.4.0"
 end

data/spec/core/association_spec.rb

@@ -13,38 +13,38 @@ describe ZendeskAPI::Association do
 
       it "should not try and fetch nil child" do
         instance.child_id = nil
-        instance.child.should be_nil
+        expect(instance.child).to be_nil
       end
 
       it "should cache an set object" do
         instance.child = child
-        instance.child.should == child
+        expect(instance.child).to eq(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
+        expect(instance.child_id).to eq(child.id)
       end
 
       it "should build a object set via hash" do
         instance.child = {:id => 2}
-        instance.child.id.should == 2
+        expect(instance.child.id).to eq(2)
       end
 
       it "should build a object set via id" do
         instance.child = 2
-        instance.child.id.should == 2
+        expect(instance.child.id).to eq(2)
       end
 
       it "should not fetch an unknown object" do
-       instance.child.should be_nil
+       expect(instance.child).to be_nil
       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
+        expect(instance.child.id).to eq(5)
       end
 
       it "should handle client errors" do
@@ -56,65 +56,65 @@ describe ZendeskAPI::Association do
       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 }
+        silence_logger{ expect(instance.child).to be_nil }
       end
 
       it "is not used when not used" do
-        instance.child_used?.should == false
+        expect(instance.child_used?).to eq(false)
       end
 
       it "is used when used" do
         instance.child = child
-        instance.child_used?.should == true
+        expect(instance.child_used?).to eq(true)
       end
     end
 
     context "has_many" do
       it "should cache a set object" do
         instance.children = [child]
-        instance.children.map(&:id).should == [1]
-        instance.children.should be_instance_of(ZendeskAPI::Collection)
+        expect(instance.children.map(&:id)).to eq([1])
+        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
       end
 
       it "should set ids" do
         instance.children_ids = []
         instance.children = [child]
-        instance.children_ids.should == [child.id]
-        instance.children.should be_instance_of(ZendeskAPI::Collection)
+        expect(instance.children_ids).to eq([child.id])
+        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
       end
 
       it "should build and cache objects set via hash" do
         instance.children = [{:id => 2}]
-        instance.children.map(&:id).should == [2]
-        instance.children.should be_instance_of(ZendeskAPI::Collection)
+        expect(instance.children.map(&:id)).to eq([2])
+        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
       end
 
       it "should build a object set via id" do
         instance.children = [2]
-        instance.children.map(&:id).should == [2]
-        instance.children.should be_instance_of(ZendeskAPI::Collection)
+        expect(instance.children.map(&:id)).to eq([2])
+        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
       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]
-        instance.children.should be_instance_of(ZendeskAPI::Collection)
+        expect(instance.children.map(&:id)).to eq([2,3])
+        expect(instance.children).to be_instance_of(ZendeskAPI::Collection)
       end
 
       it "should not change objects" do
         child = 'foo'
         children = [child]
         instance.children = children
-        children[0].should == 'foo'
+        expect(children[0]).to eq('foo')
       end
 
       it "is not used when not used" do
-        instance.children_used?.should == false
+        expect(instance.children_used?).to eq(false)
       end
 
       it "is used when used" do
         instance.children = [child]
-        instance.children_used?.should == true
+        expect(instance.children_used?).to eq(true)
       end
     end
   end
@@ -123,23 +123,23 @@ describe ZendeskAPI::Association do
     subject { described_class.new(:class => ZendeskAPI::TestResource) }
 
     it "should generate resource path" do
-      subject.generate_path.should == "test_resources"
+      expect(subject.generate_path).to eq("test_resources")
     end
 
     context "with an instance" do
       it "should generate a specific resource path" do
-        subject.generate_path(instance).should == "test_resources/1"
+        expect(subject.generate_path(instance)).to eq("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"
+          expect(subject.generate_path(instance, :with_id => false)).to eq("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"
+          expect(subject.generate_path(ZendeskAPI::TestResource.new(client))).to eq("test_resources")
         end
       end
     end
@@ -148,15 +148,15 @@ describe ZendeskAPI::Association do
       before(:each) { subject.options[:path] = "blergh" }
 
       it "should generate general resource path" do
-        subject.generate_path.should == "blergh"
+        expect(subject.generate_path).to eq("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
+        expect(subject.generate_path(opts)).to eq("test_resources/1")
+        expect(opts).to be_empty
       end
     end
   end
@@ -165,17 +165,17 @@ describe ZendeskAPI::Association do
     subject { described_class.new(:class => ZendeskAPI::TestResource::TestChild, :parent => instance, :name => :children) }
 
     it "should generate nested resource path" do
-      subject.generate_path.should == "test_resources/1/children"
+      expect(subject.generate_path).to eq("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"
+        expect(subject.generate_path(child)).to eq("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"
+          expect(subject.generate_path(child, :with_id => false)).to eq("test_resources/1/children")
         end
       end
     end
@@ -184,7 +184,7 @@ describe ZendeskAPI::Association do
       before(:each) { subject.options[:path] = "blergh" }
 
       it "should generate nested resource path" do
-        subject.generate_path.should == "test_resources/1/blergh"
+        expect(subject.generate_path).to eq("test_resources/1/blergh")
       end
     end
 
@@ -195,7 +195,7 @@ describe ZendeskAPI::Association do
       end
 
       it "should generate nested resource path" do
-        subject.generate_path.should == "test_resources/1/blergh"
+        expect(subject.generate_path).to eq("test_resources/1/blergh")
       end
     end
 
@@ -205,7 +205,7 @@ describe ZendeskAPI::Association do
       end
 
       it "should generate nested resource path" do
-        subject.generate_path.should == "test_resources/1/test_children"
+        expect(subject.generate_path).to eq("test_resources/1/test_children")
       end
     end
   end
@@ -218,14 +218,14 @@ describe ZendeskAPI::Association do
     end
 
     it "should generate specific nested resource path" do
-      subject.generate_path(child).should == "test_resources/2/children/1"
+      expect(subject.generate_path(child)).to eq("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
+        expect(subject.generate_path(opts)).to eq("test_resources/3/children")
+        expect(opts).to be_empty
       end
     end
   end
@@ -235,7 +235,7 @@ describe ZendeskAPI::Association do
 
     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"
+        expect(subject.generate_path(ZendeskAPI::SingularTestResource.new(client, :id => 1))).to eq("singular_test_resources")
       end
     end
   end

data/spec/core/client_spec.rb

@@ -49,11 +49,11 @@ describe ZendeskAPI::Client do
       end
 
       it "should build basic auth middleware" do
-        subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication).should_not be_nil
+        expect(subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to_not be_nil
       end
 
       it "should not build token middleware" do
-        subject.connection.headers["Authorization"].should be_nil
+        expect(subject.connection.headers["Authorization"]).to be_nil
       end
     end
 
@@ -66,11 +66,11 @@ describe ZendeskAPI::Client do
       end
 
       it "should not build basic auth middleware" do
-        subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication).should be_nil
+        expect(subject.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to be_nil
       end
 
       it "should build token middleware" do
-        subject.connection.headers["Authorization"].should match(/Bearer/)
+        expect(subject.connection.headers["Authorization"]).to match(/Bearer/)
       end
     end
 
@@ -90,25 +90,25 @@ describe ZendeskAPI::Client do
         let(:username) { "hello/token" }
 
         it "should not add /token to the username" do
-          subject.username.should == "hello/token"
+          expect(subject.username).to eq("hello/token")
         end
       end
 
       context "with no password" do
         it "should build basic auth middleware" do
-          client.connection.builder.handlers.index(Faraday::Request::BasicAuthentication).should_not be_nil
+          expect(client.connection.builder.handlers.index(Faraday::Request::BasicAuthentication)).to_not be_nil
         end
 
         it "should not build token middleware" do
-          client.connection.builder.handlers.index(Faraday::Request::TokenAuthentication).should be_nil
+          expect(client.connection.builder.handlers.index(Faraday::Request::TokenAuthentication)).to be_nil
         end
 
         it "should copy token to password" do
-          subject.token.should == subject.password
+          expect(subject.token).to eq(subject.password)
         end
 
         it "should add /token to the username" do
-          subject.username.should == "hello/token"
+          expect(subject.username).to eq("hello/token")
         end
       end
     end
@@ -127,12 +127,12 @@ describe ZendeskAPI::Client do
         subject { true }
 
         it "should log in faraday" do
-          @client.connection.builder.handlers.should include(ZendeskAPI::Middleware::Response::Logger)
+          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
         end
 
         context "with a request" do
           it "should log" do
-            client.config.logger.should_receive(:info).at_least(:once)
+            expect(client.config.logger).to receive(:info).at_least(:once)
             @client.connection.get('/bs')
           end
         end
@@ -142,7 +142,7 @@ describe ZendeskAPI::Client do
         subject { false }
 
         it "should not log" do
-          @client.connection.builder.handlers.should_not include(ZendeskAPI::Middleware::Response::Logger)
+          expect(@client.connection.builder.handlers).to_not include(ZendeskAPI::Middleware::Response::Logger)
         end
       end
 
@@ -150,7 +150,7 @@ describe ZendeskAPI::Client do
         subject { nil }
 
         it "should log" do
-          @client.connection.builder.handlers.should include(ZendeskAPI::Middleware::Response::Logger)
+          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
         end
       end
 
@@ -159,12 +159,12 @@ describe ZendeskAPI::Client do
         subject { Logger.new(out) }
 
         it "should log" do
-          @client.connection.builder.handlers.should include(ZendeskAPI::Middleware::Response::Logger)
+          expect(@client.connection.builder.handlers).to include(ZendeskAPI::Middleware::Response::Logger)
         end
 
         context "with a request" do
           it "should log to the subject" do
-            out.should_receive(:write).at_least(:once)
+            expect(out).to receive(:write).at_least(:once)
             @client.connection.get('/bs')
           end
         end
@@ -178,49 +178,49 @@ describe ZendeskAPI::Client do
     end
 
     it "should be a user instance" do
-      client.current_user.should be_instance_of(ZendeskAPI::User)
+      expect(client.current_user).to be_instance_of(ZendeskAPI::User)
     end
   end
 
   context "#connection" do
     it "should initially be false" do
-      subject.instance_variable_get(:@connection).should be_false
+      expect(subject.instance_variable_get(:@connection)).to be_falsey
     end
 
     it "connection should be initialized on first call to #connection" do
-      subject.connection.should be_instance_of(Faraday::Connection)
+      expect(subject.connection).to 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.instance_variable_get(:@resource_cache)["tickets"].should be_nil
+      expect(subject.instance_variable_get(:@resource_cache)["tickets"]).to be_nil
 
-      subject.tickets.should be_instance_of(ZendeskAPI::Collection)
+      expect(subject.tickets).to be_instance_of(ZendeskAPI::Collection)
 
-      subject.instance_variable_get(:@resource_cache)["tickets"].should_not be_empty
-      subject.instance_variable_get(:@resource_cache)["tickets"][:class].should == ZendeskAPI::Ticket
-      subject.instance_variable_get(:@resource_cache)["tickets"][:cache].should be_instance_of(ZendeskAPI::LRUCache)
+      expect(subject.instance_variable_get(:@resource_cache)["tickets"]).to_not be_empty
+      expect(subject.instance_variable_get(:@resource_cache)["tickets"][:class]).to eq(ZendeskAPI::Ticket)
+      expect(subject.instance_variable_get(:@resource_cache)["tickets"][:cache]).to be_instance_of(ZendeskAPI::LRUCache)
 
-      ZendeskAPI.should_not_receive(:const_get)
-      subject.tickets.should be_instance_of(ZendeskAPI::Collection)
+      expect(ZendeskAPI).to_not receive(:const_get)
+      expect(subject.tickets).to be_instance_of(ZendeskAPI::Collection)
     end
 
     it "should not cache calls with different options" do
-      subject.search(:query => 'abc').should_not == subject.search(:query => '123')
+      expect(subject.search(:query => 'abc')).to_not eq(subject.search(:query => '123'))
     end
 
     it "should not cache calls with :reload => true options" do
-      subject.search(:query => 'abc').should_not == subject.search(:query => 'abc', :reload => true)
+      expect(subject.search(:query => 'abc')).to_not eq(subject.search(:query => 'abc', :reload => true))
     end
 
     it "should not pass reload to the underlying collection" do
       collection = subject.search(:query => 'abc', :reload => true)
-      collection.options.key?(:reload).should be_false
+      expect(collection.options.key?(:reload)).to be(false)
     end
 
     it "should cache calls with the same options" do
-      subject.search(:query => 'abc').should == subject.search(:query => 'abc')
+      expect(subject.search(:query => 'abc')).to eq(subject.search(:query => 'abc'))
     end
   end
 
@@ -228,22 +228,22 @@ describe ZendeskAPI::Client 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
+    expect(client.config.allow_http).to eq(true)
+    expect(client.connection).to eq("FOO")
+    expect(client.connection.object_id).to eq(client.connection.object_id) # it's cached
   end
 
   context ZendeskAPI::Voice do
     it "defers to voice delegator" do
-      ZendeskAPI::Client.any_instance.should_receive(:phone_numbers).once
+      expect(subject).to receive(:phone_numbers).once
       subject.voice.phone_numbers
     end
 
     it "manages namespace correctly" do
-      client.certification_addresses.path.should match(/channels\/voice\/certification_addresses/)
-      client.phone_numbers.path.should match(/channels\/voice\/phone_numbers/)
-      client.greetings.path.should match(/channels\/voice\/greetings/)
-      client.greeting_categories.path.should match(/channels\/voice\/greeting_categories/)
+      expect(client.certification_addresses.path).to match(/channels\/voice\/certification_addresses/)
+      expect(client.phone_numbers.path).to match(/channels\/voice\/phone_numbers/)
+      expect(client.greetings.path).to match(/channels\/voice\/greetings/)
+      expect(client.greeting_categories.path).to match(/channels\/voice\/greeting_categories/)
     end
   end
 end