zendesk2 1.9.0 → 1.10.0

data/spec/support/client_helper.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 require 'logger'
 
 module ClientHelper
-  def create_client(options={})
-    options.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
+  def create_client(options = {})
+    options[:logger] = Logger.new(STDOUT) if ENV['VERBOSE']
     options = {
-      :username => "zendesk2@example.org",
-      :url      => "https://www.zendesk.com",
+      username: 'zendesk2@example.org',
+      url: 'https://www.zendesk.com',
     }.merge(Zendesk2.defaults).merge(options)
 
     Zendesk2.new(options)

data/spec/support/data_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module DataHelper
   def mock_email
     "zendesk2+#{mock_uuid}@example.org"

data/spec/ticket_fields_spec.rb

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "ticket_fields" do
+describe 'ticket_fields' do
   let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.ticket_fields },
-    :create_params => lambda { { title: mock_uuid, type: "text" } },
-    :update_params => lambda { { title: mock_uuid } },
-    :paged         => false,
-  }
+  include_examples 'zendesk#resource', collection: -> { client.ticket_fields },
+                                       create_params: -> { { title: mock_uuid, type: 'text' } },
+                                       update_params: -> { { title: mock_uuid } },
+                                       paged: false
 end

data/spec/tickets_spec.rb

@@ -1,29 +1,33 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "Zendesk2" do
+describe 'Zendesk2' do
   let(:client) { create_client }
 
-  describe "tickets" do
-    include_examples "zendesk#resource", {
-      :collection    => lambda { client.tickets },
-      :create_params => lambda { {subject: mock_uuid, description: mock_uuid} },
-      :update_params => lambda { {subject: mock_uuid} },
-    }
+  describe 'tickets' do
+    include_examples 'zendesk#resource',
+                     collection: -> { client.tickets },
+                     create_params: -> { { subject: mock_uuid, description: mock_uuid } },
+                     update_params: -> { { subject: mock_uuid } }
   end
 
-  describe "#create_ticket" do
-    it "should require a description" do
-      expect {
-        client.create_ticket("ticket" => {"subject" => mock_uuid})
-      }.to raise_exception(Zendesk2::Error, /Description: cannot be blank/)
+  describe '#create_ticket' do
+    it 'should require a description' do
+      expect do
+        client.create_ticket('ticket' => { 'subject' => mock_uuid })
+      end.to raise_exception(Zendesk2::Error, /Description: cannot be blank/)
     end
   end
 
-  describe "when creating a ticket" do
-    it "should create requester" do
+  describe 'when creating a ticket' do
+    it 'should create requester' do
       requester_email = mock_email
 
-      ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, requester: {name: "Josh Lane", email: requester_email})
+      ticket = client.tickets.create!(
+        subject: mock_uuid,
+        description: mock_uuid,
+        requester: { name: 'Josh Lane', email: requester_email }
+      )
 
       if Zendesk2.mocking? # this takes some time for realsies
         requester = client.users.search(email: requester_email).first
@@ -37,13 +41,13 @@ describe "Zendesk2" do
 
     context 'valid requester exists' do
       it 'sets organization id' do
-        ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, requester_id: 11111111111199)
+        ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, requester_id: 11_111_111_111_199)
 
         expect(ticket.organization_id).to be_nil
       end
     end
 
-    it "should default to the requesters primary organization if organization is not specified" do
+    it 'should default to the requesters primary organization if organization is not specified' do
       organization = client.organizations.create!(name: mock_uuid)
       requester = client.users.create!(email: mock_email, name: mock_uuid, organization: organization)
 
@@ -53,64 +57,65 @@ describe "Zendesk2" do
       expect(organization.tickets).to contain_exactly(ticket)
     end
 
-    it "should require requester name" do
-      expect {
-        client.tickets.create!(subject: mock_uuid, description: mock_uuid, requester: {email: mock_email})
-      }.to raise_exception(Zendesk2::Error, /Requester Name: .* too short/)
+    it 'should require requester name' do
+      expect do
+        client.tickets.create!(subject: mock_uuid, description: mock_uuid, requester: { email: mock_email })
+      end.to raise_exception(Zendesk2::Error, /Requester Name: .* too short/)
     end
 
-    it "should require a description" do
-      expect {
+    it 'should require a description' do
+      expect do
         client.tickets.create!(subject: mock_uuid)
-      }.to raise_exception(ArgumentError, /description is required/)
+      end.to raise_exception(ArgumentError, /description is required/)
 
-      expect {
-        client.tickets.create!(subject: mock_uuid, description: "")
-      }.to raise_exception(ArgumentError, /description is required/)
+      expect do
+        client.tickets.create!(subject: mock_uuid, description: '')
+      end.to raise_exception(ArgumentError, /description is required/)
     end
 
-    it "should set priority" do
-      priority = "urgent"
+    it 'should set priority' do
+      priority = 'urgent'
 
       ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, priority: priority)
 
-      expect(ticket.priority).to eq("urgent")
+      expect(ticket.priority).to eq('urgent')
       expect(client.tickets.get!(ticket.id).priority).to eq(priority)
     end
   end
 
-  describe "with a created ticket" do
+  describe 'with a created ticket' do
     let(:ticket) { client.tickets.create!(subject: mock_uuid, description: mock_uuid) }
 
-    it "should get requester" do
+    it 'should get requester' do
       expect(ticket.requester).to eq(client.users.current)
     end
 
-    it "should get submitter" do
+    it 'should get submitter' do
       expect(ticket.submitter).to eq(client.users.current)
     end
 
-    it "should have empty custom fields by default", mock_only: true do
+    it 'should have empty custom fields by default', mock_only: true do
       expect(ticket.custom_fields).to eq([])
     end
   end
 
-  describe "ticket#comments" do
+  describe 'ticket#comments' do
     let!(:ticket)         { client.tickets.create!(subject: mock_uuid, description: mock_uuid) }
-    let!(:another_ticket) { client.tickets.create!(subject: mock_uuid, description: mock_uuid)  }
+    let!(:another_ticket) { client.tickets.create!(subject: mock_uuid, description: mock_uuid) }
 
-    it "should scope the comments to the source ticket" do
-      target_comments = 2.times.map { ticket.comment(mock_uuid) }
-      2.times.map { another_ticket.comment(mock_uuid) }
+    it 'should scope the comments to the source ticket' do
+      target_comments = Array.new(2) { ticket.comment(mock_uuid) }
+      Array.new(2) { another_ticket.comment(mock_uuid) }
 
-      expect(ticket.comments.all).to include(*target_comments) # @fixme model (subject + description) || (comment) on create_ticket as a comment
+      # @fixme model (subject + description) || (comment) on create_ticket as a comment
+      expect(ticket.comments.all).to include(*target_comments)
     end
   end
 
-  describe "ticket comments" do
+  describe 'ticket comments' do
     let(:ticket) { client.tickets.create!(subject: mock_uuid, description: mock_uuid) }
 
-    it "lists audits" do
+    it 'lists audits' do
       body = mock_uuid
       comment = ticket.comment(body)
       expect(comment.body).to eq(body)
@@ -120,9 +125,7 @@ describe "Zendesk2" do
 
       events = audit.events
 
-      if Zendesk2.mocking?
-        expect(events.size).to eq(1)
-      end
+      expect(events.size).to eq(1) if Zendesk2.mocking?
 
       event = events.first
       expect(event.body).to eq(body)
@@ -130,32 +133,40 @@ describe "Zendesk2" do
       expect(event.ticket_audit).to eq(audit)
     end
 
-    it "lists comments" do
+    it 'lists comments' do
       body = mock_uuid
       ticket.comment(body)
 
-      expect(ticket.comments.find{|c| c.body == body}).not_to be_nil
+      expect(ticket.comments.find { |c| c.body == body }).not_to be_nil
     end
   end
 
-  describe "ticket custom fields" do
-    let!(:ticket_field) { client.ticket_fields.create!(title: SecureRandom.hex(3), type: "text") }
+  describe 'ticket custom fields' do
+    let!(:ticket_field) { client.ticket_fields.create!(title: SecureRandom.hex(3), type: 'text') }
 
-    it "should be based on ticket_fields" do
+    it 'should be based on ticket_fields' do
       ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid)
-      custom_field = ticket.custom_fields.find { |cf| cf["id"].to_s == ticket_field.identity.to_s }
+      custom_field = ticket.custom_fields.find { |cf| cf['id'].to_s == ticket_field.identity.to_s }
 
       expect(custom_field).not_to be_nil
-      expect(custom_field["value"]).to be_nil
+      expect(custom_field['value']).to be_nil
 
-      ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, custom_fields: [{"id" => ticket_field.identity, "value" => "jessicaspacekat"}])
-      custom_field = ticket.custom_fields.find { |cf| cf["id"] == ticket_field.identity }
+      ticket = client.tickets.create!(
+        subject: mock_uuid,
+        description: mock_uuid,
+        custom_fields: [{ 'id' => ticket_field.identity, 'value' => 'jessicaspacekat' }]
+      )
+      custom_field = ticket.custom_fields.find { |cf| cf['id'] == ticket_field.identity }
 
       expect(custom_field).to be
-      expect(custom_field["value"]).to eq("jessicaspacekat")
-
-      ticket = client.tickets.create!(subject: mock_uuid, description: mock_uuid, custom_fields: [{"id" => "-1", "value" => "fantasy"}])
-      expect(ticket.custom_fields).not_to include({"id" => -1, "value" => "fantasy"})
+      expect(custom_field['value']).to eq('jessicaspacekat')
+
+      ticket = client.tickets.create!(
+        subject: mock_uuid,
+        description: mock_uuid,
+        custom_fields: [{ 'id' => '-1', 'value' => 'fantasy' }]
+      )
+      expect(ticket.custom_fields).not_to include('id' => -1, 'value' => 'fantasy')
     end
   end
 end

data/spec/topic_comments_spec.rb

@@ -1,16 +1,15 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "topic_comments" do
+describe 'topic_comments' do
   let!(:client) { create_client }
   let!(:user)   { client.users.create!(email: mock_email, name: mock_uuid, verified: true) }
   let!(:forum)  { client.forums.create!(name: mock_uuid) }
   let!(:topic)  { client.topics.create!(title: mock_uuid, body: mock_uuid, forum: forum) }
 
-  include_examples "zendesk#resource",
-    {
-      :create_params => lambda { { body: mock_uuid, topic_id: topic.identity, user_id: user.identity } },
-      :update        => false,
-      :fetch_params  => lambda { |tc| {"topic_id" => tc.topic_id, "id" => tc.identity} },
-      :collection    => lambda { client.topic_comments(topic_id: topic.identity) },
-    }
+  include_examples 'zendesk#resource',
+                   create_params: -> { { body: mock_uuid, topic_id: topic.identity, user_id: user.identity } },
+                   update: false,
+                   fetch_params: ->(tc) { { 'topic_id' => tc.topic_id, 'id' => tc.identity } },
+                   collection: -> { client.topic_comments(topic_id: topic.identity) }
 end

data/spec/topics_spec.rb

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "topics" do
+describe 'topics' do
   let(:client) { create_client }
   let(:forum)  { client.forums.create(name: mock_uuid) }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.topics },
-    :create_params => lambda { { title: mock_uuid, body: mock_uuid, forum_id: forum.id } },
-    :update_params => lambda { { title: mock_uuid, body: mock_uuid } },
-  }
+  include_examples 'zendesk#resource', collection: -> { client.topics },
+                                       create_params: -> { { title: mock_uuid, body: mock_uuid, forum_id: forum.id } },
+                                       update_params: -> { { title: mock_uuid, body: mock_uuid } }
 end

data/spec/user_fields_spec.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "user_fields" do
+describe 'user_fields' do
   let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.user_fields },
-    :create_params => lambda { { title: mock_uuid, type: "text", key: "custom_#{SecureRandom.hex(3)}"} },
-    :update_params => lambda { { title: mock_uuid } },
-    :paged         => false,
-  }
+  include_examples 'zendesk#resource',
+                   collection: -> { client.user_fields },
+                   create_params: -> { { title: mock_uuid, type: 'text', key: "custom_#{SecureRandom.hex(3)}" } },
+                   update_params: -> { { title: mock_uuid } },
+                   paged: false
 end

data/spec/user_identities_spec.rb

@@ -1,46 +1,50 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "user_identities" do
+describe 'user_identities' do
   let(:client) { create_client }
   let(:user)   { client.users.create(email: mock_email, name: mock_uuid, verified: true) }
 
-  include_examples "zendesk#resource", {
-    :create_params => lambda { { value: "ey+#{mock_uuid}@example.org", type: "email", user_id: user.id } },
-    :update_params => lambda { { verified: true } },
-    :fetch_params  => lambda { |uc| { "user_id" => uc.user_id, "id" => uc.id } },
-    :collection    => lambda { client.user_identities(user_id: user.id) },
-    :paged         => false,
-    :search        => false,
-  }
+  include_examples 'zendesk#resource',
+                   create_params: -> { { value: "ey+#{mock_uuid}@example.org", type: 'email', user_id: user.id } },
+                   update_params: -> { { verified: true } },
+                   fetch_params: ->(uc) { { 'user_id' => uc.user_id, 'id' => uc.id } },
+                   collection: -> { client.user_identities(user_id: user.id) },
+                   paged: false,
+                   search: false
 
-  describe "#create_user_identity" do
+  describe '#create_user_identity' do
     let(:another_user) { client.users.create(email: mock_email, name: mock_uuid, verified: true) }
 
-    it "should prevent duplicate identities across users" do
-      expect {
-        client.create_user_identity("user_identity" => { "type" => "email", "value" => user.email, "user_id" => another_user.id })
-      }.to raise_exception(Zendesk2::Error, /is already being used by another user/)
+    it 'should prevent duplicate identities across users' do
+      expect do
+        client.create_user_identity(
+          'user_identity' => { 'type' => 'email', 'value' => user.email, 'user_id' => another_user.id }
+        )
+      end.to raise_exception(Zendesk2::Error, /is already being used by another user/)
     end
 
-    it "should prevent duplicate identities on the same user" do
-      expect {
-        client.create_user_identity("user_identity" => { "type" => "email", "value" => user.email, "user_id" => user.id })
-      }.to raise_exception(Zendesk2::Error, /is already being used by another user/)
+    it 'should prevent duplicate identities on the same user' do
+      expect do
+        client.create_user_identity(
+          'user_identity' => { 'type' => 'email', 'value' => user.email, 'user_id' => user.id }
+        )
+      end.to raise_exception(Zendesk2::Error, /is already being used by another user/)
     end
 
-    it "should be allowed if the user is deleted" do
+    it 'should be allowed if the user is deleted' do
       email = user.email
       user.destroy
 
-      expect {
+      expect do
         client.create_user_identity(
-          "user_identity" => {
-            "type"    => "email",
-            "value"   => email,
-            "user_id" => another_user.id,
+          'user_identity' => {
+            'type'    => 'email',
+            'value'   => email,
+            'user_id' => another_user.id,
           }
         )
-      }.to change { another_user.identities.all.count }.by(1)
+      end.to change { another_user.identities.all.count }.by(1)
     end
   end
 end

data/spec/users_spec.rb

@@ -1,51 +1,51 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "users" do
+describe 'users' do
   let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.users },
-    :create_params => lambda { { email: mock_email, name: mock_uuid, verified: true } },
-    :update_params => lambda { { name: mock_uuid } },
-  }
+  include_examples 'zendesk#resource',
+                   collection: -> { client.users },
+                   create_params: -> { { email: mock_email, name: mock_uuid, verified: true } },
+                   update_params: -> { { name: mock_uuid } }
 
-  it "should get current user" do
+  it 'should get current user' do
     current_user = client.users.current
     expect(current_user.email).to eq(client.username)
   end
 
-  describe "#create_user" do
-    it "should prevent duplicate external_ids" do
+  describe '#create_user' do
+    it 'should prevent duplicate external_ids' do
       external_id = mock_uuid
 
-      client.create_user("user" => {:email => mock_email, :name => "a", :external_id => nil})         # fine
-      client.create_user("user" => {:email => mock_email, :name => "b", :external_id => nil})         # also fine
-      client.create_user("user" => {:email => mock_email, :name => "c", :external_id => external_id}) # it's cool
+      client.create_user('user' => { email: mock_email, name: 'a', external_id: nil })         # fine
+      client.create_user('user' => { email: mock_email, name: 'b', external_id: nil })         # also fine
+      client.create_user('user' => { email: mock_email, name: 'c', external_id: external_id }) # it's cool
 
-      expect {
-        client.create_user("user" => {:email => mock_email, :name => "d", :external_id => external_id})
-      }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+      expect do
+        client.create_user('user' => { email: mock_email, name: 'd', external_id: external_id })
+      end.to raise_exception(Zendesk2::Error, /External has already been taken/)
     end
   end
 
-  describe "#update_user" do
-    it "should prevent duplicate external_ids" do
-      user         = client.users.create(email: mock_email, name: "a")
-      another_user = client.users.create(email: mock_email, name: "b")
+  describe '#update_user' do
+    it 'should prevent duplicate external_ids' do
+      user         = client.users.create(email: mock_email, name: 'a')
+      another_user = client.users.create(email: mock_email, name: 'b')
 
       external_id = mock_uuid
 
-      client.update_user("user" => {"id" => user.id,         "external_id" => nil})         # fine
-      client.update_user("user" => {"id" => another_user.id, "external_id" => external_id}) # also fine
+      client.update_user('user' => { 'id' => user.id,         'external_id' => nil })         # fine
+      client.update_user('user' => { 'id' => another_user.id, 'external_id' => external_id }) # also fine
 
-      expect {
-        client.update_user("user" => {"id" => user.id, "external_id" => external_id})
-      }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+      expect do
+        client.update_user('user' => { 'id' => user.id, 'external_id' => external_id })
+      end.to raise_exception(Zendesk2::Error, /External has already been taken/)
     end
   end
 
-  describe "#search", :mock_only do
-    it "should find a user based on details criteria with wildcards and by organization name" do
+  describe '#search', :mock_only do
+    it 'should find a user based on details criteria with wildcards and by organization name' do
       # detached user
       client.users.create!(email: mock_email, name: mock_uuid)
 
@@ -54,19 +54,24 @@ describe "users" do
       client.users.create!(email: mock_email, name: mock_uuid, organization: bad_org)
 
       org = client.organizations.create!(name: mock_uuid)
-      user = client.users.create!(email: mock_email, name: mock_uuid, organization: org, details: "anything_hello-something-michelle")
+      user = client.users.create!(
+        email: mock_email,
+        name: mock_uuid,
+        organization: org,
+        details: 'anything_hello-something-michelle'
+      )
 
-      expect(client.users.search(details: "*michelle*", organization: org.name)).to contain_exactly(user)
-      expect(client.users.search(details: "*michelle*", organization: org.name[0..6])).to include(user)
+      expect(client.users.search(details: '*michelle*', organization: org.name)).to contain_exactly(user)
+      expect(client.users.search(details: '*michelle*', organization: org.name[0..6])).to include(user)
     end
 
-    context "when a user has multiple identities and searching by email" do
-      it "should display the primary email in the results" do
+    context 'when a user has multiple identities and searching by email' do
+      it 'should display the primary email in the results' do
         user = client.users.create!(email: (primary = mock_email), name: mock_uuid)
 
         # create some extra identities
-        user.identities.create!(value: mock_email, type: "email")
-        user.identities.create!(value: (target = mock_email), type: "email")
+        user.identities.create!(value: mock_email, type: 'email')
+        user.identities.create!(value: (target = mock_email), type: 'email')
 
         # primary email should be returned in the results
         expect(client.users.search(email: target).first.email).to eq(primary)
@@ -74,11 +79,11 @@ describe "users" do
     end
   end
 
-  context "with a user" do
+  context 'with a user' do
     let!(:user) { client.users.create!(email: mock_email, name: mock_uuid) }
 
-    describe "#save" do
-      it "should update organization" do
+    describe '#save' do
+      it 'should update organization' do
         user.organization = organization = client.organizations.create!(name: mock_uuid)
 
         user.save!
@@ -87,27 +92,27 @@ describe "users" do
       end
     end
 
-    it "should get requested tickets" do
+    it 'should get requested tickets' do
       another_user = client.users.create!(email: mock_email, name: mock_uuid)
 
-      2.times.each {
+      2.times.each do
         another_user.tickets.create!(collaborators: [user], subject: mock_uuid, description: mock_uuid)
-      }
+      end
 
-      targets = 2.times.map {
+      targets = Array.new(2) do
         user.tickets.create!(requester: user, subject: mock_uuid, description: mock_uuid)
-      }
+      end
 
       expect(user.requested_tickets.all(per_page: 1).all_entries).to match_array(targets)
     end
 
-    it "should get ccd tickets", mock_only: true do
+    it 'should get ccd tickets', mock_only: true do
       ticket = client.tickets.create!(collaborators: [user], subject: mock_uuid, description: mock_uuid)
 
       expect(user.ccd_tickets).to contain_exactly(ticket)
     end
 
-    it "cannot destroy a user with a ticket" do
+    it 'cannot destroy a user with a ticket' do
       client.tickets.create!(requester: user, subject: mock_uuid, description: mock_uuid)
 
       expect(user.destroy).to be_falsey
@@ -115,39 +120,39 @@ describe "users" do
       expect(user).not_to be_destroyed
     end
 
-    it "should list identities" do
+    it 'should list identities' do
       identities = user.identities.all
       expect(identities.size).to eq(1)
 
       identity = identities.first
       expect(identity.primary).to be_truthy
       expect(identity.verified).to be_falsey
-      expect(identity.type).to eq("email")
+      expect(identity.type).to eq('email')
       expect(identity.value).to eq(user.email)
     end
 
-    it "should create a new identity" do
+    it 'should create a new identity' do
       email = "ey+#{mock_uuid}@example.org"
 
-      new_identity = user.identities.create!(type: "email", value: email)
+      new_identity = user.identities.create!(type: 'email', value: email)
 
       expect(new_identity.primary).to be_falsey
       expect(new_identity.verified).to be_falsey
-      expect(new_identity.type).to eq("email")
+      expect(new_identity.type).to eq('email')
       expect(new_identity.value).to eq(email)
     end
 
-    it "should mark remaining identity as primary" do
+    it 'should mark remaining identity as primary' do
       email = "ey+#{mock_uuid}@example.org"
 
       initial_identity = user.identities.all.first
-      new_identity     = user.identities.create!(type: "email", value: email)
+      new_identity     = user.identities.create!(type: 'email', value: email)
 
-      expect {
+      expect do
         initial_identity.destroy
-      }.to change { user.identities.all }.
-      from(a_collection_containing_exactly(initial_identity, new_identity)).
-      to(a_collection_containing_exactly(new_identity))
+      end.to change { user.identities.all }
+        .from(a_collection_containing_exactly(initial_identity, new_identity))
+        .to(a_collection_containing_exactly(new_identity))
 
       expect(new_identity.reload.primary).to be_falsey
 
@@ -156,11 +161,11 @@ describe "users" do
       expect(new_identity.reload.primary).to be_truthy
     end
 
-    it "should not allow multiple primary identities" do
+    it 'should not allow multiple primary identities' do
       email = "ey+#{mock_uuid}@example.org"
 
       initial_identity = user.identities.all.first
-      new_identity     = user.identities.create!(type: "email", value: email)
+      new_identity     = user.identities.create!(type: 'email', value: email)
       new_identity.primary!
       expect(new_identity.primary).to be_truthy
       expect(new_identity.reload.primary).to be_truthy
@@ -168,15 +173,15 @@ describe "users" do
       expect(initial_identity.reload.primary).to be_falsey
     end
 
-    it "persists #user_fields" do
-      user_fields = { "A" => 1 }
+    it 'persists #user_fields' do
+      user_fields = { 'A' => 1 }
 
       fields_user = client.users.create!(email: mock_email, name: mock_uuid, user_fields: user_fields)
       expect(fields_user.user_fields).to eq(user_fields)
       expect(fields_user.reload.user_fields).to eq(user_fields)
     end
 
-    it "should hate non-unique emails" do
+    it 'should hate non-unique emails' do
       email = mock_email
       client.users.create!(email: email, name: mock_uuid)
       expect { client.users.create!(email: email, name: mock_uuid) }.to raise_exception(Zendesk2::Error)
@@ -184,16 +189,16 @@ describe "users" do
       user = client.users.create(email: email, name: mock_uuid)
 
       expect(user.identity).to eq(nil)
-      expect(user.errors).to eq({"email" => ["Email: #{email} is already being used by another user"]})
+      expect(user.errors).to eq('email' => ["Email: #{email} is already being used by another user"])
     end
 
-    it "should create another identity when updating email" do
+    it 'should create another identity when updating email' do
       original_email = user.email
       user.email = (new_email = mock_email)
 
-      expect {
+      expect do
         user.save!
-      }.to change { user.identities.size }.from(1).to(2)
+      end.to change { user.identities.size }.from(1).to(2)
 
       new_identity = user.identities.find { |i| i.value == new_email }
 
@@ -206,32 +211,37 @@ describe "users" do
       expect(original_identity.primary).to eq(true)
       expect(user.reload.email).to eq(original_email)
 
-      expect {
+      expect do
         user.save!
-      }.not_to change { user.identities.size }
+      end.not_to change { user.identities.size }
     end
 
     it "should form 'legacy' login url" do
-      return_to = "http://engineyard.com"
-      login_uri = user.login_url(Time.now.to_s, return_to: return_to, token: "in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)")
+      return_to = 'http://engineyard.com'
+      login_uri = user.login_url(Time.now.to_s,
+                                 return_to: return_to,
+                                 token: 'in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)')
       query = Faraday::NestedParamsEncoder.decode(URI.parse(login_uri).query)
 
-      expect(query["return_to"]).to eq(return_to)
-      expect(query["name"]).to eq user.name
-      expect(query["email"]).to eq user.email
-      expect(query["hash"]).not_to be_nil
+      expect(query['return_to']).to eq(return_to)
+      expect(query['name']).to eq user.name
+      expect(query['email']).to eq user.email
+      expect(query['hash']).not_to be_nil
     end
 
-    it "should form jwt login url" do
-      return_to = "http://engineyard.com"
+    it 'should form jwt login url' do
+      return_to = 'http://engineyard.com'
 
-      jwt_login_uri = user.jwt_login_url(return_to: return_to, jwt_token: "in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)")
+      jwt_login_uri = user.jwt_login_url(
+        return_to: return_to,
+        jwt_token: 'in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)'
+      )
       query = Faraday::NestedParamsEncoder.decode(URI.parse(jwt_login_uri).query)
 
-      expect(query["return_to"]).to eq(return_to)
-      expect(query["name"]).to be_nil
-      expect(query["email"]).to be_nil
-      expect(query["jwt"]).not_to be_nil
+      expect(query['return_to']).to eq(return_to)
+      expect(query['name']).to be_nil
+      expect(query['email']).to be_nil
+      expect(query['jwt']).not_to be_nil
     end
   end
 end