zendesk2 1.9.0 → 1.10.0

data/spec/groups_spec.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "groups" do
+describe 'groups' do
   let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.groups },
-    :create_params => lambda { { name: mock_uuid } },
-    :update_params => lambda { { name: mock_uuid } },
-  }
+  include_examples 'zendesk#resource', collection: -> { client.groups },
+                                       create_params: -> { { name: mock_uuid } },
+                                       update_params: -> { { name: mock_uuid } }
 
-  it "should list assignable groups" do
+  it 'should list assignable groups' do
     client.groups.create(name: mock_uuid) # assignable by default
 
-    expect(client.groups.assignable).to be_all{|g| !g.deleted}
+    expect(client.groups.assignable).to be_all { |g| !g.deleted }
   end
 end

data/spec/help_center/articles_spec.rb

@@ -1,40 +1,36 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "help_center/articles" do
+describe 'help_center/articles' do
   let(:client)   { create_client }
   let!(:section) do
     category = client.help_center_categories.create!(name: mock_uuid,
-                                                     locale: "en-us",
-                                                    )
-    client.help_center_sections.create!(:name     => mock_uuid,
-                                        :locale   => "en-us",
-                                        :category => category,
-                                       )
+                                                     locale: 'en-us')
+    client.help_center_sections.create!(name: mock_uuid,
+                                        locale: 'en-us',
+                                        category: category)
   end
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.help_center_articles },
-    :create_params => lambda { { title: mock_uuid, locale: "en-us", section: section } },
-    :update_params => lambda { { title: mock_uuid } },
-    :search_params => lambda { Cistern::Hash.slice(create_params, :title) },
-    :search        => true,
-  }
+  include_examples 'zendesk#resource',
+                   collection: -> { client.help_center_articles },
+                   create_params: -> { { title: mock_uuid, locale: 'en-us', section: section } },
+                   update_params: -> { { title: mock_uuid } },
+                   search_params: -> { Cistern::Hash.slice(create_params, :title) },
+                   search: true
 
-  describe "translations" do
+  describe 'translations' do
     let!(:article) do
-      client.help_center_articles.create!(:title    => mock_uuid,
-                                          :locale   => "en-us",
-                                          :section  => section
-                                          )
+      client.help_center_articles.create!(title: mock_uuid,
+                                          locale: 'en-us',
+                                          section: section)
     end
     let!(:locale) { mock_uuid }
 
-    include_examples "zendesk#resource", {
-      :collection     => lambda { article.translations },
-      :fetch_params   => lambda { |r| Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
-      :create_params  => lambda { { source: article, locale: locale, title: mock_uuid } },
-      :update_params  => lambda { { title: mock_uuid } },
-      :search         => false
-    }
+    include_examples 'zendesk#resource',
+                     collection: -> { article.translations },
+                     fetch_params: ->(r) { Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
+                     create_params: -> { { source: article, locale: locale, title: mock_uuid } },
+                     update_params: -> { { title: mock_uuid } },
+                     search: false
   end
 end

data/spec/help_center/categories_spec.rb

@@ -1,44 +1,43 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "help_center/categories" do
-  let(:client)   { create_client }
+describe 'help_center/categories' do
+  let(:client) { create_client }
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.help_center_categories },
-    :create_params => lambda { { name: mock_uuid, locale: "en-us" } },
-    :update_params => lambda { { name: mock_uuid } },
-    :search        => false,
-  }
+  include_examples 'zendesk#resource',
+                   collection: -> { client.help_center_categories(locale: 'en-us') },
+                   create_params: -> { { name: mock_uuid, locale: 'en-us' } },
+                   update_params: -> { { name: mock_uuid } },
+                   search: false
 
-  context "with a category, sections, and articles" do
-    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: "en-us") }
-    let!(:section)  { category.sections.create!(name: mock_uuid, locale: "en-us") }
-    let!(:articles) { 2.times.map { section.articles.create(title: mock_uuid, locale: "en-us") } }
+  context 'with a category, sections, and articles' do
+    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: 'en-us') }
+    let!(:section)  { category.sections.create!(name: mock_uuid, locale: 'en-us') }
+    let!(:articles) { Array.new(2) { section.articles.create(title: mock_uuid, locale: 'en-us') } }
 
-    before {
-      client.help_center_categories.create!(name: mock_uuid, locale: "en-us").
-      sections.create!(name: mock_uuid, locale: "en-us").articles.create!(title: mock_uuid, locale: "en-us")
-    }
+    before do
+      client.help_center_categories.create!(name: mock_uuid, locale: 'en-us')
+            .sections.create!(name: mock_uuid, locale: 'en-us').articles.create!(title: mock_uuid, locale: 'en-us')
+    end
 
-    it "lists sections within a category" do
+    it 'lists sections within a category' do
       expect(category.sections.all).to contain_exactly(section)
     end
 
-    it "lists articles within a category" do
+    it 'lists articles within a category' do
       expect(category.articles.all).to match_array(articles)
     end
   end
 
-  describe "translations" do
-    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: "en-us") }
+  describe 'translations' do
+    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: 'en-us') }
     let!(:locale) { mock_uuid }
 
-    include_examples "zendesk#resource", {
-      :collection     => lambda { category.translations },
-      :fetch_params   => lambda { |r| Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
-      :create_params  => lambda { { source: category, locale: locale, title: mock_uuid } },
-      :update_params  => lambda { { title: mock_uuid } },
-      :search         => false
-    }
+    include_examples 'zendesk#resource',
+                     collection: -> { category.translations },
+                     fetch_params: ->(r) { Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
+                     create_params: -> { { source: category, locale: locale, title: mock_uuid } },
+                     update_params: -> { { title: mock_uuid } },
+                     search: false
   end
 end

data/spec/help_center/posts_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'help_center/posts' do
+  let(:client) { create_client }
+  let!(:topic) { client.help_center_topics.create(name: mock_uuid) }
+
+  include_examples 'zendesk#resource',
+                   collection: -> { topic.posts },
+                   create_params: -> { { title: mock_uuid, details: mock_uuid } },
+                   update_params: -> { { title: mock_uuid, details: mock_uuid } },
+                   search: false
+
+  let(:author) { client.users.create!(email: mock_email, name: mock_uuid) }
+
+  describe 'with an author' do
+    include_examples 'zendesk#resource',
+                     collection: -> { author.posts },
+                     create_params: lambda {
+                                      { title: mock_uuid, details: mock_uuid, topic_id: topic.id, author_id: author.id }
+                                    },
+                     update_params: -> { { title: mock_uuid, details: mock_uuid } },
+                     search: false
+  end
+
+  describe 'with a post' do
+    let!(:post) do
+      client.help_center_posts.create(title: mock_uuid, details: mock_uuid, topic_id: topic.id, author_id: author.id)
+    end
+
+    it 'returns the author' do
+      expect(post.author).to eq(author)
+    end
+
+    it 'returns the topic' do
+      expect(post.topic).to eq(topic)
+    end
+  end
+end

data/spec/help_center/sections_spec.rb

@@ -1,60 +1,59 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "help_center/sections" do
-  let(:client)   { create_client }
+describe 'help_center/sections' do
+  let(:client) { create_client }
   let!(:category) do
     client.help_center_categories.create!(
       name: mock_uuid,
-      locale: "en-us",
+      locale: 'en-us'
     )
   end
 
-  include_examples "zendesk#resource", {
-    :collection    => lambda { client.help_center_sections },
-    :create_params => lambda { { name: mock_uuid, locale: "en-us", category: category } },
-    :update_params => lambda { { name: mock_uuid } },
-    :search        => false,
-  }
+  include_examples 'zendesk#resource',
+                   collection: -> { client.help_center_sections },
+                   create_params: -> { { name: mock_uuid, locale: 'en-us', category: category } },
+                   update_params: -> { { name: mock_uuid } },
+                   search: false
 
-  context "with a category, sections, and articles" do
-    let!(:section)  { category.sections.create!(name: mock_uuid, locale: "en-us") }
-    let!(:articles) { 2.times.map { section.articles.create(title: mock_uuid, locale: "en-us") } }
+  context 'with a category, sections, and articles' do
+    let!(:section)  { category.sections.create!(name: mock_uuid, locale: 'en-us') }
+    let!(:articles) { Array.new(2) { section.articles.create(title: mock_uuid, locale: 'en-us') } }
 
-    before {
-      client.help_center_categories.create!(name: mock_uuid, locale: "en-us").
-      sections.create!(name: mock_uuid, locale: "en-us").articles.create!(title: mock_uuid, locale: "en-us")
-    }
+    before do
+      client.help_center_categories.create!(name: mock_uuid, locale: 'en-us')
+            .sections.create!(name: mock_uuid, locale: 'en-us').articles.create!(title: mock_uuid, locale: 'en-us')
+    end
 
-    it "lists articles within a section" do
+    it 'lists articles within a section' do
       expect(section.articles.all).to match_array(articles)
     end
 
-    it "shows the access policy for the section" do
-      expect(section.access_policy.viewable_by).to eq("everyone")
+    it 'shows the access policy for the section' do
+      expect(section.access_policy.viewable_by).to eq('everyone')
     end
 
-    it "updates the section access policy" do
+    it 'updates the section access policy' do
       policy = section.access_policy
       old_viewable_by = policy.viewable_by
-      new_viewable_by = "staff"
+      new_viewable_by = 'staff'
 
-      expect {
+      expect do
         policy.update!(viewable_by: new_viewable_by)
-      }.to change { section.reload.access_policy.viewable_by }.from(old_viewable_by).to(new_viewable_by)
+      end.to change { section.reload.access_policy.viewable_by }.from(old_viewable_by).to(new_viewable_by)
     end
   end
 
-  describe "translations" do
-    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: "en-us") }
-    let!(:section)  { category.sections.create!(name: mock_uuid, locale: "en-us") }
+  describe 'translations' do
+    let!(:category) { client.help_center_categories.create!(name: mock_uuid, locale: 'en-us') }
+    let!(:section)  { category.sections.create!(name: mock_uuid, locale: 'en-us') }
     let!(:locale) { mock_uuid }
 
-    include_examples "zendesk#resource", {
-      :collection     => lambda { section.translations },
-      :fetch_params   => lambda { |r| Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
-      :create_params  => lambda { { source: section, locale: locale, title: mock_uuid } },
-      :update_params  => lambda { { title: mock_uuid } },
-      :search         => false
-    }
+    include_examples 'zendesk#resource',
+                     collection: -> { section.translations },
+                     fetch_params: ->(r) { Cistern::Hash.slice(r.attributes, :source_id, :source_type, :locale) },
+                     create_params: -> { { source: section, locale: locale, title: mock_uuid } },
+                     update_params: -> { { title: mock_uuid } },
+                     search: false
   end
 end

data/spec/help_center/topics_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'help_center/topics' do
+  let(:client) { create_client }
+
+  include_examples 'zendesk#resource',
+                   collection: -> { client.help_center_topics },
+                   create_params: -> { { name: mock_uuid } },
+                   update_params: -> { { name: mock_uuid } },
+                   search: false,
+                   paged: false
+end

data/spec/lib/paged_collection_spec.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 describe Zendesk2::PagedCollection, :mock_only do
   let!(:client) { create_client }
 
-  let!(:records) { 333.times.each_with_index.map { |_,i| client.organizations.create(name: "#{i%3}_#{mock_uuid}") } }
+  let!(:records) { 333.times.each_with_index.map { |_, i| client.organizations.create(name: "#{i % 3}_#{mock_uuid}") } }
 
-  context "#each_page" do
-    it "should enumerate pages" do
+  context '#each_page' do
+    it 'should enumerate pages' do
       found_records = []
       client.organizations.all.each_page { |page| page.each { |entry| found_records << entry } }
 
@@ -14,15 +15,15 @@ describe Zendesk2::PagedCollection, :mock_only do
     end
   end
 
-  context "#each_entry" do
-    it "should enumerate entries" do
+  context '#each_entry' do
+    it 'should enumerate entries' do
       found_records = []
       client.organizations.all.each_entry { |entry| found_records << entry }
 
       expect(records).to match_array(found_records)
     end
 
-    it "should chain enumerables" do
+    it 'should chain enumerables' do
       target = records.sample
       found = client.organizations.all.each_entry.find { |entry| entry.id == target.id }
 
@@ -30,13 +31,12 @@ describe Zendesk2::PagedCollection, :mock_only do
     end
   end
 
-  context "#all_entries" do
-
-    it "should chain search paging" do
-      matching_records = records.select { |o| o.name.match(/\A2_/) }
+  context '#all_entries' do
+    it 'should chain search paging' do
+      matching_records = records.select { |o| o.name.start_with?('2_') }
       expect(matching_records).not_to be_empty
 
-      found_records = client.organizations.search(name: "2_").all_entries
+      found_records = client.organizations.search(name: '2_').all_entries
 
       expect(found_records.size).to eq(matching_records.size)
       expect(found_records).to match_array(matching_records)

data/spec/lib/rate_limit_spec.rb

@@ -1,31 +1,32 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Zendesk2::RateLimit do
   class Puppet
     def self.add_response(response)
-      self.responses.unshift(response)
+      responses.unshift(response)
     end
 
     def self.responses
       @responses ||= []
     end
 
-    def self.call(env)
-      self.responses.shift || raise("not response set")
+    def self.call(_env)
+      responses.shift || raise('not response set')
     end
   end
 
-  it "should delay requests for the specified time" do
+  it 'should delay requests for the specified time' do
     client = Faraday.new do |connection|
       connection.use Zendesk2::RateLimit
       connection.adapter :rack, Puppet
     end
 
-    Puppet.responses << [429, {"Retry-After" => 0.1}, []]
-    Puppet.responses << [429, {"Retry-After" => 0.2}, []]
-    Puppet.responses << [200, {}, ["something"]]
+    Puppet.responses << [429, { 'Retry-After' => 0.1 }, []]
+    Puppet.responses << [429, { 'Retry-After' => 0.2 }, []]
+    Puppet.responses << [200, {}, ['something']]
 
-    response = client.get("/")
+    response = client.get('/')
 
     expect(response.status).to eq(200)
     expect(response.headers[:rate_limits].to_s).to match(/^0\.3/) # ugh float math

data/spec/memberships_spec.rb

@@ -1,19 +1,24 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe "memberships" do
+describe 'memberships' do
   let!(:client)      { create_client }
   let!(:user)        { client.users.create!(email: mock_email, name: mock_uuid, verified: true) }
   let(:organization) { client.organizations.create!(name: mock_uuid) }
 
-  include_examples "zendesk#resource", {
-    :create_params => lambda { { organization_id: client.organizations.create!(name: mock_uuid).identity, user_id: user.id } },
-    :collection    => lambda { client.memberships(user: user) },
-    :paged         => true,
-    :update        => false,
-    :search        => false,
-  }
-
-  it "should be marked as default" do
+  include_examples 'zendesk#resource',
+                   create_params: lambda {
+                                    {
+                                      organization_id: client.organizations.create!(name: mock_uuid).identity,
+                                      user_id: user.id,
+                                    }
+                                  },
+                   collection: -> { client.memberships(user: user) },
+                   paged: true,
+                   update: false,
+                   search: false
+
+  it 'should be marked as default' do
     membership           = client.memberships.create!(organization: organization, user: user).reload
     another_organization = client.organizations.create!(name: mock_uuid)
 
@@ -22,9 +27,9 @@ describe "memberships" do
     expect(membership.default).to eq(true)
     expect(another_membership.default).to eq(false)
 
-    expect {
+    expect do
       another_membership.default!
-    }.to change {
+    end.to change {
       another_membership.reload.default
     }.from(false).to(true)
 
@@ -68,25 +73,31 @@ describe "memberships" do
     expect(organization.users.to_a).to         contain_exactly(another_user)
   end
 
-  describe "create_membership" do
-    it "should error when organization does not exist" do
-      expect {
-        client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => 99 })
-      }.to raise_exception(Zendesk2::Error, /RecordInvalid/)
+  describe 'create_membership' do
+    it 'should error when organization does not exist' do
+      expect do
+        client.create_membership('membership' => { 'user_id' => user.identity, 'organization_id' => 99 })
+      end.to raise_exception(Zendesk2::Error, /RecordInvalid/)
     end
 
-    it "should error when creating a duplicate membership" do
-      client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => organization.identity })
-
-      expect {
-        client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => organization.identity })
-      }.to raise_exception(Zendesk2::Error, /RecordInvalid/)
+    it 'should error when creating a duplicate membership' do
+      client.create_membership('membership' => {
+                                 'user_id' => user.identity,
+                                 'organization_id' => organization.identity,
+                               })
+
+      expect do
+        client.create_membership('membership' => {
+                                   'user_id' => user.identity,
+                                   'organization_id' => organization.identity,
+                                 })
+      end.to raise_exception(Zendesk2::Error, /RecordInvalid/)
     end
 
-    it "should error when user does not exist" do
-      expect {
-        client.create_membership("membership" => { "user_id" => 99, "organization_id" => organization.identity })
-      }.to raise_exception(Zendesk2::Error, /RecordNotFound/)
+    it 'should error when user does not exist' do
+      expect do
+        client.create_membership('membership' => { 'user_id' => 99, 'organization_id' => organization.identity })
+      end.to raise_exception(Zendesk2::Error, /RecordNotFound/)
     end
   end
 end