zendesk_api 1.3.9 → 1.4.0

data/spec/core/search_spec.rb

@@ -4,19 +4,19 @@ describe ZendeskAPI::Search do
   context ".new" do
     context "when given an existing class" do
       it "should return the correct class" do
-        ZendeskAPI::Search.new(nil, { "result_type" => "user" }).should be_instance_of(ZendeskAPI::User)
+        expect(ZendeskAPI::Search.new(nil, { "result_type" => "user" })).to be_instance_of(ZendeskAPI::User)
       end
     end
 
     context "when given a nonexistent class" do
       it "should return an object of the type Search::Result" do
-        ZendeskAPI::Search.new(nil, { "result_type" => "blah" }).should be_instance_of(ZendeskAPI::Search::Result)
+        expect(ZendeskAPI::Search.new(nil, { "result_type" => "blah" })).to be_instance_of(ZendeskAPI::Search::Result)
       end
     end
 
     context "when not given anything" do
       it "should return an object of the type Search::Result" do
-        ZendeskAPI::Search.new(nil, {}).should be_instance_of(ZendeskAPI::Search::Result)
+        expect(ZendeskAPI::Search.new(nil, {})).to be_instance_of(ZendeskAPI::Search::Result)
       end
     end
   end

data/spec/core/spec_helper.rb

@@ -15,6 +15,11 @@ require 'logger'
 require 'stringio'
 require 'multi_json'
 
+begin
+  require 'byebug'
+rescue LoadError
+end
+
 class String
   def encoding_aware?; false; end
 end
@@ -120,10 +125,6 @@ module TestHelper
 end
 
 RSpec.configure do |c|
-  # so we can use `:vcr` rather than `:vcr => true`;
-  # in RSpec 3 this will no longer be necessary.
-  c.treat_symbols_as_metadata_keys_with_true_values = true
-
   c.before(:each) do
     ZendeskAPI::TestResource.associations.clear
     ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild

data/spec/core/trackie_spec.rb

@@ -5,19 +5,19 @@ describe ZendeskAPI::Trackie do
   before(:each) { subject.clear_changes }
 
   it "should not be changed" do
-    subject.changed?.should be_false
+    expect(subject.changed?).to be(false)
   end
 
   context "adding keys" do
     before(:each) { subject[:key] = true }
 
     it "should include key in changes" do
-      subject.changes[:key].should be_true
+      expect(subject.changes[:key]).to be(true)
     end
 
     specify "key should be changed" do
-      subject.changed?(:key).should be_true
-      subject.changed?.should be_true
+      expect(subject.changed?(:key)).to be(true)
+      expect(subject.changed?).to be(true)
     end
   end
 
@@ -27,14 +27,14 @@ describe ZendeskAPI::Trackie do
     end
 
     it "returns key on deletion" do
-      subject.delete(:key).should be_true
+      expect(subject.delete(:key)).to be(true)
     end
 
     context "after deletion" do
       before(:each) { subject.delete(:key) }
 
       it "keeps the changes" do
-        subject.changed?(:key).should be_true
+        expect(subject.changed?(:key)).to be(true)
       end
     end
   end
@@ -48,12 +48,12 @@ describe ZendeskAPI::Trackie do
     end
 
     it "should not include key in changes" do
-      subject.changes[:key].should be_false
+      expect(subject.changes[:key]).to be_falsey
     end
 
     specify "key should not be changed" do
-      subject.changed?(:key).should be_false
-      subject.changed?.should be_false
+      expect(subject.changed?(:key)).to be(false)
+      expect(subject.changed?).to be(false)
     end
   end
 
@@ -65,11 +65,11 @@ describe ZendeskAPI::Trackie do
     end
 
     it "should include changes from nested hash" do
-      subject.changes[:key][:test].should be_true
+      expect(subject.changes[:key][:test]).to be(true)
     end
 
     specify "subject should be changed" do
-      subject.changed?.should be_true
+      expect(subject.changed?).to be(true)
     end
   end
 
@@ -82,11 +82,11 @@ describe ZendeskAPI::Trackie do
     end
 
     it "should include changes from nested array" do
-      subject.changes[:key].should == [:test]
+      expect(subject.changes[:key]).to eq([:test])
     end
 
     specify "subject should be changed" do
-      subject.changed?.should be_true
+      expect(subject.changed?).to be(true)
     end
   end
 =end
@@ -99,11 +99,11 @@ describe ZendeskAPI::Trackie do
     end
 
     it "should include changes from nested array" do
-      subject.changes[:key].first[:test].should be_true
+      expect(subject.changes[:key].first[:test]).to be(true)
     end
 
     specify "subject should be changed" do
-      subject.changed?.should be_true
+      expect(subject.changed?).to be(true)
     end
 
     context "clearing" do
@@ -112,7 +112,7 @@ describe ZendeskAPI::Trackie do
       end
 
       it "should not have any changes" do
-        subject.changes.should be_empty
+        expect(subject.changes).to be_empty
       end
     end
   end
@@ -123,7 +123,7 @@ describe ZendeskAPI::Trackie do
     end
 
     it "returns the value corresponding to the :size key" do
-      subject.size.should == 42
+      expect(subject.size).to eq(42)
     end
   end
 end

data/spec/live/app_installation_spec.rb

@@ -44,12 +44,12 @@ describe ZendeskAPI::AppInstallation do
     VCR.use_cassette("app_install_fetch") { installations.fetch! }
     VCR.use_cassette("app_install_find") { client.app.installations.find!(:id => install.id) }
 
-    installations.should include(install)
+    expect(installations).to include(install)
 
     install.settings.name = "My New Name"
     VCR.use_cassette("app_install_update") { install.save! }
 
-    install.settings.title.should == "My New Name"
+    expect(install.settings.title).to eq("My New Name")
 
     VCR.use_cassette("app_install_destroy") { install.destroy! }
 

data/spec/live/app_spec.rb

@@ -20,7 +20,7 @@ describe ZendeskAPI::App do
 
     VCR.use_cassette("app_save") { app.save! }
 
-    app.author_name.should == "Mr. Sprinkles"
+    expect(app.author_name).to eq("Mr. Sprinkles")
 
     VCR.use_cassette("app_find") { client.apps.find!(:id => app.id) }
     VCR.use_cassette("app_destroy") { app.destroy! }

data/spec/live/audit_spec.rb

@@ -8,8 +8,8 @@ describe ZendeskAPI::Ticket::Audit do
       audit = ticket.audits(include: :users).first
       event = audit.events.first
 
-      event.should be_instance_of(ZendeskAPI::Ticket::Audit::Event)
-      event.author.should be_instance_of(ZendeskAPI::User)
+      expect(event).to be_instance_of(ZendeskAPI::Ticket::Audit::Event)
+      expect(event.author).to be_instance_of(ZendeskAPI::User)
     end
   end
 end

data/spec/live/collection_spec.rb

@@ -24,16 +24,16 @@ describe ZendeskAPI::Collection do
         current = subject.to_a.dup
         nxt = subject.next
 
-        nxt.size.should == 1
-        nxt.should_not == current
+        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
 
-        prev.size.should == 1
-        prev.should_not == current
+        expect(prev.size).to eq(1)
+        expect(prev).to_not eq(current)
       end
     end
 
@@ -41,22 +41,22 @@ describe ZendeskAPI::Collection do
       before(:each) { subject.per_page(1).page(2) }
 
       it "should increase page option and not call fetch" do
-        subject.next.should == 3
+        expect(subject.next).to eq(3)
       end
 
       it "should decrease page option and not call fetch" do
-        subject.prev.should == 1
+        expect(subject.prev).to eq(1)
       end
 
       context "with page == 1" do
         before do
           subject.page(1)
           subject.clear_cache
-          subject.should_not_receive(:fetch)
+          expect(subject).to_not receive(:fetch)
         end
 
         it "should do nothing on #prev" do
-          subject.prev.should == []
+          expect(subject.prev).to eq([])
         end
       end
     end

data/spec/live/locale_spec.rb

@@ -2,7 +2,7 @@ require 'core/spec_helper'
 
 describe ZendeskAPI::Locale, :vcr do
   specify "client#current_locale" do
-    client.current_locale.should be_instance_of(described_class)
+    expect(client.current_locale).to be_instance_of(described_class)
   end
 
   it_should_be_readable :locales

data/spec/live/macro_spec.rb

@@ -28,15 +28,15 @@ describe ZendeskAPI::Macro, :delete_after do
     describe "to a ticket" do
       it "should return a hash" do
         result = subject.apply(ticket)
-        result.should be_instance_of(Hashie::Mash)
-        result.ticket.should_not be_nil
+        expect(result).to be_instance_of(Hashie::Mash)
+        expect(result.ticket).to_not be_nil
       end
     end
 
     it "should be appliable" do
       result = subject.apply
-      result.should be_instance_of(Hashie::Mash)
-      result.ticket.should_not be_nil
+      expect(result).to be_instance_of(Hashie::Mash)
+      expect(result.ticket).to_not be_nil
     end
   end
 end

data/spec/live/setting_spec.rb

@@ -18,7 +18,7 @@ describe ZendeskAPI::Setting do
         settings.fetch!(true)
 
         lotus = settings.detect {|set| set.on == "lotus"}
-        lotus.keyboard_shortcuts_enabled.should == !original_setting
+        expect(lotus.keyboard_shortcuts_enabled).to eq(!original_setting)
       end
     end
   end

data/spec/live/tag_spec.rb

@@ -11,45 +11,45 @@ describe ZendeskAPI::Tag, :vcr, :not_findable do
       end
 
       it "can be set" do
-        tags.should == %w{tag2 tag3}
+        expect(tags).to eq(%w{tag2 tag3})
       end
 
       it "should be removable" do
         parent.tags.destroy!(:id => "tag2")
 
-        tags.should == %w{tag3}
+        expect(tags).to eq(%w{tag3})
       end
 
       it "shouldn't re-save destroyed tags" do
         parent.tags.first.destroy!
         parent.tags.save!
 
-        tags.should == %w{tag3}
+        expect(tags).to eq(%w{tag3})
       end
 
       it "should be updatable" do
         parent.tags.update!(:id => "tag4")
 
-        tags.should == %w{tag2 tag3 tag4}
+        expect(tags).to eq(%w{tag2 tag3 tag4})
       end
 
       it "should be savable" do
         parent.tags << "tag4"
         parent.tags.save!
 
-        tags.should == %w{tag2 tag3 tag4}
+        expect(tags).to eq(%w{tag2 tag3 tag4})
       end
 
       it "should be modifiable" do
         parent.tags.delete(ZendeskAPI::Tag.new(nil, :id => "tag2"))
         parent.tags.save!
 
-        tags.should == %w{tag3}
+        expect(tags).to eq(%w{tag3})
 
         parent.tags.delete_if {|tag| tag.id == "tag3"}
         parent.tags.save!
 
-        tags.should be_empty
+        expect(tags).to be_empty
       end
     end
   end

data/spec/live/ticket_spec.rb

@@ -52,7 +52,7 @@ describe ZendeskAPI::Ticket do
     end
 
     it "finds tickets after a old date" do
-      results.to_a.first.should be_an_instance_of ZendeskAPI::Ticket
+      expect(results.to_a.first).to be_an_instance_of ZendeskAPI::Ticket
     end
 
     it "is able to do next" do
@@ -60,7 +60,7 @@ describe ZendeskAPI::Ticket do
       stub_json_request(:get, %r{/api/v2/exports/tickets}, json(:results => []))
 
       results.next
-      results.first.should_not == first
+      expect(results.first).to_not eq(first)
     end
   end
 
@@ -69,13 +69,13 @@ describe ZendeskAPI::Ticket do
       VCR.use_cassette("ticket_import_can_import") do
         old = Time.now - 5*365*24*60*60
         ticket = ZendeskAPI::Ticket.import(client, valid_attributes.merge(:created_at => old))
-        ZendeskAPI::Ticket.find(client, ticket).created_at.year.should == old.year
+        expect(ZendeskAPI::Ticket.find(client, ticket).created_at.year).to eq(old.year)
       end
     end
 
     it "returns nothing if import fails" do
       VCR.use_cassette("ticket_import_cannot_import") do
-        silence_logger { ZendeskAPI::Ticket.import(client, {}).should == nil }
+        silence_logger { expect(ZendeskAPI::Ticket.import(client, {})).to eq(nil) }
       end
     end
   end
@@ -87,8 +87,8 @@ describe ZendeskAPI::Ticket do
       ticket.comment.uploads << File.new("spec/fixtures/Argentina.gif")
 
       ticket.save!
-      ticket.changes.should == {} # uploads were set before save
-      ticket.comment.attributes[:uploads].map(&:class).should == [String, String] # upload was sent as tokens
+      expect(ticket.changes).to eq({}) # uploads were set before save
+      expect(ticket.comment.attributes[:uploads].map(&:class)).to eq([String, String]) # upload was sent as tokens
     end
   end
 
@@ -98,8 +98,8 @@ describe ZendeskAPI::Ticket do
       ticket.comment = ZendeskAPI::Ticket::Comment.new(client, :value => "My comment", :public => false)
       ticket.save!
 
-      ticket.changes.should == {} # comment was set before save
-      ticket.attributes[:comment].should == {"value" => "My comment", "public" => false}
+      expect(ticket.changes).to eq({}) # comment was set before save
+      expect(ticket.attributes[:comment]).to eq({"value" => "My comment", "public" => false})
     end
   end
 
@@ -127,12 +127,12 @@ describe ZendeskAPI::Ticket do
         end
 
         user = client.users.detect {|user| user.email == email}
-        user.should_not be_nil
+        expect(user).to_not be_nil
 
         user.requested_tickets.each(&:destroy)
         user.destroy
 
-        threads.all? {|st| [201, 422, 409].include?(st)}.should be_true
+        expect(threads.all? {|st| [201, 422, 409].include?(st)}).to be(true)
       end
     end
   end

data/spec/live/topic_comment_spec.rb

@@ -17,13 +17,13 @@ describe ZendeskAPI::Topic::TopicComment do
       VCR.use_cassette("topic_comment_import_can_import") do
         old = Time.now - 4*365*24*60*60
         comment = ZendeskAPI::Topic::TopicComment.import(client, valid_attributes.merge(:created_at => old, :topic_id => topic.id))
-        ZendeskAPI::Topic::TopicComment.find(client, comment).created_at.year.should == old.year
+        expect(ZendeskAPI::Topic::TopicComment.find(client, comment).created_at.year).to eq(old.year)
       end
     end
 
     it "returns nothing if import fails" do
       VCR.use_cassette("topic_comment_import_cannot_import") do
-        silence_logger { ZendeskAPI::Topic::TopicComment.import(client, {}).should == nil }
+        silence_logger { expect(ZendeskAPI::Topic::TopicComment.import(client, {})).to eq(nil) }
       end
     end
   end

data/spec/live/topic_spec.rb

@@ -21,13 +21,13 @@ describe ZendeskAPI::Topic do
       VCR.use_cassette("topic_import_can_import") do
         old = Time.now - 5*365*24*60*60
         topic = ZendeskAPI::Topic.import(client, valid_attributes.merge(:created_at => old))
-        ZendeskAPI::Topic.find(client, topic).created_at.year.should == old.year
+        expect(ZendeskAPI::Topic.find(client, topic).created_at.year).to eq(old.year)
       end
     end
 
     it "returns nothing if import fails" do
       VCR.use_cassette("topic_import_cannot_import") do
-        silence_logger { ZendeskAPI::Topic.import(client, {}).should == nil }
+        silence_logger { expect(ZendeskAPI::Topic.import(client, {})).to eq(nil) }
       end
     end
   end

data/spec/live/user_spec.rb

@@ -13,7 +13,7 @@ describe ZendeskAPI::User, :delete_after do
 
   it "should be able to find by email" do
     VCR.use_cassette("user_find_by_email") do
-      client.users.search(:query => current_user.email).to_a.should == [current_user]
+      expect(client.users.search(:query => current_user.email).to_a).to eq([current_user])
     end
   end
 
@@ -37,13 +37,13 @@ describe ZendeskAPI::User, :delete_after do
 
       it "should include role" do
         if subject
-          subject.changes.key?(:role_id).should be_false
-          subject.role.should_not be_nil
-          subject.role.id.should be_nil
-          subject.role.name.should == "admin"
-          subject.role.configuration.should_not be_nil
+          expect(subject.changes.key?(:role_id)).to be(false)
+          expect(subject.role).to_not be_nil
+          expect(subject.role.id).to be_nil
+          expect(subject.role.name).to eq("admin")
+          expect(subject.role.configuration).to_not be_nil
 
-          subject.custom_role.should be_nil
+          expect(subject.custom_role).to be_nil
         end
       end
     end
@@ -55,15 +55,15 @@ describe ZendeskAPI::User, :delete_after do
 
       it "should include role" do
         if subject
-          subject.changes.key?(:role_id).should be_false
-          subject.role.should_not be_nil
-          subject.role.id.should be_nil
-          subject.role.name.should == "agent"
+          expect(subject.changes.key?(:role_id)).to be(false)
+          expect(subject.role).to_not be_nil
+          expect(subject.role.id).to be_nil
+          expect(subject.role.name).to eq("agent")
 
-          subject.custom_role.should_not be_nil
-          subject.custom_role.id.should == 3692
-          subject.custom_role.name.should == "Staff"
-          subject.custom_role.configuration.should_not be_nil
+          expect(subject.custom_role).to_not be_nil
+          expect(subject.custom_role.id).to eq(3692)
+          expect(subject.custom_role.name).to eq("Staff")
+          expect(subject.custom_role.configuration).to_not be_nil
         end
       end
     end