metric_fu 4.6.0 → 4.7.0

data/spec/metric_fu/metrics/roodi/roodi_spec.rb

@@ -1,19 +1,20 @@
 require "spec_helper"
+MetricFu.metrics_require { 'roodi/roodi' }
 
 describe MetricFu::RoodiGenerator do
   describe "emit" do
     it "should add config options when present" do
       options = {:roodi_config => 'lib/config/roodi_config.yml', :dirs_to_roodi => []}
       roodi = MetricFu::RoodiGenerator.new(options)
-      roodi.should_receive(:run!).with(/-config=lib\/config\/roodi_config\.yml/).and_return("")
+      expect(roodi).to receive(:run!).with(/-config=lib\/config\/roodi_config\.yml/).and_return("")
       roodi.emit
     end
 
     it "should NOT add config options when NOT present" do
       options = {:dirs_to_roodi => []}
       roodi = MetricFu::RoodiGenerator.new(options)
-      roodi.stub(:run!)
-      roodi.should_receive(:run!).with(/-config/).never
+      allow(roodi).to receive(:run!)
+      expect(roodi).to receive(:run!).with(/-config/).never
       roodi.emit
     end
   end

data/spec/metric_fu/metrics/saikuro/saikuro_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'saikuro/saikuro' }
 
 describe MetricFu::SaikuroGenerator do
   STUB_TEST_DATA = lambda do |generator|
@@ -6,7 +7,9 @@ describe MetricFu::SaikuroGenerator do
     def generator.metric_directory
       FIXTURE.fixtures_path.join("saikuro").to_s
     end
-    generator.stub(:clear_scratch_files!)
+    def generator.clear_scratch_files!
+      # no-op
+    end
   end
   describe "to_h method" do
     before do
@@ -19,25 +22,25 @@ describe MetricFu::SaikuroGenerator do
     end
 
     it "should find the filename of a file" do
-      @output[:saikuro][:files].first[:filename].should == 'app/controllers/users_controller.rb'
+      expect(@output[:saikuro][:files].first[:filename]).to eq('app/controllers/users_controller.rb')
     end
 
     it "should find the name of the classes" do
-      @output[:saikuro][:classes].first[:name].should == "UsersController"
-      @output[:saikuro][:classes][1][:name].should == "SessionsController"
+      expect(@output[:saikuro][:classes].first[:name]).to eq("UsersController")
+      expect(@output[:saikuro][:classes][1][:name]).to eq("SessionsController")
     end
 
     it "should put the most complex method first" do
-      @output[:saikuro][:methods].first[:name].should == "UsersController#create"
-      @output[:saikuro][:methods].first[:complexity].should == 4
+      expect(@output[:saikuro][:methods].first[:name]).to eq("UsersController#create")
+      expect(@output[:saikuro][:methods].first[:complexity]).to eq(4)
     end
 
     it "should find the complexity of a method" do
-      @output[:saikuro][:methods].first[:complexity].should == 4
+      expect(@output[:saikuro][:methods].first[:complexity]).to eq(4)
     end
 
     it "should find the lines of a method" do
-      @output[:saikuro][:methods].first[:lines].should == 15
+      expect(@output[:saikuro][:methods].first[:lines]).to eq(15)
     end
   end
 
@@ -51,7 +54,7 @@ describe MetricFu::SaikuroGenerator do
     end
 
     it "doesn't try to get information if the file does not exist" do
-      @saikuro.should_receive(:file_not_exists?).at_least(:once).and_return(true)
+      expect(@saikuro).to receive(:file_not_exists?).at_least(:once).and_return(true)
       @saikuro.per_file_info('ignore_me')
     end
   end
@@ -61,7 +64,7 @@ describe MetricFu::SaikuroGenerator do
      it "should parse nested START/END sections" do
        path = FIXTURE.fixtures_path.join("saikuro_sfiles", "thing.rb_cyclo.html").to_s
        sfile = MetricFu::SaikuroScratchFile.new path
-       sfile.elements.map { |e| e.complexity }.sort.should eql(["0","0","2"])
+       expect(sfile.elements.map { |e| e.complexity }.sort).to eql(["0","0","2"])
       end
     end
   end

data/spec/metric_fu/metrics/stats/stats_grapher_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'stats/stats_grapher' }
 
 describe StatsGrapher do
   before :each do
@@ -7,16 +8,16 @@ describe StatsGrapher do
   end
 
   it "should respond to loc_counts and lot_counts and labels" do
-    @stats_grapher.should respond_to(:loc_counts)
-    @stats_grapher.should respond_to(:lot_counts)
-    @stats_grapher.should respond_to(:labels)
+    expect(@stats_grapher).to respond_to(:loc_counts)
+    expect(@stats_grapher).to respond_to(:lot_counts)
+    expect(@stats_grapher).to respond_to(:labels)
   end
 
   describe "responding to #initialize" do
     it "should initialise loc_counts and lot_counts and labels" do
-      @stats_grapher.loc_counts.should == []
-      @stats_grapher.lot_counts.should == []
-      @stats_grapher.labels.should == {}
+      expect(@stats_grapher.loc_counts).to eq([])
+      expect(@stats_grapher.lot_counts).to eq([])
+      expect(@stats_grapher.labels).to eq({})
     end
   end
 
@@ -28,17 +29,17 @@ describe StatsGrapher do
       end
 
       it "should not push to loc_counts" do
-        @stats_grapher.loc_counts.should_not_receive(:push)
+        expect(@stats_grapher.loc_counts).not_to receive(:push)
         @stats_grapher.get_metrics(@metrics, @date)
       end
 
       it "should not push to lot_counts" do
-        @stats_grapher.lot_counts.should_not_receive(:push)
+        expect(@stats_grapher.lot_counts).not_to receive(:push)
         @stats_grapher.get_metrics(@metrics, @date)
       end
 
       it "should not update labels with the date" do
-        @stats_grapher.labels.should_not_receive(:update)
+        expect(@stats_grapher.labels).not_to receive(:update)
         @stats_grapher.get_metrics(@metrics, @date)
       end
     end
@@ -50,17 +51,17 @@ describe StatsGrapher do
       end
 
       it "should push to loc_counts" do
-        @stats_grapher.loc_counts.should_receive(:push).with(15935)
+        expect(@stats_grapher.loc_counts).to receive(:push).with(15935)
         @stats_grapher.get_metrics(@metrics, @date)
       end
 
       it "should push to lot_counts" do
-        @stats_grapher.lot_counts.should_receive(:push).with(7438)
+        expect(@stats_grapher.lot_counts).to receive(:push).with(7438)
         @stats_grapher.get_metrics(@metrics, @date)
       end
 
       it "should update labels with the date" do
-        @stats_grapher.labels.should_receive(:update).with({ 0 => "01022003" })
+        expect(@stats_grapher.labels).to receive(:update).with({ 0 => "01022003" })
         @stats_grapher.get_metrics(@metrics, @date)
       end
     end

data/spec/metric_fu/metrics/stats/stats_spec.rb

@@ -1,16 +1,18 @@
 require "spec_helper"
+MetricFu.metrics_require { 'stats/stats' }
 
 describe StatsGenerator do
   describe "emit method" do
     it "should gather the raw data" do
       ENV['CC_BUILD_ARTIFACTS'] = nil
       MetricFu.configure.reset
-      File.stub(:directory?).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
       stats = MetricFu::StatsGenerator.new
       stats.emit
     end
   end
 
+  #TODO review tested output
   describe "analyze method" do
     before :each do
       @lines =  <<-HERE.gsub(/^\s*/, "")
@@ -34,32 +36,32 @@ describe StatsGenerator do
       HERE
       ENV['CC_BUILD_ARTIFACTS'] = nil
       MetricFu.configure.reset
-      File.stub(:directory?).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
       stats = MetricFu::StatsGenerator.new
       stats.instance_variable_set('@output', @lines)
       @results = stats.analyze
     end
 
     it "should get code Lines Of Code" do
-      @results[:codeLOC].should == 915
+      expect(@results[:codeLOC]).to eq(915)
     end
 
     it "should get test Lines Of Code" do
-      @results[:testLOC].should == 2226
+      expect(@results[:testLOC]).to eq(2226)
     end
 
     it "should get code to test ratio" do
-      @results[:code_to_test_ratio].should == 2.4
+      expect(@results[:code_to_test_ratio]).to eq(2.4)
     end
 
     it "should get data on models" do
       model_data = @results[:lines].find {|line| line[:name] == "Models"}
-      model_data[:classes].should == 9
-      model_data[:methods].should == 31
-      model_data[:loc].should == 285
-      model_data[:lines].should == 351
-      model_data[:methods_per_class].should == 3
-      model_data[:loc_per_method].should == 7
+      expect(model_data[:classes]).to eq(9)
+      expect(model_data[:methods]).to eq(31)
+      expect(model_data[:loc]).to eq(285)
+      expect(model_data[:lines]).to eq(351)
+      expect(model_data[:methods_per_class]).to eq(3)
+      expect(model_data[:loc_per_method]).to eq(7)
     end
 
     it 'handles code to test ratio is ratio is 1:NaN' do
@@ -73,7 +75,7 @@ describe StatsGenerator do
       HERE
       ENV['CC_BUILD_ARTIFACTS'] = nil
       MetricFu.configure.reset
-      File.stub(:directory?).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
       stats = MetricFu::StatsGenerator.new(MetricFu::Metric.get_metric(:stats).run_options)
       stats.instance_variable_set('@output', lines)
       @results = stats.analyze
@@ -85,10 +87,10 @@ describe StatsGenerator do
     it "should put things into a hash" do
       ENV['CC_BUILD_ARTIFACTS'] = nil
       MetricFu.configure.reset
-      File.stub(:directory?).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
       stats = MetricFu::StatsGenerator.new
       stats.instance_variable_set(:@stats, "the_stats")
-      stats.to_h[:stats].should == "the_stats"
+      expect(stats.to_h[:stats]).to eq("the_stats")
     end
   end
 end

data/spec/metric_fu/reporter_spec.rb

@@ -1,24 +1,25 @@
 require "spec_helper"
+MetricFu.lib_require { 'reporter' }
 
 describe MetricFu::Reporter do
 
   context 'given a single formatter' do
     before do
       @formatter = double('formatter')
-      @formatter.stub(:to_a).and_return([@formatter])
+      allow(@formatter).to receive(:to_a).and_return([@formatter])
       @reporter = Reporter.new(@formatter)
     end
 
     it 'notifies the formatter' do
-      @formatter.should_receive(:start)
-      @formatter.should_receive(:finish)
+      expect(@formatter).to receive(:start)
+      expect(@formatter).to receive(:finish)
       @reporter.start
       @reporter.finish
     end
 
     it 'only sends notifications when supported by formatter' do
-      @formatter.stub(:respond_to?).with(:display_results).and_return(false)
-      @formatter.should_not_receive(:display_results)
+      allow(@formatter).to receive(:respond_to?).with(:display_results).and_return(false)
+      expect(@formatter).not_to receive(:display_results)
       @reporter.display_results
     end
   end
@@ -31,8 +32,8 @@ describe MetricFu::Reporter do
 
     it 'notifies all formatters' do
       @formatters.each do |formatter|
-        formatter.should_receive(:start)
-        formatter.should_receive(:finish)
+        expect(formatter).to receive(:start)
+        expect(formatter).to receive(:finish)
       end
       @reporter.start
       @reporter.finish

data/spec/metric_fu/reporting/graphs/grapher_spec.rb

@@ -18,7 +18,7 @@ describe "Bluff graphers responding to #graph!" do
     graphs.each do |key, val|
       val.graph!
       output_dir = File.expand_path(File.join(MetricFu::Io::FileSystem.directory('output_directory')))
-      lambda{ File.read(File.join(output_dir, "#{key.to_s.downcase}.js")) }.should_not raise_error
+      expect{ File.read(File.join(output_dir, "#{key.to_s.downcase}.js")) }.not_to raise_error
     end
   end
 end

data/spec/metric_fu/reporting/result_spec.rb

@@ -1,10 +1,11 @@
 require "spec_helper"
+MetricFu.reporting_require { 'result' }
 
 describe MetricFu do
 
   describe "#result" do
     it 'should return an instance of Result' do
-      MetricFu.result.instance_of?(Result).should be(true)
+      expect(MetricFu.result.instance_of?(Result)).to be(true)
     end
   end
 end
@@ -18,9 +19,9 @@ describe MetricFu::Result do
   describe "#as_yaml" do
     it 'should call #result_hash' do
       result_hash = double('result_hash')
-      result_hash.should_receive(:to_yaml)
+      expect(result_hash).to receive(:to_yaml)
 
-      @result.should_receive(:result_hash).and_return(result_hash)
+      expect(@result).to receive(:result_hash).and_return(result_hash)
       @result.as_yaml
     end
   end
@@ -31,20 +32,20 @@ describe MetricFu::Result do
   describe "#add" do
     it 'should add a passed hash to the result_hash instance variable' do
       result_type = double('result_type')
-      result_type.stub(:to_s).and_return('type')
+      allow(result_type).to receive(:to_s).and_return('type')
 
       result_inst = double('result_inst')
-      result_type.should_receive(:new).and_return(result_inst)
+      expect(result_type).to receive(:new).and_return(result_inst)
 
-      result_inst.should_receive(:generate_result).and_return({:a => 'b'})
-      result_inst.should_receive(:respond_to?).and_return(false)
+      expect(result_inst).to receive(:generate_result).and_return({:a => 'b'})
+      expect(result_inst).to receive(:respond_to?).and_return(false)
 
-      MetricFu::Generator.should_receive(:get_generator).
+      expect(MetricFu::Generator).to receive(:get_generator).
                with(result_type).and_return(result_type)
       result_hash = double('result_hash')
-      result_hash.should_receive(:merge!).with({:a => 'b'})
-      @result.should_receive(:result_hash).and_return(result_hash)
-      @result.should_receive(:metric_options_for_result_type).with(result_type)
+      expect(result_hash).to receive(:merge!).with({:a => 'b'})
+      expect(@result).to receive(:result_hash).and_return(result_hash)
+      expect(@result).to receive(:metric_options_for_result_type).with(result_type)
       @result.add(result_type)
     end
   end

data/spec/metric_fu/run_spec.rb

@@ -29,9 +29,18 @@ describe MetricFu do
       # limited set, so we can test the basic functionality
       # without significantly slowing down the specs.
       MetricFu.configuration.configure_metrics do |metric|
-        if metric.name == :churn
+        if metric.name == :reek
           metric.enable
           metric.activated = true
+          # so this doesn't seem to always be true
+          # @bf4 adding that line you thought I didn't need made tests pass for me
+          # but they failed on one of the travis builds.
+          # swapping this line all seem to pass every run
+          # I don't understand what is happening in run_external well enough
+          # need some help debugging
+          # but tests seem more stable without it.
+          # metric.should_receive(:run_external).and_return('')
+          allow(metric).to receive(:run_external).and_return('')
         else
           metric.enabled = false
         end
@@ -156,17 +165,22 @@ describe MetricFu do
 
     it "displays help" do
       out = metric_fu "--help"
-      out.should include helper.banner
+      expect(out).to include helper.banner
     end
 
     it "displays version" do
       out = metric_fu "--version"
-      out.should include "#{MetricFu::VERSION}"
+      expect(out).to include "#{MetricFu::VERSION}"
     end
 
     it "errors on unknown flags" do
-      out = metric_fu "--asdasdasda"
-      out.should include 'invalid option'
+      failure = false
+      out = metric_fu "--asdasdasda" do |message|
+        # swallow the error message
+        failure = true
+      end
+      expect(out).to include 'invalid option'
+      expect(failure).to be_truthy
     end
 
   end
@@ -184,11 +198,13 @@ describe MetricFu do
         # Catch system exit so that it doesn't halt spec.
       rescue SystemExit => system_exit
         status =  system_exit.success? ? "SUCCESS" : "FAILURE"
-        message << "#{status} with code #{system_exit.status}: " <<
-          "#{system_exist.message} #{system_exit.backtrace}"
+        message << "#{status} with code #{system_exit.status}: "
+        message << "#{system_exit.message} #{system_exit.backtrace}"
       end
     }
-    STDERR.puts message if message.start_with?('FAILURE')
+    if message.start_with?('FAILURE')
+      block_given? ? yield(message) : STDERR.puts(message)
+    end
     out
   end
 

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ if ENV['COVERAGE']
 end
 
 require 'date'
-require 'construct'
+require 'test_construct'
 require 'json'
 require 'pry-nav'
 
@@ -33,7 +33,6 @@ Dir[MetricFu.root_dir + "/spec/support/**/*.rb"].each {|f| require f}
 RSpec.configure do |config|
   config.mock_with :rspec
 
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
   config.filter_run_excluding :slow unless ENV["SLOW_SPECS"]

data/spec/support/helper_methods.rb

@@ -1,3 +1,16 @@
+def enable_hotspots
+  MetricFu.configure
+  hotspot_metrics = MetricFu::Metric.metrics.map(&:name)
+  hotspot_metrics.each do |metric_name|
+    path = "#{metric_name}/#{metric_name}_hotspot"
+    begin
+      MetricFu.metrics_require { path }
+    rescue LoadError
+      # No hotspot, but that's ok
+    end
+  end
+end
+
 def metric_not_activated?(metric_name)
   MetricFu.configuration.configure_metrics
   if MetricFu::Metric.get_metric(metric_name.intern).activate
@@ -14,5 +27,5 @@ def breaks_when?(bool)
 end
 
 def compare_paths(path1, path2)
-  File.join(MetricFu.root_dir, path1).should == File.join(MetricFu.root_dir, path2)
+  expect(File.join(MetricFu.root_dir, path1)).to eq(File.join(MetricFu.root_dir, path2))
 end