zendesk2 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb29d3d9736c994d3db750ce265af4ff03808d2f
-  data.tar.gz: 36977a54b393dac6cb297fac0d022fafe8bed24d
+  metadata.gz: 34ebab53477c20ee6c21506a5997b9c3ee42f3bf
+  data.tar.gz: a8ecb162208217ad57b67e1264105228cc48d210
 SHA512:
-  metadata.gz: a1245cffe7169fec4e0d68fabf29984e413ce89205ea63e1e7a8b503f96a5ecc304a151c6b1dd39ec80f464dcbb30c4379a69b76fa6d6d8da41f8679cffcb550
-  data.tar.gz: a7ccddf702e19386e0475322fe2b55893e9d9486696ddcf3f4c3419d0fa6535d8dba8b9812071226d39c59f131c39b7f64d9882b35474eb0e5d6ae5ed21aa04e
+  metadata.gz: 9b4afc752900f25a9fc7de4d150882b959cc291ec6ff4035ea075632082fe2108d5a8555177eb6eaa4e55e7036b16cabf64a20be2ba812e8098a58ce2a9183f1
+  data.tar.gz: 56993610a6ce3779a6f5fd7e3eca9f5621621021db9a7eb49a4339a95b989fb95d62ca5fd6400beb6b0f92c305117ee301f3dd3c54a6b0d6b8b628421f337104

data/Gemfile

@@ -14,6 +14,6 @@ end
 group :test do
   gem 'awesome_print'
   gem 'guard-bundler', require: false
-  gem 'guard-rspec', require: false
-  gem 'rspec'
+  gem 'guard-rspec', '~> 4.2', require: false
+  gem 'rspec', '~> 2.99'
 end

data/lib/zendesk2/client/models/ticket.rb

@@ -72,6 +72,7 @@ class Zendesk2::Client::Ticket < Zendesk2::Model
              connection.create_ticket(params.merge("requester" => with_requester)).body["ticket"]
            else
              requires :identity
+
              connection.update_ticket(params.merge("id" => self.identity)).body["ticket"]
            end
 

data/lib/zendesk2/client/requests/create_ticket.rb

@@ -11,8 +11,14 @@ class Zendesk2::Client
 
   class Mock
     def create_ticket(params={})
+      params = Cistern::Hash.stringify_keys(params)
+
       identity = self.class.new_id
 
+      if params["description"].nil? || params["description"] == ""
+        error!(:invalid, :details => {"base" => [{"description" => "Description: cannot be blank"}]})
+      end
+
       if requester = params.delete('requester')
         if !requester['name'] || requester['name'].size < 1
           response(
@@ -40,10 +46,17 @@ class Zendesk2::Client
         params['requester_id'] = user_id
       end
 
-      custom_fields = (params.delete("custom_fields") || [])
+      requested_custom_fields = (params.delete("custom_fields") || [])
+
+      custom_fields = requested_custom_fields.map do |cf|
+        field_id = cf["id"].to_i
+        if self.data[:ticket_fields][field_id]
+          {"id" => field_id, "value" => cf["value"] }
+        end
+      end.compact
 
       self.data[:ticket_fields].each do |field_id, field|
-        custom_fields.find { |cf| cf["id"] == field_id } ||
+        requested_custom_fields.find { |cf| cf["id"] == field_id } ||
           custom_fields << {"id" => field_id, "value" => nil }
       end
 

data/lib/zendesk2/client/requests/create_user.rb

@@ -25,7 +25,7 @@ class Zendesk2::Client
       if (email = record["email"]) && self.data[:identities].find{|k,i| i["type"] == "email" && i["value"] == email}
         error!(:invalid, :details => {
               "email" => [ {
-                "description" => "Email #{email} is already being used by another user"
+                "description" => "Email: #{email} is already being used by another user"
               }]})
       else
         user_identity_id = self.class.new_id # ugh

data/lib/zendesk2/client.rb

@@ -129,15 +129,14 @@ class Zendesk2::Client < Cistern::Service
         raise ArgumentError, "missing parameters: #{missing.join(", ")}"
       end
     end
-  end
 
-  class Real
-    include Shared
+    private
 
-    attr_accessor :username, :url, :token, :logger, :jwt_token
+    def zendesk_url(options)
+      options[:url] || Zendesk2.defaults[:url] || form_zendesk_url(options)
+    end
 
-    def initialize(options={})
-      url = options[:url] || Zendesk2.defaults[:url] || begin
+    def form_zendesk_url(options)
       host      = options[:host]
       subdomain = options[:subdomain] || Zendesk2.defaults[:subdomain]
 
@@ -146,8 +145,17 @@ class Zendesk2::Client < Cistern::Service
       port   = options[:port] || (scheme == "https" ? 443 : 80)
 
       "#{scheme}://#{host}:#{port}"
-      end
+    end
+  end
+
+  class Real
+    include Shared
 
+    attr_accessor :username, :url, :token, :logger, :jwt_token
+
+    def initialize(options={})
+      options[:subdomain] ||= "mock"
+      url = zendesk_url(options)
       @url  = URI.parse(url).to_s
 
       @logger            = options[:logger] || Logger.new(nil)
@@ -235,14 +243,7 @@ class Zendesk2::Client < Cistern::Service
     end
 
     def initialize(options={})
-      url = options[:url] || begin
-      host   = options[:host]
-      host ||= "#{options[:subdomain] || "mock"}.zendesk.com"
-      scheme = options[:scheme] || "https"
-      port   = options[:port] || (scheme == "https" ? 443 : 80)
-
-      "#{scheme}://#{host}:#{port}"
-      end
+      url = zendesk_url(options)
 
       @url  = url
       @path = URI.parse(url).path

data/lib/zendesk2/model.rb

@@ -12,8 +12,8 @@ class Zendesk2::Model < Cistern::Model
   # @return [Zendesk2::Model] self, regardless of success
   def save
     save!
-  rescue Zendesk2::Error => e
-    self.errors = e.response[:body]["details"].inject({}){|r,(k,v)| r.merge(k => v.map{|e| e["type"] || e["description"]})} rescue nil
+  rescue Zendesk2::Error => exception
+    self.errors = exception.response[:body]["details"].inject({}){|r,(k,v)| r.merge(k => v.map{|e| e["type"] || e["description"]})} rescue nil
     self
   end
 
@@ -26,4 +26,9 @@ class Zendesk2::Model < Cistern::Model
   rescue Zendesk2::Error
     false
   end
+
+  # re-define Cistern::Attributes#missing_attributes to require non-blank
+  def missing_attributes(args)
+    ([:connection] | args).select{|arg| val = send("#{arg}"); val.nil? || val == "" }
+  end
 end

data/lib/zendesk2/version.rb

@@ -1,3 +1,3 @@
 module Zendesk2
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/spec/groups_spec.rb

@@ -12,6 +12,6 @@ describe "groups" do
   it "should list assignable groups" do
     client.groups.create(name: Zendesk2.uuid) # assignable by default
 
-    client.groups.assignable.should be_all{|g| !g.deleted}
+    expect(client.groups.assignable).to be_all{|g| !g.deleted}
   end
 end

data/spec/memberships_spec.rb

@@ -19,12 +19,12 @@ describe "memberships" do
 
     another_membership = client.memberships.create!(organization: another_organization, user: user)
 
-    membership.default.should be_false # for some reason
-    another_membership.default.should be_false
+    expect(membership.default).to be_falsey # for some reason
+    expect(another_membership.default).to be_falsey
 
     expect { another_membership.default! }.to change { another_membership.reload.default }.from(false).to(true)
 
-    membership.reload.default.should be_false
+    expect(membership.reload.default).to be_falsey
   end
 
   it "should get an organization's memberships" do
@@ -35,8 +35,8 @@ describe "memberships" do
     another_organization.memberships.create!(user: user)
     organization.memberships.create!(user: another_user)
 
-    organization.memberships.size.should == 1
-    another_organization.memberships.size.should == 2
+    expect(organization.memberships.size).to eq(1)
+    expect(another_organization.memberships.size).to eq(2)
   end
 
   it "should get an user's memberships" do
@@ -47,8 +47,8 @@ describe "memberships" do
     user_membership = another_organization.memberships.create!(user: user)
     organization.memberships.create!(user: another_user)
 
-    user.memberships.to_a.should == [user_membership]
-    another_user.memberships.size.should == 2
+    expect(user.memberships.to_a).to eq([user_membership])
+    expect(another_user.memberships.size).to eq(2)
   end
 
   describe "create_membership" do

data/spec/organizations_spec.rb

@@ -13,19 +13,19 @@ describe "organizations" do
     let(:organization) { client.organizations.create(name: Zendesk2.uuid) }
     it "should get #users" do
       user = client.users.create(email: "#{Zendesk2.uuid}@example.org", name: Zendesk2.uuid, organization: organization)
-      organization.users.should include user
+      expect(organization.users).to include user
     end
 
     it "should get #tickets" do
       user = client.users.create(email: "#{Zendesk2.uuid}@example.org", name: Zendesk2.uuid, organization: organization)
       ticket = client.tickets.create(subject: "#{Zendesk2.uuid}@example.org", description: Zendesk2.uuid, requester: user)
-      organization.tickets.should include ticket
+      expect(organization.tickets).to include ticket
     end
 
     it "should hate non-unique names" do
-      lambda { client.organizations.create!(name: organization.name) }.should raise_exception(Zendesk2::Error)
+      expect { client.organizations.create!(name: organization.name) }.to raise_exception(Zendesk2::Error)
       model = client.organizations.create(name: organization.name)
-      model.errors.should == {"name" => ["Name has already been taken"]}
+      expect(model.errors).to eq({"name" => ["Name has already been taken"]})
     end
 
     it "should be able to find organizations by external id" do
@@ -34,7 +34,7 @@ describe "organizations" do
       o.external_id = external_id
       o.save
       found = client.organizations.find_by_external_id(external_id).first
-      found.should === o
+      expect(found).to be === o
     end
 
   end

data/spec/shared/zendesk_resource.rb

@@ -10,12 +10,12 @@ shared_examples "zendesk resource" do |options={}|
 
     it "should be created" do
       @record = collection.create!(create_params)
-      record.identity.should_not be_nil
+      expect(record.identity).not_to be_nil
     end
 
     it "should be fetched" do
       @record = collection.create!(create_params)
-      collection.get!(fetch_params.call(record)).should == record
+      expect(collection.get!(fetch_params.call(record))).to eq(record)
     end
 
     if options.fetch(:paged, true)
@@ -27,27 +27,27 @@ shared_examples "zendesk resource" do |options={}|
         after(:each) { @resources.each { |r| r.destroy } }
 
         it "should retrieve first page" do
-          collection.all("per_page" => "1").size.should == 1
+          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
-          second_page.should_not == first_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
-          previous_to_second_page.should == first_page
+          expect(previous_to_second_page).to eq(first_page)
         end
       end
     else
       context "paging" do
         it "should not be present" do
-          collection.class.attributes.should_not have_key(:next_page_link)
-          collection.class.attributes.should_not have_key(:previous_page_link)
-          collection.class.attributes.should have_key(:count)
+          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)
         end
       end
     end
@@ -57,17 +57,17 @@ shared_examples "zendesk resource" do |options={}|
         @record = collection.create!(create_params)
         record.merge_attributes(update_params)
         record.save
-        update_params.each {|k,v| record.send(k).should == v}
+        update_params.each {|k,v| expect(record.send(k)).to eq(v)}
       end
     end
 
     it "should be destroyed" do
       @record = collection.create!(create_params)
-      record.identity.should_not be_nil
+      expect(record.identity).not_to be_nil
       record.destroy
 
       if !options.fetch(:delayed_destroy, false) && !Zendesk2::Client.mocking?
-        record.should be_destroyed
+        expect(record).to be_destroyed
       end
     end
 
@@ -75,7 +75,7 @@ shared_examples "zendesk resource" do |options={}|
       # Search index takes 2-3 minutes according to the docs
       it "should search" do
         @record = collection.create!(create_params)
-        collection.search(create_params).should include(record)
+        expect(collection.search(create_params)).to include(record)
       end
     end
   end

data/spec/tickets_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "tickets" do
+describe "Zendesk2::Client" do
   let(:client) { create_client }
 
   include_examples "zendesk resource", {
@@ -9,6 +9,14 @@ describe "tickets" do
     :update_params => lambda { {subject: Zendesk2.uuid} },
   }
 
+  describe "#create_ticket" do
+    it "should require a description" do
+      expect {
+        client.create_ticket("subject" => Zendesk2.uuid)
+      }.to raise_exception(Zendesk2::Error, /Description: cannot be blank/)
+    end
+  end
+
   describe "when creating a ticket" do
     let!(:requester_email) { "#{Zendesk2.uuid}@example.org" }
 
@@ -16,11 +24,11 @@ describe "tickets" do
       ticket = client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid, requester: {name: "Josh Lane", email: requester_email})
       if Zendesk2::Client.mocking? # this takes some time for realsies
         requester = client.users.search(email: requester_email).first
-        requester.should_not be_nil
+        expect(requester).not_to be_nil
 
-        ticket.reload.requester.should == requester
+        expect(ticket.reload.requester).to eq(requester)
       else
-        ticket.reload.requester.should_not be_nil
+        expect(ticket.reload.requester).not_to be_nil
       end
     end
 
@@ -29,22 +37,32 @@ describe "tickets" do
         client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid, requester: {email: requester_email})
       }.to raise_exception(Zendesk2::Error, /Requester Name: .* too short/)
     end
+
+    it "should require a description" do
+      expect {
+        client.tickets.create!(subject: Zendesk2.uuid)
+      }.to raise_exception(ArgumentError, /description is required/)
+
+      expect {
+        client.tickets.create!(subject: Zendesk2.uuid, description: "")
+      }.to raise_exception(ArgumentError, /description is required/)
+    end
   end
 
   describe "with a created ticket" do
     let(:ticket) { client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid) }
     it "should get requester" do
-      ticket.requester.should == client.users.current
+      expect(ticket.requester).to eq(client.users.current)
     end
 
     it "should get submitter" do
-      ticket.submitter.should == client.users.current
+      expect(ticket.submitter).to eq(client.users.current)
     end
 
     it "should have empty custom fields by default" do
       pending if !Zendesk2::Client.mocking?
 
-      ticket.custom_fields.should == []
+      expect(ticket.custom_fields).to eq([])
     end
   end
 
@@ -56,38 +74,43 @@ describe "tickets" do
       ticket.comment(body)
 
       audit = ticket.audits.last
-      audit.ticket.should == ticket
+      expect(audit.ticket).to eq(ticket)
 
       events = audit.events
-      events.size.should == 1
+      expect(events.size).to eq(1)
 
       event = events.first
-      event.body.should == body
-      event.should be_a(Zendesk2::Client::TicketComment)
-      event.ticket_audit.should == audit
+      expect(event.body).to eq(body)
+      expect(event).to be_a(Zendesk2::Client::TicketComment)
+      expect(event.ticket_audit).to eq(audit)
     end
 
     it "lists comments" do
       body = Zendesk2.uuid
       ticket.comment(body)
 
-      ticket.comments.find{|c| c.body == body}.should_not be_nil
+      expect(ticket.comments.find{|c| c.body == body}).not_to be_nil
     end
   end
 
   describe "custom fields" do
-    let!(:ticket_field) { client.ticket_fields.create!(title: Zendesk2.uuid, type: "textbox") }
+    let!(:ticket_field) { client.ticket_fields.create!(title: SecureRandom.hex(3), type: "text") }
 
     it "should be based on ticket_fields" do
       ticket = client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid)
       custom_field = ticket.custom_fields.find { |cf| cf["id"] == ticket_field.identity }
-      custom_field.should_not be_nil
-      custom_field["value"].should be_nil
+
+      expect(custom_field).not_to be_nil
+      expect(custom_field["value"]).to be_nil
 
       ticket = client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid, custom_fields: [{"id" => ticket_field.identity, "value" => "jessicaspacekat"}])
       custom_field = ticket.custom_fields.find { |cf| cf["id"] == ticket_field.identity }
-      custom_field.should_not be_nil
-      custom_field["value"].should == "jessicaspacekat"
+
+      expect(custom_field).not_to be_nil
+      expect(custom_field["value"]).to eq("jessicaspacekat")
+
+      ticket = client.tickets.create!(subject: Zendesk2.uuid, description: Zendesk2.uuid, custom_fields: [{"id" => "-1", "value" => "fantasy"}])
+      expect(ticket.custom_fields).not_to include({"id" => -1, "value" => "fantasy"})
     end
   end
 end

data/spec/users_spec.rb

@@ -11,7 +11,7 @@ describe "users" do
 
   it "should get current user" do
     current_user = client.users.current
-    current_user.email.should == client.username
+    expect(current_user.email).to eq(client.username)
   end
 
   describe do
@@ -24,49 +24,49 @@ describe "users" do
     it "should update organization" do
       organization = client.organizations.create(name: Zendesk2.uuid)
       user.organization= organization
-      user.save.should be_true
-      user.organization.should == organization
+      expect(user.save).to be_truthy
+      expect(user.organization).to eq(organization)
     end
 
     it "should get requested tickets" do
       ticket = client.tickets.create(requester: user, subject: Zendesk2.uuid, description: Zendesk2.uuid)
 
-      user.requested_tickets.should include ticket
+      expect(user.requested_tickets).to include ticket
     end
 
     it "should get ccd tickets" do
       ticket = client.tickets.create(collaborators: [user], subject: Zendesk2.uuid, description: Zendesk2.uuid)
 
-      user.ccd_tickets.should include ticket
+      expect(user.ccd_tickets).to include ticket
     end
 
     it "cannot destroy a user with a ticket" do
       client.tickets.create(requester: user, subject: Zendesk2.uuid, description: Zendesk2.uuid)
 
-      user.destroy.should be_false
+      expect(user.destroy).to be_falsey
 
-      user.should_not be_destroyed
+      expect(user).not_to be_destroyed
     end
 
     it "should list identities" do
       identities = user.identities.all
-      identities.size.should == 1
+      expect(identities.size).to eq(1)
 
       identity = identities.first
-      identity.primary.should be_true
-      identity.verified.should be_false
-      identity.type.should == "email"
-      identity.value.should == user.email
+      expect(identity.primary).to be_truthy
+      expect(identity.verified).to be_falsey
+      expect(identity.type).to eq("email")
+      expect(identity.value).to eq(user.email)
     end
 
     it "should create a new identity" do
       email = "ey+#{Zendesk2.uuid}@example.org"
 
       new_identity = user.identities.create!(type: "email", value: email)
-      new_identity.primary.should be_false
-      new_identity.verified.should be_false
-      new_identity.type.should == "email"
-      new_identity.value.should == 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.value).to eq(email)
     end
 
     it "should mark remaining identity as primary" do
@@ -77,10 +77,10 @@ describe "users" do
 
       initial_identity.destroy
 
-      new_identity.reload.primary.should be_false
+      expect(new_identity.reload.primary).to be_falsey
 
       new_identity.primary!
-      new_identity.reload.primary.should be_true
+      expect(new_identity.reload.primary).to be_truthy
     end
 
     it "should not allow multiple primary identities" do
@@ -89,19 +89,19 @@ describe "users" do
       initial_identity = user.identities.all.first
       new_identity     = user.identities.create!(type: "email", value: email)
       new_identity.primary!
-      new_identity.primary.should be_true
-      new_identity.reload.primary.should be_true
+      expect(new_identity.primary).to be_truthy
+      expect(new_identity.reload.primary).to be_truthy
 
-      initial_identity.reload.primary.should be_false
+      expect(initial_identity.reload.primary).to be_falsey
     end
 
     it "should hate non-unique emails" do
       email = "zendesk2+#{Zendesk2.uuid}@example.org"
       client.users.create(email: email, name: Zendesk2.uuid)
-      lambda { client.users.create!(email: email, name: Zendesk2.uuid) }.should raise_exception(Zendesk2::Error)
+      expect { client.users.create!(email: email, name: Zendesk2.uuid) }.to raise_exception(Zendesk2::Error)
       user = client.users.create(email: email, name: Zendesk2.uuid)
-      user.identity.should be_false
-      user.errors.should == {"email" => ["Email #{email} is already being used by another user"]}
+      expect(user.identity).to be_falsey
+      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
@@ -109,36 +109,36 @@ describe "users" do
       user.email = (new_email = "zendesk2+#{Zendesk2.uuid}@example.org")
       user.save!
 
-      (identities = user.identities.all).size.should == 2
+      expect((identities = user.identities.all).size).to eq(2)
       new_identity = identities.find{|i| i.value == new_email}
-      new_identity.should_not be_nil
+      expect(new_identity).not_to be_nil
 
-      new_identity.primary.should be_false
+      expect(new_identity.primary).to be_falsey
 
       original_identity = identities.find{|i| i.value == original_email}
-      original_identity.should_not be_nil
+      expect(original_identity).not_to be_nil
 
-      original_identity.primary.should be_true
+      expect(original_identity.primary).to be_truthy
 
-      user.reload.email.should == original_email
+      expect(user.reload.email).to eq(original_email)
     end
 
     it "should form 'legacy' login url" do
       return_to = "http://engineyard.com"
       uri = Addressable::URI.parse(user.login_url(Time.now.to_s, return_to: return_to, token: "in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)"))
-      uri.query_values["return_to"].should == return_to
-      uri.query_values["name"].should eq user.name
-      uri.query_values["email"].should eq user.email
-      uri.query_values["hash"].should_not be_nil
+      expect(uri.query_values["return_to"]).to eq(return_to)
+      expect(uri.query_values["name"]).to eq user.name
+      expect(uri.query_values["email"]).to eq user.email
+      expect(uri.query_values["hash"]).not_to be_nil
     end
 
     it "should form jwt login url" do
       return_to = "http://engineyard.com"
       uri = Addressable::URI.parse(user.jwt_login_url(return_to: return_to, jwt_token: "in-case-you-dont-have-it-in ~/.zendesk2 (aka ci)"))
-      uri.query_values["return_to"].should == return_to
-      uri.query_values["name"].should be_nil
-      uri.query_values["email"].should be_nil
-      uri.query_values["jwt"].should_not be_nil
+      expect(uri.query_values["return_to"]).to eq(return_to)
+      expect(uri.query_values["name"]).to be_nil
+      expect(uri.query_values["email"]).to be_nil
+      expect(uri.query_values["jwt"]).not_to be_nil
 
       #TODO: try JWT.decode
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zendesk2
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-13 00:00:00.000000000 Z
+date: 2014-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable