kalibro_client 1.4.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed65cbefe30d43263bfeb3de750e2cefa8a369e7
-  data.tar.gz: c931c4e8fc1caa2388c28799f9e04855da4704e0
+  metadata.gz: 3a5bcfbb03d6e6c0d2bf2c3b4d671daf6fe2dcc6
+  data.tar.gz: 968a58a0f973981f2909bdb0ef6969a0c19cce24
 SHA512:
-  metadata.gz: aa7ecfe6855dee9d5270eaf84521acf67166d436a3450053226aa34fb8ca020ca11db7b9879da4ca71e38ecf44cd5d1f5be1c22851899be5918d64abb7ddefdf
-  data.tar.gz: a8586ac0368fccb3265b596c363d2c88e364691c1f8d701007756d09b68a161ec1b45a42452c1a929e446b2e3b08f1fe1c3e72fc0f39dd414c691c948c18914f
+  metadata.gz: 815e31061ec7660983846ffed1052d3d2bcfaee8c373b287757ca2ba192f3943939fc292687738504a964f664a1dda6d5a4534512e808653407ce8fe9989022b
+  data.tar.gz: cec3da37bf2df5bd5926679ddbda0aa7fc76f5c276f309acc46daf732e75d4953b0f3e25408f59ce0c471618a545d40ccee990cf7772c3c4926889959935d754

data/.travis.yml

@@ -5,13 +5,11 @@ rvm:
 addons:
   postgresql: "9.3"
 
-before_script:
-  - git clone https://github.com/mezuro/kalibro_install.git -b v3.5 kalibro_install
-  - pushd kalibro_install
-    # Remove bugged libzmq3 package, see https://github.com/travis-ci/travis-ci/issues/982 and https://github.com/travis-ci/travis-ci/issues/1715 for details
+before_script: 
+  # Remove bugged libzmq3 package, see https://github.com/travis-ci/travis-ci/issues/982 and https://github.com/travis-ci/travis-ci/issues/1715 for details
   - sudo apt-get remove libzmq3
-  - bash install.sh
-  - popd
+  - git clone https://github.com/mezuro/kalibro_install.git -b v3.8 kalibro_install
+  - KALIBRO_PROCESSOR_VERSION='v1.0.0' KALIBRO_CONFIGURATIONS_VERSION='v1.1.1' ./kalibro_install/install.sh
   - cp features/support/kalibro_cucumber_helpers.yml.sample features/support/kalibro_cucumber_helpers.yml
   - export BUNDLE_GEMFILE=$PWD/Gemfile
   - export CODECLIMATE_REPO_TOKEN=46cbb96b053b03ad66b0355bd96d0787f56fc5a4fc171b8d6eb30c421c5e6777
@@ -20,6 +18,10 @@ script:
   - bundle exec rspec spec
   - bundle exec cucumber --tags ~@wip
 
+after_failure:
+  - echo Tests failed - preparing to ship logs to Gist
+  - ./kalibro_install/travis-send-logs.sh
+
 notifications:
   email:
     recipients:

data/features/kalibro_range/find.feature

@@ -11,4 +11,4 @@ Scenario: find a valid range
     And I have a reading within the given reading group
     And I have a range within the given reading
     When I search a range with the same id of the given range
-    Then it should return the same range as the given one
+    Then it should return the same range as the given one

data/features/kalibro_range/update.feature

@@ -49,6 +49,5 @@ Feature: Update
     And I have another range within the given reading
     When I change the "beginning" to "0"
     And I ask to update the given range
-    Then I should get the error "Beginning Should be unique within a Metric Configuration" 
+    Then I should get the error "Beginning Should be unique within a Metric Configuration"
     And I should get the error "Beginning There is already a KalibroRange within these boundaries! Please, choose another interval."
-

data/features/metric_result/hotspot_related_results.feature

@@ -0,0 +1,17 @@
+Feature: Related HotspotMetricResults
+  In order to list which HotspotMetricResult is related to a given one
+  As a developer
+  I want to be able to call them directly as they were associated
+
+  @kalibro_configuration_restart @kalibro_processor_restart
+  Scenario: when there are HotspotMetricResults
+    Given I have a kalibro configuration with name "Conf"
+    And I have a flay configuration within the given kalibro configuration
+    And I have the given repository:
+      |        name       | scm_type |                   address                        |  branch |
+      | Kalibro Processor |    GIT   | https://github.com/mezuro/kalibro_processor.git  | v0.11.0 |
+    And I call the process method for the given repository
+    And I wait up for a ready processing
+    When I request the first hotspot metric result from the root module result
+    And I ask for the related results for the given metric result
+    Then I should get a list of hotspot metric results including the given one

data/features/step_definitions/hotspot_metric_result_step.rb

@@ -0,0 +1,15 @@
+When(/^I request the first hotspot metric result from the root module result$/) do
+  root_module_result = KalibroClient::Entities::Processor::ModuleResult.find @repository.last_ready_processing.root_module_result_id
+  @hotspot_metric_result = root_module_result.hotspot_metric_results.first
+end
+
+When(/^I ask for the related results for the given metric result$/) do
+  @related_results = @hotspot_metric_result.related_results
+end
+
+Then(/^I should get a list of hotspot metric results including the given one$/) do
+  expect(@related_results).to include(@hotspot_metric_result)
+  @related_results.each do |related_result|
+    expect(related_result).to be_a KalibroClient::Entities::Processor::HotspotMetricResult
+  end
+end

data/features/step_definitions/metric_result_steps.rb

@@ -1,16 +1,16 @@
 When(/^I call the metric results of method with the results root id of the given processing$/) do
-  @response = KalibroClient::Entities::Processor::ModuleResult.find(@response.root_module_result_id).metric_results
+  @response = KalibroClient::Entities::Processor::ModuleResult.find(@response.root_module_result_id).tree_metric_results
 end
 
 Given(/^I search a metric result with descendant values for the given metric result$/) do
   first_module_result = KalibroClient::Entities::Processor::ModuleResult.find(@response.root_module_result_id)
 
-  metric_results = first_module_result.metric_results
+  metric_results = first_module_result.tree_metric_results
   @response = metric_results.first.descendant_values
 end
 
 When(/^I call the history of method with the metric name and the results root id of the given processing$/) do
-  @response = KalibroClient::Entities::Processor::MetricResult.history_of(@metric.name, @response.root_module_result_id, @repository.id)
+  @response = KalibroClient::Entities::Processor::TreeMetricResult.history_of(@metric.name, @response.root_module_result_id, @repository.id)
 end
 
 Then (/^I should get a Float list$/) do

data/features/step_definitions/processing_steps.rb

@@ -1,11 +1,9 @@
+require 'timeout'
+
 Given(/^I wait up for a ready processing$/) do
-  unless @repository.has_ready_processing
-    while(true)
-      if @repository.has_ready_processing
-        break
-      else
-        sleep(10)
-      end
+  Timeout::timeout(300) do
+    while !@repository.has_ready_processing
+      sleep(2)
     end
   end
 end

data/features/step_definitions/repository_steps.rb

@@ -10,6 +10,11 @@ Given(/^the given project has the following Repositories:$/) do |table|
   @repository = FactoryGirl.create(:repository, hash)
 end
 
+Given(/^I have the given repository:$/) do |table|
+  repository_attrs = table.hashes.first
+  @repository = FactoryGirl.create(:repository, repository_attrs)
+end
+
 When(/^I call the cancel_process method for the given repository$/) do
   @response = @repository.cancel_processing_of_repository
 end

data/lib/kalibro_client/entities.rb

@@ -33,10 +33,12 @@ require 'kalibro_client/entities/miscellaneous/compound_metric'
 require 'kalibro_client/entities/processor/base'
 require 'kalibro_client/entities/processor/metric_collector_details'
 require 'kalibro_client/entities/processor/metric_result'
+require 'kalibro_client/entities/processor/tree_metric_result'
+require 'kalibro_client/entities/processor/hotspot_metric_result'
 require 'kalibro_client/entities/processor/kalibro_module'
 require 'kalibro_client/entities/processor/module_result'
 require 'kalibro_client/entities/processor/process_time'
 require 'kalibro_client/entities/processor/processing'
 require 'kalibro_client/entities/processor/project'
 require 'kalibro_client/entities/processor/repository'
-require 'kalibro_client/entities/configurations/statistic'
+require 'kalibro_client/entities/configurations/statistic'

data/lib/kalibro_client/entities/base.rb

@@ -45,14 +45,22 @@ module KalibroClient
           url = "/#{endpoint}/#{action}".gsub(":id", params[:id].to_s)
           url = "/#{prefix}#{url}" unless prefix.empty?
           request.url url
-          request.body = params unless params.empty?
+          request.body = params unless method == :get || params.empty?
           request.options.timeout = 300
           request.options.open_timeout = 300
         end
 
-        response.body
+        if response.success?
+          response.body
+        # FIXME This condition was added to preserve the deprecated error codes that are returned by kalibro processor
+        elsif response.status == 404 || (response.body.key?('errors') && /NotFound/ === response.body['errors'])
+          raise KalibroClient::Errors::RecordNotFound.new(response: response)
+        else
+          raise KalibroClient::Errors::RequestError.new(response: response)
+        end
       end
 
+
       def self.to_object value
         value.kind_of?(Hash) ? new(value, true) : value
       end
@@ -66,28 +74,20 @@ module KalibroClient
         if persisted?
           self.update
         else
-          begin
+          without_request_error? do
             response = self.class.request(save_action, save_params, :post, save_prefix)
 
-            if response["errors"].nil?
-              self.id = response[instance_class_name]["id"]
-              self.created_at = response[instance_class_name]["created_at"] unless response[instance_class_name]["created_at"].nil?
-              self.updated_at = response[instance_class_name]["updated_at"] unless response[instance_class_name]["updated_at"].nil?
-              @persisted = true
-              true
-            else
-              self.kalibro_errors = response["errors"]
-              false
-            end
-          rescue Exception => exception
-            add_error exception
-            false
+            self.id = response[instance_class_name]["id"]
+            self.created_at = response[instance_class_name]["created_at"] unless response[instance_class_name]["created_at"].nil?
+            self.updated_at = response[instance_class_name]["updated_at"] unless response[instance_class_name]["updated_at"].nil?
+            @persisted = true
           end
         end
       end
 
       def save!
-        save
+        return true if save
+        raise KalibroClient::Errors::RecordInvalid.new(self)
       end
 
       def self.create(attributes={})
@@ -98,12 +98,8 @@ module KalibroClient
 
       def update(attributes={})
         attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) }
-        response = self.class.request(update_action, update_params, :put, update_prefix)
-        unless response["errors"].nil?
-          response["errors"].each { |error| add_error(error) }
-          false
-        else
-          true
+        without_request_error? do
+          self.class.request(update_action, update_params, :put, update_prefix)
         end
       end
 
@@ -127,31 +123,14 @@ module KalibroClient
       end
 
       def self.find(id)
-        if(exists?(id))
-          response = request(find_action, id_params(id), :get)
-          new(response[entity_name], true)
-        else
-          raise KalibroClient::Errors::RecordNotFound
-        end
+        response = request(find_action, id_params(id), :get)
+        new(response[entity_name], true)
       end
 
       def destroy
-        begin
+        without_request_error? do
           response = self.class.request(destroy_action, destroy_params, :delete, destroy_prefix)
-
-          unless response['errors'].nil?
-            response['errors'].each { |error| add_error(error) }
-          end
-
-          if self.kalibro_errors.empty?
-            @persisted = false
-            true
-          else
-            false
-          end
-        rescue Exception => exception
-          add_error exception
-          false
+          @persisted = false
         end
       end
 
@@ -224,6 +203,28 @@ module KalibroClient
         return entity_class.name.split("::").last.underscore.downcase
       end
 
+      def without_request_error?(&block)
+        begin
+          block.call
+          true
+        rescue KalibroClient::Errors::RecordNotFound => error
+          raise error
+        rescue KalibroClient::Errors::RequestError => error
+          raise error if error.response.status.between?(500, 599)
+
+          response_errors = error.response.body['errors']
+          if response_errors.is_a?(Array)
+            response_errors.each { |error_msg| add_error(error_msg) }
+          elsif !response_errors.nil?
+            add_error response_errors
+          else
+            add_error error
+          end
+
+          false
+        end
+      end
+
       include HashConverters
     end
   end

data/lib/kalibro_client/entities/configurations/metric_configuration.rb

@@ -69,9 +69,13 @@ module KalibroClient
         end
 
         def self.find(id)
-          metric_configuration = request(':id', {id: id}, :get)
-          raise KalibroClient::Errors::RecordNotFound unless metric_configuration['errors'].nil?
-          return new(metric_configuration['metric_configuration'], true)
+          begin
+            metric_configuration = request(':id', {id: id}, :get)
+            return new(metric_configuration['metric_configuration'], true)
+          #FIXME Temporary until KalibroProcessor returns proper http statuses
+          rescue KalibroClient::Errors::RequestError
+            raise KalibroClient::Errors::RecordNotFound
+          end
         end
 
         def self.exists?(id)

data/lib/kalibro_client/entities/processor/hotspot_metric_result.rb

@@ -0,0 +1,41 @@
+# This file is part of KalibroClient
+# Copyright (C) 2013  it's respectives authors (please see the AUTHORS file)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module KalibroClient
+  module Entities
+    module Processor
+      class HotspotMetricResult < KalibroClient::Entities::Processor::MetricResult
+
+        attr_accessor :line_number, :message
+
+        def initialize(attributes={}, persisted=false)
+          @line_number = attributes["line_number"].to_i
+          attributes.each do |field, value|
+            if field != "line_number" and self.class.is_valid?(field)
+              send("#{field}=", value)
+            end
+          end
+          @persisted = persisted
+        end
+
+        def related_results
+          HotspotMetricResult.create_objects_array_from_hash(self.class.request(":id/related_results",
+                                                                                {id: self.id}, :get))
+        end
+      end
+    end
+  end
+end

data/lib/kalibro_client/entities/processor/metric_result.rb

@@ -21,55 +21,35 @@ module KalibroClient
 
         # TODO: related_hotspot_metric_results_id should be enclosed to Processor which does not return this id into the response
         #       there should be a controller that returns all the HotspotMetricResults associated through RelatedHotspotMetricResult
-        attr_accessor :id, :value, :aggregated_value, :module_result_id, :metric_configuration_id,
+        attr_accessor :id, :value, :module_result_id, :metric_configuration_id,
                       :line_number, :message, :related_hotspot_metric_results_id
         attr_reader :metric_configuration
 
-        def initialize(attributes={}, persisted=false)
-          value = attributes["value"]
-          @value = (value == "NaN") ? attributes["aggregated_value"].to_f : value.to_f
-          attributes.each do |field, value|
-            if field!= "value" and field!= "aggregated_value" and self.class.is_valid?(field)
-              send("#{field}=", value)
-            end
-          end
-          @kalibro_errors = []
-          @persisted = persisted
-        end
-
         def id=(value)
           @id = value.to_i
         end
 
+        def metric_configuration
+          return nil if @metric_configuration_id.nil?
+          if @metric_configuration.nil? || @metric_configuration.id != @metric_configuration_id
+            @metric_configuration = KalibroClient::Entities::Configurations::MetricConfiguration.find(@metric_configuration_id)
+          end
+
+          @metric_configuration
+        end
+
         def metric_configuration_id=(value)
-          self.metric_configuration = KalibroClient::Entities::Configurations::MetricConfiguration.request(":id", {id: value.to_i}, :get)["metric_configuration"]
+          @metric_configuration_id = (value.nil? ? nil : value.to_i)
         end
 
         def metric_configuration=(value)
           @metric_configuration = KalibroClient::Entities::Configurations::MetricConfiguration.to_object value
-          @metric_configuration_id = @metric_configuration.id
+          @metric_configuration_id = (@metric_configuration.nil? ? nil : @metric_configuration.id)
         end
 
         def value=(value)
           @value = value.to_f
         end
-
-        def aggregated_value=(value)
-          @aggregated_value = value.to_f
-        end
-
-        def descendant_values
-          descendant_values = self.class.request(':id/descendant_values', {id: id}, :get)['descendant_values']
-          descendant_values.map {|descendant_value| descendant_value.to_f}
-        end
-
-        def self.history_of(metric_name, kalibro_module_id, repository_id)
-          response = Repository.request(':id/metric_result_history_of', {metric_name: metric_name,
-                                                        kalibro_module_id: kalibro_module_id,
-                                                        id: repository_id})['metric_result_history_of']
-          response.map { |date_metric_result|
-            KalibroClient::Entities::Miscellaneous::DateMetricResult.new date_metric_result }
-        end
       end
     end
   end

data/lib/kalibro_client/entities/processor/module_result.rb

@@ -81,8 +81,26 @@ module KalibroClient
           end
         end
 
-        def metric_results
-          MetricResult.create_objects_array_from_hash self.class.request(":id/metric_results", {id: self.id}, :get)
+        def tree_metric_results
+          TreeMetricResult.create_objects_array_from_hash(self.class.request(":id/metric_results", {id: self.id}, :get))
+        end
+
+        def hotspot_metric_results
+          HotspotMetricResult.create_objects_array_from_hash(self.class.request(":id/hotspot_metric_results",
+                                                                                {id: self.id}, :get))
+        end
+
+        # FIXME: KalibroProcessor should return a 404 if the object does not exist instead of 422
+        def self.find(id)
+          begin
+            super
+          rescue KalibroClient::Errors::RequestError => e
+            if(e.response.status == 422)
+              raise KalibroClient::Errors::RecordNotFound.new(response: e.response)
+            else
+              raise e
+            end
+          end
         end
       end
     end