zendesk2 1.9.0 → 1.10.0

data/spec/organizations_spec.rb

@@ -1,65 +1,64 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "organizations" do
+describe 'organizations' do
   let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.organizations },
-    :create_params => lambda { { name: mock_uuid } },
-    :update_params => lambda { { name: mock_uuid } },
-  }
+  include_examples 'zendesk#resource', collection: -> { client.organizations },
+                                       create_params: -> { { name: mock_uuid } },
+                                       update_params: -> { { name: mock_uuid } }
 
-  describe "with an organization" do
+  describe 'with an organization' do
     let(:organization) { client.organizations.create!(name: mock_uuid) }
 
-    it "should get #users" do
+    it 'should get #users' do
       user = client.users.create!(email: "#{mock_uuid}@example.org", name: mock_uuid, organization: organization)
       expect(organization.users).to include user
     end
 
-    it "should get #tickets" do
+    it 'should get #tickets' do
       user = client.users.create!(email: "#{mock_uuid}@example.org", name: mock_uuid, organization: organization)
       ticket = client.tickets.create!(subject: "#{mock_uuid}@example.org", description: mock_uuid, requester: user)
       expect(organization.tickets).to include ticket
     end
 
-    it "should hate non-unique names" do
+    it 'should hate non-unique names' do
       # create
-      expect {
+      expect do
         client.organizations.create!(name: organization.name)
-      }.to raise_exception(Zendesk2::Error)
+      end.to raise_exception(Zendesk2::Error)
 
       expect(
         client.organizations.create(name: organization.name).errors
-      ).to eq("name" => ["Name: has already been taken"])
+      ).to eq('name' => ['Name: has already been taken'])
 
       expect(
         client.organizations.create(name: organization.name.upcase).errors
-      ).to eq("name" => ["Name: has already been taken"])
+      ).to eq('name' => ['Name: has already been taken'])
 
       # update
       model = client.organizations.create!(name: mock_uuid)
 
       expect(
         model.update(name: organization.name).errors
-      ).to eq("name" => ["Name: has already been taken"])
+      ).to eq('name' => ['Name: has already been taken'])
 
       expect(
         model.update(name: organization.name.upcase).errors
-      ).to eq("name" => ["Name: has already been taken"])
+      ).to eq('name' => ['Name: has already been taken'])
     end
 
-    it "should update name" do
+    it 'should update name' do
       old_name = organization.name
       proxy    = organization.dup
       new_name = mock_uuid
 
-      expect {
+      expect do
         proxy.update!(name: new_name)
-      }.to change { organization.reload.name }.from(old_name).to(new_name)
+      end.to change { organization.reload.name }.from(old_name).to(new_name)
     end
 
-    it "should be able to find organizations by external id" do
+    it 'should be able to find organizations by external id' do
       external_id = organization.external_id = mock_uuid
       organization.save!
 
@@ -68,58 +67,59 @@ describe "organizations" do
   end
 end
 
-describe "#create_organization" do
+describe '#create_organization' do
   let(:client) { create_client }
 
-  it "should prevent duplicate external_ids" do
+  it 'should prevent duplicate external_ids' do
     external_id = mock_uuid
 
-    client.create_organization("organization" => { "name" => mock_uuid, external_id: nil }) # fine
-    client.create_organization("organization" => { "name" => mock_uuid, external_id: nil }) # also fine
-    client.create_organization("organization" => { "name" => mock_uuid, external_id: external_id}) # it's cool
+    client.create_organization('organization' => { 'name' => mock_uuid, external_id: nil }) # fine
+    client.create_organization('organization' => { 'name' => mock_uuid, external_id: nil }) # also fine
+    client.create_organization('organization' => { 'name' => mock_uuid, external_id: external_id }) # it's cool
 
-    expect {
-      client.create_organization("organization" => {"name" => mock_uuid, external_id: external_id})
-    }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+    expect do
+      client.create_organization('organization' => { 'name' => mock_uuid, external_id: external_id })
+    end.to raise_exception(Zendesk2::Error, /External has already been taken/)
   end
 
-  it "should correctly respond" do
-    body = { "organization" => {"name" => (name = mock_uuid)} }
+  it 'should correctly respond' do
+    body = { 'organization' => { 'name' => (name = mock_uuid) } }
 
     response = client.create_organization(body)
 
     expect(response.status).to eq(201)
-    expect(response.env[:url].path).to eq("/api/v2/organizations.json")
+    expect(response.env[:url].path).to eq('/api/v2/organizations.json')
     expect(response.env[:method]).to eq(:post)
     expect(client.last_request).to match(body)
-    expect(response.env[:body]["organization"]).to match(
+    expect(response.env[:body]['organization']).to match(
       a_hash_including(
-        "name" => name,
-      ))
+        'name' => name
+      )
+    )
   end
 end
 
-context "with a organization" do
+context 'with a organization' do
   let(:client)        { create_client }
   let!(:organization) { client.organizations.create!(name: mock_uuid) }
 
-  describe "#destroy_organization" do
-    it "should require a valid organization" do
-      expect {
+  describe '#destroy_organization' do
+    it 'should require a valid organization' do
+      expect do
         client.destroy_organization(
-          "organization" => {
-            "id" => 999999999,
+          'organization' => {
+            'id' => 999_999_999,
           }
         )
-      }.to raise_error(Zendesk2::Error) { |e|
+      end.to raise_error(Zendesk2::Error) { |e|
         expect(e.response[:status]).to eq(404)
       }
     end
 
-    it "should correctly respond" do
+    it 'should correctly respond' do
       response = client.destroy_organization(
-        "organization" => {
-          "id" => organization.id,
+        'organization' => {
+          'id' => organization.id,
         }
       )
 
@@ -131,39 +131,40 @@ context "with a organization" do
     end
   end
 
-  describe "#get_organizations" do
-    it "should correctly respond" do
+  describe '#get_organizations' do
+    it 'should correctly respond' do
       response = client.get_organizations
 
       expect(response.status).to eq(200)
-      expect(response.env[:url].path).to eq("/api/v2/organizations.json")
+      expect(response.env[:url].path).to eq('/api/v2/organizations.json')
       expect(response.env[:method]).to eq(:get)
       expect(client.last_request).to eq(nil)
       skip unless Zendesk2.mocking?
-      expect(response.env[:body]["organizations"]).to match([
-        a_hash_including(
-          "id"   => organization.id,
-        )])
+      expect(response.env[:body]['organizations']).to match([
+                                                              a_hash_including(
+                                                                'id' => organization.id
+                                                              ),
+                                                            ])
     end
   end
 
-  describe "#get_organization" do
-    it "should require a valid organization" do
-      expect {
+  describe '#get_organization' do
+    it 'should require a valid organization' do
+      expect do
         client.get_organization(
-          "organization" => {
-            "id" => 999999999,
+          'organization' => {
+            'id' => 999_999_999,
           }
         )
-      }.to raise_error(Zendesk2::Error) { |e|
+      end.to raise_error(Zendesk2::Error) { |e|
         expect(e.response[:status]).to eq(404)
       }
     end
 
-    it "should correctly respond" do
+    it 'should correctly respond' do
       response = client.get_organization(
-        "organization" => {
-          "id" => organization.id,
+        'organization' => {
+          'id' => organization.id,
         }
       )
 
@@ -171,60 +172,64 @@ context "with a organization" do
       expect(response.env[:url].path).to eq("/api/v2/organizations/#{organization.id}.json")
       expect(response.env[:method]).to eq(:get)
       expect(client.last_request).to eq(nil)
-      expect(response.env[:body]["organization"]).to match(
+      expect(response.env[:body]['organization']).to match(
         a_hash_including(
-          "id"   => organization.id,
-          "url"  => response.env[:url].to_s,
-        ))
+          'id'   => organization.id,
+          'url'  => response.env[:url].to_s
+        )
+      )
     end
   end
 
-  describe "#update_organization" do
-    it "should require a valid organization" do
-      expect {
+  describe '#update_organization' do
+    it 'should require a valid organization' do
+      expect do
         client.update_organization(
-          "organization" => {
-            "id"   => 999999999,
-            "name" => mock_uuid,
+          'organization' => {
+            'id'   => 999_999_999,
+            'name' => mock_uuid,
           }
         )
-      }.to raise_error(Zendesk2::Error) { |e|
+      end.to raise_error(Zendesk2::Error) { |e|
         expect(e.response[:status]).to eq(404)
       }
     end
 
-    it "should prevent duplicate external_ids" do
+    it 'should prevent duplicate external_ids' do
       external_id = mock_uuid
 
       organization         = client.organizations.create!(name: mock_uuid)
       another_organization = client.organizations.create!(name: mock_uuid)
 
-      client.update_organization("organization" => {"id" => organization.id, external_id: nil}) # fine
-      client.update_organization("organization" => {"id" => another_organization.id, external_id: external_id}) # also fine
+      # fine
+      client.update_organization('organization' => { 'id' => organization.id, external_id: nil })
+      # also fine
+      client.update_organization('organization' => { 'id' => another_organization.id, external_id: external_id })
 
-      expect {
-        client.update_organization("organization" => {"id" => organization.id, external_id: external_id})
-      }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+      expect do
+        client.update_organization('organization' => { 'id' => organization.id, external_id: external_id })
+      end.to raise_exception(Zendesk2::Error, /External has already been taken/)
     end
 
-    it "should correctly respond" do
+    it 'should correctly respond' do
       response = client.update_organization(
-        "organization" => {
-          "id"   => organization.id,
-          "name" => (name = mock_uuid),
+        'organization' => {
+          'id'   => organization.id,
+          'name' => (name = mock_uuid),
         }
       )
 
       expect(response.status).to eq(200)
       expect(response.env[:url].path).to eq("/api/v2/organizations/#{organization.id}.json")
       expect(response.env[:method]).to eq(:put)
-      expect(client.last_request).to eq("organization" => {"name" => name})
-      expect(response.env[:body]["organization"]).to match(
+      expect(client.last_request).to eq('organization' => { 'name' => name })
+      expect(response.env[:body]['organization']).to match(
         a_hash_including(
-          "id"   => organization.id,
-          "url"  => response.env[:url].to_s,
-          "name" => name,
-        ))
+          'id'   => organization.id,
+          'url'  => response.env[:url].to_s,
+          'name' => name
+        )
+      )
     end
   end
 end

data/spec/shared/zendesk_resource.rb

@@ -1,51 +1,52 @@
-shared_examples "zendesk#resource" do |options={}|
-  context "as a resource" do
+# frozen_string_literal: true
+shared_examples 'zendesk#resource' do |options = {}|
+  context 'as a resource' do
     let!(:collection)   { instance_exec(&options[:collection]) }
     let(:create_params) { instance_exec(&options[:create_params]) || {} }
     let(:update_params) { instance_exec(&options[:update_params]) }
-    let(:fetch_params)  { options[:fetch_params] || lambda { |r| r.identity } }
+    let(:fetch_params)  { options[:fetch_params] || ->(r) { r.identity } }
     let(:search_params) { options[:search_params] ? instance_exec(&options[:search_params]) : create_params }
 
     let(:record) { @record }
     after(:each) { @record && @record.destroy }
 
-    it "should be created" do
+    it 'should be created' do
       @record = collection.create!(create_params)
       expect(record.identity).not_to be_nil
     end
 
-    it "should be fetched" do
+    it 'should be fetched' do
       @record = collection.create!(create_params)
       expect(collection.get!(fetch_params.call(record))).to eq(record)
     end
 
     if options.fetch(:paged, true)
-      context "paging" do
+      context 'paging' do
         before(:each) do
-          @resources = 3.times.map { collection.create!(instance_exec(&options[:create_params])) }
+          @resources = Array.new(3) { collection.create!(instance_exec(&options[:create_params])) }
         end
 
-        after(:each) { (@resources || []).each { |r| r.destroy } }
+        after(:each) { (@resources || []).each(&:destroy) }
 
-        it "should retrieve first page" do
-          expect(collection.all("per_page" => "1").size).to eq(1)
+        it 'should retrieve first page' do
+          expect(collection.all('per_page' => '1').size).to eq(1)
         end
 
-        it "should retrieve next page" do
-          first_page = collection.all("per_page" => 1)
-          second_page = collection.all("per_page" => 1).next_page
+        it 'should retrieve next page' do
+          first_page = collection.all('per_page' => 1)
+          second_page = collection.all('per_page' => 1).next_page
           expect(second_page).not_to eq(first_page)
         end
 
-        it "should retreive previous page" do
-          first_page = collection.all("per_page" => "1")
-          previous_to_second_page = collection.all("per_page" => 1).next_page.previous_page
+        it 'should retreive previous page' do
+          first_page = collection.all('per_page' => '1')
+          previous_to_second_page = collection.all('per_page' => 1).next_page.previous_page
           expect(previous_to_second_page).to eq(first_page)
         end
       end
     else
-      context "paging" do
-        it "should not be present" do
+      context 'paging' do
+        it 'should not be present' do
           expect(collection.class.attributes).not_to have_key(:next_page_link)
           expect(collection.class.attributes).not_to have_key(:previous_page_link)
           expect(collection.class.attributes).to have_key(:count)
@@ -53,16 +54,30 @@ shared_examples "zendesk#resource" do |options={}|
       end
     end
 
+    context 'index' do
+      let!(:resource) { @resource = collection.create!(instance_exec(&options[:create_params])) }
+
+      after { @resource.destroy if @resource }
+
+      # real index actions sometimes have delays in population
+      it 'lists', mock_only: true do
+        expect(collection.all).to include(resource)
+      end
+    end
+
     if options.fetch(:update, true)
-      it "should be updated" do
+      it 'should be updated' do
         @record = collection.create!(create_params)
-        update_params.each { |k,v| record.send("#{k}=", v) }
+        update_params.each { |k, v| record.send("#{k}=", v) }
         record.save
-        update_params.each {|k,v| expect(record.send(k)).to eq(v)}
+        update_params.each do |k, to|
+          from = record.send(k)
+          expect(from).to eq(to), "Expected #{k} to be updated #{from.inspect} to #{to.inspect}"
+        end
       end
     end
 
-    it "should be destroyed" do
+    it 'should be destroyed' do
       @record = collection.create!(create_params)
       expect(record.identity).not_to be_nil
       record.destroy
@@ -74,14 +89,14 @@ shared_examples "zendesk#resource" do |options={}|
 
     if options.fetch(:search, true) && Zendesk2.mocking?
       # Search index takes 2-3 minutes according to the docs
-      it "should search by hash" do
+      it 'should search by hash' do
         @record = collection.create!(create_params)
         expect(collection.search(search_params).to_a).to eq([record])
       end
 
-      it "should search by string" do
+      it 'should search by string' do
         @record = collection.create!(create_params)
-        expect(collection.search(search_params.map { |k,v| [k,v].join(":") }.join(" ")).to_a).to eq([record])
+        expect(collection.search(search_params.map { |k, v| [k, v].join(':') }.join(' ')).to_a).to eq([record])
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,26 +1,21 @@
+# frozen_string_literal: true
 ENV['MOCK_ZENDESK'] ||= 'true'
 
 Bundler.require(:test)
 
-require File.expand_path("../../lib/zendesk2", __FILE__)
+require File.expand_path('../../lib/zendesk2', __FILE__)
 
-Dir[File.expand_path("../{support,shared}/**/*.rb", __FILE__)].each {|f| require f}
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
 
-if ENV["MOCK_ZENDESK"] == 'true'
-  Zendesk2.mock!
-end
+Zendesk2.mock! if ENV['MOCK_ZENDESK'] == 'true'
 
 Cistern.formatter = Cistern::Formatter::AwesomePrint
-Cistern.deprecation_warnings = !!ENV['DEBUG']
+Cistern.deprecation_warnings = ENV['DEBUG']
 
 RSpec.configure do |config|
-  if Zendesk2.mocking?
-    config.before(:each) { Zendesk2.reset! }
-  else
-    config.filter_run_excluding(mock_only: true)
-  end
-  config.filter_run(:focus => true)
+  Zendesk2.mocking? ? config.before(:each) { Zendesk2.reset! } : config.filter_run_excluding(mock_only: true)
+  config.filter_run(focus: true)
   config.run_all_when_everything_filtered = true
 
-  config.order = "random"
+  config.order = 'random'
 end