zendesk2 1.4.2 → 1.5.3

data/lib/zendesk2/version.rb

@@ -1,3 +1,3 @@
 module Zendesk2
-  VERSION = "1.4.2"
+  VERSION = "1.5.3"
 end

data/lib/zendesk2.rb

@@ -1,11 +1,11 @@
 require "zendesk2/version"
 
 # dependencies
-require 'addressable/uri'
 require 'cistern'
 require 'faraday'
 require 'faraday_middleware'
 require 'jwt'
+require 'uri'
 
 # stdlib
 require 'forwardable'
@@ -24,16 +24,6 @@ module Zendesk2
                   end
   end
 
-  def self.paging_parameters(options={})
-    params = if url = options["url"]
-               Addressable::URI.parse(url).query_values
-             else
-               options
-             end
-
-    Cistern::Hash.slice(params, "page", "per_page")
-  end
-
   def self.stringify_keys(hash)
     hash.inject({}) { |r,(k,v)| r.merge(k.to_s => v) }
   end
@@ -47,8 +37,6 @@ require 'zendesk2/attributes'
 require 'zendesk2/error'
 require 'zendesk2/searchable'
 require 'zendesk2/logger'
-require 'zendesk2/model'
-require 'zendesk2/collection'
 require 'zendesk2/paged_collection'
 
 require 'zendesk2/client'

data/spec/categories_spec.rb

@@ -8,4 +8,136 @@ describe "categories" do
     :create_params => lambda { { name: mock_uuid } },
     :update_params => lambda { { name: mock_uuid } },
   }
+
+  context "#create_category" do
+    it "should correctly respond" do
+      body = { "category" => {"name" => (name = mock_uuid)} }
+
+      response = client.create_category(body)
+
+      expect(response.status).to eq(201)
+      expect(response.env[:url].path).to eq("/api/v2/categories.json")
+      expect(response.env[:method]).to eq(:post)
+      expect(client.last_request).to match(body)
+      expect(response.env[:body]["category"]).to match(
+        a_hash_including(
+          "name" => name,
+        ))
+    end
+  end
+
+  context "with a category" do
+    let!(:category) { client.categories.create!(name: mock_uuid) }
+
+    context "#destroy_category" do
+      it "should require a valid category" do
+        expect {
+          client.destroy_category(
+            "category" => {
+              "id" => 999999999,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.destroy_category(
+          "category" => {
+            "id" => category.id,
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/categories/#{category.id}.json")
+        expect(response.env[:method]).to eq(:delete)
+        expect(client.last_request).to eq(nil)
+        expect(response.env[:body]).to be_falsey
+      end
+    end
+
+    context "#get_categories" do
+      it "should correctly respond" do
+        response = client.get_categories
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/categories.json")
+        expect(response.env[:method]).to eq(:get)
+        expect(client.last_request).to eq(nil)
+        skip unless Zendesk2::Client.mocking?
+        expect(response.env[:body]["categories"]).to match([
+          a_hash_including(
+            "id"   => category.id,
+          )])
+      end
+    end
+
+    context "#get_category" do
+      it "should require a valid category" do
+        expect {
+          client.get_category(
+            "category" => {
+              "id" => 999999999,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.get_category(
+          "category" => {
+            "id" => category.id,
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/categories/#{category.id}.json")
+        expect(response.env[:method]).to eq(:get)
+        expect(client.last_request).to eq(nil)
+        expect(response.env[:body]["category"]).to match(
+          a_hash_including(
+            "id"   => category.id,
+            "url"  => response.env[:url].to_s,
+          ))
+      end
+    end
+
+    context "#update_category" do
+      it "should require a valid category" do
+        expect {
+          client.update_category(
+            "category" => {
+              "id"   => 999999999,
+              "name" => mock_uuid,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.update_category(
+          "category" => {
+            "id"   => category.id,
+            "name" => (name = mock_uuid),
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/categories/#{category.id}.json")
+        expect(response.env[:method]).to eq(:put)
+        expect(client.last_request).to eq("category" => {"name" => name})
+        expect(response.env[:body]["category"]).to match(
+          a_hash_including(
+            "id"   => category.id,
+            "url"  => response.env[:url].to_s,
+            "name" => name,
+          ))
+      end
+    end
+  end
 end

data/spec/forums_spec.rb

@@ -9,4 +9,136 @@ describe "forums" do
     :update_params   => lambda { { name: mock_uuid } },
     :delayed_destroy => true,
   }
+
+  context "#create_forum" do
+    it "should correctly respond" do
+      body = { "forum" => {"name" => (name = mock_uuid)} }
+
+      response = client.create_forum(body)
+
+      expect(response.status).to eq(201)
+      expect(response.env[:url].path).to eq("/api/v2/forums.json")
+      expect(response.env[:method]).to eq(:post)
+      expect(client.last_request).to match(body)
+      expect(response.env[:body]["forum"]).to match(
+        a_hash_including(
+          "name" => name,
+        ))
+    end
+  end
+
+  context "with a forum" do
+    let!(:forum) { client.forums.create!(name: mock_uuid) }
+
+    context "#destroy_forum" do
+      it "should require a valid forum" do
+        expect {
+          client.destroy_forum(
+            "forum" => {
+              "id" => 999999999,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.destroy_forum(
+          "forum" => {
+            "id" => forum.id,
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/forums/#{forum.id}.json")
+        expect(response.env[:method]).to eq(:delete)
+        expect(client.last_request).to eq(nil)
+        expect(response.env[:body]).to be_falsey
+      end
+    end
+
+    context "#get_forums" do
+      it "should correctly respond" do
+        response = client.get_forums
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/forums.json")
+        expect(response.env[:method]).to eq(:get)
+        expect(client.last_request).to eq(nil)
+        skip unless Zendesk2::Client.mocking?
+        expect(response.env[:body]["forums"]).to match([
+          a_hash_including(
+            "id"   => forum.id,
+          )])
+      end
+    end
+
+    context "#get_forum" do
+      it "should require a valid forum" do
+        expect {
+          client.get_forum(
+            "forum" => {
+              "id" => 999999999,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.get_forum(
+          "forum" => {
+            "id" => forum.id,
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/forums/#{forum.id}.json")
+        expect(response.env[:method]).to eq(:get)
+        expect(client.last_request).to eq(nil)
+        expect(response.env[:body]["forum"]).to match(
+          a_hash_including(
+            "id"   => forum.id,
+            "url"  => response.env[:url].to_s,
+          ))
+      end
+    end
+
+    context "#update_forum" do
+      it "should require a valid forum" do
+        expect {
+          client.update_forum(
+            "forum" => {
+              "id"   => 999999999,
+              "name" => mock_uuid,
+            }
+          )
+        }.to raise_error(Zendesk2::Error) { |e|
+          expect(e.response[:status]).to eq(404)
+        }
+      end
+
+      it "should correctly respond" do
+        response = client.update_forum(
+          "forum" => {
+            "id"   => forum.id,
+            "name" => (name = mock_uuid),
+          }
+        )
+
+        expect(response.status).to eq(200)
+        expect(response.env[:url].path).to eq("/api/v2/forums/#{forum.id}.json")
+        expect(response.env[:method]).to eq(:put)
+        expect(client.last_request).to eq("forum" => {"name" => name})
+        expect(response.env[:body]["forum"]).to match(
+          a_hash_including(
+            "id"   => forum.id,
+            "url"  => response.env[:url].to_s,
+            "name" => name,
+          ))
+      end
+    end
+  end
 end

data/spec/lib/paged_collection_spec.rb

@@ -35,8 +35,8 @@ describe Zendesk2::PagedCollection, :mock_only do
 
       found_records = client.organizations.search(name: "2_").each_entry.to_a
 
-      expect(matching_records.size).to eq(found_records.size)
-      expect(matching_records).to match_array(found_records)
+      expect(found_records.size).to eq(matching_records.size)
+      expect(found_records).to match_array(matching_records)
     end
   end
 end

data/spec/memberships_spec.rb

@@ -6,7 +6,7 @@ describe "memberships" do
   let(:organization)   { client.organizations.create!(name: mock_uuid) }
 
   include_examples "zendesk resource", {
-    :create_params => lambda { {organization_id: organization.id, user_id: user.id} },
+    :create_params => lambda { { organization_id: organization.id, user_id: user.id } },
     :collection    => lambda { client.memberships(user: user) },
     :paged         => false,
     :update        => false,
@@ -54,25 +54,21 @@ describe "memberships" do
   describe "create_membership" do
     it "should error when organization does not exist" do
       expect {
-        client.create_membership("user_id" => user.identity, "organization_id" => 99)
+        client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => 99 })
       }.to raise_exception(Zendesk2::Error, /RecordInvalid/)
     end
 
-    it "should error when missing parameters" do
-      expect { client.create_membership({}) }.to raise_exception(ArgumentError, "missing parameters: user_id, organization_id")
-    end
-
     it "should error when creating a duplicate membership" do
-      client.create_membership("user_id" => user.identity, "organization_id" => organization.identity)
+      client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => organization.identity })
 
       expect {
-        client.create_membership("user_id" => user.identity, "organization_id" => organization.identity)
+        client.create_membership("membership" => { "user_id" => user.identity, "organization_id" => organization.identity })
       }.to raise_exception(Zendesk2::Error, /RecordInvalid/)
     end
 
     it "should error when user does not exist" do
       expect {
-        client.create_membership("user_id" => 99, "organization_id" => organization.identity)
+        client.create_membership("membership" => { "user_id" => 99, "organization_id" => organization.identity })
       }.to raise_exception(Zendesk2::Error, /RecordNotFound/)
     end
   end

data/spec/organizations_spec.rb

@@ -13,33 +13,49 @@ describe "organizations" do
     let(:organization) { client.organizations.create!(name: mock_uuid) }
 
     it "should get #users" do
-      user = client.users.create(email: "#{mock_uuid}@example.org", name: mock_uuid, organization: organization)
+      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
-      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)
+      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
-      expect { client.organizations.create!(name: organization.name) }.to raise_exception(Zendesk2::Error)
-      model = client.organizations.create(name: organization.name)
-      expect(model.errors).to eq({"name" => ["Name: has already been taken"]})
-      model = client.organizations.create(name: mock_uuid)
-      model.name = organization.name
-      model.save
-      expect(model.errors).to eq({"name" => ["Name: has already been taken"]})
+      # create
+      expect {
+        client.organizations.create!(name: organization.name)
+      }.to raise_exception(Zendesk2::Error)
+
+      expect(
+        client.organizations.create(name: organization.name).errors
+      ).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"])
+
+      # update
+      model = client.organizations.create!(name: mock_uuid)
+
+      expect(
+        model.update(name: organization.name).errors
+      ).to eq("name" => ["Name: has already been taken"])
+
+      expect(
+        model.update(name: organization.name.upcase).errors
+      ).to eq("name" => ["Name: has already been taken"])
     end
 
     it "should update name" do
       old_name = organization.name
-      proxy = organization.dup
-      new_name = proxy.name = mock_uuid
+      proxy    = organization.dup
+      new_name = mock_uuid
 
       expect {
-        proxy.save!
+        proxy.update!(name: new_name)
       }.to change { organization.reload.name }.from(old_name).to(new_name)
     end
 
@@ -50,30 +66,165 @@ describe "organizations" do
       expect(client.organizations.find_by_external_id(external_id).first).to eq(organization)
     end
   end
+end
 
-  describe "#create_organization" do
-    it "should prevent duplicate external_ids" do
-      client.create_organization("name" => "a", external_id: nil) # fine
-      client.create_organization("name" => "b", external_id: nil) # also fine
-      client.create_organization("name" => "c", external_id: "1") # it's cool
+describe "#create_organization" do
+  let(:client) { create_client }
+
+  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
 
+    expect {
+      client.create_organization("organization" => {"name" => mock_uuid, external_id: external_id})
+    }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+  end
+
+  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[:method]).to eq(:post)
+    expect(client.last_request).to match(body)
+    expect(response.env[:body]["organization"]).to match(
+      a_hash_including(
+        "name" => name,
+      ))
+  end
+end
+
+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 {
-        client.create_organization("name" => "d", external_id: "1")
-      }.to raise_exception(Zendesk2::Error, /External has already been taken/)
+        client.destroy_organization(
+          "organization" => {
+            "id" => 999999999,
+          }
+        )
+      }.to raise_error(Zendesk2::Error) { |e|
+        expect(e.response[:status]).to eq(404)
+      }
+    end
+
+    it "should correctly respond" do
+      response = client.destroy_organization(
+        "organization" => {
+          "id" => organization.id,
+        }
+      )
+
+      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(:delete)
+      expect(client.last_request).to eq(nil)
+      expect(response.env[:body]).to be_falsey
+    end
+  end
+
+  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[:method]).to eq(:get)
+      expect(client.last_request).to eq(nil)
+      skip unless Zendesk2::Client.mocking?
+      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 {
+        client.get_organization(
+          "organization" => {
+            "id" => 999999999,
+          }
+        )
+      }.to raise_error(Zendesk2::Error) { |e|
+        expect(e.response[:status]).to eq(404)
+      }
+    end
+
+    it "should correctly respond" do
+      response = client.get_organization(
+        "organization" => {
+          "id" => organization.id,
+        }
+      )
+
+      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(:get)
+      expect(client.last_request).to eq(nil)
+      expect(response.env[:body]["organization"]).to match(
+        a_hash_including(
+          "id"   => organization.id,
+          "url"  => response.env[:url].to_s,
+        ))
     end
   end
 
   describe "#update_organization" do
+    it "should require a valid organization" do
+      expect {
+        client.update_organization(
+          "organization" => {
+            "id"   => 999999999,
+            "name" => mock_uuid,
+          }
+        )
+      }.to raise_error(Zendesk2::Error) { |e|
+        expect(e.response[:status]).to eq(404)
+      }
+    end
+
     it "should prevent duplicate external_ids" do
-      organization         = client.organizations.create(name: "a")
-      another_organization = client.organizations.create(name: "b")
+      external_id = mock_uuid
+
+      organization         = client.organizations.create!(name: mock_uuid)
+      another_organization = client.organizations.create!(name: mock_uuid)
 
-      client.update_organization("id" => organization.id, external_id: nil) # fine
-      client.update_organization("id" => another_organization.id, external_id: "1") # also fine
+      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
 
       expect {
-        client.update_organization("id" => organization.id, external_id: "1")
+        client.update_organization("organization" => {"id" => organization.id, external_id: external_id})
       }.to raise_exception(Zendesk2::Error, /External has already been taken/)
     end
+
+    it "should correctly respond" do
+      response = client.update_organization(
+        "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(
+        a_hash_including(
+          "id"   => organization.id,
+          "url"  => response.env[:url].to_s,
+          "name" => name,
+        ))
+    end
   end
 end