zendesk2 1.4.2 → 1.5.3

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

@@ -1,44 +1,40 @@
-class Zendesk2::Client
-  class Real
-    def create_ticket_field(params={})
-      request(
-        :body   => {"ticket_field" => params},
-        :method => :post,
-        :path   => "/ticket_fields.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateTicketField < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/ticket_fields.json" }
+  request_body { |r| { "ticket_field" => r.ticket_field_params } }
 
-  class Mock
-    def create_ticket_field(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[type title description position active required collapsed_for_agents regexp_for_validation title_in_portal visible_in_portal editable_in_portal required_in_portal tag custom_field_options]
+  end
 
-      record = {
-        "active"                => true,
-        "collapsed_for_agents"  => false,
-        "created_at"            => Time.now.iso8601,
-        "description"           => params["title"],
-        "editable_in_portal"    => false,
-        "id"                    => identity,
-        "position"              => 9999,
-        "regexp_for_validation" => "",
-        "removable"             => true,
-        "required"              => false,
-        "required_in_portal"    => false,
-        "tag"                   => "",
-        "title_in_portal"       => params["title"],
-        "updated_at"            => Time.now.iso8601,
-        "url"                   => url_for("/ticket_fields/#{identity}.json"),
-        "visible_in_portal"     => false,
-      }.merge(params)
+  def ticket_field_params
+    Cistern::Hash.slice(params.fetch("ticket_field"), *self.class.accepted_attributes)
+  end
 
-      self.data[:ticket_fields][identity] = record
+  def mock
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"ticket_field" => record},
-        :path   => "/ticket_fields.json"
-      )
-    end
-  end # Mock
-end # Zendesk2::Client
+    record = {
+      "active"                => true,
+      "collapsed_for_agents"  => false,
+      "created_at"            => Time.now.iso8601,
+      "description"           => params["title"],
+      "editable_in_portal"    => false,
+      "id"                    => identity,
+      "position"              => 9999,
+      "regexp_for_validation" => "",
+      "removable"             => true,
+      "required"              => false,
+      "required_in_portal"    => false,
+      "tag"                   => "",
+      "title_in_portal"       => params["title"],
+      "updated_at"            => Time.now.iso8601,
+      "url"                   => url_for("/ticket_fields/#{identity}.json"),
+      "visible_in_portal"     => false,
+    }.merge(ticket_field_params)
+
+    self.data[:ticket_fields][identity] = record
+
+    mock_response("ticket_field" => record)
+  end
+end

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

@@ -1,33 +1,28 @@
-class Zendesk2::Client
-  class Real
-    def create_topic(params={})
-      request(
-        :body   => {"topic" => params},
-        :method => :post,
-        :path   => "/topics.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateTopic < Zendesk2::Client::Request
+  request_method :post
+  request_body { |r| { "topic" => r.topic_params } }
+  request_path { |_| "/topics.json" }
 
-  class Mock
-    def create_topic(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[title body submitter_id updater_id forum_id locked pinned highlighted position tags]
+  end
 
-      record = {
-        "id"         => identity,
-        "url"        => url_for("/topics/#{identity}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-      }.merge(params)
+  def topic_params
+    @_topic_params ||= Cistern::Hash.slice(params.fetch("topic"), *self.class.accepted_attributes)
+  end
 
-      path = "/topics.json"
-      self.data[:topics][identity]= record
+  def mock
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"topic" => record},
-        :path   => path,
-      )
-    end
-  end # Mock
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/topics/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+    }.merge(topic_params)
+
+    self.data[:topics][identity] = record
+
+    mock_response("topic" => record)
+  end
 end

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

@@ -1,37 +1,33 @@
-class Zendesk2::Client
-  class Real
-    def create_topic_comment(params={})
-      topic_id = params.delete("topic_id")
-      path     = "/topics/#{topic_id}/comments.json"
+class Zendesk2::Client::CreateTopicComment < Zendesk2::Client::Request
+  request_method :post
+  request_path { |r| "/topics/#{r.topic_id}/comments.json" }
+  request_body { |r| { "topic_comment" => r.topic_comment_params } }
 
-      request(
-        :body   => {"topic_comment" => params},
-        :method => :post,
-        :path   => path,
-      )
-    end
-  end # Real
+  def self.accepted_attributes
+    %w[user_id body informative]
+  end
 
-  class Mock
-    def create_topic_comment(params={})
-      identity = self.class.new_id
-      topic_id = params["topic_id"]
-      path     = "/topics/#{topic_id}/comments.json"
+  def topic_id
+    params.fetch("topic_comment").fetch("topic_id").to_i
+  end
 
-      record = {
-        "id"         => identity,
-        "url"        => url_for("/topics/#{topic_id}/comments/#{identity}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-      }.merge(params)
+  def topic_comment_params
+    Cistern::Hash.slice(params.fetch("topic_comment"), *self.class.accepted_attributes)
+  end
 
-      self.data[:topic_comments][identity]= record
+  def mock
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"topic_comment" => record},
-        :path   => path,
-      )
-    end
-  end # Mock
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/topics/#{topic_id}/comments/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+      "topic_id"   => self.topic_id,
+    }.merge(topic_comment_params)
+
+    self.data[:topic_comments][identity] = record
+
+    mock_response("topic_comment" => record)
+  end
 end

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

@@ -1,66 +1,61 @@
-class Zendesk2::Client
-  class Real
-    def create_user(params={})
-      request(
-        :body   => {"user" => params},
-        :method => :post,
-        :path   => "/users.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateUser < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/users.json" }
+  request_body { |r| { "user" => r.user_params } }
 
-  class Mock
-    def create_user(_params={})
-      params  = Cistern::Hash.stringify_keys(_params)
-      user_id = self.class.new_id
-      path    = "/users.json"
+  def self.accepted_attributes
+    %w[name email organization_id external_id alias verified locate_id time_zone phone signature details notes role custom_role_id moderator ticket_restriction only_private_comments]
+  end
 
-      if organization_id = params.delete("organization_id")
-        self.find!(:organizations, organization_id)
-        params["organization_id"] = organization_id.to_s
-      end
+  def user_params
+    Cistern::Hash.slice(params.fetch("user"), *self.class.accepted_attributes)
+  end
 
-      record = {
-        "id"         => user_id,
-        "url"        => url_for("/users/#{user_id}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-        "active"     => true,
-      }.merge(params)
+  def mock
+    user_id = service.serial_id
 
-      if record["external_id"] && self.data[:users].values.find { |o| o["external_id"] == record["external_id"] }
-        error!(:invalid, details: {"name" => [ { "description" => "External has already been taken" } ]})
-      end
+    user = params.fetch("user")
+
+    if organization_id = user["organization_id"]
+      self.find!(:organizations, organization_id)
+    end
 
-      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"
-              }]})
-      else
-        user_identity_id = self.class.new_id
+    record = {
+      "id"         => user_id,
+      "url"        => url_for("/users/#{user_id}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+      "active"     => true,
+    }.merge(user_params)
 
-        user_identity = {
-          "id"         => user_identity_id,
-          "url"        => url_for("/users/#{user_id}/identities/#{user_identity_id}.json"),
-          "created_at" => Time.now.iso8601,
-          "updated_at" => Time.now.iso8601,
-          "type"       => "email",
-          "value"      => record["email"],
-          "verified"   => false,
-          "primary"    => true,
-          "user_id"    => user_id,
-        }
+    if record["external_id"] && self.data[:users].values.find { |o| o["external_id"] == record["external_id"] }
+      error!(:invalid, details: {"name" => [ { "description" => "External has already been taken" } ]})
+    end
+
+    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"
+        }]})
+    else
+      user_identity_id = service.serial_id
+
+      user_identity = {
+        "id"         => user_identity_id,
+        "url"        => url_for("/users/#{user_id}/identities/#{user_identity_id}.json"),
+        "created_at" => Time.now.iso8601,
+        "updated_at" => Time.now.iso8601,
+        "type"       => "email",
+        "value"      => record["email"],
+        "verified"   => false,
+        "primary"    => true,
+        "user_id"    => user_id,
+      }
 
-        self.data[:identities][user_identity_id] = user_identity
-        self.data[:users][user_id] = record.reject { |k,v| k == "email" }
+      self.data[:identities][user_identity_id] = user_identity
+      self.data[:users][user_id] = record.reject { |k,v| k == "email" }
 
-        response(
-          :method => :post,
-          :body   => {"user" => record},
-          :path   => path,
-        )
-      end
+      mock_response({"user" => record}, {status: 201})
     end
-  end # Mock
+  end
 end

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

@@ -1,44 +1,40 @@
-class Zendesk2::Client
-  class Real
-    def create_user_field(params={})
-      request(
-        :body   => {"user_field" => params},
-        :method => :post,
-        :path   => "/user_fields.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateUserField < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/user_fields.json" }
+  request_body { |r| { "user_field" => r.user_field_params } }
 
-  class Mock
-    def create_user_field(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[key type title description position active, regexp_for_validation tag custom_field_options]
+  end
 
-      record = {
-        "active"                => true,
-        "collapsed_for_agents"  => false,
-        "created_at"            => Time.now.iso8601,
-        "description"           => params["title"],
-        "editable_in_portal"    => false,
-        "id"                    => identity,
-        "position"              => 9999,
-        "regexp_for_validation" => "",
-        "removable"             => true,
-        "required"              => false,
-        "required_in_portal"    => false,
-        "tag"                   => "",
-        "title_in_portal"       => params["title"],
-        "updated_at"            => Time.now.iso8601,
-        "url"                   => url_for("/user_fields/#{identity}.json"),
-        "visible_in_portal"     => false,
-      }.merge(params)
+  def user_field_params
+    Cistern::Hash.slice(params.fetch("user_field"), *self.class.accepted_attributes)
+  end
 
-      self.data[:user_fields][identity] = record
+  def mock
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"user_field" => record},
-        :path   => "/user_fields.json"
-      )
-    end
-  end # Mock
-end # Zendesk2::Client
+    record = {
+      "active"                => true,
+      "collapsed_for_agents"  => false,
+      "created_at"            => Time.now.iso8601,
+      "description"           => params["title"],
+      "editable_in_portal"    => false,
+      "id"                    => identity,
+      "position"              => 9999,
+      "regexp_for_validation" => "",
+      "removable"             => true,
+      "required"              => false,
+      "required_in_portal"    => false,
+      "tag"                   => "",
+      "title_in_portal"       => params["title"],
+      "updated_at"            => Time.now.iso8601,
+      "url"                   => url_for("/user_fields/#{identity}.json"),
+      "visible_in_portal"     => false,
+    }.merge(user_field_params)
+
+    service.data[:user_fields][identity] = record
+
+    mock_response("user_field" => record)
+  end
+end

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

@@ -1,46 +1,41 @@
-class Zendesk2::Client
-  class Real
-    def create_user_identity(params={})
-      user_id = params.delete("user_id")
-
-      request(
-        :body   => {"identity" => params},
-        :method => :post,
-        :path   => "/users/#{user_id}/identities.json",
-      )
+class Zendesk2::Client::CreateUserIdentity < Zendesk2::Client::Request
+  request_method :post
+  request_path { |r| "/users/#{r.user_id}/identities.json" }
+  request_body { |r| { "identity" => r.user_identity_params } }
+
+  def self.accepted_attributes
+    %w[primary verified type value user_id]
+  end
+
+  def user_identity_params
+    Cistern::Hash.slice(params.fetch("user_identity"), *self.class.accepted_attributes)
+  end
+
+  def user_id
+    params.fetch("user_identity").fetch("user_id").to_i
+  end
+
+  def mock
+    identity = service.serial_id
+
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/user/#{user_id}/identities/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+      "verified"   => false,
+      "primary"    => false,
+      "user_id"    => user_id,
+    }.merge(user_identity_params)
+
+    record.merge("primary" => true) if service.data[:identities].values.find { |ui| ui["user_id"] == user_id }.nil?
+
+    if service.data[:identities].values.find { |i| i["value"] == record["value"] }
+      error!(:invalid, details: { "value" => [ { "description" => "Value: #{record["value"]} is already being used by another user" } ] })
     end
-  end # Real
-
-  class Mock
-    def create_user_identity(params={})
-      params = Cistern::Hash.stringify_keys(params)
-
-      identity = self.class.new_id
-      user_id  = params.delete("user_id").to_s
-
-      record = {
-        "id"         => identity,
-        "url"        => url_for("/user/#{user_id}/identities/#{identity}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-        "verified"   => false,
-        "primary"    => false,
-        "user_id"    => user_id,
-      }.merge(params)
-
-      record.merge("primary" => true) if self.data[:identities].values.find { |ui| ui["user_id"] == user_id }.nil?
-
-      if self.data[:identities].values.find { |i| i["value"] == record["value"] }
-        error!(:invalid, details: { "value"=> [ { "description"=>"Value: #{record["value"]} is already being used by another user" } ] })
-      end
-
-      self.data[:identities][identity] = record
-
-      response(
-        :method => :post,
-        :path   => "/user/#{user_id}/identities.json",
-        :body   => {"identity" => record}
-      )
-    end
-  end # Mock
+
+    service.data[:identities][identity] = record
+
+    mock_response("identity" => record)
+  end
 end