[Mezuro] Finished refactoring project result model to processing model.

Diego Camarinha · João M. M. da Silva
1 parent 8bfb7c93
Showing 6 changed files with 201 additions and 223 deletions Show diff stats
plugins/mezuro/lib/kalibro/processing.rb
plugins/mezuro/lib/kalibro/project_result.rb
plugins/mezuro/test/fixtures/processing_fixtures.rb
plugins/mezuro/test/fixtures/project_result_fixtures.rb
plugins/mezuro/test/unit/kalibro/processing_test.rb
plugins/mezuro/test/unit/kalibro/project_result_test.rb
@@ -0,0 +1,49 @@
+class Kalibro::Processing < Kalibro::Model
+
+  attr_accessor :id, :date, :state, :error, :process_times, :results_root_id
+
+  def self.has_processing(repository_id)
+    request('Processing', :has_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_ready_processing(repository_id)
+    request('Processing', :has_ready_processing, {:repository_id => repository_id})[:exists]
+  end
+  
+  def self.has_processing_after(repository_id, date)
+    request('Processing', :has_processing_after, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.has_processing_before(repository_id, date)
+    request('Processing', :has_processing_before, {:repository_id => repository_id, :date => date})[:exists]
+  end
+
+  def self.last_processing_state_of(repository_id)
+    request('Processing', :last_processing_state, {:repository_id => repository_id})[:process_state]
+  end
+  
+  def self.last_ready_processing_of(repository_id)
+    new request('Processing', :last_ready_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_of(repository_id)
+    new request('Processing', :first_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.last_processing_of(repository_id)
+    new request('Processing', :last_processing, {:repository_id => repository_id})[:processing]
+  end
+
+  def self.first_processing_after(repository_id, date)
+    new request('Processing', :first_processing_after, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+  def self.last_processing_before(repository_id, date)
+    new request('Processing', :last_processing_before, {:repository_id => repository_id, :date => date})[:processing]
+  end
+
+  def date=(value)
+    @date = value.is_a?(String) ? DateTime.parse(value) : value
+  end
+
+end
@@ -1,100 +0,0 @@
-class Kalibro::ProjectResult < Kalibro::Model
-
-  attr_accessor :project, :date, :load_time, :analysis_time, :source_tree, :collect_time
-
-  def self.last_result(project_name)
-    new request('ProjectResult', :get_last_result_of, {:project_name => project_name})[:project_result]
-  end
-  
-  def self.first_result(project_name)
-    new request('ProjectResult', :get_first_result_of, {:project_name => project_name})[:project_result]
-  end
-
-  def self.first_result_after(project_name, date)
-    new request('ProjectResult', :get_first_result_after, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.last_result_before(project_name, date)
-    new request('ProjectResult', :get_last_result_before, {:project_name => project_name, :date => date})[:project_result]
-  end
-
-  def self.has_results?(project_name)
-    request('ProjectResult', :has_results_for, {:project_name => project_name})[:has_results]
-  end
-  
-  def self.has_results_before?(project_name, date)
-    request('ProjectResult', :has_results_before, {:project_name => project_name, :date => date})[:has_results]
-  end
-
-  def self.has_results_after?(project_name, date)
-    request('ProjectResult', :has_results_after, {:project_name => project_name, :date => date})[:has_results]
-  end
-  
-  def project=(value)
-    @project = (value.kind_of?(Hash)) ? Kalibro::Project.new(value) : value
-  end
-  
-  def date=(value)
-    @date = value.is_a?(String) ? DateTime.parse(value) : value
-  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 = value.kind_of?(Hash) ? Kalibro::ModuleNode.new(value) : value
-  end
-  
-  def formatted_load_time
-    format_milliseconds(@load_time)
-  end
-
-  def formatted_analysis_time
-     format_milliseconds(@analysis_time)
-  end
-
-  def format_milliseconds(value)
-    seconds = value.to_i/1000
-    hours = seconds/3600
-    seconds -= hours * 3600
-    minutes = seconds/60
-    seconds -= minutes * 60
-    "#{format(hours)}:#{format(minutes)}:#{format(seconds)}"
-  end
-
-  def format(amount)
-    ('%2d' % amount).sub(/\s/, '0')
-  end
-  
-  def node(module_name)
-    if module_name.nil? or module_name == project.name
-      node = source_tree
-    else
-		path = Kalibro::Module.parent_names(module_name)
-		parent = @source_tree
-		path.each do |node_name|
-		  parent = get_leaf_from(parent, node_name)
-		end
-		parent
-	end
-  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
@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/process_time_fixtures'
+
+class ProcessingFixtures
+
+  def self.processing
+    Kalibro::Processing.new processing_hash  
+  end
+
+  def self.processing_hash
+    {
+      :id => 31,
+      :date => '2011-10-20T18:26:43.151+00:00',
+      :state => 'READY',
+      :process_times => [ProcessTimeFixtures.process_time_hash],
+      :results_root_id => 13  
+    }
+  end
+    
+end
@@ -1,35 +0,0 @@
-require File.dirname(__FILE__) + '/project_fixtures'
-require File.dirname(__FILE__) + '/module_node_fixtures'
-require File.dirname(__FILE__) + '/module_result_fixtures'
-
-class ProjectResultFixtures
-
-  def self.project_result
-    Kalibro::ProjectResult.new project_result_hash  
-  end
-
-  def self.project_result_hash
-    {
-      :project => ProjectFixtures.project_hash,
-      :date => ModuleResultFixtures.module_result_hash[:date],
-      :load_time => 14878,
-      :analysis_time => 1022,
-      :source_tree => ModuleNodeFixtures.module_node_hash, 
-      :collect_time => 14878,
-      :attributes! =>
-      {
-        :source_tree =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:moduleNodeXml"
-        },
-        :project =>
-        {
-          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
-          "xsi:type"=>"kalibro:projectXml"
-        }
-      }
-    }
-  end
-    
-end
@@ -0,0 +1,133 @@
+require "test_helper"
+
+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
+
+class ProcessingTest < ActiveSupport::TestCase
+
+  def setup
+    @hash = ProcessingFixtures.processing_hash
+    @processing = ProcessingFixtures.processing
+    
+    @repository_id = 31
+    
+=begin
+    @project_name = @processing.project.name
+    @date = @processing.date
+    @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
+
+    @request = {:project_name => @project_name}
+    @request_with_date = {:project_name => @project_name, :date => @date}
+    @flag_response = {:has_results => @flag}
+    @result_response = {:processing => @processing.to_hash}
+=end
+  end
+
+  should 'create project result from hash' do
+    assert_equal @processing.results_root_id, Kalibro::Processing.new(@hash).results_root_id
+  end
+
+  should 'convert project result to hash' do
+    assert_equal @hash, @processing.to_hash
+  end
+
+  should 'verify if a repository has a processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing(true_repository_id)
+    assert !Kalibro::Processing.has_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a ready processing' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => true_repository_id}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => false_repository_id}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_ready_processing(true_repository_id)
+    assert !Kalibro::Processing.has_ready_processing(false_repository_id)
+  end
+  
+  should 'verify if a repository has a processing after a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_after(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_after(false_repository_id, @processing.date)
+  end  
+  
+  should 'verify if a repository has a processing before a date' do
+    true_repository_id = 31
+    false_repository_id = 32
+    
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
+    Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
+    
+    assert Kalibro::Processing.has_processing_before(true_repository_id, @processing.date)
+    assert !Kalibro::Processing.has_processing_before(false_repository_id, @processing.date)
+  end  
+  
+  should 'get last processing state of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing',:last_processing_state, {:repository_id => @repository_id}).returns({:process_state => @processing.state})
+    assert_equal @processing.state, Kalibro::Processing.last_processing_state_of(@repository_id)
+  end
+  
+  should 'get last ready processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_ready_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_ready_processing_of(@repository_id).id
+  end
+
+  should 'get first processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :first_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_of(@repository_id).id
+  end
+  
+  should 'get last processing of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_of(@repository_id).id
+  end
+  
+  should 'get first processing after a date of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :first_processing_after, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.first_processing_after(@repository_id, @processing.date).id
+  end
+  
+  should 'get last processing before a date of a repository' do
+    Kalibro::Processing.expects(:request).with('Processing', :last_processing_before, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
+    assert_equal @processing.id, Kalibro::Processing.last_processing_before(@repository_id, @processing.date).id
+  end
+  
+=begin
+
+  should 'retrieve formatted load time' do
+    assert_equal '00:00:14', @processing.formatted_load_time
+  end
+
+  should 'retrieve formatted analysis time' do
+    assert_equal '00:00:01', @processing.formatted_analysis_time
+  end
+
+  should 'retrive complex module' do
+    assert_equal @hash[:source_tree][:child][0][:child].first, @processing.node("org.Window").to_hash
+  end
+
+  should 'return source tree node when nil is given' do
+    assert_equal @hash[:source_tree], @processing.node(nil).to_hash 
+  end
+  
+  should 'return source tree node when project name is given' do
+    assert_equal @hash[:source_tree], @processing.node(@processing.project.name).to_hash 
+  end
+
+  should 'return correct node when module name is given' do
+    assert_equal @hash[:source_tree][:child][2], @processing.node("main").to_hash
+  end
+=end
+end
@@ -1,88 +0,0 @@
-require "test_helper"
-
-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
-
-class ProjectResultTest < ActiveSupport::TestCase
-
-  def setup
-    @hash = ProjectResultFixtures.project_result_hash
-    @project_result = ProjectResultFixtures.project_result
-    
-    @project_name = @project_result.project.name
-    @date = @project_result.date
-    @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
-
-    @request = {:project_name => @project_name}
-    @request_with_date = {:project_name => @project_name, :date => @date}
-    @flag_response = {:has_results => @flag}
-    @result_response = {:project_result => @project_result.to_hash}
-  end
-
-  should 'create project result from hash' do
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.new(@hash).analysis_time
-  end
-
-  should 'convert project result to hash' do
-    assert_equal @hash, @project_result.to_hash
-  end
-
-  should 'get last result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time , Kalibro::ProjectResult.last_result(@project_name).analysis_time
-  end
-
-  should 'get first result' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_of, @request).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result(@project_name).analysis_time
-  end
-
-  should 'get first result after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_after, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result_after(@project_name, @date).analysis_time
-  end
-  
-  should 'get last result before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_before, @request_with_date).returns(@result_response)
-    assert_equal @project_result.analysis_time, Kalibro::ProjectResult.last_result_before(@project_name, @date).analysis_time
-  end
-  
-  should 'verify if project has results' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_for, @request).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results?(@project_name)
-  end
-  
-  should 'verify if project has results before date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_before, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_before?(@project_name, @date)
-  end
-  
-  should 'verify if project has results after date' do
-    Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_after, @request_with_date).returns(@flag_response)
-    assert_equal @flag, Kalibro::ProjectResult.has_results_after?(@project_name, @date)
-  end
-
-  should 'retrieve formatted load time' do
-    assert_equal '00:00:14', @project_result.formatted_load_time
-  end
-
-  should 'retrieve formatted analysis time' do
-    assert_equal '00:00:01', @project_result.formatted_analysis_time
-  end
-
-  should 'retrive complex module' do
-    assert_equal @hash[:source_tree][:child][0][:child].first, @project_result.node("org.Window").to_hash
-  end
-
-  should 'return source tree node when nil is given' do
-    assert_equal @hash[:source_tree], @project_result.node(nil).to_hash 
-  end
-  
-  should 'return source tree node when project name is given' do
-    assert_equal @hash[:source_tree], @project_result.node(@project_result.project.name).to_hash 
-  end
-
-  should 'return correct node when module name is given' do
-    assert_equal @hash[:source_tree][:child][2], @project_result.node("main").to_hash
-  end
-
-end
@@ -0,0 +1,49 @@		@@ -0,0 +1,49 @@
	1	+class Kalibro::Processing < Kalibro::Model
	2	+
	3	+ attr_accessor :id, :date, :state, :error, :process_times, :results_root_id
	4	+
	5	+ def self.has_processing(repository_id)
	6	+ request('Processing', :has_processing, {:repository_id => repository_id})[:exists]
	7	+ end
	8	+
	9	+ def self.has_ready_processing(repository_id)
	10	+ request('Processing', :has_ready_processing, {:repository_id => repository_id})[:exists]
	11	+ end
	12	+
	13	+ def self.has_processing_after(repository_id, date)
	14	+ request('Processing', :has_processing_after, {:repository_id => repository_id, :date => date})[:exists]
	15	+ end
	16	+
	17	+ def self.has_processing_before(repository_id, date)
	18	+ request('Processing', :has_processing_before, {:repository_id => repository_id, :date => date})[:exists]
	19	+ end
	20	+
	21	+ def self.last_processing_state_of(repository_id)
	22	+ request('Processing', :last_processing_state, {:repository_id => repository_id})[:process_state]
	23	+ end
	24	+
	25	+ def self.last_ready_processing_of(repository_id)
	26	+ new request('Processing', :last_ready_processing, {:repository_id => repository_id})[:processing]
	27	+ end
	28	+
	29	+ def self.first_processing_of(repository_id)
	30	+ new request('Processing', :first_processing, {:repository_id => repository_id})[:processing]
	31	+ end
	32	+
	33	+ def self.last_processing_of(repository_id)
	34	+ new request('Processing', :last_processing, {:repository_id => repository_id})[:processing]
	35	+ end
	36	+
	37	+ def self.first_processing_after(repository_id, date)
	38	+ new request('Processing', :first_processing_after, {:repository_id => repository_id, :date => date})[:processing]
	39	+ end
	40	+
	41	+ def self.last_processing_before(repository_id, date)
	42	+ new request('Processing', :last_processing_before, {:repository_id => repository_id, :date => date})[:processing]
	43	+ end
	44	+
	45	+ def date=(value)
	46	+ @date = value.is_a?(String) ? DateTime.parse(value) : value
	47	+ end
	48	+
	49	+end
	@@ -1,100 +0,0 @@	@@ -1,100 +0,0 @@
1	-class Kalibro::ProjectResult < Kalibro::Model
2	-
3	- attr_accessor :project, :date, :load_time, :analysis_time, :source_tree, :collect_time
4	-
5	- def self.last_result(project_name)
6	- new request('ProjectResult', :get_last_result_of, {:project_name => project_name})[:project_result]
7	- end
8	-
9	- def self.first_result(project_name)
10	- new request('ProjectResult', :get_first_result_of, {:project_name => project_name})[:project_result]
11	- end
12	-
13	- def self.first_result_after(project_name, date)
14	- new request('ProjectResult', :get_first_result_after, {:project_name => project_name, :date => date})[:project_result]
15	- end
16	-
17	- def self.last_result_before(project_name, date)
18	- new request('ProjectResult', :get_last_result_before, {:project_name => project_name, :date => date})[:project_result]
19	- end
20	-
21	- def self.has_results?(project_name)
22	- request('ProjectResult', :has_results_for, {:project_name => project_name})[:has_results]
23	- end
24	-
25	- def self.has_results_before?(project_name, date)
26	- request('ProjectResult', :has_results_before, {:project_name => project_name, :date => date})[:has_results]
27	- end
28	-
29	- def self.has_results_after?(project_name, date)
30	- request('ProjectResult', :has_results_after, {:project_name => project_name, :date => date})[:has_results]
31	- end
32	-
33	- def project=(value)
34	- @project = (value.kind_of?(Hash)) ? Kalibro::Project.new(value) : value
35	- end
36	-
37	- def date=(value)
38	- @date = value.is_a?(String) ? DateTime.parse(value) : value
39	- end
40	-
41	- def load_time=(value)
42	- @load_time = value.to_i
43	- end
44	-
45	- def collect_time=(value)
46	- @collect_time = value.to_i
47	- end
48	-
49	- def analysis_time=(value)
50	- @analysis_time = value.to_i
51	- end
52	-
53	- def source_tree=(value)
54	- @source_tree = value.kind_of?(Hash) ? Kalibro::ModuleNode.new(value) : value
55	- end
56	-
57	- def formatted_load_time
58	- format_milliseconds(@load_time)
59	- end
60	-
61	- def formatted_analysis_time
62	- format_milliseconds(@analysis_time)
63	- end
64	-
65	- def format_milliseconds(value)
66	- seconds = value.to_i/1000
67	- hours = seconds/3600
68	- seconds -= hours * 3600
69	- minutes = seconds/60
70	- seconds -= minutes * 60
71	- "#{format(hours)}:#{format(minutes)}:#{format(seconds)}"
72	- end
73	-
74	- def format(amount)
75	- ('%2d' % amount).sub(/\s/, '0')
76	- end
77	-
78	- def node(module_name)
79	- if module_name.nil? or module_name == project.name
80	- node = source_tree
81	- else
82	- path = Kalibro::Module.parent_names(module_name)
83	- parent = @source_tree
84	- path.each do \|node_name\|
85	- parent = get_leaf_from(parent, node_name)
86	- end
87	- parent
88	- end
89	- end
90	-
91	- private
92	-
93	- def get_leaf_from(node, module_name)
94	- node.children.each do \|child_node\|
95	- return child_node if child_node.module.name == module_name
96	- end
97	- nil
98	- end
99	-
100	-end
@@ -0,0 +1,19 @@		@@ -0,0 +1,19 @@
	1	+require File.dirname(__FILE__) + '/process_time_fixtures'
	2	+
	3	+class ProcessingFixtures
	4	+
	5	+ def self.processing
	6	+ Kalibro::Processing.new processing_hash
	7	+ end
	8	+
	9	+ def self.processing_hash
	10	+ {
	11	+ :id => 31,
	12	+ :date => '2011-10-20T18:26:43.151+00:00',
	13	+ :state => 'READY',
	14	+ :process_times => [ProcessTimeFixtures.process_time_hash],
	15	+ :results_root_id => 13
	16	+ }
	17	+ end
	18	+
	19	+end
	@@ -1,35 +0,0 @@	@@ -1,35 +0,0 @@
1	-require File.dirname(__FILE__) + '/project_fixtures'
2	-require File.dirname(__FILE__) + '/module_node_fixtures'
3	-require File.dirname(__FILE__) + '/module_result_fixtures'
4	-
5	-class ProjectResultFixtures
6	-
7	- def self.project_result
8	- Kalibro::ProjectResult.new project_result_hash
9	- end
10	-
11	- def self.project_result_hash
12	- {
13	- :project => ProjectFixtures.project_hash,
14	- :date => ModuleResultFixtures.module_result_hash[:date],
15	- :load_time => 14878,
16	- :analysis_time => 1022,
17	- :source_tree => ModuleNodeFixtures.module_node_hash,
18	- :collect_time => 14878,
19	- :attributes! =>
20	- {
21	- :source_tree =>
22	- {
23	- "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
24	- "xsi:type"=>"kalibro:moduleNodeXml"
25	- },
26	- :project =>
27	- {
28	- "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
29	- "xsi:type"=>"kalibro:projectXml"
30	- }
31	- }
32	- }
33	- end
34	-
35	-end
@@ -0,0 +1,133 @@		@@ -0,0 +1,133 @@
	1	+require "test_helper"
	2	+
	3	+require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/processing_fixtures"
	4	+
	5	+class ProcessingTest < ActiveSupport::TestCase
	6	+
	7	+ def setup
	8	+ @hash = ProcessingFixtures.processing_hash
	9	+ @processing = ProcessingFixtures.processing
	10	+
	11	+ @repository_id = 31
	12	+
	13	+=begin
	14	+ @project_name = @processing.project.name
	15	+ @date = @processing.date
	16	+ @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
	17	+
	18	+ @request = {:project_name => @project_name}
	19	+ @request_with_date = {:project_name => @project_name, :date => @date}
	20	+ @flag_response = {:has_results => @flag}
	21	+ @result_response = {:processing => @processing.to_hash}
	22	+=end
	23	+ end
	24	+
	25	+ should 'create project result from hash' do
	26	+ assert_equal @processing.results_root_id, Kalibro::Processing.new(@hash).results_root_id
	27	+ end
	28	+
	29	+ should 'convert project result to hash' do
	30	+ assert_equal @hash, @processing.to_hash
	31	+ end
	32	+
	33	+ should 'verify if a repository has a processing' do
	34	+ true_repository_id = 31
	35	+ false_repository_id = 32
	36	+
	37	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => true_repository_id}).returns({:exists => true})
	38	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing, {:repository_id => false_repository_id}).returns({:exists => false})
	39	+
	40	+ assert Kalibro::Processing.has_processing(true_repository_id)
	41	+ assert !Kalibro::Processing.has_processing(false_repository_id)
	42	+ end
	43	+
	44	+ should 'verify if a repository has a ready processing' do
	45	+ true_repository_id = 31
	46	+ false_repository_id = 32
	47	+
	48	+ Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => true_repository_id}).returns({:exists => true})
	49	+ Kalibro::Processing.expects(:request).with('Processing',:has_ready_processing, {:repository_id => false_repository_id}).returns({:exists => false})
	50	+
	51	+ assert Kalibro::Processing.has_ready_processing(true_repository_id)
	52	+ assert !Kalibro::Processing.has_ready_processing(false_repository_id)
	53	+ end
	54	+
	55	+ should 'verify if a repository has a processing after a date' do
	56	+ true_repository_id = 31
	57	+ false_repository_id = 32
	58	+
	59	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
	60	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing_after, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
	61	+
	62	+ assert Kalibro::Processing.has_processing_after(true_repository_id, @processing.date)
	63	+ assert !Kalibro::Processing.has_processing_after(false_repository_id, @processing.date)
	64	+ end
	65	+
	66	+ should 'verify if a repository has a processing before a date' do
	67	+ true_repository_id = 31
	68	+ false_repository_id = 32
	69	+
	70	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => true_repository_id, :date => @processing.date}).returns({:exists => true})
	71	+ Kalibro::Processing.expects(:request).with('Processing',:has_processing_before, {:repository_id => false_repository_id, :date => @processing.date}).returns({:exists => false})
	72	+
	73	+ assert Kalibro::Processing.has_processing_before(true_repository_id, @processing.date)
	74	+ assert !Kalibro::Processing.has_processing_before(false_repository_id, @processing.date)
	75	+ end
	76	+
	77	+ should 'get last processing state of a repository' do
	78	+ Kalibro::Processing.expects(:request).with('Processing',:last_processing_state, {:repository_id => @repository_id}).returns({:process_state => @processing.state})
	79	+ assert_equal @processing.state, Kalibro::Processing.last_processing_state_of(@repository_id)
	80	+ end
	81	+
	82	+ should 'get last ready processing of a repository' do
	83	+ Kalibro::Processing.expects(:request).with('Processing', :last_ready_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
	84	+ assert_equal @processing.id, Kalibro::Processing.last_ready_processing_of(@repository_id).id
	85	+ end
	86	+
	87	+ should 'get first processing of a repository' do
	88	+ Kalibro::Processing.expects(:request).with('Processing', :first_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
	89	+ assert_equal @processing.id, Kalibro::Processing.first_processing_of(@repository_id).id
	90	+ end
	91	+
	92	+ should 'get last processing of a repository' do
	93	+ Kalibro::Processing.expects(:request).with('Processing', :last_processing, {:repository_id => @repository_id}).returns({:processing => @hash})
	94	+ assert_equal @processing.id, Kalibro::Processing.last_processing_of(@repository_id).id
	95	+ end
	96	+
	97	+ should 'get first processing after a date of a repository' do
	98	+ Kalibro::Processing.expects(:request).with('Processing', :first_processing_after, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
	99	+ assert_equal @processing.id, Kalibro::Processing.first_processing_after(@repository_id, @processing.date).id
	100	+ end
	101	+
	102	+ should 'get last processing before a date of a repository' do
	103	+ Kalibro::Processing.expects(:request).with('Processing', :last_processing_before, {:repository_id => @repository_id, :date => @processing.date}).returns({:processing => @hash})
	104	+ assert_equal @processing.id, Kalibro::Processing.last_processing_before(@repository_id, @processing.date).id
	105	+ end
	106	+
	107	+=begin
	108	+
	109	+ should 'retrieve formatted load time' do
	110	+ assert_equal '00:00:14', @processing.formatted_load_time
	111	+ end
	112	+
	113	+ should 'retrieve formatted analysis time' do
	114	+ assert_equal '00:00:01', @processing.formatted_analysis_time
	115	+ end
	116	+
	117	+ should 'retrive complex module' do
	118	+ assert_equal @hash[:source_tree][:child][0][:child].first, @processing.node("org.Window").to_hash
	119	+ end
	120	+
	121	+ should 'return source tree node when nil is given' do
	122	+ assert_equal @hash[:source_tree], @processing.node(nil).to_hash
	123	+ end
	124	+
	125	+ should 'return source tree node when project name is given' do
	126	+ assert_equal @hash[:source_tree], @processing.node(@processing.project.name).to_hash
	127	+ end
	128	+
	129	+ should 'return correct node when module name is given' do
	130	+ assert_equal @hash[:source_tree][:child][2], @processing.node("main").to_hash
	131	+ end
	132	+=end
	133	+end
	@@ -1,88 +0,0 @@	@@ -1,88 +0,0 @@
1	-require "test_helper"
2	-
3	-require "#{RAILS_ROOT}/plugins/mezuro/test/fixtures/project_result_fixtures"
4	-
5	-class ProjectResultTest < ActiveSupport::TestCase
6	-
7	- def setup
8	- @hash = ProjectResultFixtures.project_result_hash
9	- @project_result = ProjectResultFixtures.project_result
10	-
11	- @project_name = @project_result.project.name
12	- @date = @project_result.date
13	- @flag = DateTime.now.sec % 2 == 0 #random choose between true or false
14	-
15	- @request = {:project_name => @project_name}
16	- @request_with_date = {:project_name => @project_name, :date => @date}
17	- @flag_response = {:has_results => @flag}
18	- @result_response = {:project_result => @project_result.to_hash}
19	- end
20	-
21	- should 'create project result from hash' do
22	- assert_equal @project_result.analysis_time, Kalibro::ProjectResult.new(@hash).analysis_time
23	- end
24	-
25	- should 'convert project result to hash' do
26	- assert_equal @hash, @project_result.to_hash
27	- end
28	-
29	- should 'get last result' do
30	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_of, @request).returns(@result_response)
31	- assert_equal @project_result.analysis_time , Kalibro::ProjectResult.last_result(@project_name).analysis_time
32	- end
33	-
34	- should 'get first result' do
35	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_of, @request).returns(@result_response)
36	- assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result(@project_name).analysis_time
37	- end
38	-
39	- should 'get first result after date' do
40	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_first_result_after, @request_with_date).returns(@result_response)
41	- assert_equal @project_result.analysis_time, Kalibro::ProjectResult.first_result_after(@project_name, @date).analysis_time
42	- end
43	-
44	- should 'get last result before date' do
45	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:get_last_result_before, @request_with_date).returns(@result_response)
46	- assert_equal @project_result.analysis_time, Kalibro::ProjectResult.last_result_before(@project_name, @date).analysis_time
47	- end
48	-
49	- should 'verify if project has results' do
50	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_for, @request).returns(@flag_response)
51	- assert_equal @flag, Kalibro::ProjectResult.has_results?(@project_name)
52	- end
53	-
54	- should 'verify if project has results before date' do
55	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_before, @request_with_date).returns(@flag_response)
56	- assert_equal @flag, Kalibro::ProjectResult.has_results_before?(@project_name, @date)
57	- end
58	-
59	- should 'verify if project has results after date' do
60	- Kalibro::ProjectResult.expects(:request).with('ProjectResult',:has_results_after, @request_with_date).returns(@flag_response)
61	- assert_equal @flag, Kalibro::ProjectResult.has_results_after?(@project_name, @date)
62	- end
63	-
64	- should 'retrieve formatted load time' do
65	- assert_equal '00:00:14', @project_result.formatted_load_time
66	- end
67	-
68	- should 'retrieve formatted analysis time' do
69	- assert_equal '00:00:01', @project_result.formatted_analysis_time
70	- end
71	-
72	- should 'retrive complex module' do
73	- assert_equal @hash[:source_tree][:child][0][:child].first, @project_result.node("org.Window").to_hash
74	- end
75	-
76	- should 'return source tree node when nil is given' do
77	- assert_equal @hash[:source_tree], @project_result.node(nil).to_hash
78	- end
79	-
80	- should 'return source tree node when project name is given' do
81	- assert_equal @hash[:source_tree], @project_result.node(@project_result.project.name).to_hash
82	- end
83	-
84	- should 'return correct node when module name is given' do
85	- assert_equal @hash[:source_tree][:child][2], @project_result.node("main").to_hash
86	- end
87	-
88	-end