kalibro_entities 0.0.1.rc1

data/features/repository/process.feature

@@ -0,0 +1,16 @@
+Feature: Process
+  In order to be have repositories
+  As a developer
+  I want to start the repository processing
+
+  @kalibro_restart
+  Scenario: With one repository
+    Given I have a project with name "Kalibro"
+    And I have a configuration with name "Java"
+    And I have a reading group with name "Group"
+    And I have a metric configuration within the given configuration
+    And the given project has the following Repositories:
+      |   name    | type |              address                  |
+      |  Kalibro  |  GIT | https://github.com/mezuro/kalibro.git |
+    When I call the process method for the given repository
+    Then I should get success

data/features/repository/types.feature

@@ -0,0 +1,9 @@
+Feature: Types listing
+  In order to be able to create repositories
+  As a developer
+  I want to see all the repository types available
+
+  @kalibro_restart
+  Scenario: listing the types
+    When I list types
+    Then I should get an array of types

data/features/step_definitions/base_tool_steps.rb

@@ -0,0 +1,28 @@
+When(/^I get all base tool names$/) do
+  @base_tool_names = KalibroEntities::Entities::BaseTool.all_names
+end
+
+When(/^I search base tool Analizo by name$/) do
+  @result = KalibroEntities::Entities::BaseTool.find_by_name("Analizo")
+end
+
+When(/^I search base tool Avalio by name$/) do
+  @is_error = false
+  begin 
+  	KalibroEntities::Entities::BaseTool.find_by_name("Avalio")
+	rescue KalibroEntities::Errors::RecordNotFound
+  	@is_error = true 
+  end
+end
+
+Then(/^it should return Checkstyle and Analizo strings inside of an array$/) do
+  (@base_tool_names.include?("Checkstyle") && @base_tool_names.include?("Analizo")).should be_true
+end
+
+Then(/^I should get Analizo base tool$/) do
+  @result.name.should eq "Analizo"
+end
+
+Then(/^I should get an error$/) do
+  @is_error.should be_true
+end

data/features/step_definitions/configuration_steps.rb

@@ -0,0 +1,11 @@
+Given(/^I have a configuration with name "(.*?)"$/) do |name|
+  @configuration = FactoryGirl.create(:configuration, {name: name, id: nil})
+end
+
+When(/^I get all the configurations$/) do
+  @all_configurations = KalibroEntities::Entities::Configuration.all
+end
+
+Then(/^I should get a list with the given configuration$/) do
+  @all_configurations.include?(@configuration)
+end

data/features/step_definitions/metric_configuration_steps.rb

@@ -0,0 +1,52 @@
+Given(/^I have a metric configuration within the given configuration$/) do
+  @metric_configuration = FactoryGirl.create(:metric_configuration,
+                    {id: nil,
+                     reading_group_id: @reading_group.id,
+                     configuration_id: @configuration.id})
+end
+
+Given(/^I have a metric configuration within the given configuration with the given metric$/) do
+  @metric_configuration = FactoryGirl.create(:metric_configuration,
+                    {id: nil,
+                     metric: @metric,
+                     reading_group_id: @reading_group.id,
+                     configuration_id: @configuration.id})
+end
+
+Given(/^I have a loc configuration within the given configuration$/) do
+  @metric_configuration = FactoryGirl.create(:metric_configuration,
+                    {id: nil,
+                     metric: FactoryGirl.create(:loc),
+                     reading_group_id: @reading_group.id,
+                     configuration_id: @configuration.id})
+end
+
+When(/^I search a metric configuration with the same id of the given metric configuration$/) do
+  @found_metric_configuration = KalibroEntities::Entities::MetricConfiguration.find(@metric_configuration.id)
+end
+
+When(/^I search an inexistent metric configuration$/) do
+  @is_error = false
+  inexistent_id = rand(Time.now.to_i)
+  begin
+  	KalibroEntities::Entities::MetricConfiguration.find(inexistent_id)
+  rescue KalibroEntities::Errors::RecordNotFound
+  	@is_error = true
+  end
+end
+
+When(/^I request all metric configurations of the given configuration$/) do
+  @metric_configurations = KalibroEntities::Entities::MetricConfiguration.metric_configurations_of(@configuration.id)
+end
+
+Then(/^it should return the same metric configuration as the given one$/) do
+  @found_metric_configuration == @metric_configuration
+end
+
+Then(/^I should get a list of its metric configurations$/) do
+  @metric_configurations == [@metric_configuration]
+end
+
+Then(/^I should get an empty list of metric configurations$/) do
+  @metric_configurations == []
+end

data/features/step_definitions/metric_result_steps.rb

@@ -0,0 +1,29 @@
+When(/^I call the metric results of method with the results root id of the given processing$/) do
+  @response = KalibroEntities::Entities::MetricResult.metric_results_of(@response.results_root_id)
+end
+
+Given(/^I search a metric result with descendant results for the given metric result$/) do
+  first_module_result = KalibroEntities::Entities::ModuleResult.find(@response.results_root_id)
+
+  metric_results = KalibroEntities::Entities::MetricResult.metric_results_of(first_module_result.id)
+  @response = metric_results.first.descendant_results
+end
+
+When(/^I call the history of method with the metric name and the results root id of the given processing$/) do
+  @response = KalibroEntities::Entities::MetricResult.history_of(@metric.name, @response.results_root_id)
+end
+
+Then (/^I should get a Float list$/) do
+  @response.should be_a(Array)
+  @response.first.should be_a(Float)
+end
+
+Then(/^I should get a list of metric results$/) do
+  @response.should be_a(Array)
+  @response.first.should be_a(KalibroEntities::Entities::MetricResult)
+end
+
+Then(/^I should get a list of date metric results$/) do
+  @response.should be_a(Array)
+  @response.first.should be_a(KalibroEntities::Entities::DateMetricResult)
+end

data/features/step_definitions/metric_steps.rb

@@ -0,0 +1,3 @@
+Given(/^I have a metric with name "(.*?)"$/) do |name|
+  @metric = FactoryGirl.create(:metric, {name: name})
+end

data/features/step_definitions/module_result_steps.rb

@@ -0,0 +1,30 @@
+Given(/^I have a module result$/) do
+  Pending
+  @module_result = FactoryGirl.create(:module_result)
+end
+
+When(/^I ask a module result with the same id of the given module result$/) do
+  @found_module_result = KalibroEntities::Entities::ModuleResult.find(@module_result.id)
+end
+
+When(/^I ask for an inexistent module result$/) do
+  @is_error = false
+  begin
+    KalibroEntities::Entities::ModuleResult.find(-1)
+  rescue KalibroEntities::Errors::RecordNotFound
+    @is_error = true
+  end
+end
+
+Then(/^I should get the given module result$/) do
+  @found_module_result == @module_result
+end
+
+When(/^I ask for the children of the processing root module result$/) do
+  @children = KalibroEntities::Entities::ModuleResult.
+    find(KalibroEntities::Entities::Processing.processing_of(@repository.id).results_root_id)
+end
+
+Then(/^I should get a list with the children module results$/) do
+  @children.should be_a(KalibroEntities::Entities::ModuleResult)
+end

data/features/step_definitions/processing_steps.rb

@@ -0,0 +1,91 @@
+Given(/^I wait up to (\d+) seconds$/) do |seconds|
+  sleep(seconds.to_i)
+end
+
+Given(/^I wait up for a ready processing$/) do
+  unless KalibroEntities::Entities::Processing.has_ready_processing(@repository.id)
+    while(true)
+      if KalibroEntities::Entities::Processing.has_ready_processing(@repository.id)
+        break
+      else
+        sleep(10)
+      end
+    end
+  end
+end
+
+When(/^I call the has_processing for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.has_processing(@repository.id)
+end
+
+When(/^I call the has_ready_processing for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.has_ready_processing(@repository.id)
+end
+
+When(/^I call the has_processing_after for the given repository with yerterday's date$/) do
+  @response = KalibroEntities::Entities::Processing.has_processing_after(@repository.id, DateTime.now - 1)
+end
+
+When(/^I call the has_processing_before for the given repository with tomorrows's date$/) do
+  @response = KalibroEntities::Entities::Processing.has_processing_before(@repository.id, DateTime.now + 1)
+end
+
+When(/^I call the last_processing_state_of method for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.last_processing_state_of(@repository.id)
+end
+
+When(/^I call the last_ready_processing_of method for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.last_ready_processing_of(@repository.id)
+end
+
+When(/^I call the first_processing_of method for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.first_processing_of(@repository.id)
+end
+
+When(/^I call the last_processing_of method for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.last_processing_of(@repository.id)
+end
+
+When(/^I call the first_processing_after method for the given repository and yesterday's date$/) do
+  @response = KalibroEntities::Entities::Processing.first_processing_after(@repository.id, DateTime.now - 1)
+end
+
+When(/^I call the last_processing_before method for the given repository and tomorrow's date$/) do
+  @response = KalibroEntities::Entities::Processing.last_processing_before(@repository.id, DateTime.now + 1)
+end
+
+When(/^I call the processing_of method for the given repository$/) do
+  @response = KalibroEntities::Entities::Processing.processing_of(@repository.id)
+end
+
+When(/^I call the processing_with_date_of method for the given repository and tomorrow's date$/) do
+  @response = KalibroEntities::Entities::Processing.processing_with_date_of(@repository.id, DateTime.now + 1)
+end
+
+When(/^I call the processing_with_date_of method for the given repository and yesterday's date$/) do
+  @response = KalibroEntities::Entities::Processing.processing_with_date_of(@repository.id, DateTime.now - 1)
+end
+
+Then(/^I should get a Processing with state "(.*?)"$/) do |state|
+  @response.state.should eq(state)
+end
+
+Then(/^I should get nil$/) do
+  @response.should be_nil
+end
+
+Then(/^I should get "(.*?)"$/) do |state|
+  @response.should eq(state)
+end
+
+Then(/^I should get false$/) do
+  @response.should be_false
+end
+
+Then(/^I should get true$/) do
+  @response.should be_true
+end
+
+Then(/^I should get a Processing$/) do
+  @response.should be_a(KalibroEntities::Entities::Processing)
+end

data/features/step_definitions/project_steps.rb

@@ -0,0 +1,48 @@
+Given(/^I have a project$/) do
+  @project = FactoryGirl.build(:project)
+end
+
+Given(/^the project name is "(.*?)"$/) do |name|
+  @project.name = name
+end
+
+Given(/^I have a project with name "(.*?)"$/) do |name|
+  @project = FactoryGirl.create(:project, {name: name, id: nil})
+end
+
+When(/^I save the project$/) do
+  @project.save
+end
+
+When(/^I create the project with name "(.*?)"$/) do |name|
+  @project = FactoryGirl.create(:project, {name: name, id: nil})
+end
+
+When(/^I search a project with the same id of the given project$/) do
+  @found_project = KalibroEntities::Entities::Project.find(@project.id)
+end
+
+When(/^I destroy the project with the same id of the given project$/) do
+  @found_project = KalibroEntities::Entities::Project.find(@project.id)
+  @found_project.destroy
+end
+
+When(/^I ask for all the projects$/) do
+  @all_projects = KalibroEntities::Entities::Project.all
+end
+
+Then(/^the project should exist$/) do
+  KalibroEntities::Entities::Project.exists?(@project.id)
+end
+
+Then(/^it should return the same project as the given one$/) do
+  @found_project == @project
+end
+
+Then(/^the project should not exist$/) do
+  !KalibroEntities::Entities::Project.exists?(@found_project.id)
+end
+
+Then(/^I should get a list with the given project$/) do
+  @all_projects.include?(@project)
+end

data/features/step_definitions/range_steps.rb

@@ -0,0 +1,41 @@
+Given(/^I have a range within the given reading$/) do
+  @range = FactoryGirl.build(:range, {id: nil, reading_id: @reading.id})
+  @range.save @metric_configuration.id
+end
+
+Given(/^I have an unsaved range$/) do
+  @range = FactoryGirl.build(:range, {id: nil})
+end
+
+Given(/^I have an unsaved range within the given reading$/) do
+  @range = FactoryGirl.build(:range, {id: nil, reading_id: @reading.id})
+end
+
+When(/^I ask to save the given range$/) do
+  @range.save @metric_configuration.id
+end
+
+When(/^I ask to save the given range with an inexistent metric configuration$/) do
+  @range.save rand(Time.now.to_i)
+end
+
+When(/^I ask ranges of the given metric configuration$/) do
+  @response = KalibroEntities::Entities::Range.ranges_of @metric_configuration.id
+end
+
+Then(/^I should get an empty list$/) do
+  @response.should eq([])
+end
+
+Then(/^I should get a list with the given range$/) do
+  @response.size.should eq(1)
+  @response.first.comments.should eq(@range.comments)
+end
+
+Then(/^I should get an error in range kalibro errors attribute$/) do
+  @range.kalibro_errors.should_not eq([])
+end
+
+Then(/^the id of the given range should be set$/) do
+ @range.id.should_not eq(0)
+end

data/features/step_definitions/reading_group_steps.rb

@@ -0,0 +1,19 @@
+Given(/^I have a reading group with name "(.*?)"$/) do |name|
+  @reading_group = FactoryGirl.create(:reading_group, {id: nil, name: name})
+end
+
+When(/^I ask for all the reading groups$/) do
+  @all_reading_groups = KalibroEntities::Entities::ReadingGroup.all
+end
+
+When(/^I call the reading_group_of method for the given MetricConfiguration$/) do
+  @metric_configuration_reading_group = KalibroEntities::Entities::ReadingGroup.reading_group_of(@metric_configuration.id)
+end
+
+Then(/^I should get a list with the given reading group$/) do
+   @all_reading_groups.include?(@reading_group)
+end
+
+Then(/^I should get the given RedingGroup$/) do
+  @metric_configuration_reading_group.should eq(@reading_group)  
+end

data/features/step_definitions/reading_steps.rb

@@ -0,0 +1,20 @@
+Given(/^I have a reading within the given reading group$/) do
+  @reading = FactoryGirl.create(:reading, {id: nil, group_id: @reading_group.id})
+end
+
+When(/^I ask for a reading with the same id of the given reading$/) do
+  @found_reading = KalibroEntities::Entities::Reading.find @reading.id
+end
+
+When(/^I ask for the readings of the given reading group$/) do
+  @found_readings = KalibroEntities::Entities::Reading.readings_of @reading_group.id
+end
+
+Then(/^I should get the given reading$/) do
+  @found_reading == @reading
+end
+
+Then(/^I should get a list with the given reading$/) do
+  @found_readings.first == @reading
+end
+

data/features/step_definitions/repository_steps.rb

@@ -0,0 +1,57 @@
+Given(/^the given project has the following Repositories:$/) do |table|
+  hash = table.hashes.first
+  hash[:project_id] = @project.id
+  hash[:configuration_id] = @configuration.id
+  hash[:id] = nil
+
+  @repository = FactoryGirl.create(:repository, hash)
+end
+
+When(/^I call the cancel_process method for the given repository$/) do
+  @response = @repository.cancel_processing_of_repository
+end
+
+When(/^I ask for repositories from the given project$/) do
+  @response = KalibroEntities::Entities::Repository.repositories_of(@project.id)
+end
+
+When(/^I call the process method for the given repository$/) do
+  @response = @repository.process
+end
+
+When(/^I list types$/) do
+  @repository_types = KalibroEntities::Entities::Repository.repository_types
+end
+
+When(/^I ask for all the repositories$/) do
+  @response = KalibroEntities::Entities::Repository.all
+end
+
+When(/^I ask to find the given repository$/) do
+  @response = KalibroEntities::Entities::Repository.find(@repository.id)
+end
+
+Then(/^I should get success$/) do
+  @response == true
+end
+
+Then(/^I should get a list with the given repository$/) do
+  @response.should include(@repository)
+end
+
+Then(/^I should get an array of types$/) do
+  @repository_types.is_a?(Array)
+  @repository_types.count >= 1
+end
+
+Then(/^I should get the given repository$/) do
+  @response.should eq(@repository)
+end
+
+Then(/^the response should contain the given repository$/) do
+  @response.first.project_id.should eq(@project.id)
+end
+
+Then(/^the repositories should contain the project id$/) do
+  @response.first.project_id.should eq(@project.id)
+end