From 4c408ea484ac7498b6e8a2183d8c24d231a66ecb Mon Sep 17 00:00:00 2001 From: João M. M. da Silva + Diego Araújo Date: Thu, 12 Jul 2012 18:16:10 -0300 Subject: [PATCH] [Mezuro] Refactored metric_configuration entity and client to metric_configuration model --- plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb | 66 +++++++++++++++++++++++++++--------------------------------------- plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb | 32 -------------------------------- plugins/mezuro/lib/kalibro/entities/metric_configuration.rb | 38 -------------------------------------- plugins/mezuro/lib/kalibro/metric_configuration.rb | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ plugins/mezuro/lib/kalibro/model.rb | 6 +++++- plugins/mezuro/lib/kalibro/project.rb | 9 ++++----- plugins/mezuro/test/fixtures/metric_configuration_fixtures.rb | 40 ++++++++++++++++++---------------------- plugins/mezuro/test/unit/kalibro/metric_configuration_test.rb | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ plugins/mezuro/test/unit/kalibro/project_test.rb | 4 ++-- 9 files changed, 208 insertions(+), 139 deletions(-) delete mode 100644 plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb delete mode 100644 plugins/mezuro/lib/kalibro/entities/metric_configuration.rb create mode 100644 plugins/mezuro/lib/kalibro/metric_configuration.rb create mode 100644 plugins/mezuro/test/unit/kalibro/metric_configuration_test.rb diff --git a/plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb b/plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb index 74ef09f..c2f1769 100644 --- a/plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb +++ b/plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb @@ -26,13 +26,13 @@ class MezuroPluginMyprofileController < ProfileController def edit_metric_configuration @configuration_content = profile.articles.find(params[:id]) - @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name]) + @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(@configuration_content.name, params[:metric_name]) @metric = @metric_configuration.metric end def edit_compound_metric_configuration @configuration_content = profile.articles.find(params[:id]) - @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name]) + @metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(@configuration_content.name, params[:metric_name]) @metric_configurations = @configuration_content.metric_configurations @metric = @metric_configuration.metric end @@ -51,13 +51,13 @@ class MezuroPluginMyprofileController < ProfileController def update_metric_configuration @configuration_content = profile.articles.find(params[:id]) - auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::NATIVE_TYPE) + auxiliar_update_metric_configuration(Kalibro::MetricConfiguration::NATIVE_TYPE) redirect_to "/#{profile.identifier}/#{@configuration_content.slug}" end def update_compound_metric_configuration @configuration_content = profile.articles.find(params[:id]) - auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE) + auxiliar_update_metric_configuration(Kalibro::MetricConfiguration::COMPOUND_TYPE) redirect_to "/#{profile.identifier}/#{@configuration_content.slug}" end @@ -71,41 +71,39 @@ class MezuroPluginMyprofileController < ProfileController @metric_name = params[:metric_name] @beginning_id = params[:beginning_id] - metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, @metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(@configuration_content.name, @metric_name) @range = metric_configuration.ranges.find{ |range| range.beginning == @beginning_id.to_f } end def create_range @configuration_content = profile.articles.find(params[:id]) - @range = new_range_instance + @range = Kalibro::Range.new params[:range] metric_name = params[:metric_name] beginning_id = params[:beginning_id] - - metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(@configuration_content.name, metric_name) metric_configuration.add_range(@range) - Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name) + metric_configuration.save end def update_range configuration_content = profile.articles.find(params[:id]) metric_name = params[:metric_name] beginning_id = params[:beginning_id] - metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(configuration_content.name, metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(configuration_content.name, metric_name) index = metric_configuration.ranges.index{ |range| range.beginning == beginning_id.to_f } - metric_configuration.ranges[index] = new_range_instance - Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_content.name) + metric_configuration.ranges[index] = Kalibro::Range.new params[:range] + metric_configuration.save end def remove_range configuration_content = profile.articles.find(params[:id]) metric_name = params[:metric_name] beginning_id = params[:range_beginning] - - metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(configuration_content.name, metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(configuration_content.name, metric_name) metric_configuration.ranges.delete_if { |range| range.beginning == beginning_id.to_f }.inspect - Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name) + metric_configuration.save formatted_metric_name = metric_name.gsub(/\s/, '+') - if metric_configuration.metric.class == Kalibro::Entities::CompoundMetric + if metric_configuration.metric.class == Kalibro::CompoundMetric redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}" else redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}" @@ -115,25 +113,26 @@ class MezuroPluginMyprofileController < ProfileController def remove_metric_configuration configuration_content = profile.articles.find(params[:id]) metric_name = params[:metric_name] - Kalibro::Client::MetricConfigurationClient.new.remove(configuration_content.name, metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(configuration_content.name, metric_name) + metric_configuration.destroy redirect_to "/#{profile.identifier}/#{configuration_content.slug}" end private def new_metric_configuration_instance - metric_configuration = Kalibro::Entities::MetricConfiguration.new + metric_configuration = Kalibro::MetricConfiguration.new metric_configuration.metric = Kalibro::NativeMetric.new - assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::MetricConfiguration::NATIVE_TYPE) + assign_metric_configuration_instance(metric_configuration, Kalibro::MetricConfiguration::NATIVE_TYPE) end def new_compound_metric_configuration_instance - metric_configuration = Kalibro::Entities::MetricConfiguration.new - metric_configuration.metric = Kalibro::Entities::CompoundMetric.new - assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE) + metric_configuration = Kalibro::MetricConfiguration.new + metric_configuration.metric = Kalibro::CompoundMetric.new + assign_metric_configuration_instance(metric_configuration, Kalibro::MetricConfiguration::COMPOUND_TYPE) end - def assign_metric_configuration_instance(metric_configuration, type=Kalibro::Entities::MetricConfiguration::NATIVE_TYPE) + def assign_metric_configuration_instance(metric_configuration, type=Kalibro::MetricConfiguration::NATIVE_TYPE) metric_configuration.metric.name = params[:metric_configuration][:metric][:name] metric_configuration.metric.description = params[:metric_configuration][:metric][:description] metric_configuration.metric.scope = params[:metric_configuration][:metric][:scope] @@ -141,36 +140,25 @@ class MezuroPluginMyprofileController < ProfileController metric_configuration.weight = params[:metric_configuration][:weight] metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form] - if type == Kalibro::Entities::MetricConfiguration::NATIVE_TYPE + if type == Kalibro::MetricConfiguration::NATIVE_TYPE metric_configuration.metric.origin = params[:metric_configuration][:metric][:origin] metric_configuration.metric.language = params[:metric_configuration][:metric][:language] - elsif type == Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE + elsif type == Kalibro::MetricConfiguration::COMPOUND_TYPE metric_configuration.metric.script = params[:metric_configuration][:metric][:script] end metric_configuration end def generic_metric_configuration_creation(metric_configuration, configuration_name) - Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name) + metric_configuration.save metric_configuration.metric.name end def auxiliar_update_metric_configuration(type) metric_name = params[:metric_configuration][:metric][:name] - metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_name(@configuration_content.name, metric_name) metric_configuration = assign_metric_configuration_instance(metric_configuration, type) - Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name) - end - - def new_range_instance - range = Kalibro::Entities::Range.new - range.beginning = params[:range][:beginning] - range.end = params[:range][:end] - range.label = params[:range][:label] - range.grade = params[:range][:grade] - range.color = params[:range][:color] - range.comments = params[:range][:comments] - range + metric_configuration.save end end diff --git a/plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb b/plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb deleted file mode 100644 index 740c769..0000000 --- a/plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb +++ /dev/null @@ -1,32 +0,0 @@ -class Kalibro::Client::MetricConfigurationClient - - def self.metric_configuration(configuration_name, metric_name) - new.metric_configuration(configuration_name, metric_name) - end - - def initialize - @port = Kalibro::Client::Port.new('MetricConfiguration') - end - - def save(metric_configuration, configuration_name) - @port.request(:save_metric_configuration, { - :metric_configuration => metric_configuration.to_hash, - :configuration_name => configuration_name}) - end - - def metric_configuration(configuration_name, metric_name) - hash = @port.request(:get_metric_configuration, { - :configuration_name => configuration_name, - :metric_name => metric_name - })[:metric_configuration] - Kalibro::Entities::MetricConfiguration.from_hash(hash) - end - - def remove (configuration_name, metric_name) - @port.request(:remove_metric_configuration, { - :configuration_name => configuration_name, - :metric_name=> metric_name - }) - end - -end diff --git a/plugins/mezuro/lib/kalibro/entities/metric_configuration.rb b/plugins/mezuro/lib/kalibro/entities/metric_configuration.rb deleted file mode 100644 index 8c2e32a..0000000 --- a/plugins/mezuro/lib/kalibro/entities/metric_configuration.rb +++ /dev/null @@ -1,38 +0,0 @@ -class Kalibro::Entities::MetricConfiguration < Kalibro::Entities::Entity - - NATIVE_TYPE='native' - COMPOUND_TYPE='compound' - - attr_accessor :metric, :code, :weight, :aggregation_form, :range - - def metric=(value) - if value.kind_of?(Hash) - @metric = to_entity(value, Kalibro::Entities::CompoundMetric) if value.has_key?(:script) - @metric = to_entity(value, Kalibro::Entities::NativeMetric) if value.has_key?(:origin) - else - @metric = value - end - end - - def weight=(value) - @weight = value.to_f - end - - def range=(value) - @range = to_entity_array(value, Kalibro::Entities::Range) - end - - def add_range(new_range) - @range = [] if @range.nil? - @range << new_range - end - - def ranges - @range - end - - def ranges=(ranges) - @range = ranges - end - -end diff --git a/plugins/mezuro/lib/kalibro/metric_configuration.rb b/plugins/mezuro/lib/kalibro/metric_configuration.rb new file mode 100644 index 0000000..c015633 --- /dev/null +++ b/plugins/mezuro/lib/kalibro/metric_configuration.rb @@ -0,0 +1,82 @@ +class Kalibro::MetricConfiguration < Kalibro::Model + + NATIVE_TYPE='native' + COMPOUND_TYPE='compound' + + attr_accessor :metric, :code, :weight, :aggregation_form, :range, :configuration_name + + def metric=(value) + if value.kind_of?(Hash) + @metric = to_object(value, Kalibro::CompoundMetric) if value.has_key?(:script) + @metric = to_object(value, Kalibro::NativeMetric) if value.has_key?(:origin) + else + @metric = value + end + end + + def weight=(value) + @weight = value.to_f + end + + def range=(value) + @range = to_objects_array(value, Kalibro::Range) + end + + def add_range(new_range) + @range = [] if @range.nil? + @range << new_range + end + + def ranges + @range + end + + def ranges=(ranges) + @range = ranges + end + + def self.find_by_configuration_and_metric(configuration_name, metric_name) + metric_configuration = new request("MetricConfiguration", :get_metric_configuration, { + :configuration_name => configuration_name, + :metric_name => metric_name + })[:metric_configuration] + metric_configuration.configuration_name = configuration_name + metric_configuration + end + + def save + begin + self.class.request("MetricConfiguration", :save_metric_configuration, { + :metric_configuration => to_hash, + :configuration_name => configuration_name}) + true + rescue + false + end + end + + def destroy + self.class.request("MetricConfiguration", :remove_metric_configuration, { + :configuration_name => configuration_name, + :metric_name=> metric.name + }) + end + + def to_hash + hash = Hash.new + fields.each do |field| + if !(field == :configuration_name) + field_value = send(field) + hash[field] = convert_to_hash(field_value) + if field_value.is_a?(Kalibro::Model) + hash = {:attributes! => {}}.merge(hash) + hash[:attributes!][field.to_sym] = { + 'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance', + 'xsi:type' => 'kalibro:' + xml_class_name(field_value) } + end + end + end + hash + end + +end diff --git a/plugins/mezuro/lib/kalibro/model.rb b/plugins/mezuro/lib/kalibro/model.rb index 5e57904..bd8b0c5 100644 --- a/plugins/mezuro/lib/kalibro/model.rb +++ b/plugins/mezuro/lib/kalibro/model.rb @@ -1,7 +1,7 @@ class Kalibro::Model def initialize(attributes={}) - attributes.each { |field, value| send("#{field}=", value) } + attributes.each { |field, value| send("#{field}=", value) if self.class.is_valid?(field) } end def to_hash @@ -51,6 +51,10 @@ class Kalibro::Model response.to_hash["#{action}_response".to_sym] end + def self.is_valid?(field) + field.to_s[0] != '@' and field != :attributes! + end + def to_objects_array(value, model_class = nil) array = value.kind_of?(Array) ? value : [value] array.each.collect { |element| to_object(element, model_class) } diff --git a/plugins/mezuro/lib/kalibro/project.rb b/plugins/mezuro/lib/kalibro/project.rb index 8ac0fa3..aea2da4 100644 --- a/plugins/mezuro/lib/kalibro/project.rb +++ b/plugins/mezuro/lib/kalibro/project.rb @@ -15,10 +15,6 @@ class Kalibro::Project < Kalibro::Model end end - def self.destroy(project_name) - request("Project", :remove_project, {:project_name => project_name}) - end - def self.create (content) new({ :name => content.name, @@ -32,6 +28,10 @@ class Kalibro::Project < Kalibro::Model }) end + def destroy + self.class.request("Project", :remove_project, {:project_name => name}) + end + def save begin self.class.request("Project", :save_project, {:project => to_hash}) @@ -46,4 +46,3 @@ class Kalibro::Project < Kalibro::Model end end - diff --git a/plugins/mezuro/test/fixtures/metric_configuration_fixtures.rb b/plugins/mezuro/test/fixtures/metric_configuration_fixtures.rb index 8456c12..ed0f8cd 100644 --- a/plugins/mezuro/test/fixtures/metric_configuration_fixtures.rb +++ b/plugins/mezuro/test/fixtures/metric_configuration_fixtures.rb @@ -4,45 +4,41 @@ require File.dirname(__FILE__) + '/range_fixtures' class MetricConfigurationFixtures - def self.amloc_configuration - amloc = Kalibro::Entities::MetricConfiguration.new - amloc.metric = NativeMetricFixtures.amloc - amloc.code = 'amloc' - amloc.weight = 1.0 - amloc.aggregation_form = 'AVERAGE' - amloc.ranges = [RangeFixtures.amloc_excellent, RangeFixtures.amloc_bad] + def self.amloc_metric_configuration + amloc = Kalibro::MetricConfiguration.new amloc_metric_configuration_hash + amloc.configuration_name = "Sample Configuration" amloc end def self.metric_configuration_without_ranges - amloc = Kalibro::Entities::MetricConfiguration.new - amloc.metric = NativeMetricFixtures.amloc - amloc.code = 'amloc' - amloc.weight = 1.0 - amloc.aggregation_form = 'AVERAGE' + amloc = Kalibro::MetricConfiguration.new + { + :metric => NativeMetricFixtures.amloc_hash, + :code => 'amloc', + :weight => 1.0, + :aggregation_form => 'AVERAGE' + } + amloc.configuration_name = "Sample Configuration" amloc end - def self.sc_configuration - sc = Kalibro::Entities::MetricConfiguration.new - sc.metric = CompoundMetricFixtures.sc - sc.code = 'sc' - sc.weight = 1.0 - sc.aggregation_form = 'AVERAGE' + def self.sc_metric_configuration + sc = Kalibro::MetricConfiguration.new sc_metric_configuration_hash + sc.configuration_name = "Sample Configuration" sc end - def self.amloc_configuration_hash + def self.amloc_metric_configuration_hash {:metric => NativeMetricFixtures.amloc_hash, :code => 'amloc', :weight => 1.0, :aggregation_form => 'AVERAGE', - :range => [RangeFixtures.amloc_excellent_hash, RangeFixtures.amloc_bad_hash], + :range => [RangeFixtures.range_excellent_hash, RangeFixtures.range_bad_hash], :attributes! => {:metric => { 'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:type' => 'kalibro:nativeMetricXml' }}} end - def self.sc_configuration_hash - {:metric => CompoundMetricFixtures.sc_hash, :code => 'sc', :weight => 1.0, :aggregation_form => 'AVERAGE', + def self.sc_metric_configuration_hash + {:metric => CompoundMetricFixtures.compound_metric_hash, :code => 'sc', :weight => 1.0, :aggregation_form => 'AVERAGE', :attributes! => {:metric => { 'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:type' => 'kalibro:compoundMetricXml' }}} diff --git a/plugins/mezuro/test/unit/kalibro/metric_configuration_test.rb b/plugins/mezuro/test/unit/kalibro/metric_configuration_test.rb new file mode 100644 index 0000000..b840fa0 --- /dev/null +++ b/plugins/mezuro/test/unit/kalibro/metric_configuration_test.rb @@ -0,0 +1,70 @@ +require "test_helper" + +require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures" +require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures" + +class MetricConfigurationTest < ActiveSupport::TestCase + + def setup + @hash = MetricConfigurationFixtures.amloc_metric_configuration_hash + @metric_configuration1 = MetricConfigurationFixtures.amloc_metric_configuration + @metric_configuration2 = MetricConfigurationFixtures.sc_metric_configuration + @metric_configuration_without_ranges = MetricConfigurationFixtures.metric_configuration_without_ranges + @range1 = RangeFixtures.range_excellent + @range2 = RangeFixtures.range_bad + end + + should 'create metric configuration from hash' do + assert_equal @hash[:code], Kalibro::MetricConfiguration.new(@hash).code + end + + should 'convert metric configuration to hash' do + assert_equal @hash, @metric_configuration1.to_hash + end + + should 'create appropriate metric type' do + assert @metric_configuration1.metric.instance_of?(Kalibro::NativeMetric) + assert @metric_configuration2.metric.instance_of?(Kalibro::CompoundMetric) + end + + should 'add a range to an empty range list' do + @metric_configuration_without_ranges.add_range @range1 + assert_equal @metric_configuration_without_ranges.ranges, [@range1] + end + + should 'add a range to an non-empty range list' do + @metric_configuration_without_ranges.ranges = [@range1] + @metric_configuration_without_ranges.add_range @range2 + assert_equal @metric_configuration_without_ranges.ranges, [@range1, @range2] + end + + should 'save metric configuration' do + Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :save_metric_configuration, { + :metric_configuration => @metric_configuration1.to_hash, + :configuration_name => @metric_configuration1.configuration_name + }) + @metric_configuration1.save + end + + should 'get metric configuration by name and configuration name' do + request_body = { + :configuration_name => @metric_configuration1.configuration_name, + :metric_name => @metric_configuration1.metric.name + } + response_hash = {:metric_configuration => @metric_configuration1.to_hash} + Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :get_metric_configuration, request_body).returns(response_hash) + metric_configuration = Kalibro::MetricConfiguration.find_by_configuration_and_metric(@metric_configuration1.configuration_name, + @metric_configuration1.metric.name) + assert_equal @metric_configuration1.code, metric_configuration.code + end + + should 'destroy metric configuration by name' do + request_body = { + :configuration_name => @metric_configuration1.configuration_name, + :metric_name => @metric_configuration1.metric.name + } + Kalibro::MetricConfiguration.expects(:request).with("MetricConfiguration", :remove_metric_configuration, request_body) + @metric_configuration1.destroy + end + +end diff --git a/plugins/mezuro/test/unit/kalibro/project_test.rb b/plugins/mezuro/test/unit/kalibro/project_test.rb index 732bed1..4f0fb31 100644 --- a/plugins/mezuro/test/unit/kalibro/project_test.rb +++ b/plugins/mezuro/test/unit/kalibro/project_test.rb @@ -42,12 +42,12 @@ class ProjectTest < ActiveSupport::TestCase should 'remove existent project from service' do Kalibro::Project.expects(:request).with("Project", :remove_project, {:project_name => @project.name}) - Kalibro::Project.destroy(@project.name) + @project.destroy end should 'raise error when try to remove inexistent project from service' do Kalibro::Project.expects(:request).with("Project", :remove_project, {:project_name => @project.name}).raises(Exception.new) - assert_raise Exception do Kalibro::Project.destroy(@project.name) end + assert_raise Exception do @project.destroy end end should 'initialize new project from hash' do -- libgit2 0.21.2