zendesk_api 1.3.9 → 1.4.0

data/spec/core/configuration_spec.rb

@@ -6,19 +6,19 @@ describe ZendeskAPI::Configuration do
   it "should properly merge options" do
     url = "test.host"
     subject.url = url
-    subject.options[:url].should == url
+    expect(subject.options[:url]).to eq(url)
   end
 
   it "should set accept header properly" do
-    subject.options[:headers][:accept].should == 'application/json'
+    expect(subject.options[:headers][:accept]).to eq('application/json')
   end
 
   it "should set user agent header properly" do
-    subject.options[:headers][:user_agent].should =~ /ZendeskAPI API/
+    expect(subject.options[:headers][:user_agent]).to match(/ZendeskAPI API/)
   end
 
   it "should merge options with client_options" do
     subject.client_options = {:ssl => false}
-    subject.options[:ssl].should == false
+    expect(subject.options[:ssl]).to eq(false)
   end
 end

data/spec/core/create_resource_spec.rb

@@ -10,7 +10,7 @@ describe ZendeskAPI::CreateResource do
     end
 
     it "should return instance of resource" do
-      subject.create(client, attr).should be_instance_of(subject) 
+      expect(subject.create(client, attr)).to be_instance_of(subject)
     end
 
     context "with client error" do
@@ -19,7 +19,7 @@ describe ZendeskAPI::CreateResource do
       end
 
       it "should handle it properly" do
-        expect { silence_logger { subject.create(client, attr).should be_nil } }.to_not raise_error
+        expect { silence_logger { expect(subject.create(client, attr)).to be_nil } }.to_not raise_error
       end
     end
   end

data/spec/core/data_resource_spec.rb

@@ -2,14 +2,14 @@ require 'core/spec_helper'
 
 describe ZendeskAPI::DataResource do
   specify "singular resource name" do
-    ZendeskAPI::Ticket.singular_resource_name.should == "ticket"
-    ZendeskAPI::TicketField.singular_resource_name.should == "ticket_field"
+    expect(ZendeskAPI::Ticket.singular_resource_name).to eq("ticket")
+    expect(ZendeskAPI::TicketField.singular_resource_name).to eq("ticket_field")
   end
 
   specify "resource name" do
-    ZendeskAPI::Ticket.resource_name.should == "tickets"
-    ZendeskAPI::TicketField.resource_name.should == "ticket_fields"
-    ZendeskAPI::Category.resource_name.should == "categories"
+    expect(ZendeskAPI::Ticket.resource_name).to eq("tickets")
+    expect(ZendeskAPI::TicketField.resource_name).to eq("ticket_fields")
+    expect(ZendeskAPI::Category.resource_name).to eq("categories")
   end
 
   context "association" do
@@ -23,7 +23,7 @@ describe ZendeskAPI::DataResource do
     it "should try and find non-existent object" do
       stub_json_request(:get, %r{test_resources/1/nil}, json(:nil_data_resource => {}))
 
-      subject.nil.should be_instance_of(ZendeskAPI::NilDataResource)
+      expect(subject.nil).to be_instance_of(ZendeskAPI::NilDataResource)
     end
 
     context "inline => true" do
@@ -41,7 +41,7 @@ describe ZendeskAPI::DataResource do
       before(:each) { subject.attributes[:priority] = "normal" }
 
       it "should be able to access underlying attributes" do
-        subject.priority.should == "normal"
+        expect(subject.priority).to eq("normal")
       end
 
       it "should be able to change underlying attributes" do
@@ -62,7 +62,7 @@ describe ZendeskAPI::DataResource do
       before(:each) { subject.priority = "normal" }
 
       it "should be able to change underlying attributes" do
-        subject.priority.should == "normal"
+        expect(subject.priority).to eq("normal")
       end
 
       it "should be able to change underlying attributes" do
@@ -86,14 +86,14 @@ describe ZendeskAPI::DataResource do
       subject { ZendeskAPI::TestResource }
 
       it "should define a method with the same name" do
-        subject.instance_methods.map(&:to_s).should include("test_resource")
+        expect(subject.instance_methods.map(&:to_s)).to include("test_resource")
       end
 
       context "with explicit class name" do
         before(:all) { ZendeskAPI::TestResource.has :baz, :class => ZendeskAPI::TestResource }
 
         it "should define a method with the same name" do
-          subject.instance_methods.map(&:to_s).should include("baz")
+          expect(subject.instance_methods.map(&:to_s)).to include("baz")
         end
       end
     end
@@ -104,18 +104,18 @@ describe ZendeskAPI::DataResource do
         before(:each) { stub_json_request(:get, %r{test_resources/\d+}, json(:test_resource => {})) }
 
         it "should attempt to grab the resource from the host" do
-          subject.test_resource.should be_instance_of(ZendeskAPI::TestResource)
+          expect(subject.test_resource).to be_instance_of(ZendeskAPI::TestResource)
         end
 
         it "should pass the path on to the resource" do
-          subject.test_resource.path.should == "test_resources"
+          expect(subject.test_resource.path).to eq("test_resources")
         end
 
         context "with a client error" do
           before(:each) { stub_request(:get, %r{test_resources/\d+}).to_return(:status => 500) }
 
           it "should handle it properly" do
-            expect { silence_logger{ subject.test_resource.should be_nil } }.to_not raise_error
+            expect { silence_logger{ expect(subject.test_resource).to be_nil } }.to_not raise_error
           end
         end
 
@@ -126,7 +126,7 @@ describe ZendeskAPI::DataResource do
           end
 
           it "should call the right path" do
-            subject.test_resource.should be_instance_of(ZendeskAPI::TestResource)
+            expect(subject.test_resource).to be_instance_of(ZendeskAPI::TestResource)
           end
         end
       end
@@ -136,11 +136,11 @@ describe ZendeskAPI::DataResource do
         subject { ZendeskAPI::TestResource.new(client, :test_resource => test_resource).test_resource }
 
         it "should load the correct instance" do
-          subject.should be_instance_of(ZendeskAPI::TestResource)
+          expect(subject).to be_instance_of(ZendeskAPI::TestResource)
         end
 
         it "should load foo from the hash" do
-          subject.message.should == "FOO_OBJ"
+          expect(subject.message).to eq("FOO_OBJ")
         end
       end
 
@@ -155,8 +155,8 @@ describe ZendeskAPI::DataResource do
         end
 
         it "should handle nil response from find api" do
-          ZendeskAPI::TestResource.should_receive(:find).twice.and_return(nil)
-          subject.test_resource.should be_nil
+          expect(ZendeskAPI::TestResource).to receive(:find).twice.and_return(nil)
+          expect(subject.test_resource).to be_nil
           subject.test_resource
         end
       end
@@ -170,14 +170,14 @@ describe ZendeskAPI::DataResource do
       subject { ZendeskAPI::TestResource }
 
       it "should define a method with the same name" do
-        subject.instance_methods.map(&:to_s).should include("test_resources")
+        expect(subject.instance_methods.map(&:to_s)).to include("test_resources")
       end
 
       context "with explicit class name" do
         before(:each) { ZendeskAPI::TestResource.has_many :cats, :class => ZendeskAPI::TestResource }
 
         it "should define a method with the same name" do
-          subject.instance_methods.map(&:to_s).should include("cats")
+          expect(subject.instance_methods.map(&:to_s)).to include("cats")
         end
       end
     end
@@ -187,11 +187,11 @@ describe ZendeskAPI::DataResource do
         subject { ZendeskAPI::TestResource.new(client, :id => 1) }
 
         it "should not attempt to grab the resource from the host" do
-          subject.test_resources.should be_instance_of(ZendeskAPI::Collection)
+          expect(subject.test_resources).to be_instance_of(ZendeskAPI::Collection)
         end
 
         it "should pass the path on to the resource" do
-          subject.test_resources.path.should == "test_resources/1/test_resources"
+          expect(subject.test_resources.path).to eq("test_resources/1/test_resources")
         end
 
         context "with an explicit path set" do
@@ -200,7 +200,7 @@ describe ZendeskAPI::DataResource do
           end
 
           it "should call the right path" do
-            subject.test_resources.path.should == "test_resources/1/blargh"
+            expect(subject.test_resources.path).to eq("test_resources/1/blargh")
           end
         end
       end
@@ -210,11 +210,11 @@ describe ZendeskAPI::DataResource do
         subject { ZendeskAPI::TestResource.new(client, :test_resources => test_resources).test_resources.first }
 
         it "should properly create instance" do
-          subject.message.should == "FOO_OBJ"
+          expect(subject.message).to eq("FOO_OBJ")
         end
 
         it "should map bars onto TestResource class" do
-          subject.should be_instance_of(ZendeskAPI::TestResource)
+          expect(subject).to be_instance_of(ZendeskAPI::TestResource)
         end
       end
 
@@ -223,13 +223,13 @@ describe ZendeskAPI::DataResource do
         subject { ZendeskAPI::TestResource.new(client, :test_resource_ids => test_resource_ids) }
 
         it "should find foo_id and load it from the api" do
-          ZendeskAPI::TestResource.should_receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times
+          expect(ZendeskAPI::TestResource).to receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times
           subject.test_resources
         end
 
         it "should handle nil response from find api" do
-          ZendeskAPI::TestResource.should_receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times.and_return(nil)
-          subject.test_resources.should be_empty
+          expect(ZendeskAPI::TestResource).to receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times.and_return(nil)
+          expect(subject.test_resources).to be_empty
           subject.test_resources # Test expectations
         end
       end

data/spec/core/inflection_spec.rb

@@ -2,6 +2,6 @@ require 'core/spec_helper'
 
 describe String do
   specify "the plural of forum if forums" do
-    Inflection.plural("forum").should == "forums"
+    expect(Inflection.plural("forum")).to eq("forums")
   end
 end

data/spec/core/lru_cache_spec.rb

@@ -4,8 +4,8 @@ describe ZendeskAPI::LRUCache do
   let(:cache){ ZendeskAPI::LRUCache.new(2) }
 
   it "writes and reads" do
-    cache.write("x", 1).should == 1
-    cache.read("x").should == 1
+    expect(cache.write("x", 1)).to eq(1)
+    expect(cache.read("x")).to eq(1)
   end
 
   it "drops" do
@@ -13,14 +13,14 @@ describe ZendeskAPI::LRUCache do
     cache.write("y", 1)
     cache.write("x", 1)
     cache.write("z", 1)
-    cache.read("z").should == 1
-    cache.read("x").should == 1
-    cache.read("y").should == nil
+    expect(cache.read("z")).to eq(1)
+    expect(cache.read("x")).to eq(1)
+    expect(cache.read("y")).to eq(nil)
   end
 
   it "fetches" do
-    cache.fetch("x"){ 1 }.should == 1
-    cache.read("x").should == 1
-    cache.fetch("x"){ 2 }.should == 1
+    expect(cache.fetch("x"){ 1 }).to eq(1)
+    expect(cache.read("x")).to eq(1)
+    expect(cache.fetch("x"){ 2 }).to eq(1)
   end
 end

data/spec/core/middleware/request/encode_json_spec.rb

@@ -11,7 +11,7 @@ describe ZendeskAPI::Middleware::Request::EncodeJson do
     let(:env) {{ :body => nil }}
 
     it 'should not return json' do
-      response[:body].should be_nil
+      expect(response[:body]).to be_nil
     end
   end
 
@@ -19,7 +19,7 @@ describe ZendeskAPI::Middleware::Request::EncodeJson do
     let(:env) {{ :body => '' }}
 
     it 'should not return json' do
-      response[:body].should == ''
+      expect(response[:body]).to eq('')
     end
   end
 
@@ -28,11 +28,11 @@ describe ZendeskAPI::Middleware::Request::EncodeJson do
       let(:env) {{ :body => { :a => :b } }}
 
       it 'encodes json' do
-        response[:body].should == JSON.dump(:a => :b)
+        expect(response[:body]).to eq(JSON.dump(:a => :b))
       end
 
       it 'sets the content type' do
-        response[:request_headers]['Content-Type'].should == 'application/json'
+        expect(response[:request_headers]['Content-Type']).to eq('application/json')
       end
     end
 
@@ -45,11 +45,11 @@ describe ZendeskAPI::Middleware::Request::EncodeJson do
       }}
 
       it 'encodes json' do
-        response[:body].should == JSON.dump(:a => :b)
+        expect(response[:body]).to eq(JSON.dump(:a => :b))
       end
 
       it 'keeps the content type' do
-        response[:request_headers]['Content-Type'].should == 'application/json'
+        expect(response[:request_headers]['Content-Type']).to eq('application/json')
       end
     end
 
@@ -62,11 +62,11 @@ describe ZendeskAPI::Middleware::Request::EncodeJson do
       }}
 
       it 'encodes json' do
-        response[:body].should == JSON.dump(:a => :b)
+        expect(response[:body]).to eq(JSON.dump(:a => :b))
       end
 
       it 'keeps the content type' do
-        response[:request_headers]['Content-Type'].should == 'application/json; encoding=utf-8'
+        expect(response[:request_headers]['Content-Type']).to eq('application/json; encoding=utf-8')
       end
     end
   end

data/spec/core/middleware/request/etag_cache_spec.rb

@@ -6,16 +6,16 @@ describe ZendeskAPI::Middleware::Request::EtagCache do
 
     stub_json_request(:get, %r{blergh}, '{"x":1}', :headers => {"Etag" => "x"})
     first_response = client.connection.get("blergh")
-    first_response.status.should == 200
-    first_response.body.should == {"x"=>1}
+    expect(first_response.status).to eq(200)
+    expect(first_response.body).to eq({"x"=>1})
 
     stub_request(:get, %r{blergh}).to_return(:status => 304, :headers => {"Etag" => "x"})
     response = client.connection.get("blergh")
-    response.status.should == 304
-    response.body.should == {"x"=>1}
+    expect(response.status).to eq(304)
+    expect(response.body).to eq({"x"=>1})
 
     %w{content_encoding content_type content_length etag}.each do |header|
-      response.headers[header].should == first_response.headers[header]
+      expect(response.headers[header]).to eq(first_response.headers[header])
     end
   end
 end

data/spec/core/middleware/request/retry_spec.rb

@@ -13,9 +13,11 @@ describe ZendeskAPI::Middleware::Request::Retry do
         to_return(:status => 429, :headers => { :retry_after => 1 }).
         to_return(:status => 200)
 
-      runtime do
-        client.connection.get("blergh").status.should == 200
-      end.should be_within(0.2).of(1)
+      seconds = runtime {
+        expect(client.connection.get("blergh").status).to eq(200)
+      }
+
+      expect(seconds).to be_within(0.2).of(1)
     end
   end
 
@@ -25,17 +27,17 @@ describe ZendeskAPI::Middleware::Request::Retry do
         to_return(:status => 503).
         to_return(:status => 200)
 
-      ZendeskAPI::Middleware::Request::Retry.any_instance.should_receive(:sleep).exactly(10).times.with(1)
+      expect_any_instance_of(ZendeskAPI::Middleware::Request::Retry).to receive(:sleep).exactly(10).times.with(1)
     end
 
     it "should wait default timeout seconds and then retry request on error" do
-      runtime do
-        client.connection.get("blergh").status.should == 200
-      end.should <= 0.5
+      expect(runtime {
+        expect(client.connection.get("blergh").status).to eq(200)
+      }).to be <= 0.5
     end
 
     it "should print to logger" do
-      client.config.logger.should_receive(:warn).at_least(:once)
+      expect(client.config.logger).to receive(:warn).at_least(:once)
       client.connection.get("blergh")
     end
 

data/spec/core/middleware/request/upload_spec.rb

@@ -7,15 +7,15 @@ describe ZendeskAPI::Middleware::Request::Upload do
   let(:filename) { File.join(File.dirname(__FILE__), "test.jpg") }
 
   it "should handle no body" do
-    subject.call({}).should == {}
+    expect(subject.call({})).to eq({})
   end
 
   it "should handle body with no file" do
-    subject.call(:body => {})[:body].should == {}
+    expect(subject.call(:body => {})[:body]).to eq({})
   end
 
   it "should handle invalid types" do
-    subject.call(:body => { :file => :invalid })[:body].should == {}
+    expect(subject.call(:body => { :file => :invalid })[:body]).to eq({})
   end
 
   context "with file string" do
@@ -24,15 +24,15 @@ describe ZendeskAPI::Middleware::Request::Upload do
     end
 
     it "should convert file string to UploadIO" do
-      @env[:body][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
     end
 
     it "should remove file string" do
-      @env[:body][:file].should be_nil
+      expect(@env[:body][:file]).to be_nil
     end
 
     it "should add filename if none exist" do
-      @env[:body][:filename].should == "test.jpg"
+      expect(@env[:body][:filename]).to eq("test.jpg")
     end
 
     context "with filename" do
@@ -41,7 +41,7 @@ describe ZendeskAPI::Middleware::Request::Upload do
       end
 
       it "should not change filename" do
-        @env[:body][:filename].should_not == "test.jpg"
+        expect(@env[:body][:filename]).to_not eq("test.jpg")
       end
     end
   end
@@ -53,32 +53,32 @@ describe ZendeskAPI::Middleware::Request::Upload do
     end
 
     it "should convert file string to UploadIO" do
-      @env[:body][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
     end
 
     it "should remove file string" do
-      @env[:body][:file].should be_nil
+      expect(@env[:body][:file]).to be_nil
     end
 
     it "should add filename if none exist" do
-      @env[:body][:filename].should == "hello.jpg"
+      expect(@env[:body][:filename]).to eq("hello.jpg")
     end
 
     it "should use the content type of the tempfile" do
-      @env[:body][:uploaded_data].content_type.should == "image/jpeg"
+      expect(@env[:body][:uploaded_data].content_type).to eq("image/jpeg")
     end
 
     context "when path does not resolve a mime_type" do
       it "should pass correct filename to Faraday::UploadIO" do
-        @env[:body][:filename].should == "hello.jpg"
-        @env[:body][:uploaded_data].original_filename.should == @env[:body][:filename]
+        expect(@env[:body][:filename]).to eq("hello.jpg")
+        expect(@env[:body][:uploaded_data].original_filename).to eq(@env[:body][:filename])
       end
 
       it "should use the content_type of ActionDispatch::Http::UploadedFile " do
         @upload.content_type = 'application/random'
 
         env = subject.call(:body => { :file => @upload })
-        env[:body][:uploaded_data].content_type.should == 'application/random'
+        expect(env[:body][:uploaded_data].content_type).to eq('application/random')
       end
     end
   end
@@ -90,15 +90,15 @@ describe ZendeskAPI::Middleware::Request::Upload do
     end
 
     it "should convert file string to UploadIO" do
-      @env[:body][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+      expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
     end
 
     it "should remove file string" do
-      @env[:body][:file].should be_nil
+      expect(@env[:body][:file]).to be_nil
     end
 
     it "should add filename if none exist" do
-      @env[:body][:filename].should == File.basename(@tempfile.path)
+      expect(@env[:body][:filename]).to eq(File.basename(@tempfile.path))
     end
   end
 
@@ -109,15 +109,15 @@ describe ZendeskAPI::Middleware::Request::Upload do
       end
 
       it "should convert file string to UploadIO" do
-        @env[:body][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+        expect(@env[:body][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
       end
 
       it "should remove file string" do
-        @env[:body][:file].should be_nil
+        expect(@env[:body][:file]).to be_nil
       end
 
       it "should add filename if none exist" do
-        @env[:body][:filename].should == "test.jpg"
+        expect(@env[:body][:filename]).to eq("test.jpg")
       end
 
       context "with filename" do
@@ -126,7 +126,7 @@ describe ZendeskAPI::Middleware::Request::Upload do
         end
 
         it "should not change filename" do
-          @env[:body][:filename].should_not == "test.jpg"
+          expect(@env[:body][:filename]).to_not eq("test.jpg")
         end
       end
     end
@@ -138,11 +138,11 @@ describe ZendeskAPI::Middleware::Request::Upload do
         end
 
         it "should convert file string to UploadIO" do
-          @env[:body][:user][:photo][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+          expect(@env[:body][:user][:photo][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
         end
 
         it "should add filename if none exist" do
-          @env[:body][:user][:photo][:filename].should == "test.jpg"
+          expect(@env[:body][:user][:photo][:filename]).to eq("test.jpg")
         end
       end
 
@@ -152,11 +152,11 @@ describe ZendeskAPI::Middleware::Request::Upload do
         end
 
         it "should convert file string to UploadIO" do
-          @env[:body][:user][:photo][:uploaded_data].should be_instance_of(Faraday::UploadIO)
+          expect(@env[:body][:user][:photo][:uploaded_data]).to be_instance_of(Faraday::UploadIO)
         end
 
         it "should not change filename" do
-          @env[:body][:user][:photo][:filename].should_not == "test.jpg"
+          expect(@env[:body][:user][:photo][:filename]).to_not eq("test.jpg")
         end
       end
     end