metric_fu 4.6.0 → 4.7.0

data/spec/metric_fu/metrics/flog/flog_spec.rb

@@ -1,20 +1,21 @@
 require "spec_helper"
+MetricFu.metrics_require { 'flog/flog' }
 
 describe MetricFu::FlogGenerator do
 
   break if metric_not_activated?(:flog)
 
   before :each do
-    File.stub(:directory?).and_return(true)
+    allow(File).to receive(:directory?).and_return(true)
     options = MetricFu::Metric.get_metric(:flog).run_options
     @flog = MetricFu::FlogGenerator.new(options)
   end
 
   describe "emit method" do
     it "should look for files and flog them" do
-      FlogCLI.should_receive(:parse_options).with(["--all","--continue"]).and_return("options")
-      FlogCLI.should_receive(:new).with("options").and_return(flogger = double('flogger'))
-      flogger.should_receive(:flog).with("lib")
+      expect(FlogCLI).to receive(:parse_options).with(["--all","--continue"]).and_return("options")
+      expect(FlogCLI).to receive(:new).with("options").and_return(flogger = double('flogger'))
+      expect(flogger).to receive(:flog).with("lib")
       @flog.emit
     end
   end
@@ -28,8 +29,8 @@ describe MetricFu::FlogGenerator do
                                                       second_full_method_name => '/file/location.rb:22'},
                                 :totals => {first_full_method_name => 11.11,
                                             second_full_method_name => 22.22})
-      flogger.should_receive(:calculate)
-      flogger.should_receive(:each_by_score).and_yield(
+      expect(flogger).to receive(:calculate)
+      expect(flogger).to receive(:each_by_score).and_yield(
         first_full_method_name, 11.11, {:branch => 11.1, :puts => 1.1}
       ).and_yield(
         second_full_method_name, 22.22, {:branch => 22.2, :puts => 2.2}
@@ -37,7 +38,7 @@ describe MetricFu::FlogGenerator do
       @flog.instance_variable_set(:@flogger, flogger)
       @flog.analyze
       method_containers = @flog.instance_variable_get(:@method_containers)
-      method_containers.size.should == 1
+      expect(method_containers.size).to eq(1)
 
       expected={:methods=>{"ClassName#first_method_name" => { :path=>"/file/location.rb:11",
                                                               :score=>11.11,
@@ -53,7 +54,7 @@ describe MetricFu::FlogGenerator do
                 :highest_score=>22.22,
                 :name=>"ClassName"}
 
-      method_containers["ClassName"].to_h.should == expected
+      expect(method_containers["ClassName"].to_h).to eq(expected)
     end
   end
 
@@ -70,7 +71,7 @@ describe MetricFu::FlogGenerator do
                   :average => 7.3,
                   :method_containers => ['container_2', 'container_3', 'container_1']}}
 
-      @flog.to_h.should == expected
+      expect(@flog.to_h).to eq(expected)
     end
 
   end

data/spec/metric_fu/metrics/generator_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe MetricFu::Generator do
 
-  include Construct::Helpers
+  include TestConstruct::Helpers
 
 
   class ConcreteClass < MetricFu::Generator
@@ -30,33 +30,33 @@ describe MetricFu::Generator do
   describe "ConcreteClass#metric_directory" do
     it "should be '{artifact_dir}/scratch/concreteclass'" do
       concrete_metric = double('concrete_metric')
-      MetricFu::Metric.should_receive(:get_metric).with(:concrete).and_return(concrete_metric)
-      concrete_metric.should_receive(:run_options).and_return({})
+      expect(MetricFu::Metric).to receive(:get_metric).with(:concrete).and_return(concrete_metric)
+      expect(concrete_metric).to receive(:run_options).and_return({})
       compare_paths(ConcreteClass.metric_directory, scratch_directory('concrete'))
     end
   end
 
   describe '#metric_directory' do
     it 'should return the results of ConcreteClass#metric_directory' do
-      ConcreteClass.stub(:metric_directory).and_return('foo')
-      @concrete_class.metric_directory.should == 'foo'
+      allow(ConcreteClass).to receive(:metric_directory).and_return('foo')
+      expect(@concrete_class.metric_directory).to eq('foo')
     end
   end
 
   describe "#generate_result" do
     it 'should  raise an error when calling #emit' do
       @abstract_class = MetricFu::Generator.new
-      lambda { @abstract_class.generate_result }.should  raise_error
+      expect { @abstract_class.generate_result }.to  raise_error
     end
 
     it 'should call #analyze' do
       @abstract_class = MetricFu::Generator.new
-      lambda { @abstract_class.generate_result }.should  raise_error
+      expect { @abstract_class.generate_result }.to  raise_error
     end
 
     it 'should call #to_h' do
       @abstract_class = MetricFu::Generator.new
-      lambda { @abstract_class.generate_result }.should  raise_error
+      expect { @abstract_class.generate_result }.to  raise_error
     end
   end
 
@@ -64,13 +64,13 @@ describe MetricFu::Generator do
 
     %w[emit analyze].each do |meth|
       it "should call ##{meth}" do
-        @concrete_class.should_receive("#{meth}")
+        expect(@concrete_class).to receive("#{meth}")
         @concrete_class.generate_result
       end
     end
 
     it "should call #to_h" do
-      @concrete_class.should_receive(:to_h)
+      expect(@concrete_class).to receive(:to_h)
       @concrete_class.generate_result
     end
 
@@ -105,31 +105,31 @@ describe MetricFu::Generator do
 
       it "should return entire pathlist given no exclude pattens" do
         files = @concrete_class.remove_excluded_files(@paths)
-        files.should be == @paths
+        expect(files).to eq(@paths)
       end
 
       it "should filter filename at root level" do
         files = @concrete_class.remove_excluded_files(@paths, ['basic.rb'])
-        files.should_not include('basic.rb')
+        expect(files).not_to include('basic.rb')
       end
 
       it "should remove files that are two levels deep" do
         files = @concrete_class.remove_excluded_files(@paths, ['**/fake.rb'])
-        files.should_not include('lib/fake/fake.rb')
+        expect(files).not_to include('lib/fake/fake.rb')
       end
 
       it "should remove files from an excluded directory" do
         files = @concrete_class.remove_excluded_files(@paths, ['lib/bad/**'])
-        files.should_not include('lib/bad/one.rb')
-        files.should_not include('lib/bad/two.rb')
-        files.should_not include('lib/bad/three.rb')
+        expect(files).not_to include('lib/bad/one.rb')
+        expect(files).not_to include('lib/bad/two.rb')
+        expect(files).not_to include('lib/bad/three.rb')
       end
 
       it "should support shell alternation globs" do
         files = @concrete_class.remove_excluded_files(@paths, ['lib/this/{ben,dan}_file.rb'])
-        files.should_not include('lib/this/dan_file.rb')
-        files.should_not include('lib/this/ben_file.rb')
-        files.should include('lib/this/avdi_file.rb')
+        expect(files).not_to include('lib/this/dan_file.rb')
+        expect(files).not_to include('lib/this/ben_file.rb')
+        expect(files).to include('lib/this/avdi_file.rb')
       end
 
     end

data/spec/metric_fu/metrics/graph_spec.rb

@@ -5,7 +5,7 @@ describe MetricFu do
 
   describe "responding to #graph" do
     it "should return an instance of Graph" do
-      MetricFu.graph.should be_a(Graph)
+      expect(MetricFu.graph).to be_a(Graph)
     end
   end
 end
@@ -18,25 +18,27 @@ describe MetricFu::Graph do
 
   describe "setting the date on the graph" do
 
+    # TODO better test
     it "should set the date once for one data point" do
       metric_file = "metric_fu/tmp/_data/20101105.yml"
-      MetricFu::Utility.should_receive(:glob).and_return([metric_file].sort)
-      MetricFu::Utility.should_receive(:load_yaml).with(metric_file).and_return("Metrics")
+      expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
+      expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
       double_grapher = double
-      double_grapher.should_receive(:get_metrics).with("Metrics", "11/5")
-      double_grapher.should_receive(:graph!)
+      expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
+      expect(double_grapher).to receive(:graph!)
 
       @graph.graphers = [double_grapher]
       @graph.generate
     end
 
+    # TODO better test
     it "should set the date when the data directory isn't in the default place" do
       metric_file = "/some/kind/of/weird/directory/somebody/configured/_data/20101105.yml"
-      MetricFu::Utility.should_receive(:glob).and_return([metric_file].sort)
-      MetricFu::Utility.should_receive(:load_yaml).with(metric_file).and_return("Metrics")
+      expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
+      expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
       double_grapher = double
-      double_grapher.should_receive(:get_metrics).with("Metrics", "11/5")
-      double_grapher.should_receive(:graph!)
+      expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
+      expect(double_grapher).to receive(:graph!)
 
       @graph.graphers = [double_grapher]
       @graph.generate

data/spec/metric_fu/metrics/hotspots/analysis/analyzed_problems_spec.rb

@@ -1,7 +1,12 @@
 require 'spec_helper'
+MetricFu.metrics_require { 'hotspots/analysis/analyzed_problems' }
 
 describe MetricFu::HotspotAnalyzedProblems do
 
+  before do
+    enable_hotspots
+  end
+
   def analyzed_problems(result_hash)
     @analyzed_problems ||= {}
     @analyzed_problems.fetch(result_hash) do

data/spec/metric_fu/metrics/hotspots/analysis/analyzer_tables_spec.rb

@@ -1,7 +1,12 @@
 require 'spec_helper'
+MetricFu.metrics_require { 'hotspots/analysis/analyzer_tables' }
 
 describe MetricFu::AnalyzerTables do
 
+  before do
+    enable_hotspots
+  end
+
   def analyzer_table(result_hash)
     @analyzer_tables ||= {}
     @analyzer_tables.fetch(result_hash) do
@@ -31,17 +36,17 @@ describe MetricFu::AnalyzerTables do
 
     it "should have codeLOC" do
       row = @table.find{|row| row['stat_name'] == :codeLOC}
-      row['stat_value'].should == 4222
+      expect(row['stat_value']).to eq(4222)
     end
 
     it "should have testLOC" do
       row = @table.find{|row| row['stat_name'] == :testLOC}
-      row['stat_value'].should == 2111
+      expect(row['stat_value']).to eq(2111)
     end
 
     it "should have code_to_test_ratio" do
       row = @table.find{|row| row['stat_name'] == :code_to_test_ratio}
-      row['stat_value'].should == 2
+      expect(row['stat_value']).to eq(2)
     end
 
   end
@@ -55,16 +60,16 @@ describe MetricFu::AnalyzerTables do
 
     specify "all records should have full file_path" do
       @table.each do |row|
-        row['file_path'].should == 'lib/client/client.rb'
+        expect(row['file_path']).to eq('lib/client/client.rb')
       end
     end
 
     specify "all records should have class name" do
-      @table.select{|rows| rows.fetch(:class_name, :no_key) == nil }.should have(0).rows
+      expect(@table.select{|rows| rows.fetch(:class_name, :no_key) == nil }.size).to eq(0)
     end
 
     specify "one record should not have method name" do
-      @table.select{|rows| rows.fetch(:method_name, :no_key) == nil }.should have(0).rows
+      expect(@table.select{|rows| rows.fetch(:method_name, :no_key) == nil }.size).to eq(0)
     end
 
   end

data/spec/metric_fu/metrics/hotspots/analysis/ranking_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'hotspots/analysis/ranking' }
 
 describe MetricFu::Ranking do
 
@@ -9,14 +10,14 @@ describe MetricFu::Ranking do
       ranking[:a] = 10
       ranking[:b] = 50
       ranking[:c] = 1
-      ranking.top.should == [:b,:a, :c]
+      expect(ranking.top).to eq([:b,:a, :c])
     end
 
     specify "lowest item is at 0 percentile" do
       ranking = Ranking.new
       ranking[:a] = 10
       ranking[:b] = 50
-      ranking.percentile(:a).should == 0
+      expect(ranking.percentile(:a)).to eq(0)
     end
 
     specify "highest item is at high percentile" do
@@ -25,7 +26,7 @@ describe MetricFu::Ranking do
       ranking[:b] = 50
       ranking[:c] = 0
       ranking[:d] = 5
-      ranking.percentile(:b).should == 0.75
+      expect(ranking.percentile(:b)).to eq(0.75)
     end
 
   end

data/spec/metric_fu/metrics/hotspots/analysis/rankings_spec.rb

@@ -1,7 +1,13 @@
 require 'spec_helper'
+MetricFu.metrics_require { 'hotspots/analysis/rankings' }
 
 describe MetricFu::HotspotRankings do
 
+  before do
+    enable_hotspots
+  end
+
+  # TODO: This helper method is a huge smell. Make unnecessary
   def rankings(result_hash)
     @rankings ||= {}
     @rankings.fetch(result_hash) do
@@ -26,7 +32,7 @@ describe MetricFu::HotspotRankings do
       expected = [
                   "lib/client/client.rb",
                   "lib/client/foo.rb"]
-      rankings(result_hash).worst_files.should == expected
+      expect(rankings(result_hash).worst_files).to eq(expected)
     end
     def result_hash
       @result_hash ||= HOTSPOT_DATA["several_metrics.yml"]
@@ -39,15 +45,15 @@ describe MetricFu::HotspotRankings do
     end
 
     it "gives worst method" do
-      rankings(@result_hash).worst_methods[0].should == "Client#client_requested_sync"
+      expect(rankings(@result_hash).worst_methods[0]).to eq("Client#client_requested_sync")
     end
 
     it "gives worst class" do
-      rankings(@result_hash).worst_classes[0].should == "Client"
+      expect(rankings(@result_hash).worst_classes[0]).to eq("Client")
     end
 
     it "gives worst file" do
-      rankings(@result_hash).worst_files[0].should == "lib/client/client.rb"
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/client/client.rb")
     end
 
   end
@@ -58,11 +64,11 @@ describe MetricFu::HotspotRankings do
     end
 
     it "gives worst method" do
-      rankings(@result_hash).worst_methods[0].should == "Supr#self.handle_full_or_hash_option"
+      expect(rankings(@result_hash).worst_methods[0]).to eq("Supr#self.handle_full_or_hash_option")
     end
 
     it "gives worst class" do
-      rankings(@result_hash).worst_classes[0].should == "Bitly"
+      expect(rankings(@result_hash).worst_classes[0]).to eq("Bitly")
     end
 
   end
@@ -73,15 +79,15 @@ describe MetricFu::HotspotRankings do
     end
 
     it "gives worst method" do
-      rankings(@result_hash).worst_methods[0].should == "main#none"
+      expect(rankings(@result_hash).worst_methods[0]).to eq("main#none")
     end
 
     it "gives worst class" do
-      rankings(@result_hash).worst_classes[0].should == "main"
+      expect(rankings(@result_hash).worst_classes[0]).to eq("main")
     end
 
     it "gives worst file" do
-      rankings(@result_hash).worst_files[0].should == "lib/generators/rcov.rb:57"
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/generators/rcov.rb:57")
     end
 
   end
@@ -93,7 +99,7 @@ describe MetricFu::HotspotRankings do
     end
 
     it "gives worst file" do
-      rankings(@result_hash).worst_files[0].should == "lib/client/client.rb"
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/client/client.rb")
     end
 
   end

data/spec/metric_fu/metrics/hotspots/analysis/table_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
+MetricFu.metrics_require { 'hotspots/analysis/table' }
 
-describe Table do
+describe MetricFu::Table do
 
   it "needs tests"
 

data/spec/metric_fu/metrics/hotspots/hotspot_analyzer_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
+MetricFu.metrics_require { 'hotspots/hotspot_analyzer' }
 
-describe HotspotAnalyzer do
+describe MetricFu::HotspotAnalyzer do
 
   it "should have its own tests regarding how it orchestrates the analysis of results, rankings, tables, and analyzed_problems"
 

data/spec/metric_fu/metrics/hotspots/hotspot_spec.rb

@@ -1,11 +1,17 @@
 require 'spec_helper'
+MetricFu.metrics_require { 'hotspots/hotspot' }
+
+describe MetricFu::Hotspot do
+
+  before do
+    enable_hotspots
+  end
 
-describe "MetricFu::Hotspot" do
   it "returns an array of of the analyzers that subclass it" do
     expected_analyzers = [ReekHotspot, RoodiHotspot,
       FlogHotspot, ChurnHotspot, SaikuroHotspot,
       FlayHotspot, StatsHotspot, RcovHotspot]
 
-    MetricFu::Hotspot.analyzers.size.should == expected_analyzers.size
+    expect(MetricFu::Hotspot.analyzers.size).to eq(expected_analyzers.size)
   end
 end

data/spec/metric_fu/metrics/hotspots/hotspots_spec.rb

@@ -1,22 +1,17 @@
 require "spec_helper"
+MetricFu.metrics_require { 'hotspots/hotspots' }
 
 describe MetricFu::HotspotsGenerator do
   describe "analyze method" do
-    before :each do
-      MetricFu::Configuration.run {}
-      File.stub(:directory?).and_return(true)
-      @yaml = HOTSPOT_DATA["generator.yml"]
-    end
 
     it "should be empty on error" do
       hotspots = MetricFu::HotspotsGenerator.new
       hotspots.instance_variable_set(:@analyzer, nil)
       result = hotspots.analyze
-      result.should == {:files => [], :classes => [], :methods => []}
+      expect(result).to eq({:files => [], :classes => [], :methods => []})
     end
 
     it "should put the changes into a hash" do
-      MetricFu.result.should_receive(:result_hash).and_return(@yaml)
       hotspots = MetricFu::HotspotsGenerator.new
       hotspots.analyze
       result = hotspots.to_h[:hotspots]
@@ -44,7 +39,8 @@ describe MetricFu::HotspotsGenerator do
     # really testing the output of analyzed_problems#worst_items
     it "should return the worst item granularities: files, classes, methods" do
       hotspots = MetricFu::HotspotsGenerator.new
-      analyzer = HotspotAnalyzer.new(@yaml)
+      yaml = HOTSPOT_DATA["generator.yml"]
+      analyzer = HotspotAnalyzer.new(yaml)
       expect(hotspots.analyze.keys).to eq([:files, :classes, :methods])
     end
   end