rodzilla 0.1.3 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDUwNjdjOGNmNzE3ZWQzNDg2ZTE1MmVhZDFmNmUyYWU4N2RmM2ZkMA==
+    OGE5NzhhNGZkZDIyZWIwNWQxNTQ5MzI5YjRlYjliZjk3NDRkOWMwNw==
   data.tar.gz: !binary |-
-    ODU5NjEwNDMyNGQ5YWIyNjViNTExOWVhYWYyMDJkY2JiNTYxN2EwYw==
+    NDJiZjc4MDI0YjE3M2E3MzQ3ZTU4ZWFjOTc2ZmY4MGM3MDgxZmEzNw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NTVkZmFhMzliYjcxM2RlNzdmMzU2YTE4NDRiMjJmYjViNmVlM2Q1NDlmMWRl
-    OGNlNTA1MmU4MGU1OGExZDk2MjQyMWQ1N2MyOWY0YWZkMDNmY2VjODc1OGMz
-    MDZlNzNkZDY3MWMyMzE0YTYyOWE4NWYyZmU2OGI5YTI5ZDU0ZWQ=
+    NTU4YzIyNjI0NDk4OTdkZGQ4ZjY4YjlkNzIwNWRmYzRhZDUzY2VlNmMyNmY4
+    MmJlMGVlMGIyMTAzZTA5ZWY5ZTk4MDIxYTg1ZDRkNTcxOTZjOWY3Mzc0MTU0
+    MjJhNzNkN2Q5ZjA0MDJiMGNkMzdkNmM5YjVhZjg1MDA2OWE0NDc=
   data.tar.gz: !binary |-
-    NGM1ZTU1NWE4ZGVhZGVkNDI1MWZmNzc0ODYwMTdlZjMxZmUxMTBlNmNiZTdi
-    M2I3Yjc0MTVjMTYxODZjZGI2ZTEzNjllZjI3NWMwZjQxZmIwYWMyZTdkOGUy
-    OTRlNzZlYmQ3ZWJlOTJjY2MzNzU1ZThlOTBlYWI2MGUxOGRlZDA=
+    N2RhOGMyNmE2NjdkYWVlYzMzNDM5NDY0NGJjNDU0YWUxZjRjZWIxNGQ1ZDIx
+    ZmI2ZGZlYzUwNDY2Nzc0YTVkMzJmMzE1YWRlNGJiZDExNWMxZTY5YTI0OTAy
+    NTFkNDBiMmI1YmY2NDA3NTU2MzBiODhjN2U0ODFhZmJlNjc2N2I=

data/Gemfile

@@ -1,4 +1,13 @@
 source 'https://rubygems.org'
 
+gem "rake"
+
+group :test do
+  gem "minitest"
+  gem "mocha"
+  gem "simplecov", :require => false
+  gem "webmock"
+end
+
 # Specify your gem's dependencies in rodzilla.gemspec
 gemspec

data/lib/rodzilla.rb

@@ -1,53 +1,28 @@
 require "httparty"
 require "json"
-require "rodzilla/version"
-require "rodzilla/exception"
-
-# load resources
-require "rodzilla/resource/base"
-require "rodzilla/resource/product"
-require "rodzilla/resource/classification"
-require "rodzilla/resource/bugzilla"
-require "rodzilla/resource/bug"
 
 module Rodzilla
-  class WebService
-
-    attr_accessor :base_url, :username, :password, :format 
-
-    # @param base_url [String]  the bugzilla full url
-    # @param username [String]  the bugzilla authorized users username
-    # @param password [String]  the bugzilla authorized users password
-    # @param format   [Symbol]  the request/response format `:xml` or `:json`
-    def initialize(base_url, username, password, format=:json)
-      @base_url = base_url
-      @username = username
-      @password = password
-      @format   = format
-    end
-
-    def products
-      bugzilla_resource('Product')
-    end
-
-    def bugzilla
-      bugzilla_resource('Bugzilla')
-    end
-
-    def classifications
-      bugzilla_resource('Classification')
-    end
-
-    def bugs
-      bugzilla_resource('Bug')
-    end
-
-    protected
-      def bugzilla_resource(resource)
-        raise Rodzilla::ResourceNotFoundError, "Error: #{resource} not found." unless Rodzilla::Resource.constants.include?(resource.to_sym)
-        klass = Object.module_eval("Rodzilla::Resource::#{resource}").new(@base_url, @username, @password, @format)
-      end
-
+  
+  autoload :VERSION, 'rodzilla/version'
+  autoload :Util, 'rodzilla/util'
+  autoload :Error, 'rodzilla/error'
+  autoload :WebService, 'rodzilla/web_service'
+
+  module JsonRpc
+    autoload :Error, 'rodzilla/json_rpc/error'
+    autoload :Service, 'rodzilla/json_rpc/service'
+    autoload :Request, 'rodzilla/json_rpc/request'
+    autoload :Response, 'rodzilla/json_rpc/response'
+  end
 
+  module Resource
+    autoload :Base,   'rodzilla/resource/base'
+    autoload :Bug,    'rodzilla/resource/bug'
+    autoload :Bugzilla, 'rodzilla/resource/bugzilla'
+    autoload :Classification, 'rodzilla/resource/classification'
+    autoload :Group, 'rodzilla/resource/group'
+    autoload :Product, 'rodzilla/resource/product'
+    autoload :User, 'rodzilla/resource/user'
   end
+
 end

data/lib/rodzilla/error.rb

@@ -0,0 +1,6 @@
+module Rodzilla
+  module Error
+    class ResourceNotFoundError < StandardError; ;end
+    class JsonRpcResponseError < StandardError; ;end
+  end
+end

data/lib/rodzilla/json_rpc/error.rb

@@ -0,0 +1,35 @@
+module Rodzilla
+  module JsonRpc
+    module Error
+
+      # Raised if a JsonRpc Response id is not the same as the request id
+      class InvalidResponseId < StandardError; ;end
+
+      # Raised when any other method besides POST or GET is used
+      class UnsupportedHttpMethod < StandardError; ;end
+
+      # Raised whenever the JsonRpc::Response#error attribute is not nil
+      #
+      # Also inherited by Client & ServerError for handling HTTP Status Codes
+      class ResponseError < StandardError
+        attr_reader :code
+
+        def initialize(code)
+          @code = code
+        end
+
+      end
+
+      # Raised when the HTTP Response Status Code is in the 400 Range
+      class ClientError < ResponseError; ;end
+
+      # Raised when the HTTP Response Status Code is in the 500 Range
+      class ServerError < ResponseError; ;end
+
+      # Raised when something goes wrong with the raw HTTP Request
+      class HttpError < StandardError; ;end
+
+
+    end
+  end
+end

data/lib/rodzilla/json_rpc/request.rb

@@ -0,0 +1,24 @@
+module Rodzilla
+  module JsonRpc
+    class Request
+      attr_accessor :id, :params, :method, :headers
+
+      def initialize(&block)
+        yield(self) if block_given?
+      end
+
+      def get_request_object
+        {
+          id: @id,
+          method: @method,
+          params: [@params]
+        }
+      end
+
+      def serialize
+        JSON.dump(get_request_object)
+      end
+
+    end
+  end
+end

data/lib/rodzilla/json_rpc/response.rb

@@ -0,0 +1,20 @@
+module Rodzilla
+  module JsonRpc
+    class Response
+      attr_accessor :result, :error, :id
+
+      def initialize
+        @error = nil
+      end
+      
+      def read_http_response(http_response)
+        body = http_response.parsed_response
+        @id     = body["id"]
+        @error  = body["error"]
+        @result = body["result"]
+        self
+      end
+      
+    end
+  end
+end

data/lib/rodzilla/json_rpc/service.rb

@@ -0,0 +1,94 @@
+module Rodzilla
+  module JsonRpc
+
+    class Service
+
+      include HTTParty
+
+      attr_accessor :rpc_request, :rpc_response,
+                    :username, :password, :credentials, :url
+
+      def initialize(url, username, password)
+        @url = url
+        @username = username
+        @password = password
+        @credentials = {
+          Bugzilla_login: @username,
+          Bugzilla_password: @password
+        }
+        setup_request
+      end
+
+      def send_request!(rpc_method, params={}, http_method=:post)
+        setup_request
+        setup_request_data(rpc_method, params)
+
+        unless ["post","get"].include?(http_method.to_s.downcase)
+          raise Rodzilla::JsonRpc::Error::UnsupportedHttpMethod, "Error: Only GET and POST request are supported HTTP methods."
+        end
+
+        execute_request_and_response(http_method)
+      end
+
+      def execute_request_and_response(http_method)
+        raw_request(http_method)
+        parse_http_response
+        raise Rodzilla::JsonRpc::Error::InvalidResponseId unless check_cycle_id
+        raise Rodzilla::JsonRpc::Error::ResponseError.new(@rpc_response.error["code"]), @rpc_response.error["message"] if @rpc_response.error
+        @rpc_response.result
+      end
+
+      private
+
+        def raw_request(http_method)
+          begin
+            @http_response = self.class.send(http_method, @url, body: rpc_request.serialize, headers: rpc_request.headers )
+          rescue => ex
+            raise Rodzilla::JsonRpc::Error::HttpError,  ex.message
+          end
+
+          case @http_response.code
+          when 400...500
+            raise Rodzilla::JsonRpc::Error::ClientError
+          when 500...600
+            raise Rodzilla::JsonRpc::Error::ServerError
+          end
+
+        end
+
+        # Sets the Content-Type to application/json-rpc for the Service
+        # also adds Bugzilla defined login/password to the request parameters
+        # 
+        # sets id for the request which is later checked using check_cycle_id
+        # 
+        # Return 
+        def setup_request
+          @rpc_request = Rodzilla::JsonRpc::Request.new do |request|
+            request.headers = { 'Content-Type' => 'application/json-rpc' }
+            request.id = generate_cycle_id
+          end
+        end
+
+        def setup_request_data(rpc_method, params={})
+          @rpc_request.method = rpc_method
+          @rpc_request.params = @credentials.merge(params)
+        end
+
+        # TODO: Consider replacing with Random.rand(1..N) for increased security
+        def generate_cycle_id; 1; end
+
+        def check_cycle_id
+          return false if rpc_request.id != rpc_response.id
+          true
+        end
+
+        def parse_http_response
+          @rpc_response = Rodzilla::JsonRpc::Response.new
+          @rpc_response.read_http_response(@http_response)
+          @rpc_response
+        end
+
+    end
+
+  end
+end

data/lib/rodzilla/resource/base.rb

@@ -1,71 +1,48 @@
 module Rodzilla
   module Resource
     class Base
-      @@_request_id = 1
-      include HTTParty
-      attr_accessor :base_url, :username, :password, :format, 
-                    :request_url, :response, :result, :credentials, :headers
+      attr_accessor :base_url, :username, :password, :service, :format
       
       def initialize(base_url, username, password, format=:json)
         @base_url = base_url
         @username = username
         @password = password
-        @format   = format
-        @credentials = {
-          Bugzilla_login: @username,
-          Bugzilla_password: @password
-        }
-        @headers = { "Content-Type" => 'application/json-rpc' }
+        @format = format
+
+        setup_service(format)
       end
 
-      
+      def rpc_call(rpc_method_name, params={}, http_method=:post)
+        service.send_request!( get_resource_rpc_method_name(rpc_method_name), params, http_method)
+      end
 
       protected
       
-        def prepare_request(params={})
-          @request_url  = build_url
-          @params       = build_params(params)
-        end
-
-        def build_url
-          File.join("#{@base_url}", "#{@format}rpc.cgi")
-        end
-
-        def build_params(params={})
-          rpc_method = params.delete(:rpc_method)
-          { params: [@credentials.merge(params)], method: "#{self.class.demodulize(self.class)}.#{rpc_method}", id: make_id }
+        def get_resource_rpc_method_name(rpc_method_name)
+          [Rodzilla::Util.demodulize(self.class), rpc_method_name.to_s].join('.')
         end
 
-        def self.demodulize(path)
-          path = path.to_s
-          if i = path.rindex('::')
-            path[(i+2)..-1]
-          else
-            path
+        def setup_service(format)
+          case format
+          when :json
+            @endpoint_url = set_endpoint_url(:json)
+            @service  = Rodzilla::JsonRpc::Service.new(@endpoint_url, @username, @password)
           end
         end
 
-        def make_id
-          @@_request_id += 1
-        end
-
-        def rpc_call(params={})
-          prepare_request( params )
-          @response = self.class.post(@request_url, body: JSON.dump(@params), headers: @headers )
-          parse_rpc_response!
+        def set_endpoint_url(format)
+          case format
+          when :json
+            File.join(@base_url, 'jsonrpc.cgi')
+          end
         end
 
-        def parse_rpc_response!
-          begin
-            res = @response.parsed_response
-            if err = res["error"]
-              raise Rodzilla::JsonRpcResponseError, "Error (#{err['code']}): #{err['message']}"
-            end
-            @result = res["result"]
-          rescue => ex
-            raise ex
+        def check_params(required=[], actual)
+          if actual.is_a?(Hash)
+            (required - actual.keys).length == 0
+          else
+            (required - actual).length == 0
           end
-          @result
         end
 
     end

data/lib/rodzilla/resource/bug.rb

@@ -1,37 +1,107 @@
 module Rodzilla
   module Resource
     class Bug < Base
-      REQUIRED_FIELDS = [:product, :component, :summary, :version, :description, :op_sys, :platform, :priority, :severity]
 
+      # Get information about valid bug fields, including the lists of legal values for each field.
+      # 
+      # ids (array) - An array of integer field ids.
+      # names (array) - An array of strings representing field names.
+      # 
+      # Support: >= 3.6
+      # 
+      # If neither ids nor names is specified, then all non-obsolete fields will be returned.
       def fields(params={})
-        rpc_call( params.merge(rpc_method: "fields"))
-      end
-
-      # Returns all comments associated with a Bug
-      def comments(params={})
-        raise ArgumentError, "Error: comments requires that bug_id be set" unless params[:ids]
+        rpc_call :fields, params
       end
 
+      # Allows you to search for bugs based on particular criteria.
+      # 
       # Unless otherwise specified in the description of a parameter,
       # bugs are returned if they match exactly the criteria you specify in these parameters.
       # That is, we don't match against substrings--if a bug is in the "Widgets" product and you ask for bugs in the "Widg" product, you won't get anything.
       # 
-      # Criteria are joined in a logical AND. 
-      # That is, you will be returned bugs that match all of the criteria, not bugs that match any of the criteria.
+      # Criteria are joined in a logical AND
+      # 
+      # alias         - string The unique alias for this bug.
+      # assigned_to   - string The login name of a user that a bug is assigned to.
+      # component     - string The name of the Component that the bug is in. Note that if there are multiple Components with the same name, and you search for that name, bugs in all those Components will be returned. If you don't want this, be sure to also specify the product argument.
+      # creation_time - dateTime Searches for bugs that were created at this time or later. May not be an array.
+      # creator       - string The login name of the user who created the bug.
+      # id            - int The numeric id of the bug.
+      # last_change_time - dateTime Searches for bugs that were modified at this time or later. May not be an array.
+      # limit         - int Limit the number of results returned to int records. If the limit is more than zero and higher than the maximum limit set by the administrator, then the maximum limit will be used instead. If you set the limit equal to zero, then all matching results will be returned instead.
+      # offset - int Used in conjunction with the limit argument, offset defines the starting position for the search. For example, given a search that would return 100 bugs, setting limit to 10 and offset to 10 would return bugs 11 through 20 from the set of 100.
+      # op_sys - string The "Operating System" field of a bug.
+      # platform -string The Platform (sometimes called "Hardware") field of a bug.
+      # priority  - string The Priority field on a bug.
+      # product - string The name of the Product that the bug is in.
+      # resolution - string The current resolution--only set if a bug is closed. You can find open bugs by searching for bugs with an empty resolution.
+      # severity - string The Severity field on a bug.
+      # status - string The current status of a bug (not including its resolution, if it has one, which is a separate field above).
+      # summary - string Searches for substrings in the single-line Summary field on bugs. If you specify an array, then bugs whose summaries match any of the passed substrings will be returned.
+      # target_milestone - string The Target Milestone field of a bug. Note that even if this Bugzilla does not have the Target Milestone field enabled, you can still search for bugs by Target Milestone. However, it is likely that in that case, most bugs will not have a Target Milestone set (it defaults to "---" when the field isn't enabled).
+      # qa_contact - string The login name of the bug's QA Contact. Note that even if this Bugzilla does not have the QA Contact field enabled, you can still search for bugs by QA Contact (though it is likely that no bug will have a QA Contact set, if the field is disabled).
+      # url - string The "URL" field of a bug.
+      # version
+      # 
+      # All params can be either the type or an array of the types
+      def search(params={})
+        rpc_call :search, params
+      end
+
+      # It allows you to get data about attachments, given a list of bugs and/or attachment ids.
+      # Note: Private attachments will only be returned if you are in the insidergroup or if you are the submitter of the attachment.
+      # 
+      # ids (Array)             - An array of integer field ids.
+      # attachment_ids (Array)  - An array of integer attachment ids.
+      # 
+      # Support: >= 3.6
+      # 
+      # Returns a Hash containing two elements: bugs and attachments
+      def attachments(params={})
+        raise ArgumentError, "Error: ids or attachment_ids must be set" unless params[:ids] || params[:attachment_ids]
+        rpc_call :attachments, params
+      end
+
+      # Gets information about particular bugs in the database.
+      # 
+      # ids (Array) - An array of numbers and strings. If an element in the array is entirely numeric, 
+      #               it represents a bug_id from the Bugzilla database to fetch. If it contains any non-numeric characters, 
+      #               it is considered to be a bug alias instead, and the bug with that alias will be loaded.
+      # permissive (Boolean) - Normally, if you request any inaccessible or invalid bug ids, Bug.get will throw an error. If true it returns info
+      #               about bugs that fail.
+      # 
       # 
-      # Each parameter can be either the type it says, or an array of the types it says.
-      # If you pass an array, it means "Give me bugs with any of these values."
-      # For example, if you wanted bugs that were in either the "Foo" or "Bar" products, you'd pass:
+      # Support: >= 3.4              
+      # 
+      # Returns a Hash containing two elements: bugs and faults
+      def get(params={})
+        rpc_call :get, params
+      end
+
+      # Same as get
       # 
-      # Valid values:
-      # product, url, id, alias, limit
-      def search(query={})
-        rpc_call( query.merge(rpc_method: 'search') )
+      # Backwards compat with v3.0
+      def get_bugs(params={})
+        rpc_call :get_bugs, params
       end
 
-      # see: http://www.bugzilla.org/docs/tip/en/html/api/Bugzilla/WebService/Bug.html#create
+
+      # This allows you to get data about comments, given a list of bugs and/or comment ids.
+      # 
+      # ids (Array)             - An array of integer field ids.
+      # comment_ids (Array)             - An array of integer field ids.
       # 
-      # Required Fields:
+      # Support: >= 3.4
+      # 
+      # Returns a Hash containing two items: bugs and comments
+      def comments(params={})
+        raise ArgumentError, "Error: ids or comment_ids must be set" unless params[:ids] || params[:comment_ids]
+        rpc_call :comments, params
+      end
+
+      # This allows you to create a new bug in Bugzilla.
+      #
       # product (string) Required - The name of the product the bug is being filed against.
       # component (string) Required - The name of a component in the product above.
       # summary (string) Required - A brief description of the bug being filed.
@@ -41,17 +111,51 @@ module Rodzilla
       # platform (string) Defaulted - What type of hardware the bug was experienced on.
       # priority (string) Defaulted - What order the bug will be fixed in by the developer, compared to the developer's other bugs.
       # severity (string) Defaulted - How severe the bug is.
-      # 
-      # Raises an exception if a required field is not provided
       def create!(params={})
-        REQUIRED_FIELDS.each { |field| raise ArgumentError, "Error: #{field} is required" unless params[field] }
-        rpc_call( params.merge(rpc_method: 'create' ))
+        raise ArgumentError, "Error: product, component, summary, version are required args" unless check_params([:product, :component, :summary, :version], params)
+        rpc_call :create, params
       end
 
+      # Same as create! but does not raise an ArgumentError for required arguments
       def create(params={})
-        rpc_call( params.merge(rpc_method: 'create'))
+        rpc_call :create, params
+      end
+
+      # This allows you to add an attachment to a bug in Bugzilla.
+      # 
+      # ids - (Required) An array of ints and/or strings--the ids or aliases of bugs that you want to add this attachment to. The same attachment and comment will be added to all these bugs.
+      # data - (Required) base64 or string The content of the attachment. If the content of the attachment is not ASCII text, you must encode it in base64 and declare it as the base64 type.
+      # file_name - (Required) string The "file name" that will be displayed in the UI for this attachment.
+      # summary - (Required) string A short string describing the attachment.
+      # content_type - (Required) string The MIME type of the attachment, like text/plain or image/png.
+      # 
+      # comment - String A comment to add along with this attachment.
+      # is_patch Boolean true if Bugzilla should treat this attachment as a patch
+      # is_private  Boolean true if the attachment should be private 
+      # 
+      # Support: >= 4.0
+      #
+      # Returns a single item ids, which contains an array of the attachment id(s) created. 
+      def add_attachment!(params={})
+        raise ArgumentError, "Error: ids, data, file_name, summary, and content_type are required args" unless check_params([:ids, :data, :file_name, :summary, :content_type], params)
+        rpc_call :add_attachment, params
+      end
+
+      # Same as add_attachment! but won't raise an exception for missing required arguments
+      def add_attachment(params={})
+        rcp_call :add_attachment, params
       end
-      
+
+      # Allows you to update the fields of a bug. Automatically sends emails out about the changes.
+      # 
+      # ids - Array of ints or strings. The ids or aliases of the bugs that you want to modify.
+      # 
+      # Returns a Hash with a single field, "bugs".
+      def update(params={})
+        raise ArgumentError, "Error: ids is a required arg" unless check_params([:ids], params)
+        rpc_call :update, params
+      end
+
     end
   end
 end