zendesk2 1.4.2 → 1.5.3

data/lib/zendesk2/client/request.rb

@@ -0,0 +1,271 @@
+class Zendesk2::Client::Request
+  def self.request_method(request_method=nil)
+    @request_method ||= request_method
+  end
+
+  def self.request_params(&block)
+    @request_params ||= block
+  end
+
+  def self.request_body(&block)
+    @request_body ||= block
+  end
+
+  def self.request_path(&block)
+    @request_path ||= block
+  end
+
+  def self.page_params!
+    @page_params = true
+  end
+
+  def self.page_params?
+    @page_params
+  end
+
+  def self.error_map
+    @@error_map ||= {
+      :invalid => [422, {
+        "error"       => "RecordInvalid",
+        "description" => "Record validation errors",
+      }],
+      :not_found => [404, {
+        "error"       => "RecordNotFound",
+        "description" => "Not found",
+      }],
+    }
+  end
+
+  attr_reader :params
+
+  def setup(params)
+    @params = Cistern::Hash.stringify_keys(params)
+  end
+
+  def _mock(params={})
+    setup(params)
+    mock
+  end
+
+  def _real(params={})
+    setup(params)
+    real
+  end
+
+  def page_params!(options)
+    if url = options.delete("url")
+      Faraday::NestedParamsEncoder.decode(URI.parse(url).query)
+    else
+      Cistern::Hash.stringify_keys(options)
+    end
+  end
+
+  def page_params?
+    self.class.page_params?
+  end
+
+  def request_params
+    if page_params?
+      page_params = page_params!(self.params)
+    end
+
+    if self.class.request_params
+      self.class.request_params.call(self)
+    else
+      page_params
+    end
+  end
+
+  def request_path
+    case (generator = self.class.request_path)
+    when Proc then
+      generator.call(self)
+    else raise ArgumentError.new("Couldn't generate request_path from #{generator.inspect}")
+    end
+  end
+
+  def request_body
+    case (generator = self.class.request_body)
+    when Proc then
+      generator.call(self)
+    when NilClass then nil
+    else raise("Invalid request body generator: #{generator.inspect}")
+    end
+  end
+
+  def pluralize(word)
+    pluralized = word.dup
+    [[/y$/, 'ies'], [/$/, 's']].find{|regex, replace| pluralized.gsub!(regex, replace) if pluralized.match(regex)}
+    pluralized
+  end
+
+  def data
+    self.service.data
+  end
+
+  def html_url_for(path)
+    File.join(service.url, path.to_s)
+  end
+
+  def url_for(path, options={})
+    URI.parse(
+      File.join(service.url, "/api/v2", path.to_s)
+    ).tap do |uri|
+      if query = options[:query]
+        uri.query = Faraday::NestedParamsEncoder.encode(query)
+      end
+    end.to_s
+  end
+
+  def real(params={})
+    service.request(:method => self.class.request_method,
+                    :path   => self.request_path,
+                    :body   => self.request_body,
+                    :url    => params["url"],
+                    :params => self.request_params,
+                   )
+  end
+
+  def real_request(params={})
+    request({
+      :method => self.class.request_method,
+      :path   => self.request_path(params),
+      :body   => self.request_body(params),
+    }.merge(cistern::hash.slice(params, :method, :path, :body, :headers)))
+  end
+
+  def mock_response(body, options={})
+    response(
+      :method        => self.class.request_method,
+      :path          => options[:path]    || self.request_path,
+      :request_body  => self.request_body,
+      :response_body => body,
+      :headers       => options[:headers] || {},
+      :status        => options[:status]  || 200,
+      :params        => options[:params]  || self.request_params,
+    )
+  end
+
+  def find!(collection, identity, options={})
+    if resource = self.service.data[collection][identity.to_i]
+      resource
+    else
+      error!(options[:error] || :not_found, options)
+    end
+  end
+
+  def delete!(collection, identity, options={})
+    self.service.data[collection].delete(identity.to_i) ||
+      error!(options[:error] || :not_found, options)
+  end
+
+  def error!(type, options={})
+    status, body = self.class.error_map[type]
+    body.merge!("details" => options[:details]) if options[:details]
+
+    response(
+      :path   => self.request_path,
+      :status => status,
+      :body   => body,
+    )
+  end
+
+  def resources(collection, options={})
+    page = collection.is_a?(Array) ? collection : service.data[collection.to_sym].values
+    root = options.fetch(:root) { !collection.is_a?(Array) && collection.to_s }
+
+    mock_response(
+      root    => page,
+      "count" => page.size,
+    )
+  end
+
+  def page(collection, options={})
+    url_params = options[:params] || params
+    page_params = page_params!(params)
+
+    page_size  = (page_params.delete("per_page") || 50).to_i
+    page_index = (page_params.delete("page") || 1).to_i
+    root       = options.fetch(:root) { !collection.is_a?(Array) && collection.to_s }
+    path       = options[:path] || request_path
+
+    offset     = (page_index - 1) * page_size
+
+    resources   = collection.is_a?(Array) ? collection : service.data[collection.to_sym].values
+    count       = resources.size
+    total_pages = (count / page_size) + 1
+
+    next_page = if page_index < total_pages
+                  url_for(path, query: {"page" => page_index + 1, "per_page" =>  page_size}.merge(url_params))
+                end
+    previous_page = if page_index > 1
+                      url_for(path, query: {"page" => page_index - 1, "per_page" =>  page_size}.merge(url_params))
+                    end
+
+    resource_page = resources.slice(offset, page_size)
+
+    body = {
+      root            => resource_page,
+      "count"         => count,
+      "next_page"     => next_page,
+      "previous_page" => previous_page,
+    }
+
+    response(
+      :body => body,
+      :path => path
+    )
+  end
+
+  # @fixme
+  # id values are validate for format / type
+  #
+  # {
+  #   "error": {
+  #     "title": "Invalid attribute",
+  #     "message": "You passed an invalid value for the id attribute. must be an integer"
+  #   }
+  # }
+  # @note
+  #
+  # \@request_body is special because it's need for spec assertions but
+  # {Faraday::Env} replaces the request body with the response body after
+  # the request and the reference is lost
+  def response(options={})
+    body                 = options[:response_body] || options[:body]
+    method               = options[:method]        || :get
+    params               = options[:params]
+    service.last_request = options[:request_body]
+    status               = options[:status]        || 200
+
+    path = options[:path]
+    url  = options[:url] || url_for(path, query: params)
+
+    request_headers  = {"Accept"       => "application/json"}
+    response_headers = {"Content-Type" => "application/json; charset=utf-8"}
+
+    # request phase
+    # * :method - :get, :post, ...
+    # * :url    - URI for the current request; also contains GET parameters
+    # * :body   - POST parameters for :post/:put requests
+    # * :request_headers
+
+    # response phase
+    # * :status - HTTP response status code, such as 200
+    # * :body   - the response body
+    # * :response_headers
+    env = Faraday::Env.from(
+      :method           => method,
+      :url              => URI.parse(url),
+      :body             => body,
+      :request_headers  => request_headers,
+      :response_headers => response_headers,
+      :status           => status,
+    )
+
+    Faraday::Response::RaiseError.new.on_complete(env) ||
+      Faraday::Response.new(env)
+  rescue Faraday::Error::ClientError => e
+    raise Zendesk2::Error.new(e)
+  end
+end

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

@@ -1,32 +1,24 @@
-class Zendesk2::Client
-  class Real
-    def create_category(params={})
-      request(
-        :body   => {"category" => params},
-        :method => :post,
-        :path   => "/categories.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateCategory < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/categories.json" }
+  request_body { |r| {"category" => r.params["category"]} }
 
-  class Mock
-    def create_category(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[id name description position]
+  end
 
-      record = {
-        "id"         => identity,
-        "url"        => url_for("/categories/#{identity}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-      }.merge(params)
+  def mock
+    identity = service.serial_id
 
-      self.data[:categories][identity] = record
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/categories/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+    }.merge(Cistern::Hash.slice(params.fetch("category"), *self.class.accepted_attributes))
 
-      response(
-        :method => :post,
-        :body   => {"category" => record},
-        :path   => "/categories.json"
-      )
-    end
-  end # Mock
+    service.data[:categories][identity] = record
+
+    mock_response({"category" => record}, {status: 201})
+  end
 end

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

@@ -1,33 +1,28 @@
-class Zendesk2::Client
-  class Real
-    def create_forum(params={})
-      request(
-        :body   => {"forum" => params},
-        :method => :post,
-        :path   => "/forums.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateForum < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/forums.json" }
+  request_body { |r| {"forum" => r.forum_params } }
 
-  class Mock
-    def create_forum(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[name description category_id organization_id locale_id locked position forum_type access]
+  end
 
-      record = {
-        "id"         => identity,
-        "url"        => url_for("/forums/#{identity}.json"),
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-      }.merge(params)
+  def forum_params
+    Cistern::Hash.slice(params.fetch("forum"), *self.class.accepted_attributes)
+  end
 
-      path = "/forums.json"
-      self.data[:forums][identity]= record
+  def mock
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"forum" => record},
-        :path   => path,
-      )
-    end
-  end # Mock
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/forums/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+    }.merge(Cistern::Hash.slice(params.fetch("forum"), *self.class.accepted_attributes))
+
+    service.data[:forums][identity] = record
+
+    mock_response({"forum" => record}, {status: 201})
+  end
 end

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

@@ -1,33 +1,29 @@
-class Zendesk2::Client
-  class Real
-    def create_group(params={})
-      request(
-        :body   => {"group" => params},
-        :method => :post,
-        :path   => "/groups.json",
-      )
-    end
-  end # Real
+class Zendesk2::Client::CreateGroup < Zendesk2::Client::Request
+  request_method :post
+  request_path { |_| "/groups.json" }
+  request_body { |r|  { "group" => r.group_params } }
 
-  class Mock
-    def create_group(params={})
-      identity = self.class.new_id
+  def self.accepted_attributes
+    %w[name]
+  end
 
-      record = {
-        "id"               => identity,
-        "url"              => url_for("/groups/#{identity}.json"),
-        "created_at"       => Time.now.iso8601,
-        "updated_at"       => Time.now.iso8601,
-        "deleted"          => false,
-      }.merge(params)
+  def group_params
+    @_group_params ||= Cistern::Hash.slice(params.fetch("group"), *self.class.accepted_attributes)
+  end
 
-      self.data[:groups][identity] = record
+  def mock(params={})
+    identity = service.serial_id
 
-      response(
-        :method => :post,
-        :body   => {"group" => record},
-        :path   => "/groups.json"
-      )
-    end
-  end # Mock
-end # Zendesk2::Client
+    record = {
+      "id"         => identity,
+      "url"        => url_for("/groups/#{identity}.json"),
+      "created_at" => Time.now.iso8601,
+      "updated_at" => Time.now.iso8601,
+      "deleted"    => false,
+    }.merge(group_params)
+
+    self.data[:groups][identity] = record
+
+    mock_response({"group" => record}, {status: 201})
+  end
+end

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

@@ -1,61 +1,55 @@
-class Zendesk2::Client
-  class Real
-    def create_help_center_article(params={})
-      section_id = require_parameters(params, "section_id")
-      path = if locale = params["locale"]
-              "/help_center/#{locale}/sections/#{section_id}/articles.json"
-            else
-              "/help_center/sections/#{section_id}/articles.json"
-            end
-
-
-      request(
-        :body   => {"article" => params},
-        :method => :post,
-        :path   => path,
-      )
+class Zendesk2::Client::CreateHelpCenterArticle < Zendesk2::Client::Request
+  request_method :post
+  request_body { |r| { "article" => r.article_params } }
+  request_path { |r|
+    if locale = r.article_params["locale"]
+      "/help_center/#{locale}/sections/#{r.section_id}/articles.json"
+    else
+      "/help_center/sections/#{r.section_id}/articles.json"
     end
-  end # Real
-
-  class Mock
-    def create_help_center_article(params={})
-      params = Cistern::Hash.stringify_keys(params)
-
-      identity = self.class.new_id
-
-      section_id = *require_parameters(params, "section_id")
-
-      locale = params["locale"] ||= "en-us"
-      position = self.data[:help_center_articles].values.select { |a| a["section_id"] == section_id }.size
-
-      record = {
-        "id"                => identity,
-        "url"               => url_for("/help_center/#{locale}/articles/#{identity}.json"),
-        "html_url"          => html_url_for("/hc/#{locale}/articles/#{identity}.json"),
-        "author_id"         => current_user["id"],
-        "comments_disabled" => false,
-        "label_names"       => [],
-        "draft"             => false,
-        "promoted"          => false,
-        "position"          => position,
-        "vote_sum"          => 0,
-        "vote_count"        => 0,
-        "section_id"        => section_id,
-        "created_at"        => Time.now.iso8601,
-        "updated_at"        => Time.now.iso8601,
-        "title"             => "",
-        "body"              => "",
-        "source_locale"     => locale,
-        "outdated"          => false,
-      }.merge(params)
-
-      self.data[:help_center_articles][identity] = record
-
-      response(
-        :method => :post,
-        :body   => {"article" => record},
-        :path   => "/sections/#{section_id}.json"
-      )
-    end
-  end # Mock
-end # Zendesk2::Client
+  }
+
+  def self.accepted_attributes
+    %w[author_id body comments_disabled draft label_names locale position promoted section_id title]
+  end
+
+  def article_params
+    @_article_params ||= Cistern::Hash.slice(params.fetch("article"), *self.class.accepted_attributes)
+  end
+
+  def section_id
+    params.fetch("article").fetch("section_id")
+  end
+
+  def mock
+    identity = service.serial_id
+
+    locale = params["locale"] ||= "en-us"
+    position = self.data[:help_center_articles].values.select { |a| a["section_id"] == section_id }.size
+
+    record = {
+      "id"                => identity,
+      "url"               => url_for("/help_center/#{locale}/articles/#{identity}.json"),
+      "html_url"          => html_url_for("/hc/#{locale}/articles/#{identity}.json"),
+      "author_id"         => service.current_user["id"],
+      "comments_disabled" => false,
+      "label_names"       => [],
+      "draft"             => false,
+      "promoted"          => false,
+      "position"          => position,
+      "vote_sum"          => 0,
+      "vote_count"        => 0,
+      "section_id"        => section_id,
+      "created_at"        => Time.now.iso8601,
+      "updated_at"        => Time.now.iso8601,
+      "title"             => "",
+      "body"              => "",
+      "source_locale"     => locale,
+      "outdated"          => false,
+    }.merge(article_params)
+
+    self.data[:help_center_articles][identity] = record
+
+    mock_response("article" => record)
+  end
+end