[Mezuro] Refactoring configuration (myprofile) controller, clients, and validations

Paulo Meireles
1 parent 1488e688
Showing 10 changed files with 177 additions and 192 deletions Show diff stats
plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb
plugins/mezuro/lib/kalibro/client/base_tool_client.rb
plugins/mezuro/lib/kalibro/client/configuration_client.rb
plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb
plugins/mezuro/lib/kalibro/entities/metric_configuration.rb
plugins/mezuro/lib/mezuro_plugin/configuration_content.rb
plugins/mezuro/lib/mezuro_plugin/metric_configuration_content.rb
plugins/mezuro/public/javascripts/validations.js
plugins/mezuro/test/functional/mezuro_plugin_myprofile_controller_test.rb
plugins/mezuro/test/unit/mezuro_plugin/metric_configuration_content_test.rb
@@ -4,123 +4,119 @@ class MezuroPluginMyprofileController &lt; ProfileController
  
  
   def choose_base_tool
-    @configuration_name = params[:configuration_name]
-    @tool_names = Kalibro::Client::BaseToolClient.new
+    @configuration_content = profile.articles.find(params[:id])
+    @base_tools = Kalibro::Client::BaseToolClient.base_tools
   end
  
   def choose_metric
-    @configuration_name = params[:configuration_name]
-    @collector_name = params[:collector_name]
-    @collector = Kalibro::Client::BaseToolClient.new.base_tool(@collector_name)
+    @configuration_content = profile.articles.find(params[:id])
+    @base_tool = params[:base_tool]
+    @supported_metrics = Kalibro::Client::BaseToolClient.metrics @base_tool
   end
  
   def new_metric_configuration
-    metric_name = params[:metric_name]
-    collector_name = params[:collector_name]
-    collector = Kalibro::Client::BaseToolClient.new.base_tool(collector_name)
-    @metric = collector.supported_metrics.find {|metric| metric.name == metric_name}
-    @configuration_name = params[:configuration_name]
+    @configuration_content = profile.articles.find(params[:id])
+    @metric = Kalibro::Client::BaseToolClient.metric params[:metric_name], params[:base_tool]
   end
  
   def new_compound_metric_configuration
-    @configuration_name = params[:configuration_name]
-    @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).metric_configurations
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_configurations = @configuration_content.metric_configurations
   end
  
   def edit_metric_configuration
-    metric_name = params[:metric_name]
-    @configuration_name = params[:configuration_name]
-    @metric_configuration = Kalibro::Client::MetricConfigurationClient.new.metric_configuration(@configuration_name, metric_name)
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name])
     @metric = @metric_configuration.metric
   end
  
   def edit_compound_metric_configuration
-    metric_name = params[:metric_name]
-    @configuration_name = params[:configuration_name]
-    @metric_configuration = Kalibro::Client::MetricConfigurationClient.new.metric_configuration(@configuration_name, metric_name)
-    @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).metric_configurations
+    @configuration_content = profile.articles.find(params[:id])
+    @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name])
+    @metric_configurations = @configuration_content.metric_configurations
     @metric = @metric_configuration.metric
   end
  
   def create_metric_configuration
-    metric_name = generic_metric_configuration_creation(new_metric_configuration_instance)
-    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?configuration_name=#{@configuration_name.gsub(/\s/, '+')}&metric_name=#{metric_name.gsub(/\s/, '+')}"
+    configuration_content = profile.articles.find(params[:id])
+    metric_name = generic_metric_configuration_creation(new_metric_configuration_instance, configuration_content.name)
+    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
   end
  
   def create_compound_metric_configuration
-    metric_name = generic_metric_configuration_creation(new_compound_metric_configuration_instance)
-    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?configuration_name=#{@configuration_name.gsub(/\s/, '+')}&metric_name=#{metric_name.gsub(/\s/, '+')}"
+    configuration_content = profile.articles.find(params[:id])
+    metric_name = generic_metric_configuration_creation(new_compound_metric_configuration_instance, configuration_content.name)
+    redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
   end
  
   def update_metric_configuration
-    auxiliar_update_metric_configuration(MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
-    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
+    @configuration_content = profile.articles.find(params[:id])
+    auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::NATIVE_TYPE)
+    redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
   end
  
   def update_compound_metric_configuration
-    auxiliar_update_metric_configuration(MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE)
-    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
+    @configuration_content = profile.articles.find(params[:id])
+    auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE)
+    redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
   end
  
   def new_range
+    @configuration_content = profile.articles.find(params[:id])
     @metric_name = params[:metric_name]
-    @configuration_name = params[:configuration_name]
   end
  
   def edit_range
+    @configuration_content = profile.articles.find(params[:id])
     @metric_name = params[:metric_name]
-    @configuration_name = params[:configuration_name]
     @beginning_id = params[:beginning_id]
  
-    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
-    metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, @metric_name)
+    metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@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
-    configuration_name = params[:configuration_name]
     metric_name = params[:metric_name]
     beginning_id = params[:beginning_id]
-    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
-    metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)   
+
+    metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name)   
     metric_configuration.add_range(@range)
-    metric_configuration_client.save(metric_configuration, configuration_name)
+    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name)
   end
  
   def update_range
+    configuration_content = profile.articles.find(params[:id])
     metric_name = params[:metric_name]
-    configuration_name = params[:configuration_name]
     beginning_id = params[:beginning_id]
-    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
-    metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
+    metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(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_name)
+    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_content.name)
   end
  
   def remove_range
-    configuration_name = params[:configuration_name]
+    configuration_content = profile.articles.find(params[:id])
     metric_name = params[:metric_name]
     beginning_id = params[:range_beginning]
-    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
-    metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
+    
+    metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(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)
-    formatted_configuration_name = configuration_name.gsub(/\s/, '+')
     formatted_metric_name = metric_name.gsub(/\s/, '+')
     if metric_configuration.metric.class == Kalibro::Entities::CompoundMetric
-      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
+      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?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
+      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
     end
   end
  
   def remove_metric_configuration
-    configuration_name = params[:configuration_name]
+    configuration_content = profile.articles.find(params[:id])
     metric_name = params[:metric_name]
-    Kalibro::Client::MetricConfigurationClient.new.remove(configuration_name, metric_name)
-    redirect_to "/#{profile.identifier}/#{configuration_name.downcase.gsub(/\s/, '-')}"
+    Kalibro::Client::MetricConfigurationClient.new.remove(configuration_content.name, metric_name)
+    redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
   end
  
   private 
@@ -128,16 +124,16 @@ class MezuroPluginMyprofileController &lt; ProfileController
   def new_metric_configuration_instance
     metric_configuration = Kalibro::Entities::MetricConfiguration.new
     metric_configuration.metric = Kalibro::Entities::NativeMetric.new
-    assign_metric_configuration_instance(metric_configuration, MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
+    assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::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, MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE)
+    assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE)
   end
  
-  def assign_metric_configuration_instance(metric_configuration, type=MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
+  def assign_metric_configuration_instance(metric_configuration, type=Kalibro::Entities::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]
@@ -145,28 +141,25 @@ class MezuroPluginMyprofileController &lt; ProfileController
     metric_configuration.weight = params[:metric_configuration][:weight]
     metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
  
-    if type == MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE
+    if type == Kalibro::Entities::MetricConfiguration::NATIVE_TYPE
       metric_configuration.metric.origin = params[:metric_configuration][:metric][:origin]
       metric_configuration.metric.language = params[:metric_configuration][:metric][:language]
-    elsif type == MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE
+    elsif type == Kalibro::Entities::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 = params[:configuration_name]
-    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_name)
+  def generic_metric_configuration_creation(metric_configuration, configuration_name)
+    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
     metric_configuration.metric.name
   end
  
   def auxiliar_update_metric_configuration(type)
-    @configuration_name = params[:configuration_name]
     metric_name = params[:metric_configuration][:metric][:name]
-    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
-    metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)  
+    metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name)  
     metric_configuration = assign_metric_configuration_instance(metric_configuration, type)
-    metric_configuration_client.save(metric_configuration, @configuration_name)
+    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name)
   end
  
   def new_range_instance
 class Kalibro::Client::BaseToolClient
  
+  def self.base_tools
+    new.base_tool_names
+  end
+  
+  def self.metrics(base_tool)
+    new.base_tool(base_tool).supported_metrics
+  end
+  
+  def self.metric(metric_name, base_tool)
+    metrics(base_tool).find {|metric| metric.name == metric_name}
+  end
+  
   def initialize
     @port = Kalibro::Client::Port.new('BaseTool')
   end
 class Kalibro::Client::ConfigurationClient
  
+  def self.configuration(configuration_name)
+    new.configuration(configuration_name)
+  end
+
   def self.save(configuration_content)
-    configuration = Kalibro::Entities::Configuration.new
-    configuration.name = configuration_content.name
+    begin
+      configuration = new.configuration(configuration_content.name)
+    rescue
+      configuration = Kalibro::Entities::Configuration.new      
+      configuration.name = configuration_content.name
+    end
+    
     configuration.description = configuration_content.description
     new.save(configuration)
   end
 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
@@ -25,4 +29,4 @@ class Kalibro::Client::MetricConfigurationClient
       })
   end
  
-end
 \ No newline at end of file
+end
 class Kalibro::Entities::MetricConfiguration < Kalibro::Entities::Entity
  
+  NATIVE_TYPE='native'
+  COMPOUND_TYPE='compound'
+  
   attr_accessor :metric, :code, :weight, :aggregation_form, :range
  
   def metric=(value)
 class MezuroPlugin::ConfigurationContent < Article
+  validate_on_create :validate_kalibro_configuration_name
  
   def self.short_description
     'Kalibro configuration'
@@ -8,7 +9,7 @@ class MezuroPlugin::ConfigurationContent &lt; Article
     'Sets of thresholds to interpret metrics'
   end
  
-  settings_items :description, :metrics
+  settings_items :description
  
   include ActionView::Helpers::TagHelper
   def to_html(options = {})
@@ -17,15 +18,29 @@ class MezuroPlugin::ConfigurationContent &lt; Article
     end
   end
  
-  def configuration #FIXME invalid method name
+  def configuration
     Kalibro::Client::ConfigurationClient.configuration(name)
   end
+  
+  def metric_configurations
+    configuration.metric_configurations
+  end
+  
  
   after_save :send_configuration_to_service
   after_destroy :remove_configuration_from_service
  
   private
  
+  def validate_kalibro_configuration_name
+    existing = Kalibro::Client::ConfigurationClient.new.configuration_names
+    existing.each { |a| a.downcase!}
+
+    if existing.include?(name.downcase)
+      errors.add_to_base("Configuration name already exists in Kalibro")
+    end
+  end
+
   def send_configuration_to_service
     Kalibro::Client::ConfigurationClient.save(self)
   end
@@ -1,40 +0,0 @@
-class MezuroPlugin::MetricConfigurationContent < Article
-
-  NATIVE_TYPE='native'
-  COMPOUND_TYPE='compound'
-
-  def self.short_description
-    'Kalibro Configurated Metric'
-  end
-
-  def self.description
-    'Sets of thresholds to interpret a metric'
-  end
-
-  settings_items :description, :code, :weight, :scope, :aggregation_form, :range
-
-  include ActionView::Helpers::TagHelper
-  def to_html(options = {})
-    lambda do
-      render :file => 'content_viewer/show_configuration.rhtml'
-    end
-  end
-
-  def metric_configuration #FIXME invalid method name
-    Kalibro::Client::MetricConfigurationClient.metric_configuration(name)
-  end
-
-  after_save :send_metric_configuration_to_service
-  after_destroy :remove_metric_configuration_from_service
-
-  private
-
-  def send_metric_configuration_to_service
-    Kalibro::Client::MetricConfigurationClient.save(self)
-  end
-
-  def remove_metric_configuration_from_service
-    Kalibro::Client::MetricConfigurationClient.remove(name)
-  end
-
-end
@@ -30,8 +30,15 @@ function IsNotNumeric(value){
     return true;
 }
  
+function IsNotInfinite(value){
+    if(value.match(/INF/)){
+      return false;
+    }
+    return true;
+}
+
 function IsNotHexadecimal(value){
-    if(value.match(/[0-9a-fA-F]{1,8}/))
+    if(value.match(/^[0-9a-fA-F]{1,8}$/))
     {
       return false;
     }
@@ -50,15 +57,17 @@ function validate_new_range_configuration(event){
         alert("Please fill all fields marked with (*)");
         return false;
     }
-    if (IsNotNumeric(beginning) || IsNotNumeric(end) || IsNotNumeric(grade))
+    if ( (IsNotNumeric(beginning) && IsNotInfinite(beginning)) || (IsNotNumeric(end) && IsNotInfinite(end)) || IsNotNumeric(grade))
     {
         alert("Beginning, End and Grade must be numeric values");
         return false;
     }
     if (parseInt(beginning) > parseInt(end))
     {
-        alert("End must be greater than Beginning");
-        return false;
+        if(IsNotInfinite(beginning) && IsNotInfinite(end)){
+          alert("End must be greater than Beginning");
+          return false;
+        }
     }
     if (IsNotHexadecimal(color)){
         alert("Color must be an hexadecimal value");
@@ -14,7 +14,7 @@ class MezuroPluginMyprofileControllerTest &lt; ActionController::TestCase
     @response = ActionController::TestResponse.new
     @profile = fast_create(Community)
  
-    @collector = BaseToolFixtures.analizo
+    @base_tool = BaseToolFixtures.analizo
     @base_tool_client = Kalibro::Client::BaseToolClient.new
     @metric = NativeMetricFixtures.amloc
     @metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
@@ -23,70 +23,73 @@ class MezuroPluginMyprofileControllerTest &lt; ActionController::TestCase
     @configuration = ConfigurationFixtures.kalibro_configuration
   end
  
-  should 'assign configuration name in choose_base_tool' do
-    get :choose_base_tool, :profile => @profile.identifier, :configuration_name => "test name"
-    assert_equal assigns(:configuration_name), "test name"
+  should 'assign configuration content in choose_base_tool' do
+    create_configuration_content
+    Kalibro::Client::BaseToolClient.expects(:base_tools).returns([])
+    get :choose_base_tool, :profile => @profile.identifier, :id => @content.id
+    assert_equal assigns(:configuration_content), @content
   end
  
-  should 'create base tool client' do
-    get :choose_base_tool, :profile => @profile.identifier, :configuration_name => "test name"
-    assert assigns(:tool_names).instance_of?(Kalibro::Client::BaseToolClient)
-  end
-
-  should 'assign configuration and collector name in choose_metric' do
+  should 'assign configuration and base_tool name in choose_metric' do
+    create_configuration_content
     Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
-    @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
-    get :choose_metric, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo"
-    assert_equal assigns(:configuration_name), "test name"
-    assert_equal assigns(:collector_name), "Analizo"
+    @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
+    get :choose_metric, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name
+    assert_equal @content, assigns(:configuration_content)
+    assert_equal @base_tool.name, assigns(:base_tool)
   end
  
-  should 'get collector by name' do
+  should 'get base_tool by name' do
+    create_configuration_content
     Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
-    @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
-    get :choose_metric, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo"
-    assert_equal assigns(:collector), @collector
+    @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
+    get :choose_metric, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name
+    assert_equal @base_tool.name, assigns(:base_tool)
   end
  
   should 'get chosen native metric and configuration name' do
+    create_configuration_content
     Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
-    @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
-    get :new_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo", :metric_name => @metric.name
-    assert_equal assigns(:configuration_name), "test name"
-    assert_equal assigns(:metric), @metric
+    @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
+    get :new_metric_configuration, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name, :metric_name => @metric.name
+    assert_equal @content, assigns(:configuration_content)
+    assert_equal @metric, assigns(:metric)
   end
  
   should 'call configuration client in new_compound_metric_configuration method' do
+    create_configuration_content
     configuration_client = mock
     Kalibro::Client::ConfigurationClient.expects(:new).returns(configuration_client)
     configuration_client.expects(:configuration).with(@configuration.name).returns(@configuration)
-    get :new_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name
+    get :new_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id
     assert_response 200
   end
  
   should 'assign configuration name and get metric_configuration' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
-    @metric_configuration_client.expects(:metric_configuration).with("test name", @metric.name).returns(@metric_configuration)
-    get :edit_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
-    assert_equal assigns(:configuration_name), "test name"
+    @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric.name).returns(@metric_configuration)
+    get :edit_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
+    assert_equal assigns(:configuration_content), @content
     assert_equal assigns(:metric_configuration), @metric_configuration
     assert_equal assigns(:metric), @metric_configuration.metric
   end
  
   should 'test metric creation' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     @metric_configuration_client.expects(:save)
-    get :create_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", 
+    get :create_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
     :metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.code, :aggregation => @metric_configuration.aggregation_form, 
     :metric => { :name => @metric.name, :origin => @metric.origin, :description => @metric.description, :scope => @metric.scope, :language => @metric.language }}
-    assert_equal assigns(:configuration_name), "test name"
     assert_response 302
   end
  
   should 'test compound metric creation' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     @metric_configuration_client.expects(:save)
-    get :create_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", 
+    get :create_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
     :metric_configuration => { :code => @compound_metric_configuration.code, :weight => @compound_metric_configuration.weight, 
     :aggregation_form => @compound_metric_configuration.aggregation_form, :metric => { :name => @compound_metric_configuration.metric.name , 
     :description => @compound_metric_configuration.metric.description, :scope => @compound_metric_configuration.metric.scope, 
@@ -95,37 +98,43 @@ class MezuroPluginMyprofileControllerTest &lt; ActionController::TestCase
   end
  
   should 'test metric edition' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
-    @metric_configuration_client.expects(:metric_configuration).with("test name","test metric name").returns(@metric_configuration)
-    get :edit_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => "test metric name"
+    @metric_configuration_client.expects(:metric_configuration).with(@configuration.name,@metric.name).returns(@metric_configuration)
+    get :edit_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
     assert_response 200
   end
  
   should 'test compound metric edition' do
+    create_configuration_content
     configuration_client = mock
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     Kalibro::Client::ConfigurationClient.expects(:new).returns(configuration_client)
     configuration_client.expects(:configuration).with(@configuration.name).returns(@configuration)
     @metric_configuration_client.expects(:metric_configuration).with(@configuration.name,@metric.name).returns(@compound_metric_configuration)
-    get :edit_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name, :metric_name => @metric.name
+    get :edit_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
     assert_response 200
   end
  
   should 'update metric configuration' do
+    create_configuration_content
+    Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric_configuration.metric.name).returns(@metric_configuration)
     @metric_configuration_client.expects(:save)
-    get :update_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name, 
+    get :update_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
     :metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.weight, :aggregation => @metric_configuration.aggregation_form, 
     :metric => { :name => @metric.name, :origin => @metric.origin, :description => @metric.description, :scope => @metric.scope, :language => @metric.language }}
     assert_response 302
   end
  
   should 'update compound metric configuration' do
+    create_configuration_content
+    Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @compound_metric_configuration.metric.name).returns(@compound_metric_configuration)
     @metric_configuration_client.expects(:save)
-    get :update_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name, 
+    get :update_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, 
     :metric_configuration => { :code => @compound_metric_configuration.code, :weight => @compound_metric_configuration.weight, 
     :aggregation_form => @compound_metric_configuration.aggregation_form, :metric => { :name => @compound_metric_configuration.metric.name , 
     :description => @compound_metric_configuration.metric.description, :scope => @compound_metric_configuration.metric.scope, 
@@ -134,26 +143,41 @@ class MezuroPluginMyprofileControllerTest &lt; ActionController::TestCase
   end
  
   should 'assign configuration name and metric name to new range' do
-    get :new_range, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
-    assert_equal assigns(:configuration_name), "test name"
+    create_configuration_content
+    get :new_range, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
+    assert_equal assigns(:configuration_content), @content
     assert_equal assigns(:metric_name), @metric.name
   end
  
   should 'create instance range' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
-    @metric_configuration_client.expects(:metric_configuration).with("test name", @metric.name).returns(@metric_configuration)    
+    Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
+    @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric.name).returns(@metric_configuration)    
     @metric_configuration_client.expects(:save)
     range = @metric_configuration.ranges[0]
     get :create_range, :profile => @profile.identifier, :range => { :beginning => range.beginning, :end => range.end, :label => range.label,
-    :grade => range.grade, :color => range.color, :comments => range.comments }, :configuration_name => "test name", :metric_name => @metric.name
+    :grade => range.grade, :color => range.color, :comments => range.comments }, :id => @content.id, :metric_name => @metric.name
     assert assigns(:range).instance_of?(Kalibro::Entities::Range)
   end
  
   should 'redirect from remove metric configuration' do
+    create_configuration_content
     Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
     @metric_configuration_client.expects(:remove)
-    get :remove_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
+    get :remove_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
     assert_response 302
   end
+  
+  private
+  
+  def create_configuration_content
+    client = mock
+    Kalibro::Client::ConfigurationClient.expects(:new).returns(client)
+    client.expects(:configuration_names).returns([])
+    @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
+    @content.expects(:send_configuration_to_service).returns(nil)
+    @content.save
+  end
  
 end
@@ -1,44 +0,0 @@
-require "test_helper"
-
-class MetricConfigurationContentTest < ActiveSupport::TestCase
-  
-  def setup
-    @metric_configuration = MezuroPlugin::MetricConfigurationContent.new
-  end
-  
-  should 'be a metric configuration' do
-    assert_kind_of Article, @metric_configuration
-  end
-
-  should 'have short description' do
-    assert_equal 'Kalibro Configurated Metric', MezuroPlugin::MetricConfigurationContent.short_description
-  end
-  
-  should 'have description' do
-    assert_equal 'Sets of thresholds to interpret a metric', MezuroPlugin::MetricConfigurationContent.description
-  end
-  
-  should 'have an html view' do
-    assert_not_nil @metric_configuration.to_html
-  end
-  
-  #should 'return metric configuration' do
-  #  pending "Need refactoring"
-  #end
-  
-  should 'send metric configuration to service after saving' do
-    @metric_configuration.expects :send_metric_configuration_to_service
-    @metric_configuration.run_callbacks :after_save
-  end
-
-  should 'send correct metric configuration to service' do
-    Kalibro::Client::MetricConfigurationClient.expects(:save).with(@metric_configuration)
-    @metric_configuration.send :send_metric_configuration_to_service
-  end
-
-  should 'remove metric configuration from service' do
-    Kalibro::Client::MetricConfigurationClient.expects(:remove).with(@metric_configuration.name)
-    @metric_configuration.send :remove_metric_configuration_from_service
-  end
-  
-end
...	...	@@ -4,123 +4,119 @@ class MezuroPluginMyprofileController < ProfileController
4	4
5	5
6	6	def choose_base_tool
7		- @configuration_name = params[:configuration_name]
8		- @tool_names = Kalibro::Client::BaseToolClient.new
	7	+ @configuration_content = profile.articles.find(params[:id])
	8	+ @base_tools = Kalibro::Client::BaseToolClient.base_tools
9	9	end
10	10
11	11	def choose_metric
12		- @configuration_name = params[:configuration_name]
13		- @collector_name = params[:collector_name]
14		- @collector = Kalibro::Client::BaseToolClient.new.base_tool(@collector_name)
	12	+ @configuration_content = profile.articles.find(params[:id])
	13	+ @base_tool = params[:base_tool]
	14	+ @supported_metrics = Kalibro::Client::BaseToolClient.metrics @base_tool
15	15	end
16	16
17	17	def new_metric_configuration
18		- metric_name = params[:metric_name]
19		- collector_name = params[:collector_name]
20		- collector = Kalibro::Client::BaseToolClient.new.base_tool(collector_name)
21		- @metric = collector.supported_metrics.find {\|metric\| metric.name == metric_name}
22		- @configuration_name = params[:configuration_name]
	18	+ @configuration_content = profile.articles.find(params[:id])
	19	+ @metric = Kalibro::Client::BaseToolClient.metric params[:metric_name], params[:base_tool]
23	20	end
24	21
25	22	def new_compound_metric_configuration
26		- @configuration_name = params[:configuration_name]
27		- @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).metric_configurations
	23	+ @configuration_content = profile.articles.find(params[:id])
	24	+ @metric_configurations = @configuration_content.metric_configurations
28	25	end
29	26
30	27	def edit_metric_configuration
31		- metric_name = params[:metric_name]
32		- @configuration_name = params[:configuration_name]
33		- @metric_configuration = Kalibro::Client::MetricConfigurationClient.new.metric_configuration(@configuration_name, metric_name)
	28	+ @configuration_content = profile.articles.find(params[:id])
	29	+ @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name])
34	30	@metric = @metric_configuration.metric
35	31	end
36	32
37	33	def edit_compound_metric_configuration
38		- metric_name = params[:metric_name]
39		- @configuration_name = params[:configuration_name]
40		- @metric_configuration = Kalibro::Client::MetricConfigurationClient.new.metric_configuration(@configuration_name, metric_name)
41		- @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).metric_configurations
	34	+ @configuration_content = profile.articles.find(params[:id])
	35	+ @metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, params[:metric_name])
	36	+ @metric_configurations = @configuration_content.metric_configurations
42	37	@metric = @metric_configuration.metric
43	38	end
44	39
45	40	def create_metric_configuration
46		- metric_name = generic_metric_configuration_creation(new_metric_configuration_instance)
47		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?configuration_name=#{@configuration_name.gsub(/\s/, '+')}&metric_name=#{metric_name.gsub(/\s/, '+')}"
	41	+ configuration_content = profile.articles.find(params[:id])
	42	+ metric_name = generic_metric_configuration_creation(new_metric_configuration_instance, configuration_content.name)
	43	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
48	44	end
49	45
50	46	def create_compound_metric_configuration
51		- metric_name = generic_metric_configuration_creation(new_compound_metric_configuration_instance)
52		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?configuration_name=#{@configuration_name.gsub(/\s/, '+')}&metric_name=#{metric_name.gsub(/\s/, '+')}"
	47	+ configuration_content = profile.articles.find(params[:id])
	48	+ metric_name = generic_metric_configuration_creation(new_compound_metric_configuration_instance, configuration_content.name)
	49	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{metric_name.gsub(/\s/, '+')}"
53	50	end
54	51
55	52	def update_metric_configuration
56		- auxiliar_update_metric_configuration(MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
57		- redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	53	+ @configuration_content = profile.articles.find(params[:id])
	54	+ auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::NATIVE_TYPE)
	55	+ redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
58	56	end
59	57
60	58	def update_compound_metric_configuration
61		- auxiliar_update_metric_configuration(MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE)
62		- redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	59	+ @configuration_content = profile.articles.find(params[:id])
	60	+ auxiliar_update_metric_configuration(Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE)
	61	+ redirect_to "/#{profile.identifier}/#{@configuration_content.slug}"
63	62	end
64	63
65	64	def new_range
	65	+ @configuration_content = profile.articles.find(params[:id])
66	66	@metric_name = params[:metric_name]
67		- @configuration_name = params[:configuration_name]
68	67	end
69	68
70	69	def edit_range
	70	+ @configuration_content = profile.articles.find(params[:id])
71	71	@metric_name = params[:metric_name]
72		- @configuration_name = params[:configuration_name]
73	72	@beginning_id = params[:beginning_id]
74	73
75		- metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
76		- metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, @metric_name)
	74	+ metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, @metric_name)
77	75	@range = metric_configuration.ranges.find{ \|range\| range.beginning == @beginning_id.to_f }
78	76	end
79	77
80	78	def create_range
	79	+ @configuration_content = profile.articles.find(params[:id])
81	80	@range = new_range_instance
82		- configuration_name = params[:configuration_name]
83	81	metric_name = params[:metric_name]
84	82	beginning_id = params[:beginning_id]
85		- metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
86		- metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	83	+
	84	+ metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name)
87	85	metric_configuration.add_range(@range)
88		- metric_configuration_client.save(metric_configuration, configuration_name)
	86	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name)
89	87	end
90	88
91	89	def update_range
	90	+ configuration_content = profile.articles.find(params[:id])
92	91	metric_name = params[:metric_name]
93		- configuration_name = params[:configuration_name]
94	92	beginning_id = params[:beginning_id]
95		- metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
96		- metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	93	+ metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(configuration_content.name, metric_name)
97	94	index = metric_configuration.ranges.index{ \|range\| range.beginning == beginning_id.to_f }
98	95	metric_configuration.ranges[index] = new_range_instance
99		- Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
	96	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_content.name)
100	97	end
101	98
102	99	def remove_range
103		- configuration_name = params[:configuration_name]
	100	+ configuration_content = profile.articles.find(params[:id])
104	101	metric_name = params[:metric_name]
105	102	beginning_id = params[:range_beginning]
106		- metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
107		- metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	103	+
	104	+ metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(configuration_content.name, metric_name)
108	105	metric_configuration.ranges.delete_if { \|range\| range.beginning == beginning_id.to_f }.inspect
109	106	Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
110		- formatted_configuration_name = configuration_name.gsub(/\s/, '+')
111	107	formatted_metric_name = metric_name.gsub(/\s/, '+')
112	108	if metric_configuration.metric.class == Kalibro::Entities::CompoundMetric
113		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
	109	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
114	110	else
115		- redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
	111	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?id=#{configuration_content.id}&metric_name=#{formatted_metric_name}"
116	112	end
117	113	end
118	114
119	115	def remove_metric_configuration
120		- configuration_name = params[:configuration_name]
	116	+ configuration_content = profile.articles.find(params[:id])
121	117	metric_name = params[:metric_name]
122		- Kalibro::Client::MetricConfigurationClient.new.remove(configuration_name, metric_name)
123		- redirect_to "/#{profile.identifier}/#{configuration_name.downcase.gsub(/\s/, '-')}"
	118	+ Kalibro::Client::MetricConfigurationClient.new.remove(configuration_content.name, metric_name)
	119	+ redirect_to "/#{profile.identifier}/#{configuration_content.slug}"
124	120	end
125	121
126	122	private
...	...	@@ -128,16 +124,16 @@ class MezuroPluginMyprofileController < ProfileController
128	124	def new_metric_configuration_instance
129	125	metric_configuration = Kalibro::Entities::MetricConfiguration.new
130	126	metric_configuration.metric = Kalibro::Entities::NativeMetric.new
131		- assign_metric_configuration_instance(metric_configuration, MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
	127	+ assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::MetricConfiguration::NATIVE_TYPE)
132	128	end
133	129
134	130	def new_compound_metric_configuration_instance
135	131	metric_configuration = Kalibro::Entities::MetricConfiguration.new
136	132	metric_configuration.metric = Kalibro::Entities::CompoundMetric.new
137		- assign_metric_configuration_instance(metric_configuration, MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE)
	133	+ assign_metric_configuration_instance(metric_configuration, Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE)
138	134	end
139	135
140		- def assign_metric_configuration_instance(metric_configuration, type=MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE)
	136	+ def assign_metric_configuration_instance(metric_configuration, type=Kalibro::Entities::MetricConfiguration::NATIVE_TYPE)
141	137	metric_configuration.metric.name = params[:metric_configuration][:metric][:name]
142	138	metric_configuration.metric.description = params[:metric_configuration][:metric][:description]
143	139	metric_configuration.metric.scope = params[:metric_configuration][:metric][:scope]
...	...	@@ -145,28 +141,25 @@ class MezuroPluginMyprofileController < ProfileController
145	141	metric_configuration.weight = params[:metric_configuration][:weight]
146	142	metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
147	143
148		- if type == MezuroPlugin::MetricConfigurationContent::NATIVE_TYPE
	144	+ if type == Kalibro::Entities::MetricConfiguration::NATIVE_TYPE
149	145	metric_configuration.metric.origin = params[:metric_configuration][:metric][:origin]
150	146	metric_configuration.metric.language = params[:metric_configuration][:metric][:language]
151		- elsif type == MezuroPlugin::MetricConfigurationContent::COMPOUND_TYPE
	147	+ elsif type == Kalibro::Entities::MetricConfiguration::COMPOUND_TYPE
152	148	metric_configuration.metric.script = params[:metric_configuration][:metric][:script]
153	149	end
154	150	metric_configuration
155	151	end
156	152
157		- def generic_metric_configuration_creation(metric_configuration)
158		- @configuration_name = params[:configuration_name]
159		- Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_name)
	153	+ def generic_metric_configuration_creation(metric_configuration, configuration_name)
	154	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
160	155	metric_configuration.metric.name
161	156	end
162	157
163	158	def auxiliar_update_metric_configuration(type)
164		- @configuration_name = params[:configuration_name]
165	159	metric_name = params[:metric_configuration][:metric][:name]
166		- metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
167		- metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)
	160	+ metric_configuration = Kalibro::Client::MetricConfigurationClient.metric_configuration(@configuration_content.name, metric_name)
168	161	metric_configuration = assign_metric_configuration_instance(metric_configuration, type)
169		- metric_configuration_client.save(metric_configuration, @configuration_name)
	162	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_content.name)
170	163	end
171	164
172	165	def new_range_instance
...	...
1	1	class Kalibro::Client::BaseToolClient
2	2
	3	+ def self.base_tools
	4	+ new.base_tool_names
	5	+ end
	6	+
	7	+ def self.metrics(base_tool)
	8	+ new.base_tool(base_tool).supported_metrics
	9	+ end
	10	+
	11	+ def self.metric(metric_name, base_tool)
	12	+ metrics(base_tool).find {\|metric\| metric.name == metric_name}
	13	+ end
	14	+
3	15	def initialize
4	16	@port = Kalibro::Client::Port.new('BaseTool')
5	17	end
...	...
1	1	class Kalibro::Client::ConfigurationClient
2	2
	3	+ def self.configuration(configuration_name)
	4	+ new.configuration(configuration_name)
	5	+ end
	6	+
3	7	def self.save(configuration_content)
4		- configuration = Kalibro::Entities::Configuration.new
5		- configuration.name = configuration_content.name
	8	+ begin
	9	+ configuration = new.configuration(configuration_content.name)
	10	+ rescue
	11	+ configuration = Kalibro::Entities::Configuration.new
	12	+ configuration.name = configuration_content.name
	13	+ end
	14	+
6	15	configuration.description = configuration_content.description
7	16	new.save(configuration)
8	17	end
...	...
1	1	class Kalibro::Client::MetricConfigurationClient
2	2
	3	+ def self.metric_configuration(configuration_name, metric_name)
	4	+ new.metric_configuration(configuration_name, metric_name)
	5	+ end
	6	+
3	7	def initialize
4	8	@port = Kalibro::Client::Port.new('MetricConfiguration')
5	9	end
...	...	@@ -25,4 +29,4 @@ class Kalibro::Client::MetricConfigurationClient
25	29	})
26	30	end
27	31
28		-end
29	32	\ No newline at end of file
	33	+end
...	...
1	1	class Kalibro::Entities::MetricConfiguration < Kalibro::Entities::Entity
2	2
	3	+ NATIVE_TYPE='native'
	4	+ COMPOUND_TYPE='compound'
	5	+
3	6	attr_accessor :metric, :code, :weight, :aggregation_form, :range
4	7
5	8	def metric=(value)
...	...
1	1	class MezuroPlugin::ConfigurationContent < Article
	2	+ validate_on_create :validate_kalibro_configuration_name
2	3
3	4	def self.short_description
4	5	'Kalibro configuration'
...	...	@@ -8,7 +9,7 @@ class MezuroPlugin::ConfigurationContent < Article
8	9	'Sets of thresholds to interpret metrics'
9	10	end
10	11
11		- settings_items :description, :metrics
	12	+ settings_items :description
12	13
13	14	include ActionView::Helpers::TagHelper
14	15	def to_html(options = {})
...	...	@@ -17,15 +18,29 @@ class MezuroPlugin::ConfigurationContent < Article
17	18	end
18	19	end
19	20
20		- def configuration #FIXME invalid method name
	21	+ def configuration
21	22	Kalibro::Client::ConfigurationClient.configuration(name)
22	23	end
	24	+
	25	+ def metric_configurations
	26	+ configuration.metric_configurations
	27	+ end
	28	+
23	29
24	30	after_save :send_configuration_to_service
25	31	after_destroy :remove_configuration_from_service
26	32
27	33	private
28	34
	35	+ def validate_kalibro_configuration_name
	36	+ existing = Kalibro::Client::ConfigurationClient.new.configuration_names
	37	+ existing.each { \|a\| a.downcase!}
	38	+
	39	+ if existing.include?(name.downcase)
	40	+ errors.add_to_base("Configuration name already exists in Kalibro")
	41	+ end
	42	+ end
	43	+
29	44	def send_configuration_to_service
30	45	Kalibro::Client::ConfigurationClient.save(self)
31	46	end
...	...
...	...	@@ -1,40 +0,0 @@
1		-class MezuroPlugin::MetricConfigurationContent < Article
2		-
3		- NATIVE_TYPE='native'
4		- COMPOUND_TYPE='compound'
5		-
6		- def self.short_description
7		- 'Kalibro Configurated Metric'
8		- end
9		-
10		- def self.description
11		- 'Sets of thresholds to interpret a metric'
12		- end
13		-
14		- settings_items :description, :code, :weight, :scope, :aggregation_form, :range
15		-
16		- include ActionView::Helpers::TagHelper
17		- def to_html(options = {})
18		- lambda do
19		- render :file => 'content_viewer/show_configuration.rhtml'
20		- end
21		- end
22		-
23		- def metric_configuration #FIXME invalid method name
24		- Kalibro::Client::MetricConfigurationClient.metric_configuration(name)
25		- end
26		-
27		- after_save :send_metric_configuration_to_service
28		- after_destroy :remove_metric_configuration_from_service
29		-
30		- private
31		-
32		- def send_metric_configuration_to_service
33		- Kalibro::Client::MetricConfigurationClient.save(self)
34		- end
35		-
36		- def remove_metric_configuration_from_service
37		- Kalibro::Client::MetricConfigurationClient.remove(name)
38		- end
39		-
40		-end
...	...	@@ -30,8 +30,15 @@ function IsNotNumeric(value){
30	30	return true;
31	31	}
32	32
	33	+function IsNotInfinite(value){
	34	+ if(value.match(/INF/)){
	35	+ return false;
	36	+ }
	37	+ return true;
	38	+}
	39	+
33	40	function IsNotHexadecimal(value){
34		- if(value.match(/[0-9a-fA-F]{1,8}/))
	41	+ if(value.match(/^[0-9a-fA-F]{1,8}$/))
35	42	{
36	43	return false;
37	44	}
...	...	@@ -50,15 +57,17 @@ function validate_new_range_configuration(event){
50	57	alert("Please fill all fields marked with (*)");
51	58	return false;
52	59	}
53		- if (IsNotNumeric(beginning) \|\| IsNotNumeric(end) \|\| IsNotNumeric(grade))
	60	+ if ( (IsNotNumeric(beginning) && IsNotInfinite(beginning)) \|\| (IsNotNumeric(end) && IsNotInfinite(end)) \|\| IsNotNumeric(grade))
54	61	{
55	62	alert("Beginning, End and Grade must be numeric values");
56	63	return false;
57	64	}
58	65	if (parseInt(beginning) > parseInt(end))
59	66	{
60		- alert("End must be greater than Beginning");
61		- return false;
	67	+ if(IsNotInfinite(beginning) && IsNotInfinite(end)){
	68	+ alert("End must be greater than Beginning");
	69	+ return false;
	70	+ }
62	71	}
63	72	if (IsNotHexadecimal(color)){
64	73	alert("Color must be an hexadecimal value");
...	...
...	...	@@ -14,7 +14,7 @@ class MezuroPluginMyprofileControllerTest < ActionController::TestCase
14	14	@response = ActionController::TestResponse.new
15	15	@profile = fast_create(Community)
16	16
17		- @collector = BaseToolFixtures.analizo
	17	+ @base_tool = BaseToolFixtures.analizo
18	18	@base_tool_client = Kalibro::Client::BaseToolClient.new
19	19	@metric = NativeMetricFixtures.amloc
20	20	@metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
...	...	@@ -23,70 +23,73 @@ class MezuroPluginMyprofileControllerTest < ActionController::TestCase
23	23	@configuration = ConfigurationFixtures.kalibro_configuration
24	24	end
25	25
26		- should 'assign configuration name in choose_base_tool' do
27		- get :choose_base_tool, :profile => @profile.identifier, :configuration_name => "test name"
28		- assert_equal assigns(:configuration_name), "test name"
	26	+ should 'assign configuration content in choose_base_tool' do
	27	+ create_configuration_content
	28	+ Kalibro::Client::BaseToolClient.expects(:base_tools).returns([])
	29	+ get :choose_base_tool, :profile => @profile.identifier, :id => @content.id
	30	+ assert_equal assigns(:configuration_content), @content
29	31	end
30	32
31		- should 'create base tool client' do
32		- get :choose_base_tool, :profile => @profile.identifier, :configuration_name => "test name"
33		- assert assigns(:tool_names).instance_of?(Kalibro::Client::BaseToolClient)
34		- end
35		-
36		- should 'assign configuration and collector name in choose_metric' do
	33	+ should 'assign configuration and base_tool name in choose_metric' do
	34	+ create_configuration_content
37	35	Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
38		- @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
39		- get :choose_metric, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo"
40		- assert_equal assigns(:configuration_name), "test name"
41		- assert_equal assigns(:collector_name), "Analizo"
	36	+ @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
	37	+ get :choose_metric, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name
	38	+ assert_equal @content, assigns(:configuration_content)
	39	+ assert_equal @base_tool.name, assigns(:base_tool)
42	40	end
43	41
44		- should 'get collector by name' do
	42	+ should 'get base_tool by name' do
	43	+ create_configuration_content
45	44	Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
46		- @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
47		- get :choose_metric, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo"
48		- assert_equal assigns(:collector), @collector
	45	+ @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
	46	+ get :choose_metric, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name
	47	+ assert_equal @base_tool.name, assigns(:base_tool)
49	48	end
50	49
51	50	should 'get chosen native metric and configuration name' do
	51	+ create_configuration_content
52	52	Kalibro::Client::BaseToolClient.expects(:new).returns(@base_tool_client)
53		- @base_tool_client.expects(:base_tool).with(@collector.name).returns(@collector)
54		- get :new_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :collector_name => "Analizo", :metric_name => @metric.name
55		- assert_equal assigns(:configuration_name), "test name"
56		- assert_equal assigns(:metric), @metric
	53	+ @base_tool_client.expects(:base_tool).with(@base_tool.name).returns(@base_tool)
	54	+ get :new_metric_configuration, :profile => @profile.identifier, :id => @content.id, :base_tool => @base_tool.name, :metric_name => @metric.name
	55	+ assert_equal @content, assigns(:configuration_content)
	56	+ assert_equal @metric, assigns(:metric)
57	57	end
58	58
59	59	should 'call configuration client in new_compound_metric_configuration method' do
	60	+ create_configuration_content
60	61	configuration_client = mock
61	62	Kalibro::Client::ConfigurationClient.expects(:new).returns(configuration_client)
62	63	configuration_client.expects(:configuration).with(@configuration.name).returns(@configuration)
63		- get :new_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name
	64	+ get :new_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id
64	65	assert_response 200
65	66	end
66	67
67	68	should 'assign configuration name and get metric_configuration' do
	69	+ create_configuration_content
68	70	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
69		- @metric_configuration_client.expects(:metric_configuration).with("test name", @metric.name).returns(@metric_configuration)
70		- get :edit_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
71		- assert_equal assigns(:configuration_name), "test name"
	71	+ @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric.name).returns(@metric_configuration)
	72	+ get :edit_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
	73	+ assert_equal assigns(:configuration_content), @content
72	74	assert_equal assigns(:metric_configuration), @metric_configuration
73	75	assert_equal assigns(:metric), @metric_configuration.metric
74	76	end
75	77
76	78	should 'test metric creation' do
	79	+ create_configuration_content
77	80	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
78	81	@metric_configuration_client.expects(:save)
79		- get :create_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name",
	82	+ get :create_metric_configuration, :profile => @profile.identifier, :id => @content.id,
80	83	:metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.code, :aggregation => @metric_configuration.aggregation_form,
81	84	:metric => { :name => @metric.name, :origin => @metric.origin, :description => @metric.description, :scope => @metric.scope, :language => @metric.language }}
82		- assert_equal assigns(:configuration_name), "test name"
83	85	assert_response 302
84	86	end
85	87
86	88	should 'test compound metric creation' do
	89	+ create_configuration_content
87	90	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
88	91	@metric_configuration_client.expects(:save)
89		- get :create_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name",
	92	+ get :create_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id,
90	93	:metric_configuration => { :code => @compound_metric_configuration.code, :weight => @compound_metric_configuration.weight,
91	94	:aggregation_form => @compound_metric_configuration.aggregation_form, :metric => { :name => @compound_metric_configuration.metric.name ,
92	95	:description => @compound_metric_configuration.metric.description, :scope => @compound_metric_configuration.metric.scope,
...	...	@@ -95,37 +98,43 @@ class MezuroPluginMyprofileControllerTest < ActionController::TestCase
95	98	end
96	99
97	100	should 'test metric edition' do
	101	+ create_configuration_content
98	102	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
99		- @metric_configuration_client.expects(:metric_configuration).with("test name","test metric name").returns(@metric_configuration)
100		- get :edit_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => "test metric name"
	103	+ @metric_configuration_client.expects(:metric_configuration).with(@configuration.name,@metric.name).returns(@metric_configuration)
	104	+ get :edit_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
101	105	assert_response 200
102	106	end
103	107
104	108	should 'test compound metric edition' do
	109	+ create_configuration_content
105	110	configuration_client = mock
106	111	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
107	112	Kalibro::Client::ConfigurationClient.expects(:new).returns(configuration_client)
108	113	configuration_client.expects(:configuration).with(@configuration.name).returns(@configuration)
109	114	@metric_configuration_client.expects(:metric_configuration).with(@configuration.name,@metric.name).returns(@compound_metric_configuration)
110		- get :edit_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name, :metric_name => @metric.name
	115	+ get :edit_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
111	116	assert_response 200
112	117	end
113	118
114	119	should 'update metric configuration' do
	120	+ create_configuration_content
	121	+ Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
115	122	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
116	123	@metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric_configuration.metric.name).returns(@metric_configuration)
117	124	@metric_configuration_client.expects(:save)
118		- get :update_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name,
	125	+ get :update_metric_configuration, :profile => @profile.identifier, :id => @content.id,
119	126	:metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.weight, :aggregation => @metric_configuration.aggregation_form,
120	127	:metric => { :name => @metric.name, :origin => @metric.origin, :description => @metric.description, :scope => @metric.scope, :language => @metric.language }}
121	128	assert_response 302
122	129	end
123	130
124	131	should 'update compound metric configuration' do
	132	+ create_configuration_content
	133	+ Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
125	134	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
126	135	@metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @compound_metric_configuration.metric.name).returns(@compound_metric_configuration)
127	136	@metric_configuration_client.expects(:save)
128		- get :update_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => @configuration.name,
	137	+ get :update_compound_metric_configuration, :profile => @profile.identifier, :id => @content.id,
129	138	:metric_configuration => { :code => @compound_metric_configuration.code, :weight => @compound_metric_configuration.weight,
130	139	:aggregation_form => @compound_metric_configuration.aggregation_form, :metric => { :name => @compound_metric_configuration.metric.name ,
131	140	:description => @compound_metric_configuration.metric.description, :scope => @compound_metric_configuration.metric.scope,
...	...	@@ -134,26 +143,41 @@ class MezuroPluginMyprofileControllerTest < ActionController::TestCase
134	143	end
135	144
136	145	should 'assign configuration name and metric name to new range' do
137		- get :new_range, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
138		- assert_equal assigns(:configuration_name), "test name"
	146	+ create_configuration_content
	147	+ get :new_range, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
	148	+ assert_equal assigns(:configuration_content), @content
139	149	assert_equal assigns(:metric_name), @metric.name
140	150	end
141	151
142	152	should 'create instance range' do
	153	+ create_configuration_content
143	154	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
144		- @metric_configuration_client.expects(:metric_configuration).with("test name", @metric.name).returns(@metric_configuration)
	155	+ Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
	156	+ @metric_configuration_client.expects(:metric_configuration).with(@configuration.name, @metric.name).returns(@metric_configuration)
145	157	@metric_configuration_client.expects(:save)
146	158	range = @metric_configuration.ranges[0]
147	159	get :create_range, :profile => @profile.identifier, :range => { :beginning => range.beginning, :end => range.end, :label => range.label,
148		- :grade => range.grade, :color => range.color, :comments => range.comments }, :configuration_name => "test name", :metric_name => @metric.name
	160	+ :grade => range.grade, :color => range.color, :comments => range.comments }, :id => @content.id, :metric_name => @metric.name
149	161	assert assigns(:range).instance_of?(Kalibro::Entities::Range)
150	162	end
151	163
152	164	should 'redirect from remove metric configuration' do
	165	+ create_configuration_content
153	166	Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
154	167	@metric_configuration_client.expects(:remove)
155		- get :remove_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => @metric.name
	168	+ get :remove_metric_configuration, :profile => @profile.identifier, :id => @content.id, :metric_name => @metric.name
156	169	assert_response 302
157	170	end
	171	+
	172	+ private
	173	+
	174	+ def create_configuration_content
	175	+ client = mock
	176	+ Kalibro::Client::ConfigurationClient.expects(:new).returns(client)
	177	+ client.expects(:configuration_names).returns([])
	178	+ @content = MezuroPlugin::ConfigurationContent.new(:profile => @profile, :name => @configuration.name)
	179	+ @content.expects(:send_configuration_to_service).returns(nil)
	180	+ @content.save
	181	+ end
158	182
159	183	end
...	...
...	...	@@ -1,44 +0,0 @@
1		-require "test_helper"
2		-
3		-class MetricConfigurationContentTest < ActiveSupport::TestCase
4		-
5		- def setup
6		- @metric_configuration = MezuroPlugin::MetricConfigurationContent.new
7		- end
8		-
9		- should 'be a metric configuration' do
10		- assert_kind_of Article, @metric_configuration
11		- end
12		-
13		- should 'have short description' do
14		- assert_equal 'Kalibro Configurated Metric', MezuroPlugin::MetricConfigurationContent.short_description
15		- end
16		-
17		- should 'have description' do
18		- assert_equal 'Sets of thresholds to interpret a metric', MezuroPlugin::MetricConfigurationContent.description
19		- end
20		-
21		- should 'have an html view' do
22		- assert_not_nil @metric_configuration.to_html
23		- end
24		-
25		- #should 'return metric configuration' do
26		- # pending "Need refactoring"
27		- #end
28		-
29		- should 'send metric configuration to service after saving' do
30		- @metric_configuration.expects :send_metric_configuration_to_service
31		- @metric_configuration.run_callbacks :after_save
32		- end
33		-
34		- should 'send correct metric configuration to service' do
35		- Kalibro::Client::MetricConfigurationClient.expects(:save).with(@metric_configuration)
36		- @metric_configuration.send :send_metric_configuration_to_service
37		- end
38		-
39		- should 'remove metric configuration from service' do
40		- Kalibro::Client::MetricConfigurationClient.expects(:remove).with(@metric_configuration.name)
41		- @metric_configuration.send :remove_metric_configuration_from_service
42		- end
43		-
44		-end