Merge branch 'mezuro-dev' into mezuro

Paulo Meireles
2 parents 60b69b3c 32e0145e
Showing 114 changed files with 2790 additions and 803 deletions Show diff stats
plugins/mezuro/controllers/mezuro_plugin_myprofile_controller.rb
plugins/mezuro/controllers/mezuro_plugin_profile_controller.rb
plugins/mezuro/features/mezuro.feature
plugins/mezuro/lib/kalibro/client/base_tool_client.rb
plugins/mezuro/lib/kalibro/client/configuration_client.rb
plugins/mezuro/lib/kalibro/client/kalibro_client.rb
plugins/mezuro/lib/kalibro/client/metric_configuration_client.rb
plugins/mezuro/lib/kalibro/client/module_result_client.rb
plugins/mezuro/lib/kalibro/client/port.rb
plugins/mezuro/lib/kalibro/client/project_client.rb
plugins/mezuro/lib/kalibro/client/project_result_client.rb
plugins/mezuro/lib/kalibro/entities/configuration.rb
plugins/mezuro/lib/kalibro/entities/entity.rb
plugins/mezuro/lib/kalibro/entities/error.rb
plugins/mezuro/lib/kalibro/entities/metric.rb
plugins/mezuro/lib/kalibro/entities/metric_configuration.rb
plugins/mezuro/lib/kalibro/entities/metric_result.rb
plugins/mezuro/lib/kalibro/entities/module.rb
plugins/mezuro/lib/kalibro/entities/module_node.rb
plugins/mezuro/lib/kalibro/entities/module_result.rb
@@ -0,0 +1,189 @@
+class MezuroPluginMyprofileController < ProfileController
+
+  append_view_path File.join(File.dirname(__FILE__) + '/../views')
+
+ 
+  def choose_base_tool
+    @configuration_name = params[:configuration_name]
+    @tool_names = Kalibro::Client::BaseToolClient.new
+  end
+
+  def choose_metric
+    @configuration_name = params[:configuration_name]
+    @collector_name = params[:collector_name]
+    @collector = Kalibro::Client::BaseToolClient.new.base_tool(@collector_name)
+  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]
+  end
+  
+  def new_compound_metric_configuration
+    @configuration_name = params[:configuration_name]
+    @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).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)
+    @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 = @metric_configuration.metric
+  end
+  
+  def create_metric_configuration
+    @configuration_name = params[:configuration_name]
+    metric_configuration = new_metric_configuration_instance
+    Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_name)
+    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
+  end
+  
+  def create_compound_metric_configuration
+    @configuration_name = params[:configuration_name]
+    compound_metric_configuration = new_compound_metric_configuration_instance
+    Kalibro::Client::MetricConfigurationClient.new.save(compound_metric_configuration, @configuration_name)
+    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"    
+  end
+
+  def update_metric_configuration
+    @configuration_name = params[:configuration_name]
+    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
+    metric_name = params[:metric][:name]
+    metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)  
+    metric_configuration = assign_metric_configuration_instance(metric_configuration)
+    metric_configuration_client.save(metric_configuration, @configuration_name)
+    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
+  end
+
+  def update_compound_metric_configuration
+    @configuration_name = params[:configuration_name]
+    metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
+    metric_name = params[:metric_configuration][:metric][:name]
+    compound_metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)  
+    compound_metric_configuration = assign_compound_metric_configuration_instance(compound_metric_configuration)
+    metric_configuration_client.save(compound_metric_configuration, @configuration_name)
+    redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
+  end
+  
+  def new_range
+    @metric_name = params[:metric_name]
+    @configuration_name = params[:configuration_name]
+  end
+  
+  def edit_range
+    @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)
+    @range = metric_configuration.ranges.find{ |range| range.beginning == @beginning_id.to_f }
+  end
+
+  def create_range
+    @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.add_range(@range)
+    metric_configuration_client.save(metric_configuration, configuration_name)
+  end
+  
+  def update_range
+    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)
+    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)
+  end
+  
+  def remove_range
+    configuration_name = params[:configuration_name]
+    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.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}"
+    else
+      redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
+    end
+  end
+
+  def remove_metric_configuration
+    configuration_name = params[:configuration_name]
+    metric_name = params[:metric_name]
+    Kalibro::Client::MetricConfigurationClient.new.remove(configuration_name, metric_name)
+    redirect_to "/#{profile.identifier}/#{configuration_name.downcase.gsub(/\s/, '-')}"
+  end
+
+  
+
+  private 
+
+  def new_metric_configuration_instance
+    metric_configuration = Kalibro::Entities::MetricConfiguration.new
+    metric_configuration.metric = Kalibro::Entities::NativeMetric.new
+    assign_metric_configuration_instance (metric_configuration)
+  end
+  
+  def new_compound_metric_configuration_instance
+    metric_configuration = Kalibro::Entities::MetricConfiguration.new
+    metric_configuration.metric = Kalibro::Entities::CompoundMetric.new
+    assign_compound_metric_configuration_instance (metric_configuration)
+  end
+  
+  def assign_metric_configuration_instance (metric_configuration)
+    metric_configuration.metric.name = params[:metric][:name]
+    metric_configuration.metric.description = params[:description]
+    metric_configuration.metric.origin = params[:metric][:origin]
+    metric_configuration.metric.scope = params[:scope]
+    metric_configuration.metric.language = params[:language]
+    metric_configuration.code = params[:metric_configuration][:code]
+    metric_configuration.weight = params[:metric_configuration][:weight]
+    metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
+    metric_configuration
+  end
+
+  def assign_compound_metric_configuration_instance (metric_configuration)
+    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]
+    metric_configuration.metric.script = params[:metric_configuration][:metric][:script]
+    metric_configuration.code = params[:metric_configuration][:code]
+    metric_configuration.weight = params[:metric_configuration][:weight]
+    metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
+    metric_configuration
+  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
+  end
+
+end
 class MezuroPluginProfileController < ProfileController
  
-  def metrics
-    project_content = profile.articles.find(params[:id])
-    module_name = params[:module_name]
-    render :partial => 'content_viewer/module_result', :locals => { :module_result => project_content.module_result(module_name) }
+  append_view_path File.join(File.dirname(__FILE__) + '/../views')
+
+  def project_state
+    content = profile.articles.find(params[:id])
+    project = content.project
+    state = project.error.nil? ? project.state : "ERROR"
+    render :text => state
+  end
+
+  def project_error
+    content = profile.articles.find(params[:id])
+    project = content.project
+    render :partial => 'content_viewer/project_error', :locals => { :project => project }
+  end
+
+  def project_result
+    content = profile.articles.find(params[:id])
+    date = params[:date]
+    project_result = date.nil? ? content.project_result : content.get_date_result(date)
+    project = content.project
+    render :partial => 'content_viewer/project_result', :locals => { :project_result => project_result}
+  end 	
+
+  def module_result
+    content = profile.articles.find(params[:id])
+    date = params[:date]
+    date.nil? ? content.project_result : content.get_date_result(date)
+    module_result = content.module_result(params[:module_name])
+   render :partial => 'content_viewer/module_result', :locals => { :module_result =>  module_result}
   end
  
+  def project_tree
+    content = profile.articles.find(params[:id])
+    date = params[:date]
+    project_result = date.nil? ? content.project_result : content.get_date_result(date)
+    source_tree = project_result.node_of(params[:module_name])
+    render :partial =>'content_viewer/source_tree', :locals => { :source_tree => source_tree, :project_name => content.project.name}
+  end
+
+  def module_metrics_history
+    metric_name = params[:metric_name]
+    content = profile.articles.find(params[:id])
+    module_history = content.result_history(params[:module_name])
+    score_history = (module_history.collect { |module_result| (module_result.metric_results.select { |metric_result| metric_result.metric.name.delete("() ") == metric_name })[0] }).collect { |metric_result| metric_result.value }
+    render :partial => 'content_viewer/score_history', :locals => {:score_history => score_history}
+  end
+
+  def module_grade_history
+    content = profile.articles.find(params[:id])
+    modules_results = content.result_history(params[:module_name])
+    score_history = modules_results.collect { |module_result| module_result.grade }
+    render :partial => 'content_viewer/score_history', :locals => {:score_history => score_history}
+  end
 end
@@ -1,69 +0,0 @@
-Feature: mezuro content
-  As a noosfero user
-  I want to create a Kalibro project
-
-  Background:
-    Given the following users
-      | login     | name       |
-      | joaosilva | Joao Silva |
-    And I am logged in as "joaosilva"
-    And "Mezuro" plugin is enabled
-    And the following community
-      | identifier  | name         |
-      | mycommunity | My Community |
-    And "Joao Silva" is admin of "My Community"
-
-  Scenario: I see Kalibro project as an option to new content
-    Given I am on My Community's cms
-    When I follow "New content"
-    Then I should see "Kalibro project"
-
-  Scenario: I see Kalibro project's input form
-    Given I am on My Community's cms
-    When I follow "New content"
-    And I follow "Kalibro project"
-    Then I should see "Title"
-    And I should see "License"
-    And I should see "Repository type"
-    And I should see "GIT"
-    And I should see "REMOTE_ZIP"
-    And I should see "REMOTE_TARBALL"
-    And I should see "SUBVERSION"
-    And I should see "Repository url"
-    And I should see "Configuration"
-    And I should see "Kalibro for Java"
-
-  Scenario: I create a sample mezuro content
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Sample project          |
-      | License         | BSD                     |
-      | Repository type | GIT                     |
-      | Repository url  | git://example           |
-    Then I should see "Sample project"
-    And I should see "Viewed one time"
-    And I should see "BSD"
-
-  Scenario: I create a real mezuro content
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Qt-Calculator           |
-      | License         | GPL 2.0                 |
-      | Repository type | SUBVERSION              |
-      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
-    Then I should see "Qt-Calculator"
-
-  Scenario: I see results from a real Kalibro project
-    Given I am on My Community's cms
-    When I create a content of type "Kalibro project" with the following data
-      | Title           | Qt-Calculator           |
-      | License         | GPL                     |
-      | Repository type | SUBVERSION              |
-      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
-      | Configuration   | Kalibro for Java        |
-   Then I should see "Qt-Calculator"
-   And I should see "GPL"
-   And I should see "SUBVERSION"
-   And I should see "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator"
-   And I should see "Kalibro for Java"
-   And I should see "Kalibro Service is loading the source code"
@@ -13,4 +13,4 @@ class Kalibro::Client::BaseToolClient
     Kalibro::Entities::BaseTool.from_hash(hash)
   end
  
-end
 \ No newline at end of file
+end
 class Kalibro::Client::ConfigurationClient
  
+  def self.save(configuration_content)
+    configuration = Kalibro::Entities::Configuration.new
+    configuration.name = configuration_content.name
+    configuration.description = configuration_content.description
+    new.save(configuration)
+  end
+
+  def self.remove(configuration_name)
+    client = new
+    client.remove(configuration_name) if client.configuration_names.include? configuration_name
+  end
+
   def initialize
     @port = Kalibro::Client::Port.new('Configuration')
   end
@@ -8,10 +20,6 @@ class Kalibro::Client::ConfigurationClient
     @port.request(:save_configuration, {:configuration => configuration.to_hash})
   end
  
-  def self.save(configuration)
-    new.save(configuration)
-  end
-
   def configuration_names
     @port.request(:get_configuration_names)[:configuration_name].to_a
   end
@@ -25,7 +33,4 @@ class Kalibro::Client::ConfigurationClient
     @port.request(:remove_configuration, {:configuration_name => configuration_name})
   end
  
-  def self.remove(configuration_name)
-    new.remove(configuration_name)
-  end
 end
 class Kalibro::Client::KalibroClient
+
+  def self.process_project(project_name)
+    new.process_project(project_name)
+  end
  
   def initialize
     @port = Kalibro::Client::Port.new('Kalibro')
@@ -12,8 +16,24 @@ class Kalibro::Client::KalibroClient
     @port.request(:process_project, {:project_name => project_name})
   end
  
-  def self.process_project(project_name)
-    new.process_project(project_name)
+  def self.process_project(project_name, days)
+    if days.to_i.zero?
+    	new.process_project(project_name)
+  	else
+  		new.process_periodically(project_name, days)
+  	end
+  end
+
+	def process_periodically(project_name, period_in_days)
+    @port.request(:process_periodically, {:project_name => project_name, :period_in_days => period_in_days})
+  end
+
+	def process_period(project_name)
+    @port.request(:get_process_period, {:project_name => project_name})[:period]
+  end
+
+	def cancel_periodic_process(project_name)
+    @port.request(:cancel_periodic_process, {:project_name => project_name})
   end
  
 end
@@ -0,0 +1,28 @@
+class Kalibro::Client::MetricConfigurationClient
+
+  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
 \ No newline at end of file
 class Kalibro::Client::ModuleResultClient
-  
+
   def initialize
     @port = Kalibro::Client::Port.new('ModuleResult')
   end
@@ -7,7 +7,7 @@ class Kalibro::Client::ModuleResultClient
   def module_result(project_name, module_name, date)
     hash = @port.request(:get_module_result,
       {:project_name => project_name, :module_name => module_name,
-       :date => date_with_milliseconds(date)})[:module_result]
+       :date => Kalibro::Entities::Entity.date_with_milliseconds(date)})[:module_result]
     Kalibro::Entities::ModuleResult.from_hash(hash)
   end
  
@@ -16,12 +16,4 @@ class Kalibro::Client::ModuleResultClient
       {:project_name => project_name, :module_name => module_name})[:module_result]
     Kalibro::Entities::Entity.new.to_entity_array(value, Kalibro::Entities::ModuleResult)
   end
-
-  private
-
-  def date_with_milliseconds(date)
-    milliseconds = "." + (date.sec_fraction * 60 * 60 * 24 * 1000).to_s
-    date.to_s[0..18] + milliseconds + date.to_s[19..-1]
-  end
-
-end
 \ No newline at end of file
+end
@@ -7,7 +7,8 @@ end
 class Kalibro::Client::Port
  
   def initialize(endpoint)
-    @client = Savon::Client.new("#{service_address}#{endpoint}Endpoint/?wsdl")
+    @endpoint = endpoint
+    initialize_client
   end
  
   def service_address
@@ -18,9 +19,20 @@ class Kalibro::Client::Port
     @service_address
   end
  
+  def service_address=(address)
+    @service_address = address
+    initialize_client
+  end
+
   def request(action, request_body = nil)
     response = @client.request(:kalibro, action) { soap.body = request_body }
     response.to_hash["#{action}_response".to_sym]
   end
  
+  private
+
+  def initialize_client
+    @client = Savon::Client.new("#{service_address}#{@endpoint}Endpoint/?wsdl")
+  end
+
 end
 class Kalibro::Client::ProjectClient
  
+  def self.project(project_name)
+    new.project(project_name)
+  end
+
+  def self.save(project_content)
+    project = create_project(project_content)
+    new.save(project)
+  end
+
+  def self.remove(project_name)
+    instance = new
+    if (instance.project_names.include?(project_name))
+      instance.remove(project_name)
+    end
+  end
+
+  def self.create_project (project_content)
+    project = Kalibro::Entities::Project.new
+    project.name = project_content.name
+    project.license = project_content.license
+    project.description = project_content.description
+    project.repository = create_repository(project_content)
+    project.configuration_name = project_content.configuration_name
+    project
+  end
+
+  def self.create_repository(project_content)
+    repository = Kalibro::Entities::Repository.new
+    repository.type = project_content.repository_type
+    repository.address = project_content.repository_url
+    repository
+  end
+  
   def initialize
     @port = Kalibro::Client::Port.new('Project')
   end
@@ -8,16 +41,20 @@ class Kalibro::Client::ProjectClient
     @port.request(:save_project, {:project => project.to_hash})
   end
  
-  def self.save(project)
-    new.save(project)
-  end
-
   def project_names
     @port.request(:get_project_names)[:project_name].to_a
   end
  
-  def project(name)
-    hash = @port.request(:get_project, {:project_name => name})[:project]
+  def project(project_name)
+    begin 
+      hash = @port.request(:get_project, {:project_name => project_name})[:project]
+    rescue Exception => error
+      unless (error.message =~ /There is no project named/).nil?
+        return nil
+      else
+        raise error
+      end
+    end
     Kalibro::Entities::Project.from_hash(hash)
   end
  
@@ -25,7 +62,4 @@ class Kalibro::Client::ProjectClient
     @port.request(:remove_project, {:project_name => project_name})
   end
  
-  def self.remove(project_name)
-    new.remove(project_name)
-  end
 end
 class Kalibro::Client::ProjectResultClient
  
+  # TODO test this
+  def self.last_result(project_name)
+    new.last_result(project_name)
+  end
+
   def initialize
     @port = Kalibro::Client::Port.new('ProjectResult')
   end
@@ -7,7 +7,11 @@ class Kalibro::Entities::Configuration &lt; Kalibro::Entities::Entity
   end
  
   def metric_configurations
-    @metric_configuration
+    if @metric_configuration != nil
+      @metric_configuration
+    else
+      []
+    end
   end
  
   def metric_configurations=(metric_configurations)
@@ -2,12 +2,21 @@ class Kalibro::Entities::Entity
  
   def self.from_hash(hash)
     entity = self.new
-    hash.each { |field, value| entity.set(field, value) }
+    hash.each { |field, value| entity.set(field, value) if is_valid?(field) }
     entity
   end
  
+  def self.is_valid?(field)
+    field.to_s[0] != '@' and field != :attributes!
+  end
+
+  def self.date_with_milliseconds(date)
+    milliseconds = "." + (date.sec_fraction * 60 * 60 * 24 * 1000).to_s
+    date.to_s[0..18] + milliseconds + date.to_s[19..-1]
+  end
+
   def set(field, value)
-    send("#{field}=", value)
+    send("#{field}=", value) if not field.to_s.start_with? '@'
   end
  
   def to_entity_array(value, entity_class = nil)
@@ -24,16 +33,16 @@ class Kalibro::Entities::Entity
     fields.each do |field|
       field_value = self.get(field)
       hash[field] = convert_to_hash(field_value) if ! field_value.nil?
+      if need_xml_type?(field_value)
+        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
     hash
   end
  
-  def convert_to_hash(value)
-    return value.collect { |element| convert_to_hash(element) } if value.kind_of?(Array)
-    return value.to_hash if value.kind_of?(Kalibro::Entities::Entity)
-    value
-  end
-
   def ==(other)
     begin
       fields.each.inject(true) { |equal, field| equal && (self.get(field) == other.get(field)) }
@@ -42,6 +51,8 @@ class Kalibro::Entities::Entity
     end
   end
  
+  protected
+
   def fields
     instance_variable_names.each.collect { |variable| variable.to_s.sub(/@/, '').to_sym }
   end
@@ -50,4 +61,24 @@ class Kalibro::Entities::Entity
     send("#{field}")
   end
  
-end
 \ No newline at end of file
+  def convert_to_hash(value)
+    return value.collect { |element| convert_to_hash(element) } if value.is_a?(Array)
+    return value.to_hash if value.is_a?(Kalibro::Entities::Entity)
+    return self.class.date_with_milliseconds(value) if value.is_a?(DateTime)
+    return 'INF' if value.is_a?(Float) and value.infinite? == 1
+    return '-INF' if value.is_a?(Float) and value.infinite? == -1
+    value
+  end
+
+  def need_xml_type?(value)
+    value.is_a?(Kalibro::Entities::Entity) and value.class.superclass != Kalibro::Entities::Entity
+  end
+
+  def xml_class_name(entity)
+    xml_name = entity.class.name
+    xml_name["Kalibro::Entities::"] = ""
+    xml_name[0..0] = xml_name[0..0].downcase
+    xml_name + "Xml"
+  end
+  
+end
 class Kalibro::Entities::Error < Kalibro::Entities::Entity
  
-  attr_accessor :message, :stack_trace_element
+  attr_accessor :error_class, :message, :stack_trace_element
  
   def stack_trace_element=(value)
     @stack_trace_element = to_entity_array(value, Kalibro::Entities::StackTraceElement)
@@ -2,4 +2,4 @@ class Kalibro::Entities::Metric &lt; Kalibro::Entities::Entity
  
   attr_accessor :name, :scope, :description
  
-end
 \ No newline at end of file
+end
@@ -11,10 +11,19 @@ class Kalibro::Entities::MetricConfiguration &lt; Kalibro::Entities::Entity
     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
@@ -23,4 +32,4 @@ class Kalibro::Entities::MetricConfiguration &lt; Kalibro::Entities::Entity
     @range = ranges
   end
  
-end
 \ No newline at end of file
+end
@@ -14,12 +14,17 @@ class Kalibro::Entities::MetricResult &lt; Kalibro::Entities::Entity
     end
   end
  
+  def value=(value)
+    @value = value.to_f
+  end
+
   def range=(value)
     @range = to_entity(value, Kalibro::Entities::Range)
   end
  
   def descendent_result=(value)
-    @descendent_result = to_entity_array(value)
+    array = value.kind_of?(Array) ? value : [value]
+    @descendent_result = array.collect {|element| element.to_f}
   end
  
   def descendent_results
@@ -2,4 +2,17 @@ class Kalibro::Entities::Module &lt; Kalibro::Entities::Entity
  
   attr_accessor :name, :granularity
  
-end
 \ No newline at end of file
+  def self.parent_names(name)
+    path = []
+    ancestors = []
+    name.split(".").each do |token|
+       path << token
+       ancestors << path.join(".")
+     end
+     ancestors
+  end
+
+  def ancestor_names
+    Kalibro::Entities::Module.parent_names(@name)
+  end
+end
@@ -6,14 +6,6 @@ class Kalibro::Entities::ModuleNode &lt; Kalibro::Entities::Entity
     @module = to_entity(value, Kalibro::Entities::Module)
   end
  
-  def module_name
-    @module.name
-  end
-
-  def granularity
-    @module.granularity
-  end
-
   def child=(value)
     @child = to_entity_array(value, Kalibro::Entities::ModuleNode)
   end
@@ -6,6 +6,15 @@ class Kalibro::Entities::ModuleResult &lt; Kalibro::Entities::Entity
     @module = to_entity(value, Kalibro::Entities::Module)
   end
  
+  def date=(value)
+    @date = value
+    @date = DateTime.parse(value) if value.is_a?(String)
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  end
+
   def metric_result=(value)
     @metric_result = to_entity_array(value, Kalibro::Entities::MetricResult)
   end
@@ -2,4 +2,16 @@ class Kalibro::Entities::NativeMetric &lt; Kalibro::Entities::Metric
  
   attr_accessor :origin, :language
  
-end
 \ No newline at end of file
+  def languages
+    @language
+  end
+
+  def languages=(languages)
+    @language = languages
+  end
+
+  def language=(value)
+    @language = to_entity_array(value)
+  end
+
+end
@@ -9,5 +9,4 @@ class Kalibro::Entities::Project &lt; Kalibro::Entities::Entity
   def error=(value)
     @error = to_entity(value, Kalibro::Entities::Error)
   end
-
-end
 \ No newline at end of file
+end
 class Kalibro::Entities::ProjectResult < Kalibro::Entities::Entity
-  
-  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree
+
+  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree, :collect_time
  
   def project=(value)
     @project = to_entity(value, Kalibro::Entities::Project)
   end
  
+  def date=(value)
+    @date = value
+    @date = DateTime.parse(value) if value.is_a?(String)
+  end
+
+  def load_time=(value)
+    @load_time = value.to_i
+  end
+
+  def collect_time=(value)
+    @collect_time = value.to_i
+  end
+
+  def analysis_time=(value)
+    @analysis_time = value.to_i
+  end
+
   def source_tree=(value)
     @source_tree = to_entity(value, Kalibro::Entities::ModuleNode)
   end
@@ -31,4 +48,29 @@ class Kalibro::Entities::ProjectResult &lt; Kalibro::Entities::Entity
     ('%2d' % amount).sub(/\s/, '0')
   end
  
-end
 \ No newline at end of file
+  def node_of(module_name)
+    if module_name.nil? or module_name == project.name
+      node = source_tree
+    else
+      node = get_node(module_name)
+    end
+  end
+
+  def get_node(module_name)
+    path = Kalibro::Entities::Module.parent_names(module_name)
+    parent = @source_tree
+    path.each do |node_name|
+      parent = get_leaf_from(parent, node_name)
+    end
+    return parent
+  end
+
+  private
+  def get_leaf_from(node, module_name) 
+    node.children.each do |child_node|
+      return child_node if child_node.module.name == module_name
+    end
+    nil
+  end
+
+end
@@ -2,4 +2,18 @@ class Kalibro::Entities::Range &lt; Kalibro::Entities::Entity
  
   attr_accessor :beginning, :end, :label, :grade, :color, :comments
  
+  def beginning=(value)
+    @beginning = value.to_f
+    @beginning = -1.0/0.0 if value == "-INF"
+  end
+
+  def end=(value)
+    @end = value.to_f
+    @end = 1.0/0.0 if value == "INF"
+  end
+
+  def grade=(value)
+    @grade = value.to_f
+  end
+
 end
 \ No newline at end of file
@@ -2,4 +2,8 @@ class Kalibro::Entities::StackTraceElement &lt; Kalibro::Entities::Entity
  
   attr_accessor :declaring_class, :method_name, :file_name, :line_number
  
+  def line_number=(value)
+    @line_number = value.to_i
+  end
+
 end
 \ No newline at end of file
@@ -9,16 +9,11 @@ class MezuroPlugin &lt; Noosfero::Plugin
   end
  
   def content_types
-    [MezuroPlugin::ProjectContent,
-     MezuroPlugin::ConfigurationContent]
+    [MezuroPlugin::ConfigurationContent, MezuroPlugin::ProjectContent]
   end
  
   def stylesheet?
     true
   end
  
-  def js_files
-    ['javascripts/results.js', 'javascripts/toogle.js']
-  end
-
 end
@@ -5,10 +5,10 @@ class MezuroPlugin::ConfigurationContent &lt; Article
   end
  
   def self.description
-    'Kalibro configuration for some project'
+    'Sets of thresholds to interpret metrics'
   end
  
-  settings_items :description
+  settings_items :description, :metrics
  
   include ActionView::Helpers::TagHelper
   def to_html(options = {})
@@ -17,8 +17,8 @@ class MezuroPlugin::ConfigurationContent &lt; Article
     end
   end
  
-  def configuration
-    Kalibro::Client::ConfigurationClient.new.configuration(title)
+  def configuration #FIXME invalid method name
+    Kalibro::Client::ConfigurationClient.configuration(name)
   end
  
   after_save :send_configuration_to_service
@@ -27,18 +27,11 @@ class MezuroPlugin::ConfigurationContent &lt; Article
   private
  
   def send_configuration_to_service
-    Kalibro::Client::ConfigurationClient.save(create_configuration)
+    Kalibro::Client::ConfigurationClient.save(self)
   end
  
   def remove_configuration_from_service
-    Kalibro::Client::ConfigurationClient.remove(title)
-  end
-
-  def create_configuration
-    configuration = Kalibro::Entities::Configuration.new
-    configuration.name = title
-    configuration.description = description
-    configuration
+    Kalibro::Client::ConfigurationClient.remove(name)
   end
  
 end
@@ -0,0 +1,27 @@
+require 'googlecharts'
+
+class MezuroPlugin::Helpers::ContentViewerHelper
+  def self.format_grade(grade)
+    sprintf("%.2f", grade.to_f)
+  end
+
+  def self.create_periodicity_options
+   [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]]
+  end
+  
+  def self.generate_chart(values)
+    Gchart.line(  
+                :title_color => 'FF0000',
+                :size => '600x180', 
+                :bg => {:color => 'efefef', :type => 'stripes'},
+                :line_colors => 'c4a000',
+                :data => values,
+                :axis_with_labels => 'y')
+  end
+
+  def self.get_periodicity_option(index)
+   options = [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]]
+   selected_option = options.find { |option| option.last == index.to_i }
+   selected_option.first
+  end
+end
@@ -0,0 +1,37 @@
+class MezuroPlugin::MetricConfigurationContent < Article
+
+  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
 class MezuroPlugin::ProjectContent < Article 
+  validate :validate_kalibro_project_name
  
   def self.short_description
     'Kalibro project'
@@ -8,7 +9,7 @@ class MezuroPlugin::ProjectContent &lt; Article
     'Software project tracked by Kalibro'
   end
  
-  settings_items :license, :description, :repository_type, :repository_url, :configuration_name
+  settings_items :license, :description, :repository_type, :repository_url, :configuration_name, :periodicity_in_days
  
   include ActionView::Helpers::TagHelper
   def to_html(options = {})
@@ -16,19 +17,33 @@ class MezuroPlugin::ProjectContent &lt; Article
       render :file => 'content_viewer/show_project.rhtml'
     end
   end
+  
  
-  # FIXME is this really needed?
   def project
-    Kalibro::Client::ProjectClient.new.project(title)
+    @project ||= Kalibro::Client::ProjectClient.project(name)
   end
  
   def project_result
-    @project_result ||= Kalibro::Client::ProjectResultClient.new.last_result(title)
+    @project_result ||= Kalibro::Client::ProjectResultClient.last_result(name)
+  end
+  
+  def get_date_result(date)
+    client =  Kalibro::Client::ProjectResultClient.new
+    @project_result ||= client.has_results_before(name, date) ? client.last_result_before(name, date) : 
+client.first_result_after(name, date)
   end
  
   def module_result(module_name)
-    @module_client ||= Kalibro::Client::ModuleResultClient.new
-    @module_client.module_result(title, module_name, project_result.date)
+    module_name = project.name if module_name.nil? 
+    @module_client ||= module_result_client.module_result(project.name, module_name, project_result.date)
+  end
+
+  def result_history(module_name)
+    @result_history ||= module_result_client.result_history(project.name, module_name)
+  end
+
+  def module_result_client
+    @module_result_client ||= Kalibro::Client::ModuleResultClient.new
   end
  
   after_save :send_project_to_service
@@ -36,31 +51,20 @@ class MezuroPlugin::ProjectContent &lt; Article
  
   private
  
-  def send_project_to_service
-    Kalibro::Client::ProjectClient.save(create_project)
-    Kalibro::Client::KalibroClient.process_project(title)
-  end
-
-  def remove_project_from_service
-    Kalibro::Client::ProjectClient.remove(title)
+  def validate_kalibro_project_name
+    existing = Kalibro::Client::ProjectClient.new.project_names
+    
+    if existing.include?(name)
+      errors.add_to_base("Project name already exists in Kalibro")
+    end
   end
  
-  def create_project
-    project = Kalibro::Entities::Project.new
-    project.name = title
-    project.license = license
-    project.description = description
-    project.repository = create_repository
-    project.configuration_name = configuration_name
-    project
+  def send_project_to_service
+    Kalibro::Client::ProjectClient.save(self)
+    Kalibro::Client::KalibroClient.process_project(name, periodicity_in_days)
   end
  
-  def create_repository
-    repository = Kalibro::Entities::Repository.new
-    repository.type = repository_type
-    repository.address = repository_url
-    repository
+  def remove_project_from_service
+    Kalibro::Client::ProjectClient.remove(name)
   end
-
 end
-
@@ -0,0 +1,140 @@
+var processingTree = false;
+var metricName;
+jQuery(function (){
+  jQuery('.source-tree-link').live("click", reloadModule);
+  jQuery('[data-show]').live("click", toggle_mezuro);
+  jQuery('[show-metric-history]').live("click", display_metric_history);
+  jQuery('[show-grade-history]').live("click", display_grade_history);
+  showLoadingProcess(true);
+  showProjectContent();
+});
+
+function showProjectContent() {
+  callAction('project_state', {}, showProjectContentFor);
+}
+
+function display_metric_history() {
+  var module_name = jQuery(this).attr('data-module-name');
+  var metric_name = jQuery(this).attr('data-metric-name');
+  metricName = metric_name;
+  callAction('module_metrics_history', {module_name: module_name, metric_name: metric_name}, show_metrics);
+  return false;
+}
+
+function display_grade_history() {
+  var module_name = jQuery(this).attr('data-module-name');
+  callAction('module_grade_history', {module_name: module_name}, show_grades);
+  return false;
+}
+
+function show_metrics(content) {
+  jQuery('#historical-' + metricName).html(content);
+}
+
+function show_grades(content) {
+  jQuery('#historical-grade').html(content);
+}
+
+function toggle_mezuro(){
+  var element = jQuery(this).attr('data-show');
+  jQuery(element).toggle();
+  return false;
+}
+
+function reloadModule(){
+  var module_name = jQuery(this).attr('data-module-name');
+  showLoadingProcess(false);
+  processingTree = true;
+  callAction('project_tree', {module_name: module_name }, showProjectTree);
+  callAction('module_result', {module_name: module_name}, showModuleResult);
+  return false;
+}
+
+function reloadProjectWithDate(){
+	var day = jQuery("#project_date_day").val();
+	var month = jQuery("#project_date_month").val();
+	var year = jQuery("#project_date_year").val();
+
+	var date = year + "-" + month + "-" + day + "T00:00:00+00:00";
+	
+	reloadProject(date);
+  return false;
+}
+
+function reloadProject(date){
+  showLoadingProcess(true);
+  
+  callAction('project_result', {date: date}, showProjectResult);
+  callAction('project_tree', {date: date}, showProjectTree);
+  callAction('module_result', {date: date}, showModuleResult);
+}
+
+function showProjectContentFor(state){
+  if (state == 'ERROR') {
+    jQuery('#project-state').html('ERROR');
+    callAction('project_error', {}, showProjectResult);
+  }
+  else if (state == 'READY') {
+    jQuery('#msg-time').html('');
+    jQuery('#project-state').html('READY');
+    callAction('project_result', {}, showProjectResult);
+    callAction('project_tree', {}, showProjectTree);
+    var project_name = jQuery("#project-result").attr('data-project-name');
+    callAction('module_result', {module_name: project_name}, showModuleResult);
+  } 
+  else if (state.endsWith("ING")) {
+    jQuery('#project-state').html(state);
+    jQuery('#msg-time').html("The project analysis may take long. <br/> You'll receive an e-mail when it's ready!");
+    showProjectContentAfter(20);
+  }	
+}
+
+function showProjectContentAfter(seconds){
+  if (seconds > 0){
+    setTimeout(function() { showProjectContentAfter(seconds - 10);}, 10000);
+  } else {
+    showProjectContent();
+  }
+}
+
+function showProjectResult(content) {
+  jQuery('#project-result').html(content);
+}
+
+function showProjectTree(content){ 
+  processingTree = false;
+  jQuery('#project-tree').html(content);
+	return false;
+}
+
+function showModuleResult(content){
+  if (processingTree != true){ 
+    jQuery('#module-result').html(content);
+  }
+  return false;
+}
+
+function callAction(action, params, callback){
+  var profile = projectContentData('profile');
+  var content = projectContentData('content');
+  var endpoint = '/profile/' + profile + '/plugins/mezuro/' + action + '/' + content;
+  jQuery.get(endpoint, params, callback);
+}
+
+function projectContentData(data){
+  return jQuery('#project-result').attr('data-' + data);
+}
+
+function showLoadingProcess(firstLoad){
+	if(firstLoad)	
+  	showProjectResult("<img src='/images/loading-small.gif'/>");
+	
+  showProjectTree("<img src='/images/loading-small.gif'/>");
+  showModuleResult("<img src='/images/loading-small.gif'/>");
+}
+
+function sourceNodeToggle(id){
+  var suffixes = ['_hidden', '_plus', '_minus'];
+  for (var i in suffixes)
+    jQuery('#' + id + suffixes[i]).toggle();
+}
@@ -1,21 +0,0 @@
-function results($) {
-  $('.module-result-link').click(show_module_result);
-}
-
-function show_module_result(){
-  var profile = jQuery('#module-result').attr('data-profile');
-  var project = jQuery('#module-result').attr('data-project-id');
-  var module_name = jQuery(this).attr('data-module-name');
-  var endpoint = '/profile/' + profile + '/plugins/mezuro/metrics/' + project;
-  show_loading_message(module_name);
-  jQuery.get(endpoint, {module_name: module_name}, show_result_table);
-  return false;
-}
-
-function show_loading_message(module_name) {
-  jQuery('#module-result').html("Loading results for " + module_name + "...");
-}
-
-function show_result_table(content){
-  jQuery('#module-result').html(content);
-}
 \ No newline at end of file
@@ -1,6 +0,0 @@
-function toogle(id){
-  var suffixes = ['_hidden', '_plus', '_minus'];
-  for (var i in suffixes){
-    jQuery('#' + id + suffixes[i]).toggle();
-  }
-}
 \ No newline at end of file
@@ -0,0 +1,68 @@
+jQuery(function (){
+  jQuery('#range_submit').live("click", validate_new_range_configuration);
+  jQuery('#metric_configuration_submit').live("click", validate_metric_configuration);
+});
+
+
+
+function validate_metric_configuration(){
+    var code = jQuery('#metric_configuration_code').val();
+    if (is_null(code))
+    {
+        alert("Code must be filled out");
+        return false;
+    }
+    return true;
+}
+
+function is_null(value){
+    if(value == "" || value == null){
+      return true;
+    }
+    return false;
+}
+
+function IsNotNumeric(value){
+    if(value.match(/[0-9]*\.?[0-9]+/))
+    {
+      return false;
+    }
+    return true;
+}
+
+function IsNotHexadecimal(value){
+    if(value.match(/[0-9a-fA-F]{1,8}/))
+    {
+      return false;
+    }
+    return true;
+}
+
+function validate_new_range_configuration(event){    
+    var label = jQuery("#range_label").val();
+    var beginning = jQuery("#range_beginning").val();
+    var end = jQuery("#range_end").val();
+    var color = jQuery("#range_color").val();
+    var grade = jQuery("#range_grade").val();
+    
+    if (is_null(label) || is_null(beginning) || is_null(end) || is_null(color) || is_null(grade))
+    {
+        alert("Please fill all fields marked with (*)");
+        return false;
+    }
+    if (IsNotNumeric(beginning) || IsNotNumeric(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 (IsNotHexadecimal(color)){
+        alert("Color must be an hexadecimal value");
+        return false;
+    }
+    return true;
+}
 .link {
     cursor: pointer;
 }
+
+.source-tree{
+	background: #e7e7e7;
+	border: groove 1px #666;
+}
+
+.icon {
+        width: 20px;
+}
+
+.source-tree-text{
+	font-family: Arial, Impact;
+	font-size: 12px;
+	border-left: solid 1px #666;
+}
+
+a:link,active,visited .ancestor{
+        font-family: Arial, Impact;
+        color: #5E5400;
+}
+
+.path{
+	font-family: Arial, Impact;
+	font-size: 14px;
+	font-style: underline;
+	display: inline;
+}
@@ -0,0 +1,69 @@
+Feature: mezuro content
+  As a noosfero user
+  I want to create a Kalibro project
+
+  Background:
+    Given the following users
+      | login     | name       |
+      | joaosilva | Joao Silva |
+    And I am logged in as "joaosilva"
+    And "Mezuro" plugin is enabled
+    And the following community
+      | identifier  | name         |
+      | mycommunity | My Community |
+    And "Joao Silva" is admin of "My Community"
+
+  Scenario: I see Kalibro project as an option to new content
+    Given I am on My Community's cms
+    When I follow "New content"
+    Then I should see "Kalibro project"
+
+  Scenario: I see Kalibro project's input form
+    Given I am on My Community's cms
+    When I follow "New content"
+    And I follow "Kalibro project"
+    Then I should see "Title"
+    And I should see "License"
+    And I should see "Repository type"
+    And I should see "GIT"
+    And I should see "REMOTE_ZIP"
+    And I should see "REMOTE_TARBALL"
+    And I should see "SUBVERSION"
+    And I should see "Repository url"
+    And I should see "Configuration"
+    And I should see "Kalibro for Java"
+
+  Scenario: I create a sample mezuro content
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro project" with the following data
+      | Title           | Sample project          |
+      | License         | BSD                     |
+      | Repository type | GIT                     |
+      | Repository url  | git://example           |
+    Then I should see "Sample project"
+    And I should see "Viewed one time"
+    And I should see "BSD"
+
+  Scenario: I create a real mezuro content
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro project" with the following data
+      | Title           | Qt-Calculator           |
+      | License         | GPL 2.0                 |
+      | Repository type | SUBVERSION              |
+      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
+    Then I should see "Qt-Calculator"
+
+  Scenario: I see results from a real Kalibro project
+    Given I am on My Community's cms
+    When I create a content of type "Kalibro project" with the following data
+      | Title           | Qt-Calculator           |
+      | License         | GPL                     |
+      | Repository type | SUBVERSION              |
+      | Repository url  | https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator |
+      | Configuration   | Kalibro for Java        |
+   Then I should see "Qt-Calculator"
+   And I should see "GPL"
+   And I should see "SUBVERSION"
+   And I should see "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator"
+   And I should see "Kalibro for Java"
+   And I should see "Kalibro Service is loading the source code"
@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+
+class BaseToolFixtures
+    
+  def self.analizo
+    base_tool = Kalibro::Entities::BaseTool.new
+    base_tool.name = 'Analizo'
+    base_tool.supported_metrics = [
+      NativeMetricFixtures.total_cof,
+      NativeMetricFixtures.amloc]
+    base_tool
+  end
+
+  def self.analizo_hash
+    {:name => 'Analizo', :supported_metric => [
+        NativeMetricFixtures.total_cof_hash,
+        NativeMetricFixtures.amloc_hash]}
+  end
+
+end
@@ -0,0 +1,16 @@
+class CompoundMetricFixtures
+
+  def self.sc
+    sc = Kalibro::Entities::CompoundMetric.new
+    sc.description = 'Calculate the Structural Complexity of the Code'
+    sc.name = 'Structural Complexity'
+    sc.scope = 'CLASS'
+    sc.script = 'return 42;'
+    sc
+  end
+
+  def self.sc_hash
+    {:name => 'Structural Complexity', :scope => 'CLASS', :script => 'return 42;', :description => 'Calculate the Structural Complexity of the Code'}
+  end
+
+end
@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/error_fixtures'
+
+class CompoundMetricWithErrorFixtures
+    
+  def self.create
+    fixture = Kalibro::Entities::CompoundMetricWithError.new
+    fixture.metric = CompoundMetricFixtures.sc
+    fixture.error = ErrorFixtures.create
+    fixture
+  end
+
+  def self.create_hash
+    {:metric => CompoundMetricFixtures.sc_hash, :error => ErrorFixtures.create_hash,
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:compoundMetricXml'  }}}
+  end
+
+end
@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/metric_configuration_fixtures'
+
+class ConfigurationFixtures
+
+  def self.kalibro_configuration
+    configuration = Kalibro::Entities::Configuration.new
+    configuration.name = 'Kalibro for Java'
+    configuration.description = 'Kalibro configuration for Java projects.'
+    configuration.metric_configurations = [
+      MetricConfigurationFixtures.amloc_configuration,
+      MetricConfigurationFixtures.sc_configuration]
+    configuration
+  end
+
+  def self.kalibro_configuration_hash
+    {:name => 'Kalibro for Java', :description => 'Kalibro configuration for Java projects.',
+      :metric_configuration => [
+        MetricConfigurationFixtures.amloc_configuration_hash,
+        MetricConfigurationFixtures.sc_configuration_hash]}
+  end
+    
+end
@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/stack_trace_element_fixtures'
+
+class ErrorFixtures
+
+  def self.create
+    error = Kalibro::Entities::Error.new
+    error.error_class = 'java.lang.Exception'
+    error.message = 'Error message from ErrorTest'
+    error.stack_trace = [
+      StackTraceElementFixtures.create('my method 1', 42),
+      StackTraceElementFixtures.create('my method 2', 84)]
+    error
+  end
+
+  def self.create_hash
+    {:error_class => 'java.lang.Exception', :message => 'Error message from ErrorTest',
+      :stack_trace_element => [
+        StackTraceElementFixtures.create_hash('my method 1', 42),
+        StackTraceElementFixtures.create_hash('my method 2', 84)]}
+  end
+    
+end
@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/compound_metric_fixtures'
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+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]
+    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
+  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'
+    sc
+  end
+
+  def self.amloc_configuration_hash
+    {:metric => NativeMetricFixtures.amloc_hash, :code => 'amloc', :weight => 1.0,
+      :aggregation_form => 'AVERAGE',
+      :range => [RangeFixtures.amloc_excellent_hash, RangeFixtures.amloc_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',
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:compoundMetricXml'  }}}
+  end
+    
+end
@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/compound_metric_fixtures'
+require File.dirname(__FILE__) + '/native_metric_fixtures'
+require File.dirname(__FILE__) + '/range_fixtures'
+
+class MetricResultFixtures
+
+  def self.amloc_result
+    result = Kalibro::Entities::MetricResult.new
+    result.metric = NativeMetricFixtures.amloc
+    result.value = 0.0
+    result.descendent_results = [40.0, 42.0]
+    result.range = RangeFixtures.amloc_excellent
+    result
+  end
+
+  def self.sc_result
+    result = Kalibro::Entities::MetricResult.new
+    result.metric = CompoundMetricFixtures.sc
+    result.value = 1.0
+    result.descendent_results = [2.0, 42.0]
+    result
+  end
+
+  def self.amloc_result_hash
+    {:metric => NativeMetricFixtures.amloc_hash, :value => 0.0, :descendent_result => [40.0, 42.0],
+      :range => RangeFixtures.amloc_excellent_hash,
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:nativeMetricXml'  }}}
+  end
+
+  def self.sc_result_hash
+    {:metric => CompoundMetricFixtures.sc_hash, :value => 1.0, :descendent_result => [2.0, 42.0],
+      :attributes! => {:metric => {
+          'xmlns:xsi'=> 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:type' => 'kalibro:compoundMetricXml'  }}}
+  end
+
+end
@@ -0,0 +1,14 @@
+class ModuleFixtures
+
+  def self.qt_calculator
+    entity = Kalibro::Entities::Module.new
+    entity.name = 'Qt-Calculator'
+    entity.granularity = 'APPLICATION'
+    entity
+  end
+
+  def self.qt_calculator_hash
+    {:name => 'Qt-Calculator', :granularity => 'APPLICATION'}
+  end
+    
+end
@@ -0,0 +1,34 @@
+class ModuleNodeFixtures
+
+  def self.qt_calculator_tree
+    node = Kalibro::Entities::ModuleNode.new
+    node.module = ModuleFixtures.qt_calculator
+    org_node = new_node('org', 'PACKAGE')
+    org_node.children = [new_node('org.Window', 'CLASS')]
+    node.children = [org_node, new_node('Dialog', 'CLASS'), new_node('main', 'CLASS')]
+    node
+  end
+
+  def self.qt_calculator_tree_hash
+    {:module => ModuleFixtures.qt_calculator_hash,
+      :child => [
+        {:module => {:name => 'org', :granularity => 'PACKAGE'},
+         :child => [{:module => {:name => 'org.Window', :granularity => 'CLASS'}}]},
+        {:module => {:name => 'Dialog', :granularity => 'CLASS'}},
+        {:module => {:name => 'main', :granularity => 'CLASS'}}
+      ]
+    }
+  end
+
+  private
+
+  def self.new_node(name, granularity)
+    the_module = Kalibro::Entities::Module.new
+    the_module.name = name
+    the_module.granularity = granularity
+    node = Kalibro::Entities::ModuleNode.new
+    node.module = the_module
+    node
+  end
+    
+end
@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/module_fixtures'
+require File.dirname(__FILE__) + '/metric_result_fixtures'
+require File.dirname(__FILE__) + '/compound_metric_with_error_fixtures'
+
+class ModuleResultFixtures
+
+  def self.create
+    fixture = Kalibro::Entities::ModuleResult.new
+    fixture.module = ModuleFixtures.qt_calculator
+    fixture.date = DateTime.parse('Thu, 20 Oct 2011 18:26:43.151 +0000')
+    fixture.grade = 10.0
+    fixture.metric_results = [
+      MetricResultFixtures.amloc_result,
+      MetricResultFixtures.sc_result]
+    fixture.compound_metrics_with_error = [CompoundMetricWithErrorFixtures.create]
+    fixture
+  end
+
+  def self.create_hash
+    {:module => ModuleFixtures.qt_calculator_hash,
+      :date => '2011-10-20T18:26:43.151+00:00', :grade => 10.0, :metric_result => [
+        MetricResultFixtures.amloc_result_hash,
+        MetricResultFixtures.sc_result_hash],
+      :compound_metric_with_error => [CompoundMetricWithErrorFixtures.create_hash]}
+  end
+
+end
@@ -0,0 +1,29 @@
+class NativeMetricFixtures
+
+  def self.total_cof
+    total_cof = Kalibro::Entities::NativeMetric.new
+    total_cof.name = 'Total Coupling Factor'
+    total_cof.scope = 'APPLICATION'
+    total_cof.origin = 'Analizo'
+    total_cof.languages = ['JAVA']
+    total_cof
+  end
+
+  def self.total_cof_hash
+    {:name => 'Total Coupling Factor', :scope => 'APPLICATION', :origin => 'Analizo', :language => ['JAVA']}
+  end
+
+  def self.amloc
+    total_cof = Kalibro::Entities::NativeMetric.new
+    total_cof.name = 'Average Method LOC'
+    total_cof.scope = 'CLASS'
+    total_cof.origin = 'Analizo'
+    total_cof.languages = ['JAVA']
+    total_cof
+  end
+
+  def self.amloc_hash
+    {:name => 'Average Method LOC', :scope => 'CLASS', :origin => 'Analizo', :language => ['JAVA']}
+  end
+
+end
@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/repository_fixtures'
+
+class ProjectFixtures
+
+  def self.qt_calculator
+    project = Kalibro::Entities::Project.new
+    project.name = 'Qt-Calculator'
+    project.license = 'GPL'
+    project.description = 'Calculator for Qt'
+    project.repository = RepositoryFixtures.qt_calculator
+    project.configuration_name = 'Kalibro for Java'
+    project.state = 'READY'
+    project
+  end
+
+  def self.qt_calculator_hash
+    {:name => 'Qt-Calculator', :license => 'GPL', :description => 'Calculator for Qt',
+        :repository => RepositoryFixtures.qt_calculator_hash,
+        :configuration_name => 'Kalibro for Java', :state => 'READY'}
+  end
+    
+end
@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/project_fixtures'
+require File.dirname(__FILE__) + '/module_node_fixtures'
+require File.dirname(__FILE__) + '/module_result_fixtures'
+
+class ProjectResultFixtures
+
+  def self.qt_calculator
+    result = Kalibro::Entities::ProjectResult.new
+    result.project = ProjectFixtures.qt_calculator
+    result.date = ModuleResultFixtures.create.date
+    result.load_time = 14878
+    result.analysis_time = 1022
+    result.source_tree = ModuleNodeFixtures.qt_calculator_tree
+    result.collect_time = 14878
+    result
+  end
+
+  def self.qt_calculator_hash
+    {:project => ProjectFixtures.qt_calculator_hash, :date => ModuleResultFixtures.create_hash[:date],
+      :load_time => 14878, :analysis_time => 1022, :source_tree => ModuleNodeFixtures.qt_calculator_tree_hash, 
+      :collect_time => 14878}
+  end
+    
+end
@@ -0,0 +1,33 @@
+class RangeFixtures
+
+  Infinity = 1.0/0.0
+
+  def self.amloc_excellent
+    range = Kalibro::Entities::Range.new
+    range.beginning = 0.0
+    range.end = 7.0
+    range.label = 'Excellent'
+    range.grade = 10.0
+    range.color = 'ff00ff00'
+    range
+  end
+
+  def self.amloc_bad
+    range = Kalibro::Entities::Range.new
+    range.beginning = 19.5
+    range.end = Infinity
+    range.label = 'Bad'
+    range.grade = 0.0
+    range.color = 'ffff0000'
+    range
+  end
+
+  def self.amloc_excellent_hash
+    {:beginning => 0.0, :end => 7.0, :label => 'Excellent', :grade => 10.0, :color => 'ff00ff00'}
+  end
+
+  def self.amloc_bad_hash
+    {:beginning => 19.5, :end => "INF", :label => 'Bad',:grade => 0.0, :color => 'ffff0000'}
+  end
+
+end
@@ -0,0 +1,14 @@
+class RepositoryFixtures
+
+  def self.qt_calculator
+    repository = Kalibro::Entities::Repository.new
+    repository.type = 'SUBVERSION'
+    repository.address = 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'
+    repository
+  end
+
+  def self.qt_calculator_hash
+    {:type => 'SUBVERSION', :address => 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'}
+  end
+
+end
@@ -0,0 +1,17 @@
+class StackTraceElementFixtures
+    
+  def self.create(method_name = 'my method name', line_number = 42)
+    element = Kalibro::Entities::StackTraceElement.new
+    element.declaring_class = 'my.declaring.Class'
+    element.method_name = method_name
+    element.file_name = 'MyFile.java'
+    element.line_number = line_number
+    element
+  end
+
+  def self.create_hash(method_name = 'my method name', line_number = 42)
+    {:declaring_class => 'my.declaring.Class', :method_name => method_name, :file_name => 'MyFile.java',
+     :line_number => line_number}
+  end
+
+end
@@ -0,0 +1,88 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+
+class EchoPortTest < ActiveSupport::TestCase
+
+  def setup
+    @port = Kalibro::Client::Port.new('Echo')
+    @port.service_address=('http://valinhos.ime.usp.br:50688/KalibroFake/');
+  end
+
+  should 'echo base tool' do
+    test BaseToolFixtures.analizo, 'BaseTool' do |base_tool|
+      base_tool.name = "echo " + base_tool.name
+    end
+  end
+  
+  should 'echo configuration' do
+    test ConfigurationFixtures.kalibro_configuration, 'Configuration' do |configuration|
+      configuration.name = "echo " + configuration.name
+    end
+  end
+
+  should 'echo metric configuration' do
+    test_metric_configuration(MetricConfigurationFixtures.amloc_configuration)
+    test_metric_configuration(MetricConfigurationFixtures.sc_configuration)
+  end
+
+  should 'echo module result' do
+    test ModuleResultFixtures.create, 'ModuleResult' do |module_result|
+      module_result.module.name = "echo." + module_result.module.name
+    end
+  end
+
+  should 'echo project' do
+    test(ProjectFixtures.qt_calculator, 'Project') do |project|
+      project.name = "echo " + project.name
+    end
+  end
+
+  should 'echo project result' do
+    test(ProjectResultFixtures.qt_calculator, 'ProjectResult') do |project_result|
+      project_result.project.name = "echo " + project_result.project.name
+    end
+  end
+
+  should 'echo raw project' do
+    project = ProjectFixtures.qt_calculator
+    echoed = @port.request(:echo_raw_project, {:project => project.to_hash})[:project]
+    project.name = "echo " + project.name
+    project.state = nil
+    project.error = nil
+    assert_equal project, Kalibro::Entities::Project.from_hash(echoed)
+  end
+
+  should 'work with enums' do
+    test_granularity("METHOD", "CLASS")
+    test_granularity("CLASS", "PACKAGE")
+    test_granularity("PACKAGE", "PACKAGE")
+    test_granularity("APPLICATION", "APPLICATION")
+  end
+
+  private
+  
+  def test_metric_configuration(fixture)
+    test fixture, 'MetricConfiguration' do |metric_configuration|
+      metric_configuration.code = "echo_" + metric_configuration.code
+    end
+  end
+
+  def test(fixture, entity_name)
+    entity_symbol = entity_name.underscore.to_sym
+    request_body = {entity_symbol => fixture.to_hash}
+    echoed = @port.request("echo_#{entity_symbol}".to_sym, request_body)[entity_symbol]
+    yield fixture
+    entity_class = "Kalibro::Entities::#{entity_name}".constantize
+    assert_equal fixture, entity_class.from_hash(echoed)
+  end
+
+  def test_granularity(granularity, parent)
+    body = {:granularity => granularity}
+    assert_equal parent, @port.request(:infer_parent_granularity, body)[:parent_granularity]
+  end
+
+end
@@ -0,0 +1,156 @@
+require 'test_helper'
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+
+class MezuroPluginMyprofileControllerTest < ActionController::TestCase
+
+  def setup
+    @controller = MezuroPluginMyprofileController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @profile = fast_create(Community)
+
+    @collector = BaseToolFixtures.analizo
+    @base_tool_client = Kalibro::Client::BaseToolClient.new
+    @metric = NativeMetricFixtures.amloc
+    @metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
+    @metric_configuration = MetricConfigurationFixtures.amloc_configuration
+    @compound_metric_configuration = MetricConfigurationFixtures.sc_configuration
+    @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"
+  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
+    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"
+  end
+
+  should 'get collector by name' do
+    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
+  end
+
+  should 'get chosen native metric and configuration name' do
+    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
+  end
+  
+  should 'call configuration client in new_compound_metric_configuration method' do
+    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
+    assert_response 200
+  end
+
+  should 'assign configuration name and get metric_configuration' do
+    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"
+    assert_equal assigns(:metric_configuration), @metric_configuration
+    assert_equal assigns(:metric), @metric_configuration.metric
+  end
+  
+  should 'test metric creation' do
+    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", :description => @metric.description,
+    :scope => @metric.scope, :language => @metric.language, :metric => { :name => @metric.name, :origin => @metric.origin},
+    :metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.code, :aggregation => @metric_configuration.aggregation_form }
+    assert_equal assigns(:configuration_name), "test name"
+    assert_response 302
+  end
+  
+  should 'test compound metric creation' do
+    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", 
+    :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, 
+    :script => @compound_metric_configuration.metric.script}}
+    assert_response 302
+  end
+
+  should 'test metric edition' do
+    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"
+    assert_response 200
+  end
+  
+  should 'test compound metric edition' do
+    Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
+    @metric_configuration_client.expects(:metric_configuration).with("test name","test metric name").returns(@compound_metric_configuration)
+    get :edit_compound_metric_configuration, :profile => @profile.identifier, :configuration_name => "test name", :metric_name => "test metric name"
+    assert_response 200
+  end
+
+  should 'update metric configuration' do
+    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, :description => @metric.description,
+    :scope => @metric.scope, :language => @metric.language, :metric => { :name => @metric.name, :origin => @metric.origin},
+    :metric_configuration => { :code => @metric_configuration.code, :weight => @metric_configuration.code, :aggregation => @metric_configuration.aggregation_form }
+    assert_response 302
+  end
+
+  should 'update compound metric configuration' do
+    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, 
+    :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, 
+    :script => @compound_metric_configuration.metric.script}}
+    assert_response 302
+  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"
+    assert_equal assigns(:metric_name), @metric.name
+  end
+
+  should 'create instance range' do
+    Kalibro::Client::MetricConfigurationClient.expects(:new).returns(@metric_configuration_client)
+    @metric_configuration_client.expects(:metric_configuration).with("test 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
+    assert assigns(:range).instance_of?(Kalibro::Entities::Range)
+  end
+
+  should 'redirect from remove metric configuration' do
+    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
+    assert_response 302
+  end
+
+end
 require 'test_helper'
  
-class MezuroPluginProfileControllerTest < ActiveSupport::TestCase
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
+
+class MezuroPluginProfileControllerTest < ActionController::TestCase
  
   def setup
     @controller = MezuroPluginProfileController.new
     @request = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
+    @response = ActionController::TestResponse.new
     @profile = fast_create(Community)
-    @profile_id = @profile.identifier
+
+    @project_result = ProjectResultFixtures.qt_calculator
+    @module_result = ModuleResultFixtures.create
+    @project = @project_result.project
+    @name = @project.name
+    
+    @date = "2012-04-13T20:39:41+04:00"
+
   end
  
-#  def test_metrics_for_unknown_module
-#    get :metrics, :profile => @profile_id, :id => 0
-#    assert_response 404
-#  end
+  should 'not find project state for inexistent project content' do
+    get :project_state, :profile => '', :id => -1
+    assert_response 404
+  end
+  
+  should 'get project state' do
+    create_project_content
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :project_state, :profile => @profile.identifier, :id => @content.id
+    assert_response 200
+  end
  
-#  def test_metric_unknown_module
-#  get :metrics, :profile => @profile_id, :id => @project_content.id, :module_name => 'veryunlikelyname'
-#  assert_response 404
-#  end
+  should 'get error state if project has error' do
+    create_project_content
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    @project.expects(:error).returns(ErrorFixtures.create)
+    get :project_state, :profile => @profile.identifier, :id => @content.id
+    assert_response 200
+  end
  
+  should 'not find content in project error for inexistent project content' do
+    get :project_error, :profile => '', :id => -1
+    assert_response 404
+  end
+  
+  should 'get project error' do
+    create_project_content
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    @project.expects(:error).returns(ErrorFixtures.create)
+    get :project_error, :profile => @profile.identifier, :id => @content.id
+    assert_response 200
+    assert_select('h3', 'ERROR')
+  end
  
-#  def test_metrics_for_known_module
-#    @project_content = create_project_content(@profile)
-#    get :metrics, :profile => @profile_id, :id => @project_content.id, :module_name => @project_content.name
-#    assert_response 200
-#    # assert_tag # TODO
-#  end
+  should 'not find project result for inexistent project content' do
+    get :project_result, :profile => '', :id => -1
+    assert_response 404
+  end
+  
+  should 'get project results without date' do
+    create_project_content
+    Kalibro::Client::ProjectResultClient.expects(:last_result).with(@name).returns(@project_result)
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :project_result, :profile => @profile.identifier, :id => @content.id
+    assert_response 200
+    assert_select('h4', 'Last Result')
+  end
+  
+  should 'get project results from a specific date' do
+    create_project_content
+    mock_project_result
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :project_result, :profile => @profile.identifier, :id => @content.id, :date => @project_result.date
+    assert_response 200
+  end
  
-  protected
+  should 'not find module result for inexistent project content' do
+    get :module_result, :profile => '', :id => -1, :module_name => ''
+    assert_response 404
+  end
  
-  # returns a new ProjectContent for the given profile
-  def create_project_content(profile)
-    project_content = MezuroPlugin::ProjectContent.create!(:profile => profile, :name => 'foo') 
+  should 'get module result without date' do
+    create_project_content
+    mock_module_result
+    Kalibro::Client::ProjectResultClient.expects(:last_result).with(@name).returns(@project_result)
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
  
-    project = create_project(project_content.name)
-    project_content.license = project.license
-    project_content.description = project.description
-    project_content.repository_type = project.repository.type
-    project_content.repository_url = project.repository.address
-    project_content.configuration_name = project.configuration_name
+    get :module_result, :profile => @profile.identifier, :id => @content.id, :module_name => @name
+    assert_response 200
+    assert_select('h5', 'Metric results for: Qt-Calculator (APPLICATION)')
+  end
  
-    MezuroPlugin::ProjectContent.any_instance.stubs(:project_content).returns(project_content)
-    project_content
+  should 'get module result from a specific date' do
+	  create_project_content
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    mock_module_result
+	  mock_project_result
+	  get :module_result, :profile => @profile.identifier, :id => @content.id, :date => @project_result.date, :module_name => @name
+	  assert_response 200
+	  assert_select('h5', 'Metric results for: Qt-Calculator (APPLICATION)')
+  end
+
+  should 'not find project tree for inexistent project content' do
+    get :project_tree, :profile => '', :id => -1, :module_name => ''
+    assert_response 404
+  end
+
+  should 'get project tree without date' do
+    create_project_content
+    Kalibro::Client::ProjectResultClient.expects(:last_result).with(@name).returns(@project_result)
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+  	get :project_tree, :profile => @profile.identifier, :id => @content.id, :module_name => @name
+	  assert_response 200
+  	assert_select('h2', /Qt-Calculator/)
+  end
+
+  should 'get project tree from a specific date' do
+    create_project_content
+  	mock_project_result
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :project_tree, :profile => @profile.identifier, :id => @content.id, :module_name => @name, :date => "2012-04-13T20:39:41+04:00"
+	  assert_response 200
+  end
+
+  should 'get grade history' do
+    create_project_content
+    mock_module_result_history
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :module_grade_history, :profile => @profile.identifier, :id => @content.id, :module_name => @name
+    assert_response 200
+  end
+      
+  should 'not find metrics history for inexistent project content' do
+    get :module_metrics_history, :profile => '', :id => -1, :module_name => ''
+    assert_response 404
+  end
+  #copied from 'get grade history' test
+  should 'get metrics history' do
+    create_project_content
+    mock_module_result_history
+    Kalibro::Client::ProjectClient.expects(:project).with(@name).returns(@project)
+    get :module_metrics_history, :profile => @profile.identifier, :id => @content.id, :module_name => @name,
+    :metric_name => @module_result.metric_result.first.metric.name.delete("() ")
+    assert_response 200
+  end
+
+  private
+
+  def create_project_content
+    client = mock
+    @content = MezuroPlugin::ProjectContent.new(:profile => @profile, :name => @name)
+    @content.expects(:send_project_to_service).returns(nil)
+    Kalibro::Client::ProjectClient.expects(:new).returns(client)
+    client.expects(:project_names).returns([])
+    @content.save
+  end
+  
+  def mock_project_result
+    project_result_client = mock
+	  Kalibro::Client::ProjectResultClient.expects(:new).returns(project_result_client)
+	  project_result_client.expects(:has_results_before).returns(true)
+	  project_result_client.expects(:last_result_before).returns(@project_result)
   end
  
-  def create_project(name)
-    project = Kalibro::Entities::Project.new
-    project.name = name
-    project.license = 'GPL'
-    project.description = 'testing' 
-    project.repository = crieate_repository
-    project.configuration_name = 'Kalibro Default'
-    project
-  end
-
-  def create_repository
-    repository = Kalibro::Entities::Repository.new
-    repository.type = 'git'
-    repository.address = 'http://git.git'
-    repository
-  end
- 
-  #TODO Adicionar module result manualmente
-  #TODO Ver testes do project content, refatorar o project content em cima dos testes
-  #TODO Repensar design OO: nao amarrar o project_content ao webservice. Criar um modelo abstrato do webservice
+  def mock_module_result
+    module_result_client = mock
+    Kalibro::Client::ModuleResultClient.expects(:new).returns(module_result_client)
+    module_result_client.expects(:module_result).with(@name, @name, @project_result.date).returns(@module_result)
+  end
+
+  def mock_module_result_history
+    module_result_client = mock
+    module_result_client.expects(:result_history).with(@name, @name).returns([@module_result])
+    Kalibro::Client::ModuleResultClient.expects(:new).returns(module_result_client)
+  end
 end
@@ -1,11 +0,0 @@
-require "test_helper"
-require File.dirname(__FILE__) + '/../controllers/mezuro_plugin_myprofile_controller'
-
-class MezuroTest < ActiveSupport::TestCase
-
-  should 'create a mezuro project' do
-    controller = MezuroPluginMyprofileController.new
-    controller.create
-  end
-
-end
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
+
 class BaseToolClientTest < ActiveSupport::TestCase
  
   def setup
@@ -25,7 +28,7 @@ class BaseToolClientTest &lt; ActiveSupport::TestCase
   end
  
   should 'get base tool by name' do
-    analizo = BaseToolTest.analizo
+    analizo = BaseToolFixtures.analizo
     request_body = {:base_tool_name => 'Analizo'}
     @port.expects(:request).with(:get_base_tool, request_body).returns({:base_tool => analizo.to_hash})
     assert_equal analizo, @client.base_tool('Analizo')
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+
 class ConfigurationClientTest < ActiveSupport::TestCase
  
   def setup
@@ -8,7 +11,7 @@ class ConfigurationClientTest &lt; ActiveSupport::TestCase
   end
  
   should 'save configuration' do
-    configuration = ConfigurationTest.kalibro_configuration
+    configuration = ConfigurationFixtures.kalibro_configuration
     @port.expects(:request).with(:save_configuration, {:configuration => configuration.to_hash})
     @client.save(configuration)
   end
@@ -31,7 +34,7 @@ class ConfigurationClientTest &lt; ActiveSupport::TestCase
   end
  
   should 'get configuration by name' do
-    configuration = ConfigurationTest.kalibro_configuration
+    configuration = ConfigurationFixtures.kalibro_configuration
     request_body = {:configuration_name => configuration.name}
     response_hash = {:configuration => configuration.to_hash}
     @port.expects(:request).with(:get_configuration, request_body).returns(response_hash)
 require "test_helper"
+
 class KalibroClientTest < ActiveSupport::TestCase
  
   def setup
@@ -23,7 +24,20 @@ class KalibroClientTest &lt; ActiveSupport::TestCase
     instance = mock
     Kalibro::Client::KalibroClient.expects(:new).returns(instance)
     instance.expects(:process_project).with('myproject')
-    Kalibro::Client::KalibroClient.process_project('myproject')
+    Kalibro::Client::KalibroClient.process_project('myproject', 0)
+  end
+  
+  should 'process project with periodicity' do
+  	name = 'KalibroClientTest'
+    @port.expects(:request).with(:process_periodically, {:project_name => name, :period_in_days => 30})
+    @client.process_periodically(name, 30)
+  end
+  
+  should 'instantiate for processing project periodically' do
+    instance = mock
+    Kalibro::Client::KalibroClient.expects(:new).returns(instance)
+    instance.expects(:process_periodically).with('myproject', 30)
+    Kalibro::Client::KalibroClient.process_project('myproject', 30)
   end
  
 end
@@ -0,0 +1,44 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
+
+class MetricConfigurationClientTest < ActiveSupport::TestCase
+
+  def setup
+    @port = mock
+    Kalibro::Client::Port.expects(:new).with('MetricConfiguration').returns(@port)
+    @client = Kalibro::Client::MetricConfigurationClient.new
+  end
+
+  should 'save metric configuration' do
+    configuration = MetricConfigurationFixtures.amloc_configuration
+    @port.expects(:request).with(:save_metric_configuration, {
+        :metric_configuration => configuration.to_hash,
+        :configuration_name => 'x'
+      })
+    @client.save(configuration, 'x')
+  end
+
+  should 'get metric configuration by name' do
+    configuration = MetricConfigurationFixtures.amloc_configuration
+    request_body = {
+      :configuration_name => 'configuration.name',
+      :metric_name => configuration.metric.name
+    }
+    response_hash = {:metric_configuration => configuration.to_hash}
+    @port.expects(:request).with(:get_metric_configuration, request_body).returns(response_hash)
+    assert_equal configuration, @client.metric_configuration('configuration.name', configuration.metric.name)
+  end
+
+  should 'remove metric configuration by name' do
+    metric_name = 'MetricConfigurationClientTest'
+    configuration_name = 'xxxx'
+    request_body = {
+      :configuration_name => configuration_name,
+      :metric_name => metric_name
+    }
+    @port.expects(:request).with(:remove_metric_configuration, request_body)
+    @client.remove(configuration_name, metric_name)
+  end
+
+end
 \ No newline at end of file
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
+
 class ModuleResultClientTest < ActiveSupport::TestCase
  
   def setup
     @port = mock
     Kalibro::Client::Port.expects(:new).with('ModuleResult').returns(@port)
     @client = Kalibro::Client::ModuleResultClient.new
-    @result = ModuleResultTest.fixture
+    @result = ModuleResultFixtures.create
   end
  
   should 'get module result' do
@@ -23,5 +26,4 @@ class ModuleResultClientTest &lt; ActiveSupport::TestCase
     @port.expects(:request).with(:get_result_history, request_body).returns(response)
     assert_equal [@result], @client.result_history('Qt-Calculator', 'main')
   end
-
-end
 \ No newline at end of file
+end
 require "test_helper"
+
 class PortTest < ActiveSupport::TestCase
  
   def setup
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_fixtures"
+
 class ProjectClientTest < ActiveSupport::TestCase
  
   def setup
     @port = mock
     Kalibro::Client::Port.expects(:new).with('Project').returns(@port)
-    @client = Kalibro::Client::ProjectClient.new
+    @project = ProjectFixtures.qt_calculator
   end
  
-  should 'save project' do
-    project = ProjectTest.qt_calculator
-    @port.expects(:request).with(:save_project, {:project => project.to_hash})
-    @client.save(project)
+  should 'get project by name' do
+    request_body = {:project_name => @project.name}
+    response_hash = {:project => @project.to_hash}
+    @port.expects(:request).with(:get_project, request_body).returns(response_hash)
+    assert_equal @project, Kalibro::Client::ProjectClient.project(@project.name)
   end
-
-  should 'get project names (zero)' do
-    @port.expects(:request).with(:get_project_names).returns({})
-    assert_equal [], @client.project_names
+  
+  should 'raise error when project doesnt exist' do
+    request_body = {:project_name => @project.name}
+    @port.expects(:request).with(:get_project, request_body).raises(Exception.new("(S:Server) There is no project named " + @project.name))
+    assert_nil Kalibro::Client::ProjectClient.project(@project.name)
   end
  
-  should 'get project names (one)' do
-    name = 'Qt-Calculator'
-    @port.expects(:request).with(:get_project_names).returns({:project_name => name})
-    assert_equal [name], @client.project_names
+  should 'save project' do
+    create_project_content_mock
+    @project.state = nil
+    @port.expects(:request).with(:save_project, {:project => @project.to_hash})
+    Kalibro::Client::ProjectClient.save(@project_content)
   end
  
-  should 'get project names' do
-    names = ['Hello World', 'Qt-Calculator']
-    @port.expects(:request).with(:get_project_names).returns({:project_name => names})
-    assert_equal names, @client.project_names
+  should 'remove existent project from service' do
+    @port.expects(:request).with(:get_project_names).returns({:project_name => @project.name})
+    @port.expects(:request).with(:remove_project, {:project_name => @project.name})
+    Kalibro::Client::ProjectClient.remove(@project.name)
   end
  
-  should 'get project by name' do
-    project = ProjectTest.qt_calculator
-    request_body = {:project_name => project.name}
-    response_hash = {:project => project.to_hash}
-    @port.expects(:request).with(:get_project, request_body).returns(response_hash)
-    assert_equal project, @client.project(project.name)
+  should 'not try to remove inexistent project from service' do
+    @port.expects(:request).with(:get_project_names).returns({:project_name => 'Different project'})
+    @port.expects(:request).with(:remove_project, {:project_name => @project.name}).never
+    Kalibro::Client::ProjectClient.remove(@project.name)
   end
  
-  should 'remove project by name' do
-    name = 'ProjectClientTest'
-    @port.expects(:request).with(:remove_project, {:project_name => name})
-    @client.remove(name)
-  end
+  private
  
-  should 'instantiate for saving a project' do
-    project = mock
-    instance = mock
-    Kalibro::Client::ProjectClient.expects(:new).returns(instance)
-    instance.expects(:save).with(project)
-    Kalibro::Client::ProjectClient.save(project)
+  def create_project_content_mock
+    @project_content = mock
+    @project_content.expects(:name).returns(@project.name)
+    @project_content.expects(:license).returns(@project.license)
+    @project_content.expects(:description).returns(@project.description)
+    @project_content.expects(:repository_type).returns(@project.repository.type)
+    @project_content.expects(:repository_url).returns(@project.repository.address)
+    @project_content.expects(:configuration_name).returns(@project.configuration_name)
   end
  
 end
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+
 class ProjectResultClientTest < ActiveSupport::TestCase
  
   def setup
@@ -6,63 +9,50 @@ class ProjectResultClientTest &lt; ActiveSupport::TestCase
     Kalibro::Client::Port.expects(:new).with('ProjectResult').returns(@port)
     @client = Kalibro::Client::ProjectResultClient.new
  
-    @result = ProjectResultTest.qt_calculator
+    @result = ProjectResultFixtures.qt_calculator
     @project_name = @result.project.name
     @date = @result.date
     @flag = DateTime.now.sec % 2 == 0
+
+    @request = {:project_name => @project_name}
+    @request_with_date = {:project_name => @project_name, :date => @date}
+    @flag_response = {:has_results => @flag}
+    @result_response = {:project_result => @result.to_hash}
   end
  
   should 'retrieve if project has results' do
-    @port.expects(:request).with(:has_results_for, request).returns(flag_response)
+    @port.expects(:request).with(:has_results_for, @request).returns(@flag_response)
     assert_equal @flag, @client.has_results_for(@project_name)
   end
  
   should 'retrieve if project has results before date' do
-    @port.expects(:request).with(:has_results_before, request_with_date).returns(flag_response)
+    @port.expects(:request).with(:has_results_before, @request_with_date).returns(@flag_response)
     assert_equal @flag, @client.has_results_before(@project_name, @date)
   end
  
   should 'retrieve if project has results after date' do
-    @port.expects(:request).with(:has_results_after, request_with_date).returns(flag_response)
+    @port.expects(:request).with(:has_results_after, @request_with_date).returns(@flag_response)
     assert_equal @flag, @client.has_results_after(@project_name, @date)
   end
  
   should 'get first result of project' do
-    @port.expects(:request).with(:get_first_result_of, request).returns(result_response)
+    @port.expects(:request).with(:get_first_result_of, @request).returns(@result_response)
     assert_equal @result, @client.first_result(@project_name)
   end
  
   should 'get last result of project' do
-    @port.expects(:request).with(:get_last_result_of, request).returns(result_response)
+    @port.expects(:request).with(:get_last_result_of, @request).returns(@result_response)
     assert_equal @result, @client.last_result(@project_name)
   end
  
   should 'get first result of project after date' do
-    @port.expects(:request).with(:get_first_result_after, request_with_date).returns(result_response)
+    @port.expects(:request).with(:get_first_result_after, @request_with_date).returns(@result_response)
     assert_equal @result, @client.first_result_after(@project_name, @date)
   end
  
   should 'get last result of project before date' do
-    @port.expects(:request).with(:get_last_result_before, request_with_date).returns(result_response)
+    @port.expects(:request).with(:get_last_result_before, @request_with_date).returns(@result_response)
     assert_equal @result, @client.last_result_before(@project_name, @date)
   end
  
-  private
-
-  def request
-    {:project_name => @project_name}
-  end
-
-  def request_with_date
-    {:project_name => @project_name, :date => @date}
-  end
-
-  def flag_response
-    {:has_results => @flag}
-  end
-
-  def result_response
-    {:project_result => @result.to_hash}
-  end
-
 end
 \ No newline at end of file
 require "test_helper"
-class BaseToolTest < ActiveSupport::TestCase
  
-  def self.analizo
-    total_cof = NativeMetricTest.total_cof
-    amloc = NativeMetricTest.amloc
-    base_tool = Kalibro::Entities::BaseTool.new
-    base_tool.name = 'Analizo'
-    base_tool.supported_metrics = [total_cof, amloc]
-    base_tool
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/base_tool_fixtures"
  
-  def self.analizo_hash
-    total_cof_hash = NativeMetricTest.total_cof_hash
-    amloc_hash = NativeMetricTest.amloc_hash
-    {:name => 'Analizo',
-     :supported_metric => [total_cof_hash, amloc_hash]}
-  end
+class BaseToolTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.analizo_hash
-    @base_tool = self.class.analizo
+    @hash = BaseToolFixtures.analizo_hash
+    @base_tool = BaseToolFixtures.analizo
   end
  
   should 'create base tool from hash' do
 require "test_helper"
-class CompoundMetricTest < ActiveSupport::TestCase
  
-  def self.sc
-    sc = Kalibro::Entities::CompoundMetric.new
-    sc.name = 'Structural Complexity'
-    sc.scope = 'CLASS'
-    sc.script = 'return cbo * lcom4;'
-    sc
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/compound_metric_fixtures"
+
+class CompoundMetricTest < ActiveSupport::TestCase
  
-  def self.sc_hash
-    {:name => 'Structural Complexity', :scope => 'CLASS',
-      :script => 'return cbo * lcom4;'}
-  end
-  
   def setup
-    @hash = self.class.sc_hash
-    @metric = self.class.sc
+    @hash = CompoundMetricFixtures.sc_hash
+    @metric = CompoundMetricFixtures.sc
   end
  
   should 'create compound metric from hash' do
 require "test_helper"
-class CompoundMetricWithErrorTest < ActiveSupport::TestCase
-  
-  def self.fixture
-    fixture = Kalibro::Entities::CompoundMetricWithError.new
-    fixture.metric = CompoundMetricTest.sc
-    fixture.error = ErrorTest.fixture
-    fixture
-  end
  
-  def self.fixture_hash
-    {:metric => CompoundMetricTest.sc_hash,
-     :error => ErrorTest.fixture_hash}
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/compound_metric_with_error_fixtures"
  
+class CompoundMetricWithErrorTest < ActiveSupport::TestCase
+  
   def setup
-    @hash = self.class.fixture_hash
-    @entity = self.class.fixture
+    @hash = CompoundMetricWithErrorFixtures.create_hash
+    @entity = CompoundMetricWithErrorFixtures.create
   end
  
   should 'create error from hash' do
 require "test_helper"
-class ConfigurationTest < ActiveSupport::TestCase
  
-  def self.kalibro_configuration
-    amloc_configuration = MetricConfigurationTest.amloc_configuration
-    sc_configuration = MetricConfigurationTest.sc_configuration
-    configuration = Kalibro::Entities::Configuration.new
-    configuration.name = 'Kalibro for Java'
-    configuration.description = 'Kalibro configuration for Java projects.'
-    configuration.metric_configurations = [amloc_configuration, sc_configuration]
-    configuration
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
  
-  def self.kalibro_configuration_hash
-    amloc_hash = MetricConfigurationTest.amloc_configuration_hash
-    sc_hash = MetricConfigurationTest.sc_configuration_hash
-    {:name => 'Kalibro for Java',
-      :description => 'Kalibro configuration for Java projects.',
-      :metric_configuration => [amloc_hash, sc_hash]}
-  end
+class ConfigurationTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.kalibro_configuration_hash
-    @configuration = self.class.kalibro_configuration
+    @hash = ConfigurationFixtures.kalibro_configuration_hash
+    @configuration = ConfigurationFixtures.kalibro_configuration
   end
  
   should 'create configuration from hash' do
@@ -32,4 +17,4 @@ class ConfigurationTest &lt; ActiveSupport::TestCase
     assert_equal @hash, @configuration.to_hash
   end
  
-end
 \ No newline at end of file
+end
 require "test_helper"
+
 class EntityTest < ActiveSupport::TestCase
  
 	def setup
 require "test_helper"
-class ErrorTest < ActiveSupport::TestCase
  
-  def self.fixture
-    error = Kalibro::Entities::Error.new
-    error.message = 'Error message from ErrorTest'
-    element1 = StackTraceElementTest.fixture
-    element2 = StackTraceElementTest.fixture('errorTestMethod', 84)
-    error.stack_trace = [element1, element2]
-    error
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/error_fixtures"
  
-  def self.fixture_hash
-    element1 = StackTraceElementTest.fixture_hash
-    element2 = StackTraceElementTest.fixture_hash('errorTestMethod', 84)
-    {:message => 'Error message from ErrorTest',
-     :stack_trace_element => [element1, element2]}
-  end
+class ErrorTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.fixture_hash
-    @error = self.class.fixture
+    @hash = ErrorFixtures.create_hash
+    @error = ErrorFixtures.create
   end
  
   should 'create error from hash' do
 require "test_helper"
-class MetricConfigurationTest < ActiveSupport::TestCase
-
-  def self.amloc_configuration
-    range1 = RangeTest.amloc_excellent
-    range2 = RangeTest.amloc_bad
-    amloc = Kalibro::Entities::MetricConfiguration.new
-    amloc.metric = NativeMetricTest.amloc
-    amloc.code = 'amloc'
-    amloc.weight = 1.0
-    amloc.aggregation_form = 'AVERAGE'
-    amloc.ranges = [range1, range2]
-    amloc
-  end
  
-  def self.sc_configuration
-    sc = Kalibro::Entities::MetricConfiguration.new
-    sc.metric = CompoundMetricTest.sc
-    sc.code = 'sc'
-    sc.weight = 1.0
-    sc.aggregation_form = 'AVERAGE'
-    sc
-  end
-
-  def self.amloc_configuration_hash
-    range1 = RangeTest.amloc_excellent_hash
-    range2 = RangeTest.amloc_bad_hash
-    {:metric => NativeMetricTest.amloc_hash,
-      :code => 'amloc', :weight => 1.0, :aggregation_form => 'AVERAGE',
-      :range => [range1, range2]}
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_configuration_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
  
-  def self.sc_configuration_hash
-    {:metric => CompoundMetricTest.sc_hash,
-      :code => 'sc', :weight => 1.0, :aggregation_form => 'AVERAGE'}
-  end
+class MetricConfigurationTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.amloc_configuration_hash
-    @range = self.class.amloc_configuration
+    @hash = MetricConfigurationFixtures.amloc_configuration_hash
+    @metric_configuration = MetricConfigurationFixtures.amloc_configuration
+    @metric_configuration_without_ranges = MetricConfigurationFixtures.metric_configuration_without_ranges
+    @range1 = RangeFixtures.amloc_excellent
+    @range2 = RangeFixtures.amloc_bad
   end
  
   should 'create metric configuration from hash' do
-    assert_equal @range, Kalibro::Entities::MetricConfiguration.from_hash(@hash)
+    assert_equal @metric_configuration, Kalibro::Entities::MetricConfiguration.from_hash(@hash)
   end
  
   should 'convert metric configuration to hash' do
-    assert_equal @hash, @range.to_hash
+    assert_equal @hash, @metric_configuration.to_hash
   end
  
   should 'create appropriate metric type' do
-    assert self.class.amloc_configuration.metric.instance_of?(Kalibro::Entities::NativeMetric)
-    assert self.class.sc_configuration.metric.instance_of?(Kalibro::Entities::CompoundMetric)
+    amloc = MetricConfigurationFixtures.amloc_configuration
+    sc = MetricConfigurationFixtures.sc_configuration
+    assert amloc.metric.instance_of?(Kalibro::Entities::NativeMetric)
+    assert sc.metric.instance_of?(Kalibro::Entities::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
  
+
 end
 require "test_helper"
-class MetricResultTest < ActiveSupport::TestCase
-
-  def self.amloc_result
-    result = Kalibro::Entities::MetricResult.new
-    result.metric = NativeMetricTest.amloc
-    result.value = 0.0
-    result.descendent_results = [40.0, 42.0]
-    result.range = RangeTest.amloc_excellent
-    result
-  end
-
-  def self.sc_result
-    result = Kalibro::Entities::MetricResult.new
-    result.metric = CompoundMetricTest.sc
-    result.value = 1.0
-    result.descendent_results = [2.0, 42.0]
-    result
-  end
  
-  def self.amloc_result_hash
-    {:metric => NativeMetricTest.amloc_hash,
-      :value => 0.0, :descendent_result => [40.0, 42.0],
-      :range => RangeTest.amloc_excellent_hash}
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/metric_result_fixtures"
  
-  def self.sc_result_hash
-    {:metric => CompoundMetricTest.sc_hash,
-      :value => 1.0, :descendent_result => [2.0, 42.0]}
-  end
+class MetricResultTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.amloc_result_hash
-    @result = self.class.amloc_result
+    @hash = MetricResultFixtures.amloc_result_hash
+    @result = MetricResultFixtures.amloc_result
   end
  
   should 'create metric result from hash' do
@@ -43,8 +18,8 @@ class MetricResultTest &lt; ActiveSupport::TestCase
   end
  
   should 'create appropriate metric type' do
-    assert self.class.amloc_result.metric.instance_of?(Kalibro::Entities::NativeMetric)
-    assert self.class.sc_result.metric.instance_of?(Kalibro::Entities::CompoundMetric)
+    assert MetricResultFixtures.amloc_result.metric.instance_of?(Kalibro::Entities::NativeMetric)
+    assert MetricResultFixtures.sc_result.metric.instance_of?(Kalibro::Entities::CompoundMetric)
   end
  
   should 'convert single descendent result to array' do
 require "test_helper"
+
 class MetricTest < ActiveSupport::TestCase
  
   def setup
 require "test_helper"
  
-class ModuleNodeTest < ActiveSupport::TestCase
-
-  def self.qt_calculator_tree
-    node = Kalibro::Entities::ModuleNode.new
-    node.module = ModuleTest.qt_calculator
-    node.children = [new_node('Dialog', 'CLASS'), new_node('main', 'CLASS')]
-    node
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_node_fixtures"
  
-  def self.new_node(name, granularity)
-    the_module = Kalibro::Entities::Module.new
-    the_module.name = name
-    the_module.granularity = granularity
-    node = Kalibro::Entities::ModuleNode.new
-    node.module = the_module
-    node
-  end
-
-  def self.qt_calculator_tree_hash
-    {:module => ModuleTest.qt_calculator_hash,
-      :child => [
-        {:module => {:name => 'Dialog', :granularity => 'CLASS'}},
-        {:module => {:name => 'main', :granularity => 'CLASS'}}
-      ]
-    }
-  end
+class ModuleNodeTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.qt_calculator_tree_hash
-    @node = self.class.qt_calculator_tree
+    @hash = ModuleNodeFixtures.qt_calculator_tree_hash
+    @node = ModuleNodeFixtures.qt_calculator_tree
   end
  
   should 'create module node from hash' do
 require "test_helper"
  
-class ModuleResultTest < ActiveSupport::TestCase
-
-  def self.fixture
-    amloc_result = MetricResultTest.amloc_result
-    sc_result = MetricResultTest.sc_result
-    fixture = Kalibro::Entities::ModuleResult.new
-    fixture.module = ModuleTest.qt_calculator
-    fixture.date = DateTime.parse('Thu, 20 Oct 2011 18:26:43.151 +0000')
-    fixture.grade = 10.0
-    fixture.metric_results = [amloc_result, sc_result]
-    fixture.compound_metrics_with_error = [CompoundMetricWithErrorTest.fixture]
-    fixture
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_result_fixtures"
  
-  def self.fixture_hash
-    amloc_result = MetricResultTest.amloc_result_hash
-    sc_result = MetricResultTest.sc_result_hash
-    {:module => ModuleTest.qt_calculator_hash,
-      :date => DateTime.parse('Thu, 20 Oct 2011 18:26:43.151 +0000'),
-      :grade => 10.0, :metric_result => [amloc_result, sc_result],
-      :compound_metric_with_error => [CompoundMetricWithErrorTest.fixture_hash]}
-  end
+class ModuleResultTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.fixture_hash
-    @result = self.class.fixture
+    @hash = ModuleResultFixtures.create_hash
+    @result = ModuleResultFixtures.create
   end
  
   should 'create module result from hash' do
 require "test_helper"
-class ModuleTest < ActiveSupport::TestCase
  
-  def self.qt_calculator
-    entity = Kalibro::Entities::Module.new
-    entity.name = ProjectTest.qt_calculator.name
-    entity.granularity = 'APPLICATION'
-    entity
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/module_fixtures"
  
-  def self.qt_calculator_hash
-    name = ProjectTest.qt_calculator.name
-    {:name => name, :granularity => 'APPLICATION'}
-  end
+class ModuleTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.qt_calculator_hash
-    @module = self.class.qt_calculator
+    @hash = ModuleFixtures.qt_calculator_hash
+    @module = ModuleFixtures.qt_calculator
   end
  
   should 'create module from hash' do
@@ -26,4 +17,14 @@ class ModuleTest &lt; ActiveSupport::TestCase
     assert_equal @hash, @module.to_hash
   end
  
-end
 \ No newline at end of file
+  should 'list ancestor names' do
+    @module.name = "org.kalibro.core"
+    assert_equal ["org", "org.kalibro", "org.kalibro.core"], @module.ancestor_names
+  end
+
+  should 'list ancestor with one name' do
+    @module.name = "org"
+    assert_equal ["org"], @module.ancestor_names
+  end
+ 
+end
 require "test_helper"
-class NativeMetricTest < ActiveSupport::TestCase
-
-  def self.total_cof
-    total_cof = Kalibro::Entities::NativeMetric.new
-    total_cof.name = 'Total Coupling Factor'
-    total_cof.scope = 'APPLICATION'
-    total_cof.origin = 'Analizo'
-    total_cof.language = 'JAVA'
-    total_cof
-  end
  
-  def self.amloc
-    total_cof = Kalibro::Entities::NativeMetric.new
-    total_cof.name = 'Average Method LOC'
-    total_cof.scope = 'CLASS'
-    total_cof.origin = 'Analizo'
-    total_cof.language = 'JAVA'
-    total_cof
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/native_metric_fixtures"
  
-  def self.total_cof_hash
-    {:name => 'Total Coupling Factor', :scope => 'APPLICATION',
-      :origin => 'Analizo', :language => 'JAVA'}
-  end
+class NativeMetricTest < ActiveSupport::TestCase
  
-  def self.amloc_hash
-    {:name => 'Average Method LOC', :scope => 'CLASS',
-      :origin => 'Analizo', :language => 'JAVA'}
-  end
-  
   def setup
-    @hash = self.class.amloc_hash
-    @metric = self.class.amloc
+    @hash = NativeMetricFixtures.amloc_hash
+    @metric = NativeMetricFixtures.amloc
   end
  
   should 'create native metric from hash' do
 require "test_helper"
-class ProjectResultTest < ActiveSupport::TestCase
  
-  def self.qt_calculator
-    result = Kalibro::Entities::ProjectResult.new
-    result.project = ProjectTest.qt_calculator
-    result.date = DateTime.parse('Thu, 20 Oct 2011 18:26:43.151 +0000')
-    result.load_time = 14878
-    result.analysis_time = 1022
-    result.source_tree = ModuleNodeTest.qt_calculator_tree
-    result
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
  
-  def self.qt_calculator_hash
-    {:project => ProjectTest.qt_calculator_hash,
-      :date => DateTime.parse('Thu, 20 Oct 2011 18:26:43.151 +0000'),
-      :load_time => 14878,
-      :analysis_time => 1022,
-      :source_tree => ModuleNodeTest.qt_calculator_tree_hash}
-  end
+class ProjectResultTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.qt_calculator_hash
-    @result = self.class.qt_calculator
+    @hash = ProjectResultFixtures.qt_calculator_hash
+    @result = ProjectResultFixtures.qt_calculator
   end
  
   should 'create project result from hash' do
@@ -39,5 +24,26 @@ class ProjectResultTest &lt; ActiveSupport::TestCase
   should 'retrieve formatted analysis time' do
     assert_equal '00:00:01', @result.formatted_analysis_time
   end
+
+  should 'retrieve module node' do
+    node = @result.get_node("main")
+    assert_equal @hash[:source_tree][:child][2], node.to_hash
+  end
+
+  should 'retrive complex module' do
+    node = @result.get_node("org.Window")
+    assert_equal @hash[:source_tree][:child][0][:child].first, node.to_hash
+  end
+
+  should 'return source tree node when nil is given' do
+    assert_equal @hash[:source_tree], @result.node_of(nil).to_hash 
+  end
  
-end
 \ No newline at end of file
+  should 'return source tree node when project name is given' do
+    assert_equal @hash[:source_tree], @result.node_of(@result.project.name).to_hash 
+  end
+
+  should 'return correct node when module name is given' do
+    assert_equal @hash[:source_tree][:child][2], @result.node_of("main").to_hash
+  end
+end
 require "test_helper"
-class ProjectTest < ActiveSupport::TestCase
  
-  def self.qt_calculator
-    project = Kalibro::Entities::Project.new
-    project.name = 'Qt-Calculator'
-    project.license = 'GPL'
-    project.description = 'Calculator for Qt'
-    project.repository = RepositoryTest.qt_calculator
-    project.configuration_name = 'Kalibro for Java'
-    project.state = 'READY'
-    project
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_fixtures"
  
-  def self.qt_calculator_hash
-    {:name => 'Qt-Calculator', :license => 'GPL',
-        :description => 'Calculator for Qt',
-        :repository => RepositoryTest.qt_calculator_hash,
-        :configuration_name => 'Kalibro for Java',
-        :state => 'READY'}
-  end
+class ProjectTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.qt_calculator_hash
-    @project = self.class.qt_calculator
+    @hash = ProjectFixtures.qt_calculator_hash
+    @project = ProjectFixtures.qt_calculator
   end
  
   should 'create project from hash' do
 require "test_helper"
-class RangeTest < ActiveSupport::TestCase
-
-  Infinity = 1.0/0.0
  
-  def self.amloc_excellent
-    range = Kalibro::Entities::Range.new
-    range.beginning = 0.0
-    range.end = 7.0
-    range.label = 'Excellent'
-    range.grade = 10.0
-    range.color = 'ff00ff00'
-    range
-  end
-
-  def self.amloc_bad
-    range = Kalibro::Entities::Range.new
-    range.beginning = 19.5
-    range.end = Infinity
-    range.label = 'Bad'
-    range.grade = 0.0
-    range.color = 'ffff0000'
-    range
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/range_fixtures"
  
-  def self.amloc_excellent_hash
-    {:beginning => 0.0, :end => 7.0, :label => 'Excellent',
-      :grade => 10.0, :color => 'ff00ff00'}
-  end
-
-  def self.amloc_bad_hash
-    {:beginning => 19.5, :end => Infinity, :label => 'Bad',
-      :grade => 0.0, :color => 'ffff0000'}
-  end
+class RangeTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.amloc_bad_hash
-    @range = self.class.amloc_bad
+    @hash = RangeFixtures.amloc_bad_hash
+    @range = RangeFixtures.amloc_bad
   end
  
   should 'create range from hash' do
 require "test_helper"
-class RepositoryTest < ActiveSupport::TestCase
  
-  def self.qt_calculator
-    repository = Kalibro::Entities::Repository.new
-    repository.type = 'SUBVERSION'
-    repository.address = 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'
-    repository
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/repository_fixtures"
  
-  def self.qt_calculator_hash
-    {:type => 'SUBVERSION',
-     :address => 'https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator'}
-  end
+class RepositoryTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.qt_calculator_hash
-    @repository = self.class.qt_calculator
+    @hash = RepositoryFixtures.qt_calculator_hash
+    @repository = RepositoryFixtures.qt_calculator
   end
  
   should 'create repository from hash' do
 require "test_helper"
-class StackTraceElementTest < ActiveSupport::TestCase
  
-  def self.fixture(method_name = 'stackTraceElementTestMethod', line_number = 42)
-    stack_trace_element = Kalibro::Entities::StackTraceElement.new
-    stack_trace_element.declaring_class = 'org.declaring.Class'
-    stack_trace_element.method_name = method_name
-    stack_trace_element.file_name = 'Class.java'
-    stack_trace_element.line_number = line_number
-    stack_trace_element
-  end
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/stack_trace_element_fixtures"
  
-  def self.fixture_hash(method_name = 'stackTraceElementTestMethod', line_number = 42)
-    {:declaring_class => 'org.declaring.Class',
-     :method_name => method_name,
-     :file_name => 'Class.java',
-     :line_number => line_number}
-  end
+class StackTraceElementTest < ActiveSupport::TestCase
  
   def setup
-    @hash = self.class.fixture_hash
-    @stack_trace_element = self.class.fixture
+    @hash = StackTraceElementFixtures.create_hash
+    @stack_trace_element = StackTraceElementFixtures.create
   end
  
   should 'create stack trace element from hash' do
@@ -0,0 +1,50 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/configuration_fixtures"
+
+class ConfigurationContentTest < ActiveSupport::TestCase
+
+  def setup
+    @configuration = ConfigurationFixtures.kalibro_configuration
+    @content = MezuroPlugin::ConfigurationContent.new
+    @content.name = @configuration.name
+    @content.description = @configuration.description
+  end
+
+  should 'be an article' do
+    assert_kind_of Article, @content
+  end
+
+  should 'provide proper short description' do
+    assert_equal 'Kalibro configuration', MezuroPlugin::ConfigurationContent.short_description
+  end
+
+  should 'provide proper description' do
+    assert_equal 'Sets of thresholds to interpret metrics', MezuroPlugin::ConfigurationContent.description
+  end
+
+  should 'have an html view' do
+    assert_not_nil @content.to_html
+  end
+
+  should 'get configuration from service' do
+    Kalibro::Client::ConfigurationClient.expects(:configuration).with(@content.name).returns(@configuration)
+    assert_equal @configuration, @content.configuration
+  end
+
+  should 'send configuration to service after saving' do
+    @content.expects :send_configuration_to_service
+    @content.run_callbacks :after_save
+  end
+
+  should 'send correct configuration to service' do
+    Kalibro::Client::ConfigurationClient.expects(:save).with(@content)
+    @content.send :send_configuration_to_service
+  end
+
+  should 'remove configuration from service' do
+    Kalibro::Client::ConfigurationClient.expects(:remove).with(@content.name)
+    @content.send :remove_configuration_from_service
+  end
+  
+end
@@ -0,0 +1,14 @@
+require "test_helper"
+
+class ContentViewerHelperTest < ActiveSupport::TestCase
+
+  should 'get the number rounded by two decimal points' do
+    assert_equal '4.22', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4.22344')
+    assert_equal '4.10', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4.1')
+    assert_equal '4.00', MezuroPlugin::Helpers::ContentViewerHelper.format_grade('4')
+  end
+
+  should 'create the periodicity options array' do
+    assert_equal [["Not Periodically", 0], ["1 day", 1], ["2 days", 2], ["Weekly", 7], ["Biweeky", 15], ["Monthly", 30]], MezuroPlugin::Helpers::ContentViewerHelper.create_periodicity_options
+  end
+end
@@ -0,0 +1,44 @@
+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
 require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_fixtures"
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
+
 class ProjectContentTest < ActiveSupport::TestCase
  
   def setup
-    @project = ProjectTest.qt_calculator
+    @project = ProjectFixtures.qt_calculator
     @content = MezuroPlugin::ProjectContent.new
     @content.name = @project.name
     @content.license = @project.license
@@ -10,6 +14,7 @@ class ProjectContentTest &lt; ActiveSupport::TestCase
     @content.repository_type = @project.repository.type
     @content.repository_url = @project.repository.address
     @content.configuration_name = @project.configuration_name
+    @content.periodicity_in_days = 1
   end
  
   should 'be an article' do
@@ -28,19 +33,105 @@ class ProjectContentTest &lt; ActiveSupport::TestCase
     assert_not_nil @content.to_html
   end
  
-  should 'run send project to service on after_save callback' do
+  should 'get project from service' do
+    Kalibro::Client::ProjectClient.expects(:project).with(@content.name).returns(@project)
+    assert_equal @project, @content.project
+  end
+
+  should 'get project result from service' do
+    project_result = mock
+    Kalibro::Client::ProjectResultClient.expects(:last_result).with(@content.name).returns(project_result)
+    assert_equal project_result, @content.project_result
+  end
+  
+  should 'get date result from service when has_result_before is true' do
+    client = mock
+    project_result = mock
+    Kalibro::Client::ProjectResultClient.expects(:new).returns(client)
+    client.expects(:has_results_before).with(@project.name, "2012-05-22T22:00:33+04:00").returns(true)
+    client.expects(:last_result_before).with(@project.name, "2012-05-22T22:00:33+04:00").returns(project_result)
+    assert_equal project_result, @content.get_date_result("2012-05-22T22:00:33+04:00")
+  end
+
+  should 'get date result from service when has_result_before is false' do
+    client = mock
+    project_result = mock
+    Kalibro::Client::ProjectResultClient.expects(:new).returns(client)
+    client.expects(:has_results_before).with(@project.name, "2012-05-22T22:00:33+04:00").returns(false)
+    client.expects(:first_result_after).with(@project.name, "2012-05-22T22:00:33+04:00").returns(project_result)
+    assert_equal project_result, @content.get_date_result("2012-05-22T22:00:33+04:00")
+  end
+
+  should 'get module result from service' do
+    mock_project_client
+    project_result = mock_project_result_client
+    module_name = 'My module name'
+    module_result_client = mock
+    module_result = Kalibro::Entities::ModuleResult.new
+    @content.expects(:module_result_client).returns(module_result_client)
+    module_result_client.expects(:module_result).with(@project.name, module_name, project_result.date).
+returns(module_result)
+    assert_equal module_result, @content.module_result(module_name)
+  end
+
+  should 'get module result root when nil is given' do
+    mock_project_client
+    project_result = mock_project_result_client
+    module_result_client = mock
+    module_result = Kalibro::Entities::ModuleResult.new
+    @content.expects(:module_result_client).returns(module_result_client)
+    module_result_client.expects(:module_result).with(@project.name, @project.name, project_result.date).
+returns(module_result)
+    assert_equal module_result, @content.module_result(nil)
+  end
+
+  should 'get result history' do
+    mock_project_client
+    module_name = 'Fake Name'
+  	module_result_client = mock
+    module_result_client.expects(:result_history).with(@project.name, module_name)
+  	@content.expects(:module_result_client).returns(module_result_client)
+  	@content.result_history(module_name)
+  end
+
+  should 'send project to service after saving' do
     @content.expects :send_project_to_service
     @content.run_callbacks :after_save
   end
  
   should 'send correct project to service' do
-    Kalibro::Client::ProjectClient.expects(:save).with(@project)
-    Kalibro::Client::KalibroClient.expects(:process_project).with(@project.name)
+    Kalibro::Client::ProjectClient.expects(:save).with(@content)
+    Kalibro::Client::KalibroClient.expects(:process_project).with(@content.name, @content.periodicity_in_days)
     @content.send :send_project_to_service
   end
  
   should 'remove project from service' do
-    Kalibro::Client::ProjectClient.expects(:remove).with(@project.name)
+    Kalibro::Client::ProjectClient.expects(:remove).with(@content.name)
     @content.send :remove_project_from_service
   end
+  
+  should 'not save a project with an existing project name in kalibro' do
+    client = mock
+ 		Kalibro::Client::ProjectClient.expects(:new).returns(client)
+		client.expects(:project_names).returns([@content.name])
+		@content.send :validate_kalibro_project_name
+		assert_equal "Project name already exists in Kalibro", @content.errors.on_base
+	end
+  
+  private
+
+    def mock_project_client
+      Kalibro::Client::ProjectClient.expects(:project).with(@content.name).returns(@project)
+    end
+    
+    def mock_project_result_client
+      project_result = ProjectResultFixtures.qt_calculator
+      Kalibro::Client::ProjectResultClient.expects(:last_result).with(@content.name).returns(project_result)
+      project_result
+    end
+
+	  def create_project_error
+	      raise "Error on Kalibro" 
+	  end
+
 end
 require "test_helper"
+
 class MezuroPluginTest < ActiveSupport::TestCase
  
   def setup
@@ -29,8 +30,4 @@ class MezuroPluginTest &lt; ActiveSupport::TestCase
     assert @plugin.stylesheet?
   end
  
-  should 'list javascript files' do
-    assert_equal ['javascripts/results.js', 'javascripts/toogle.js'], @plugin.js_files
-  end
-
 end
 <h1> <%= _(MezuroPlugin::ConfigurationContent.short_description) %> </h1>
  
 <%
-  begin
-    @configuration = @article.title.nil? ? nil : Kalibro::Client::ConfigurationClient.new.configuration(@article.title)
-  rescue
-    @configuration = nil
-  end
+begin
+  @configuration = @article.title.nil? ? nil : Kalibro::Client::ConfigurationClient.new.configuration(@article.title)
+rescue
+  @configuration = nil
+end 
 %>
  
 <%= error_messages_for 'kalibro_configuration' %>
@@ -2,7 +2,8 @@
  
 <%
   begin
-    @project = @article.title.nil? ? nil : Kalibro::Client::ProjectClient.new.project(@article.title)
+    @project = @article.title.nil? ? nil : Kalibro::Client::ProjectClient.project(@article.title)
+    @kalibro_client = Kalibro::Client::KalibroClient.new
   rescue
     @project = nil
   end
@@ -21,7 +22,7 @@
  
 <%= f.text_field :description %><br/>
  
-<% @repository_types = Kalibro::Client::KalibroClient.new.supported_repository_types.sort %>
+<% @repository_types = @kalibro_client.supported_repository_types.sort %>
 <% @selected = (@project.nil? ? @repository_types : @project.repository.type) %>
 <%= required labelled_form_field _('Repository type'),
   f.select(:repository_type, @repository_types, {:selected => @selected}) %><br/>
@@ -31,4 +32,9 @@
 <% @configuration_names = Kalibro::Client::ConfigurationClient.new.configuration_names.sort %>
 <% @selected = (@project.nil? ? @configuration_names[0] : @project.configuration_name) %>
 <%= required labelled_form_field _('Configuration'),
-  f.select(:configuration_name, @configuration_names.sort, {:selected => @selected}) %><br/>
 \ No newline at end of file
+  f.select(:configuration_name, @configuration_names, {:selected => @selected}) %><br/>
+
+
+<% selected = (@project.nil? ? 0 : @kalibro_client.process_period(@article.title).to_i) %>
+<%= required labelled_form_field _('Periodic Avaliation'),
+  f.select(:periodicity_in_days, MezuroPlugin::Helpers::ContentViewerHelper.create_periodicity_options ,{:selected => selected}) %><br/>
-<h5><%= _('Metric Result') %> </h5>
-<strong>
-  <%= _('Module:') %>
-  <%=  module_result.module.name %>
-</strong>
-<br/>
+<% the_module = module_result.module %>
+<% module_label = "#{the_module.name} (#{the_module.granularity})" %>
+
+<h5><%= _('Metric results for: ') + module_label %> </h5>
+
 <hr/>
-<table id="project_metric_result">
+<div class="zoomable-image">
+<table>
   <thead>
     <tr>
       <th>Metric</th>
@@ -17,23 +17,40 @@
   <tbody>
     <% module_result.metric_results.each do |metric_result|  %>
       <% range = metric_result.range %>
-      <tr title=" <%= range.comments %>">
-        <td><%= metric_result.metric.name %></td>
-        <td><%= metric_result.value %></td>
-        <td><%= metric_result.weight %></td>
-        <td style="background-color: #<%= range.color[2..-1] %>"><%= range.label %></td>
-      </tr>   
+      <% if !range.nil? %>
+        <tr>
+          <td><a href="#" data-show=".<%= metric_result.metric.name.delete("() ")%>"><%= metric_result.metric.name %></a></td>
+          <td><%= MezuroPlugin::Helpers::ContentViewerHelper.format_grade(metric_result.value) %></td>
+          <td><%= metric_result.weight %></td>
+          <td style="background-color: #<%= range.color[2..-1] %>"><%= range.label %></td>
+        </tr>	  
+        <tr class="<%= metric_result.metric.name.delete("() ")%>" style="display: none;">
+          <td colspan="3">
+            <div id='historical-<%= metric_result.metric.name.delete("() ") %>'>
+              <a href="#" show-metric-history="<%= metric_result.metric.name.delete("() ") %>" data-module-name="<%= the_module.name %>" data-metric-name="<%= metric_result.metric.name.delete("() ") %>"> <p style="text-indent: 3em;"> Get Historical Values </p> </a>
+            </div>
+          </td>
+          <td align="right">
+            <%= range.comments.nil? ? '' : range.comments %>
+          </td> 
+        </tr>
+      <% end %>
     <% end %>
   </tbody>
   <tfoot>
     <tr>
-      <td colspan = "4" align = "right">
-        <strong>
-          <%= _('Grade:') %>
-          <%=  module_result.grade %>
-        </strong>
+      <td colspan = "3">
+        <div id='historical-grade'></div>
+      </td>
+      <td align = "right">
+        <a href="#" show-grade-history="<%= module_result.module.name %>" data-module-name="<%= the_module.name%>" >
+          <strong>
+            <%= _('Grade:') %>
+            <%= "%.02f" % module_result.grade %>
+          </strong>
+        </a>
       </td>
     </tr>
   </tfoot>
 </table>
-
+</div>
@@ -0,0 +1,12 @@
+<h3><%= _('ERROR') %></h3>
+<p>
+  <%= "State when error ocurred: #{project.state}" %>
+  <br/>
+  <% error = project.error %>
+  <%= error.message %>
+<ul>
+  <% error.stack_trace.each do |trace| %>
+    <li><%= "#{trace.declaring_class}.#{trace.method_name}(#{trace.file_name}:#{trace.line_number})" %></li>
+  <% end %>
+</ul>
+</p>
@@ -0,0 +1,48 @@
+
+<% form_for :project_date, :html=>{:id=>"project_history_date"} do |f| %>
+	<%= f.label :day, "Choose project date:" %>
+	
+<table>
+	<tr>
+		<td>
+			Day
+		</td>
+		<td>
+			Month
+		</td>
+		<td>
+			Year
+		</td>
+	</tr>
+	<tr>
+		<td>
+			<%= f.text_field :day, :size => 1, :maxlength => 2, :placeholder =>"dd" %>
+			</td>
+		<td>
+			<%= f.text_field :month, :size => 1, :maxlength => 2, :placeholder =>"mm"  %>
+		</td>
+		<td>
+			<%= f.text_field :year, :size => 1, :maxlength => 4, :placeholder =>"yyyy"   %>
+		</td>
+	</tr>
+</table>
+  <%= f.submit "Refresh" %>
+<% end %>
+
+ 
+<h4><%= _('Last Result') %></h4>
+
+<table>
+  <tr>
+    <td><%= _('Date') %></td>
+    <td><%= project_result.date %></td>
+  </tr>
+  <tr>
+    <td><%= _('Load time') %></td>
+    <td><%= project_result.formatted_load_time %></td>
+  </tr>
+  <tr>
+    <td><%= _('Analysis time') %></td>
+    <td><%= project_result.formatted_analysis_time %></td>
+  </tr>
+</table>
@@ -0,0 +1,2 @@
+<%= image_tag(MezuroPlugin::Helpers::ContentViewerHelper.generate_chart(score_history)) %>
+
-<% module_name = source_tree.module_name %>
-<% module_label = "#{module_name} (#{source_tree.granularity})" %>
+<h4><%= _('Source tree') %></h4>
+<% module_name = source_tree.module.name %>
+<% module_label = "#{module_name} (#{source_tree.module.granularity})" %>
+
+<p><h2 class="path">
+  <% if module_name != project_name %>
+    <a href="#" class="source-tree-link" data-module-name="<%= project_name %>">
+      <%= project_name %>
+    </a>
+  <% end %>
+
+
+  <% split_link = source_tree.module.ancestor_names %>
+  <% split_link.each do |link| %>
+    /<a href="#" class="source-tree-link" data-module-name="<%= link %>">
+      <%= link.split(".").last %>
+    </a>
+  <% end %>
+</h2></p>
+  
 <% if source_tree.children %>
-  <table>
-    <tr>
-      <td width="10%">
-        <img alt="+" src="/plugins/mezuro/images/plus.png" class="link"
-          id="<%= module_name %>_plus" onclick="toogle('<%= module_name %>')"/>
-        <img alt="-" src="/plugins/mezuro/images/minus.png" class="link"
-          id="<%= module_name %>_minus" onclick="toogle('<%= module_name %>')" style="display: none"/>
-      </td>
-      <td>
-        <a href="#" class="module-result-link" data-module-name="<%= module_name %>">
-          <%= module_label %>
-        </a>
-      </td>
-    </tr> 
-    <tr id="<%= module_name %>_hidden" style="display: none">
-      <td></td> 
-      <td style="text-align: left">
-        <% source_tree.children.each do |child| %>
-          <%= render :partial => 'source_tree', :locals => { :source_tree => child } %>
-        <% end %>
-      </td> 
-    </tr> 
-  </table>
-<% else %>
-  <table>
-    <tr>
-      <td width="1"></td>
-      <td>
-        <a href="#" class="module-result-link" data-module-name="<%= module_name %>">
-          <%= module_label %>
-        </a>
-      </td>
-    </tr>
+  <table border="0" class="source-tree">
+    <% source_tree.children.each do |child| %>
+      <% if child.module.granularity=='PACKAGE' %>
+        <tr>
+	        <td class="icon"><%= image_tag('/plugins/mezuro/images/folder.png')%></td>
+	        <td class="source-tree-text"><a href='#' class="source-tree-link" data-module-name="<%= child.module.name %>"><%= child.module.name %></a></td>
+        </tr>
+      <% else %>
+        <tr>
+	        <td class="icon"><%= image_tag('/plugins/mezuro/images/file.png') %></td>
+	        <td class="source-tree-text">
+                  <a href='#' class="source-tree-link" data-module-name="<%= child.module.name %>">
+                    <%= child.module.name %>
+                  </a>
+                </td>
+        </tr>
+      <% end %>
+    <% end %>  
   </table>
 <% end %>
-<% @configuration = @page.configuration %>
+<% @configuration_content = @page
+@configuration = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_content.name) %>
  
 <table id="project_info">
   <tr>
@@ -10,3 +11,39 @@
     <td><%= @configuration.description %></td>
   </tr>
 </table>
+
+<br/>
+
+<%= link_to "#{image_tag ('/plugins/mezuro/images/plus.png')}Add Metric", :controller => "mezuro_plugin_myprofile",
+:action => "choose_base_tool", :params => {:configuration_name => @configuration.name} %><br/>
+
+<table>
+  <tr class="titles">
+      <td><h5>Metric Name</h5></td>
+      <td><h5>Collector Name</h5></td>
+      <td><h5>Metric Code</h5></td>
+  </tr>
+  <% @configuration.metric_configurations.each do |metric_configuration| %>
+    <tr class="metric">
+      <td><%= metric_configuration.metric.name %></td>
+      <% if metric_configuration.metric.instance_of? Kalibro::Entities::NativeMetric %>
+        <td>
+          <%= metric_configuration.metric.origin %>
+        </td>
+        <td><%= metric_configuration.code %></td>
+        <td><%= link_to "Edit", :controller => "mezuro_plugin_myprofile", :action => "edit_metric_configuration", :params =>
+          {:configuration_name => @configuration.name, :metric_name => metric_configuration.metric.name} %></td>
+      <% else %>
+        <td>
+          Compound Metric
+        </td>
+        <td><%= metric_configuration.code %></td>
+        <td><%= link_to "Edit", :controller => "mezuro_plugin_myprofile", :action => "edit_compound_metric_configuration", :params =>
+          {:configuration_name => @configuration.name, :metric_name => metric_configuration.metric.name} %></td>
+      <% end %>
+      
+      <td><%= link_to "Remove", :controller => "mezuro_plugin_myprofile", :action => "remove_metric_configuration", :params =>
+        {:configuration_name => @configuration.name, :metric_name => metric_configuration.metric.name} %></td>
+    </tr>
+  <% end %>
+</table>
+<script src="/plugins/mezuro/javascripts/project_content.js" type="text/javascript"></script>
+
 <% @project = @page.project %>
+<% if (@project==nil) %>
+  <h3>Warning:</h3>
+ <p>This project doesn't exist on the Web Service. Do you want to <a href="/myprofile/<%= @page.profile.name %>/cms/destroy/<%= @page.id%>">delete</a> or <a href="/myprofile/<%= @page.profile.name %>/cms/edit/<%= @page.id%>">save it again</a>?</p>
+<% else %>
+
  
-<table id="project_info">
+<table>
   <tr>
     <td><%= _('Name') %></td>
     <td><%= @project.name %></td>
@@ -25,55 +32,26 @@
     <td><%= _('Configuration') %></td>
     <td><%= @project.configuration_name %></td>
   </tr>
+  <tr> 
+    <td><%= _('Periodicity') %></td>
+    <td><%= MezuroPlugin::Helpers::ContentViewerHelper.get_periodicity_option(@page.periodicity_in_days) %></td>
+  </tr>
+  <tr>
+    <td><%= _('Status')%></td>
+    <td>
+      <div id="project-state"><%= @project.state %></div>
+      <div id="msg-time"></div> 
+    </td>
+  </tr>
 </table>
  
 <br />
  
-<% if ! @project.error.nil? %>
-  <h3><%= _('ERROR') %></h3>
-  <p>
-    <%= "State when error ocurred: #{@project.state}" %>
-    <br/>
-    <% error = @project.error %>
-    <%= error.message %>
-    <ul><% error.stack_trace.each do |trace| %>
-      <li><%= "#{trace.declaring_class}.#{trace.method_name}(#{trace.file_name}:#{trace.line_number})" %></li>
-    <% end %></ul>
-  </p>
-<% elsif @project.state.end_with? 'ING' %>
-  <p>
-    <%= _("Kalibro Service is #{@project.state.downcase} the source code.") %>
-    <br/>
-    <%= _('Reload the page manually in a few moments.') %>
-  </p>
-<% elsif @project.state == 'READY' %>
-  <h3><%= _('LAST RESULT') %></h3>
-  <% @project_result = @page.project_result %>
-
-  <table id="project_result_info">
-    <tr>
-      <td><%= _('Date') %></td>
-      <td><%= @project_result.date %></td>
-    </tr>
-    <tr>
-      <td><%= _('Load time') %></td>
-      <td><%= @project_result.formatted_load_time %></td>
-    </tr>
-    <tr>
-      <td><%= _('Analysis time') %></td>
-      <td><%= @project_result.formatted_analysis_time %></td>
-    </tr>
-  </table>
-
-  <h5><%= _('Source tree') %></h5>
-
-  <%= render :partial => 'source_tree', :locals => { :source_tree => @project_result.source_tree } %>
-
-  <div id='module-result' data-profile="<%= @page.profile.identifier %>" data-project-id='<%= @page.id %>'>
-    <%= render :partial => 'module_result', :locals => { :module_result => @page.module_result(@project.name) } %>
-  </div>
+<div id="project-result" data-profile="<%= @page.profile.identifier %>" data-content="<%= @page.id %>"
+     data-project-name="<%= @project.name %>">
+</div>
+<div id="project-tree"></div>
+<div id="module-result">
+</div>
+<% end %>
  
-  <script type="text/javascript">
-    jQuery(results);
-  </script>
-<% end %>
 \ No newline at end of file
...	...	@@ -0,0 +1,189 @@
	1	+class MezuroPluginMyprofileController < ProfileController
	2	+
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../views')
	4	+
	5	+
	6	+ def choose_base_tool
	7	+ @configuration_name = params[:configuration_name]
	8	+ @tool_names = Kalibro::Client::BaseToolClient.new
	9	+ end
	10	+
	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)
	15	+ end
	16	+
	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]
	23	+ end
	24	+
	25	+ def new_compound_metric_configuration
	26	+ @configuration_name = params[:configuration_name]
	27	+ @metric_configurations = Kalibro::Client::ConfigurationClient.new.configuration(@configuration_name).metric_configurations
	28	+ end
	29	+
	30	+ 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)
	34	+ @metric = @metric_configuration.metric
	35	+ end
	36	+
	37	+ 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 = @metric_configuration.metric
	42	+ end
	43	+
	44	+ def create_metric_configuration
	45	+ @configuration_name = params[:configuration_name]
	46	+ metric_configuration = new_metric_configuration_instance
	47	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, @configuration_name)
	48	+ redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	49	+ end
	50	+
	51	+ def create_compound_metric_configuration
	52	+ @configuration_name = params[:configuration_name]
	53	+ compound_metric_configuration = new_compound_metric_configuration_instance
	54	+ Kalibro::Client::MetricConfigurationClient.new.save(compound_metric_configuration, @configuration_name)
	55	+ redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	56	+ end
	57	+
	58	+ def update_metric_configuration
	59	+ @configuration_name = params[:configuration_name]
	60	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	61	+ metric_name = params[:metric][:name]
	62	+ metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)
	63	+ metric_configuration = assign_metric_configuration_instance(metric_configuration)
	64	+ metric_configuration_client.save(metric_configuration, @configuration_name)
	65	+ redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	66	+ end
	67	+
	68	+ def update_compound_metric_configuration
	69	+ @configuration_name = params[:configuration_name]
	70	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	71	+ metric_name = params[:metric_configuration][:metric][:name]
	72	+ compound_metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, metric_name)
	73	+ compound_metric_configuration = assign_compound_metric_configuration_instance(compound_metric_configuration)
	74	+ metric_configuration_client.save(compound_metric_configuration, @configuration_name)
	75	+ redirect_to "/#{profile.identifier}/#{@configuration_name.downcase.gsub(/\s/, '-')}"
	76	+ end
	77	+
	78	+ def new_range
	79	+ @metric_name = params[:metric_name]
	80	+ @configuration_name = params[:configuration_name]
	81	+ end
	82	+
	83	+ def edit_range
	84	+ @metric_name = params[:metric_name]
	85	+ @configuration_name = params[:configuration_name]
	86	+ @beginning_id = params[:beginning_id]
	87	+
	88	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	89	+ metric_configuration = metric_configuration_client.metric_configuration(@configuration_name, @metric_name)
	90	+ @range = metric_configuration.ranges.find{ \|range\| range.beginning == @beginning_id.to_f }
	91	+ end
	92	+
	93	+ def create_range
	94	+ @range = new_range_instance
	95	+ configuration_name = params[:configuration_name]
	96	+ metric_name = params[:metric_name]
	97	+ beginning_id = params[:beginning_id]
	98	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	99	+ metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	100	+ metric_configuration.add_range(@range)
	101	+ metric_configuration_client.save(metric_configuration, configuration_name)
	102	+ end
	103	+
	104	+ def update_range
	105	+ metric_name = params[:metric_name]
	106	+ configuration_name = params[:configuration_name]
	107	+ beginning_id = params[:beginning_id]
	108	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	109	+ metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	110	+ index = metric_configuration.ranges.index{ \|range\| range.beginning == beginning_id.to_f }
	111	+ metric_configuration.ranges[index] = new_range_instance
	112	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
	113	+ end
	114	+
	115	+ def remove_range
	116	+ configuration_name = params[:configuration_name]
	117	+ metric_name = params[:metric_name]
	118	+ beginning_id = params[:range_beginning]
	119	+ metric_configuration_client = Kalibro::Client::MetricConfigurationClient.new
	120	+ metric_configuration = metric_configuration_client.metric_configuration(configuration_name, metric_name)
	121	+ metric_configuration.ranges.delete_if { \|range\| range.beginning == beginning_id.to_f }.inspect
	122	+ Kalibro::Client::MetricConfigurationClient.new.save(metric_configuration, configuration_name)
	123	+ formatted_configuration_name = configuration_name.gsub(/\s/, '+')
	124	+ formatted_metric_name = metric_name.gsub(/\s/, '+')
	125	+ if metric_configuration.metric.class == Kalibro::Entities::CompoundMetric
	126	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_compound_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
	127	+ else
	128	+ redirect_to "/myprofile/#{profile.identifier}/plugin/mezuro/edit_metric_configuration?configuration_name=#{formatted_configuration_name}&metric_name=#{formatted_metric_name}"
	129	+ end
	130	+ end
	131	+
	132	+ def remove_metric_configuration
	133	+ configuration_name = params[:configuration_name]
	134	+ metric_name = params[:metric_name]
	135	+ Kalibro::Client::MetricConfigurationClient.new.remove(configuration_name, metric_name)
	136	+ redirect_to "/#{profile.identifier}/#{configuration_name.downcase.gsub(/\s/, '-')}"
	137	+ end
	138	+
	139	+
	140	+
	141	+ private
	142	+
	143	+ def new_metric_configuration_instance
	144	+ metric_configuration = Kalibro::Entities::MetricConfiguration.new
	145	+ metric_configuration.metric = Kalibro::Entities::NativeMetric.new
	146	+ assign_metric_configuration_instance (metric_configuration)
	147	+ end
	148	+
	149	+ def new_compound_metric_configuration_instance
	150	+ metric_configuration = Kalibro::Entities::MetricConfiguration.new
	151	+ metric_configuration.metric = Kalibro::Entities::CompoundMetric.new
	152	+ assign_compound_metric_configuration_instance (metric_configuration)
	153	+ end
	154	+
	155	+ def assign_metric_configuration_instance (metric_configuration)
	156	+ metric_configuration.metric.name = params[:metric][:name]
	157	+ metric_configuration.metric.description = params[:description]
	158	+ metric_configuration.metric.origin = params[:metric][:origin]
	159	+ metric_configuration.metric.scope = params[:scope]
	160	+ metric_configuration.metric.language = params[:language]
	161	+ metric_configuration.code = params[:metric_configuration][:code]
	162	+ metric_configuration.weight = params[:metric_configuration][:weight]
	163	+ metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
	164	+ metric_configuration
	165	+ end
	166	+
	167	+ def assign_compound_metric_configuration_instance (metric_configuration)
	168	+ metric_configuration.metric.name = params[:metric_configuration][:metric][:name]
	169	+ metric_configuration.metric.description = params[:metric_configuration][:metric][:description]
	170	+ metric_configuration.metric.scope = params[:metric_configuration][:metric][:scope]
	171	+ metric_configuration.metric.script = params[:metric_configuration][:metric][:script]
	172	+ metric_configuration.code = params[:metric_configuration][:code]
	173	+ metric_configuration.weight = params[:metric_configuration][:weight]
	174	+ metric_configuration.aggregation_form = params[:metric_configuration][:aggregation_form]
	175	+ metric_configuration
	176	+ end
	177	+
	178	+ def new_range_instance
	179	+ range = Kalibro::Entities::Range.new
	180	+ range.beginning = params[:range][:beginning]
	181	+ range.end = params[:range][:end]
	182	+ range.label = params[:range][:label]
	183	+ range.grade = params[:range][:grade]
	184	+ range.color = params[:range][:color]
	185	+ range.comments = params[:range][:comments]
	186	+ range
	187	+ end
	188	+
	189	+end
...	...
1	1	class MezuroPluginProfileController < ProfileController
2	2
3		- def metrics
4		- project_content = profile.articles.find(params[:id])
5		- module_name = params[:module_name]
6		- render :partial => 'content_viewer/module_result', :locals => { :module_result => project_content.module_result(module_name) }
	3	+ append_view_path File.join(File.dirname(__FILE__) + '/../views')
	4	+
	5	+ def project_state
	6	+ content = profile.articles.find(params[:id])
	7	+ project = content.project
	8	+ state = project.error.nil? ? project.state : "ERROR"
	9	+ render :text => state
	10	+ end
	11	+
	12	+ def project_error
	13	+ content = profile.articles.find(params[:id])
	14	+ project = content.project
	15	+ render :partial => 'content_viewer/project_error', :locals => { :project => project }
	16	+ end
	17	+
	18	+ def project_result
	19	+ content = profile.articles.find(params[:id])
	20	+ date = params[:date]
	21	+ project_result = date.nil? ? content.project_result : content.get_date_result(date)
	22	+ project = content.project
	23	+ render :partial => 'content_viewer/project_result', :locals => { :project_result => project_result}
	24	+ end
	25	+
	26	+ def module_result
	27	+ content = profile.articles.find(params[:id])
	28	+ date = params[:date]
	29	+ date.nil? ? content.project_result : content.get_date_result(date)
	30	+ module_result = content.module_result(params[:module_name])
	31	+ render :partial => 'content_viewer/module_result', :locals => { :module_result => module_result}
7	32	end
8	33
	34	+ def project_tree
	35	+ content = profile.articles.find(params[:id])
	36	+ date = params[:date]
	37	+ project_result = date.nil? ? content.project_result : content.get_date_result(date)
	38	+ source_tree = project_result.node_of(params[:module_name])
	39	+ render :partial =>'content_viewer/source_tree', :locals => { :source_tree => source_tree, :project_name => content.project.name}
	40	+ end
	41	+
	42	+ def module_metrics_history
	43	+ metric_name = params[:metric_name]
	44	+ content = profile.articles.find(params[:id])
	45	+ module_history = content.result_history(params[:module_name])
	46	+ score_history = (module_history.collect { \|module_result\| (module_result.metric_results.select { \|metric_result\| metric_result.metric.name.delete("() ") == metric_name })[0] }).collect { \|metric_result\| metric_result.value }
	47	+ render :partial => 'content_viewer/score_history', :locals => {:score_history => score_history}
	48	+ end
	49	+
	50	+ def module_grade_history
	51	+ content = profile.articles.find(params[:id])
	52	+ modules_results = content.result_history(params[:module_name])
	53	+ score_history = modules_results.collect { \|module_result\| module_result.grade }
	54	+ render :partial => 'content_viewer/score_history', :locals => {:score_history => score_history}
	55	+ end
9	56	end
...	...
...	...	@@ -1,69 +0,0 @@
1		-Feature: mezuro content
2		- As a noosfero user
3		- I want to create a Kalibro project
4		-
5		- Background:
6		- Given the following users
7		- \| login \| name \|
8		- \| joaosilva \| Joao Silva \|
9		- And I am logged in as "joaosilva"
10		- And "Mezuro" plugin is enabled
11		- And the following community
12		- \| identifier \| name \|
13		- \| mycommunity \| My Community \|
14		- And "Joao Silva" is admin of "My Community"
15		-
16		- Scenario: I see Kalibro project as an option to new content
17		- Given I am on My Community's cms
18		- When I follow "New content"
19		- Then I should see "Kalibro project"
20		-
21		- Scenario: I see Kalibro project's input form
22		- Given I am on My Community's cms
23		- When I follow "New content"
24		- And I follow "Kalibro project"
25		- Then I should see "Title"
26		- And I should see "License"
27		- And I should see "Repository type"
28		- And I should see "GIT"
29		- And I should see "REMOTE_ZIP"
30		- And I should see "REMOTE_TARBALL"
31		- And I should see "SUBVERSION"
32		- And I should see "Repository url"
33		- And I should see "Configuration"
34		- And I should see "Kalibro for Java"
35		-
36		- Scenario: I create a sample mezuro content
37		- Given I am on My Community's cms
38		- When I create a content of type "Kalibro project" with the following data
39		- \| Title \| Sample project \|
40		- \| License \| BSD \|
41		- \| Repository type \| GIT \|
42		- \| Repository url \| git://example \|
43		- Then I should see "Sample project"
44		- And I should see "Viewed one time"
45		- And I should see "BSD"
46		-
47		- Scenario: I create a real mezuro content
48		- Given I am on My Community's cms
49		- When I create a content of type "Kalibro project" with the following data
50		- \| Title \| Qt-Calculator \|
51		- \| License \| GPL 2.0 \|
52		- \| Repository type \| SUBVERSION \|
53		- \| Repository url \| https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator \|
54		- Then I should see "Qt-Calculator"
55		-
56		- Scenario: I see results from a real Kalibro project
57		- Given I am on My Community's cms
58		- When I create a content of type "Kalibro project" with the following data
59		- \| Title \| Qt-Calculator \|
60		- \| License \| GPL \|
61		- \| Repository type \| SUBVERSION \|
62		- \| Repository url \| https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator \|
63		- \| Configuration \| Kalibro for Java \|
64		- Then I should see "Qt-Calculator"
65		- And I should see "GPL"
66		- And I should see "SUBVERSION"
67		- And I should see "https://qt-calculator.svn.sourceforge.net/svnroot/qt-calculator"
68		- And I should see "Kalibro for Java"
69		- And I should see "Kalibro Service is loading the source code"
...	...	@@ -13,4 +13,4 @@ class Kalibro::Client::BaseToolClient
13	13	Kalibro::Entities::BaseTool.from_hash(hash)
14	14	end
15	15
16		-end
17	16	\ No newline at end of file
	17	+end
...	...
1	1	class Kalibro::Client::ConfigurationClient
2	2
	3	+ def self.save(configuration_content)
	4	+ configuration = Kalibro::Entities::Configuration.new
	5	+ configuration.name = configuration_content.name
	6	+ configuration.description = configuration_content.description
	7	+ new.save(configuration)
	8	+ end
	9	+
	10	+ def self.remove(configuration_name)
	11	+ client = new
	12	+ client.remove(configuration_name) if client.configuration_names.include? configuration_name
	13	+ end
	14	+
3	15	def initialize
4	16	@port = Kalibro::Client::Port.new('Configuration')
5	17	end
...	...	@@ -8,10 +20,6 @@ class Kalibro::Client::ConfigurationClient
8	20	@port.request(:save_configuration, {:configuration => configuration.to_hash})
9	21	end
10	22
11		- def self.save(configuration)
12		- new.save(configuration)
13		- end
14		-
15	23	def configuration_names
16	24	@port.request(:get_configuration_names)[:configuration_name].to_a
17	25	end
...	...	@@ -25,7 +33,4 @@ class Kalibro::Client::ConfigurationClient
25	33	@port.request(:remove_configuration, {:configuration_name => configuration_name})
26	34	end
27	35
28		- def self.remove(configuration_name)
29		- new.remove(configuration_name)
30		- end
31	36	end
...	...
1	1	class Kalibro::Client::KalibroClient
	2	+
	3	+ def self.process_project(project_name)
	4	+ new.process_project(project_name)
	5	+ end
2	6
3	7	def initialize
4	8	@port = Kalibro::Client::Port.new('Kalibro')
...	...	@@ -12,8 +16,24 @@ class Kalibro::Client::KalibroClient
12	16	@port.request(:process_project, {:project_name => project_name})
13	17	end
14	18
15		- def self.process_project(project_name)
16		- new.process_project(project_name)
	19	+ def self.process_project(project_name, days)
	20	+ if days.to_i.zero?
	21	+ new.process_project(project_name)
	22	+ else
	23	+ new.process_periodically(project_name, days)
	24	+ end
	25	+ end
	26	+
	27	+ def process_periodically(project_name, period_in_days)
	28	+ @port.request(:process_periodically, {:project_name => project_name, :period_in_days => period_in_days})
	29	+ end
	30	+
	31	+ def process_period(project_name)
	32	+ @port.request(:get_process_period, {:project_name => project_name})[:period]
	33	+ end
	34	+
	35	+ def cancel_periodic_process(project_name)
	36	+ @port.request(:cancel_periodic_process, {:project_name => project_name})
17	37	end
18	38
19	39	end
...	...
...	...	@@ -0,0 +1,28 @@
	1	+class Kalibro::Client::MetricConfigurationClient
	2	+
	3	+ def initialize
	4	+ @port = Kalibro::Client::Port.new('MetricConfiguration')
	5	+ end
	6	+
	7	+ def save(metric_configuration, configuration_name)
	8	+ @port.request(:save_metric_configuration, {
	9	+ :metric_configuration => metric_configuration.to_hash,
	10	+ :configuration_name => configuration_name})
	11	+ end
	12	+
	13	+ def metric_configuration(configuration_name, metric_name)
	14	+ hash = @port.request(:get_metric_configuration, {
	15	+ :configuration_name => configuration_name,
	16	+ :metric_name => metric_name
	17	+ })[:metric_configuration]
	18	+ Kalibro::Entities::MetricConfiguration.from_hash(hash)
	19	+ end
	20	+
	21	+ def remove (configuration_name, metric_name)
	22	+ @port.request(:remove_metric_configuration, {
	23	+ :configuration_name => configuration_name,
	24	+ :metric_name=> metric_name
	25	+ })
	26	+ end
	27	+
	28	+end
0	29	\ No newline at end of file
...	...
1	1	class Kalibro::Client::ModuleResultClient
2		-
	2	+
3	3	def initialize
4	4	@port = Kalibro::Client::Port.new('ModuleResult')
5	5	end
...	...	@@ -7,7 +7,7 @@ class Kalibro::Client::ModuleResultClient
7	7	def module_result(project_name, module_name, date)
8	8	hash = @port.request(:get_module_result,
9	9	{:project_name => project_name, :module_name => module_name,
10		- :date => date_with_milliseconds(date)})[:module_result]
	10	+ :date => Kalibro::Entities::Entity.date_with_milliseconds(date)})[:module_result]
11	11	Kalibro::Entities::ModuleResult.from_hash(hash)
12	12	end
13	13
...	...	@@ -16,12 +16,4 @@ class Kalibro::Client::ModuleResultClient
16	16	{:project_name => project_name, :module_name => module_name})[:module_result]
17	17	Kalibro::Entities::Entity.new.to_entity_array(value, Kalibro::Entities::ModuleResult)
18	18	end
19		-
20		- private
21		-
22		- def date_with_milliseconds(date)
23		- milliseconds = "." + (date.sec_fraction * 60 * 60 * 24 * 1000).to_s
24		- date.to_s[0..18] + milliseconds + date.to_s[19..-1]
25		- end
26		-
27		-end
28	19	\ No newline at end of file
	20	+end
...	...
...	...	@@ -7,7 +7,8 @@ end
7	7	class Kalibro::Client::Port
8	8
9	9	def initialize(endpoint)
10		- @client = Savon::Client.new("#{service_address}#{endpoint}Endpoint/?wsdl")
	10	+ @endpoint = endpoint
	11	+ initialize_client
11	12	end
12	13
13	14	def service_address
...	...	@@ -18,9 +19,20 @@ class Kalibro::Client::Port
18	19	@service_address
19	20	end
20	21
	22	+ def service_address=(address)
	23	+ @service_address = address
	24	+ initialize_client
	25	+ end
	26	+
21	27	def request(action, request_body = nil)
22	28	response = @client.request(:kalibro, action) { soap.body = request_body }
23	29	response.to_hash["#{action}_response".to_sym]
24	30	end
25	31
	32	+ private
	33	+
	34	+ def initialize_client
	35	+ @client = Savon::Client.new("#{service_address}#{@endpoint}Endpoint/?wsdl")
	36	+ end
	37	+
26	38	end
...	...
1	1	class Kalibro::Client::ProjectClient
2	2
	3	+ def self.project(project_name)
	4	+ new.project(project_name)
	5	+ end
	6	+
	7	+ def self.save(project_content)
	8	+ project = create_project(project_content)
	9	+ new.save(project)
	10	+ end
	11	+
	12	+ def self.remove(project_name)
	13	+ instance = new
	14	+ if (instance.project_names.include?(project_name))
	15	+ instance.remove(project_name)
	16	+ end
	17	+ end
	18	+
	19	+ def self.create_project (project_content)
	20	+ project = Kalibro::Entities::Project.new
	21	+ project.name = project_content.name
	22	+ project.license = project_content.license
	23	+ project.description = project_content.description
	24	+ project.repository = create_repository(project_content)
	25	+ project.configuration_name = project_content.configuration_name
	26	+ project
	27	+ end
	28	+
	29	+ def self.create_repository(project_content)
	30	+ repository = Kalibro::Entities::Repository.new
	31	+ repository.type = project_content.repository_type
	32	+ repository.address = project_content.repository_url
	33	+ repository
	34	+ end
	35	+
3	36	def initialize
4	37	@port = Kalibro::Client::Port.new('Project')
5	38	end
...	...	@@ -8,16 +41,20 @@ class Kalibro::Client::ProjectClient
8	41	@port.request(:save_project, {:project => project.to_hash})
9	42	end
10	43
11		- def self.save(project)
12		- new.save(project)
13		- end
14		-
15	44	def project_names
16	45	@port.request(:get_project_names)[:project_name].to_a
17	46	end
18	47
19		- def project(name)
20		- hash = @port.request(:get_project, {:project_name => name})[:project]
	48	+ def project(project_name)
	49	+ begin
	50	+ hash = @port.request(:get_project, {:project_name => project_name})[:project]
	51	+ rescue Exception => error
	52	+ unless (error.message =~ /There is no project named/).nil?
	53	+ return nil
	54	+ else
	55	+ raise error
	56	+ end
	57	+ end
21	58	Kalibro::Entities::Project.from_hash(hash)
22	59	end
23	60
...	...	@@ -25,7 +62,4 @@ class Kalibro::Client::ProjectClient
25	62	@port.request(:remove_project, {:project_name => project_name})
26	63	end
27	64
28		- def self.remove(project_name)
29		- new.remove(project_name)
30		- end
31	65	end
...	...