metric_fu 4.6.0 → 4.7.0

data/spec/metric_fu/metrics/rails_best_practices/rails_best_practices_grapher_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'rails_best_practices/rails_best_practices_grapher' }
 
 describe RailsBestPracticesGrapher do
   before :each do
@@ -7,14 +8,14 @@ describe RailsBestPracticesGrapher do
   end
 
   it "should respond to rails_best_practices_count and labels" do
-    @stats_grapher.should respond_to(:rails_best_practices_count)
-    @stats_grapher.should respond_to(:labels)
+    expect(@stats_grapher).to respond_to(:rails_best_practices_count)
+    expect(@stats_grapher).to respond_to(:labels)
   end
 
   describe "responding to #initialize" do
     it "should initialise rails_best_practices_count and labels" do
-      @stats_grapher.rails_best_practices_count.should == []
-      @stats_grapher.labels.should == {}
+      expect(@stats_grapher.rails_best_practices_count).to eq([])
+      expect(@stats_grapher.labels).to eq({})
     end
   end
 
@@ -26,12 +27,12 @@ describe RailsBestPracticesGrapher do
       end
 
       it "should not push to rails_best_practices_count" do
-        @stats_grapher.rails_best_practices_count.should_not_receive(:push)
+        expect(@stats_grapher.rails_best_practices_count).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
@@ -43,17 +44,17 @@ describe RailsBestPracticesGrapher do
       end
 
       it "should push to rails_best_practices_count" do
-        @stats_grapher.rails_best_practices_count.should_receive(:push).with(2)
+        expect(@stats_grapher.rails_best_practices_count).to receive(:push).with(2)
         @stats_grapher.get_metrics(@metrics, @date)
       end
 
       it "should push 0 to rails_best_practices_count when no problems were found" do
-        @stats_grapher.rails_best_practices_count.should_receive(:push).with(0)
+        expect(@stats_grapher.rails_best_practices_count).to receive(:push).with(0)
         @stats_grapher.get_metrics({ :rails_best_practices => {} }, @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/rails_best_practices/rails_best_practices_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'rails_best_practices/rails_best_practices' }
 
 describe RailsBestPracticesGenerator do
 
@@ -7,18 +8,18 @@ describe RailsBestPracticesGenerator do
   describe "emit method" do
     let(:analyzer) { ::RailsBestPractices::Analyzer.new('.', { 'silent' => true }) }
     context "RailsBestPractices provides the expected API" do
-      it { analyzer.should respond_to :analyze }
-      it { analyzer.should respond_to :errors }
+      it { expect(analyzer).to respond_to :analyze }
+      it { expect(analyzer).to respond_to :errors }
     end
   end
 
   describe "analyze method" do
     let(:error) { ::RailsBestPractices::Core::Error.new }
     context "RailsBestPractices provdies the expected API" do
-      it { error.should respond_to :filename }
-      it { error.should respond_to :line_number }
-      it { error.should respond_to :message }
-      it { error.should respond_to :url }
+      it { expect(error).to respond_to :filename }
+      it { expect(error).to respond_to :line_number }
+      it { expect(error).to respond_to :message }
+      it { expect(error).to respond_to :url }
     end
   end
 
@@ -27,7 +28,7 @@ describe RailsBestPracticesGenerator do
       MetricFu::Configuration.run {}
       practices = MetricFu::RailsBestPracticesGenerator.new
       practices.instance_variable_set(:@rails_best_practices_results, "the_practices")
-      practices.to_h[:rails_best_practices].should == "the_practices"
+      expect(practices.to_h[:rails_best_practices]).to eq("the_practices")
     end
   end
 end

data/spec/metric_fu/metrics/rcov/rcov_grapher_spec.rb

@@ -7,14 +7,14 @@ describe RcovGrapher do
   end
 
   it "should respond to rcov_percent and labels" do
-    @rcov_grapher.should respond_to(:rcov_percent)
-    @rcov_grapher.should respond_to(:labels)
+    expect(@rcov_grapher).to respond_to(:rcov_percent)
+    expect(@rcov_grapher).to respond_to(:labels)
   end
 
   describe "responding to #initialize" do
     it "should initialise rcov_percent and labels" do
-      @rcov_grapher.rcov_percent.should == []
-      @rcov_grapher.labels.should == {}
+      expect(@rcov_grapher.rcov_percent).to eq([])
+      expect(@rcov_grapher.labels).to eq({})
     end
   end
 
@@ -26,12 +26,12 @@ describe RcovGrapher do
       end
 
       it "should not push to rcov_percent" do
-        @rcov_grapher.rcov_percent.should_not_receive(:push)
+        expect(@rcov_grapher.rcov_percent).not_to receive(:push)
         @rcov_grapher.get_metrics(@metrics, @date)
       end
 
       it "should not update labels with the date" do
-        @rcov_grapher.labels.should_not_receive(:update)
+        expect(@rcov_grapher.labels).not_to receive(:update)
         @rcov_grapher.get_metrics(@metrics, @date)
       end
     end
@@ -43,12 +43,12 @@ describe RcovGrapher do
       end
 
       it "should push to rcov_percent" do
-        @rcov_grapher.rcov_percent.should_receive(:push).with(49.6)
+        expect(@rcov_grapher.rcov_percent).to receive(:push).with(49.6)
         @rcov_grapher.get_metrics(@metrics, @date)
       end
 
       it "should update labels with the date" do
-        @rcov_grapher.labels.should_receive(:update).with({ 0 => "1/2" })
+        expect(@rcov_grapher.labels).to receive(:update).with({ 0 => "1/2" })
         @rcov_grapher.get_metrics(@metrics, @date)
       end
     end

data/spec/metric_fu/metrics/rcov/rcov_hotspot_spec.rb

@@ -1,5 +1,8 @@
 require "spec_helper"
-require "metric_fu/metrics/hotspots/analysis/record"
+MetricFu.metrics_require { 'hotspots/init' }
+MetricFu.metrics_require { 'hotspots/hotspot' }
+MetricFu.metrics_require { 'hotspots/analysis/record' }
+MetricFu.metrics_require { 'rcov/rcov_hotspot' }
 
 describe MetricFu::RcovHotspot do
   describe "map" do
@@ -11,7 +14,7 @@ describe MetricFu::RcovHotspot do
       MetricFu::Record.new({"percentage_uncovered"=>0.75}, nil)
     end
 
-    it {subject.map(zero_row).should eql(0.0)}
-    it {subject.map(non_zero_row).should eql(0.75)}
+    it {expect(subject.map(zero_row)).to eql(0.0)}
+    it {expect(subject.map(non_zero_row)).to eql(0.75)}
   end
-end
+end

data/spec/metric_fu/metrics/rcov/rcov_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'rcov/rcov' }
 
 describe MetricFu::RcovGenerator do
 
@@ -22,14 +23,14 @@ describe MetricFu::RcovGenerator do
     end
 
     it "should clear out previous output and make output folder" do
-      MetricFu::Utility.should_receive(:rm_rf).with(MetricFu::RcovGenerator.metric_directory, :verbose => false)
-      MetricFu::Utility.should_receive(:mkdir_p).with(MetricFu::RcovGenerator.metric_directory)
+      expect(MetricFu::Utility).to receive(:rm_rf).with(MetricFu::RcovGenerator.metric_directory, :verbose => false)
+      expect(MetricFu::Utility).to receive(:mkdir_p).with(MetricFu::RcovGenerator.metric_directory)
       @rcov.reset_output_location
     end
 
     it "should set the RAILS_ENV" do
-      MetricFu::Utility.should_receive(:rm_rf).with(MetricFu::RcovGenerator.metric_directory, :verbose => false)
-      MetricFu::Utility.should_receive(:mkdir_p).with(MetricFu::RcovGenerator.metric_directory)
+      expect(MetricFu::Utility).to receive(:rm_rf).with(MetricFu::RcovGenerator.metric_directory, :verbose => false)
+      expect(MetricFu::Utility).to receive(:mkdir_p).with(MetricFu::RcovGenerator.metric_directory)
       options = {:environment => 'metrics', :external => nil}
       @rcov = MetricFu::RcovGenerator.new(@default_options.merge(options))
       expect(@rcov.command).to include('RAILS_ENV=metrics')
@@ -40,30 +41,30 @@ describe MetricFu::RcovGenerator do
     before :each do
       options = {:external =>  nil}
       @rcov = MetricFu::RcovGenerator.new(@default_options.merge(options))
-      @rcov.should_receive(:load_output).and_return(RCOV_OUTPUT)
+      expect(@rcov).to receive(:load_output).and_return(RCOV_OUTPUT)
       @files = @rcov.analyze
     end
 
     describe "analyze" do
       it "should compute percent of lines run" do
-        @files["lib/templates/awesome/awesome_template.rb"][:percent_run].should == 13
-        @files["lib/templates/standard/standard_template.rb"][:percent_run].should == 14
+        expect(@files["lib/templates/awesome/awesome_template.rb"][:percent_run]).to eq(13)
+        expect(@files["lib/templates/standard/standard_template.rb"][:percent_run]).to eq(14)
       end
 
       it "should know which lines were run" do
-        @files["lib/templates/awesome/awesome_template.rb"][:lines].
-              should include({:content=>"require 'fileutils'", :was_run=>true})
+        expect(@files["lib/templates/awesome/awesome_template.rb"][:lines]).
+              to include({:content=>"require 'fileutils'", :was_run=>true})
       end
 
       it "should know which lines NOT were run" do
-        @files["lib/templates/awesome/awesome_template.rb"][:lines].
-              should include({:content=>"      if template_exists?(section)", :was_run=>false})
+        expect(@files["lib/templates/awesome/awesome_template.rb"][:lines]).
+              to include({:content=>"      if template_exists?(section)", :was_run=>false})
       end
     end
 
     describe "to_h" do
       it "should calculate total percentage for all files" do
-        @rcov.to_h[:rcov][:global_percent_run].should == 13.7
+        expect(@rcov.to_h[:rcov][:global_percent_run]).to eq(13.7)
       end
     end
   end
@@ -74,12 +75,12 @@ describe MetricFu::RcovGenerator do
     end
 
     it "should emit nothing if external configuration option is set" do
-      MetricFu::Utility.should_not_receive(:rm_rf)
+      expect(MetricFu::Utility).not_to receive(:rm_rf)
       @rcov.emit
     end
 
     it "should open the external rcov analysis file" do
-      @rcov.should_receive(:load_output).and_return(RCOV_OUTPUT)
+      expect(@rcov).to receive(:load_output).and_return(RCOV_OUTPUT)
       @files = @rcov.analyze
     end
 

data/spec/metric_fu/metrics/reek/reek_grapher_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'reek/reek_grapher' }
 
 describe ReekGrapher do
   before :each do
@@ -7,14 +8,14 @@ describe ReekGrapher do
   end
 
   it "should respond to reek_count and labels" do
-    @reek_grapher.should respond_to(:reek_count)
-    @reek_grapher.should respond_to(:labels)
+    expect(@reek_grapher).to respond_to(:reek_count)
+    expect(@reek_grapher).to respond_to(:labels)
   end
 
   describe "responding to #initialize" do
     it "should initialise reek_count and labels" do
-      @reek_grapher.reek_count.should == {}
-      @reek_grapher.labels.should == {}
+      expect(@reek_grapher.reek_count).to eq({})
+      expect(@reek_grapher.labels).to eq({})
     end
   end
 
@@ -27,11 +28,11 @@ describe ReekGrapher do
 
       it "should not set a hash of code smells to reek_count" do
         @reek_grapher.get_metrics(@metrics, @date)
-        @reek_grapher.reek_count.should == {}
+        expect(@reek_grapher.reek_count).to eq({})
       end
 
       it "should not update labels with the date" do
-        @reek_grapher.labels.should_not_receive(:update)
+        expect(@reek_grapher.labels).not_to receive(:update)
         @reek_grapher.get_metrics(@metrics, @date)
       end
     end
@@ -44,7 +45,7 @@ describe ReekGrapher do
 
       it "should set a hash of code smells to reek_count" do
         @reek_grapher.get_metrics(@metrics, @date)
-        @reek_grapher.reek_count.should == {
+        expect(@reek_grapher.reek_count).to eq({
           "Uncommunicative Name" => [27],
           "Feature Envy" => [20],
           "Utility Function" => [15],
@@ -53,11 +54,11 @@ describe ReekGrapher do
           "Control Couple" => [4],
           "Duplication" => [48],
           "Large Class" => [1]
-        }
+        })
       end
 
       it "should update labels with the date" do
-        @reek_grapher.labels.should_receive(:update).with({ 0 => "1/2" })
+        expect(@reek_grapher.labels).to receive(:update).with({ 0 => "1/2" })
         @reek_grapher.get_metrics(@metrics, @date)
       end
     end

data/spec/metric_fu/metrics/reek/reek_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'reek/reek' }
 
 describe MetricFu::ReekGenerator do
   describe "emit" do
@@ -6,12 +7,13 @@ describe MetricFu::ReekGenerator do
       options = {:config_file_pattern => 'lib/config/*.reek', :dirs_to_reek => []}
       reek = MetricFu::ReekGenerator.new(options)
       files_to_analyze = ['lib/foo.rb','lib/bar.rb']
-      reek.stub(:files_to_analyze).and_return(files_to_analyze)
-      reek.should_receive(:run!).with(/--config lib\/config\/\*\.reek lib\/foo.rb lib\/bar.rb/).and_return("")
+      allow(reek).to receive(:files_to_analyze).and_return(files_to_analyze)
+      expect(reek).to receive(:run!).with(/--config lib\/config\/\*\.reek lib\/foo.rb lib\/bar.rb/).and_return("")
       reek.emit
     end
   end
 
+  #TODO review tested output
   describe "analyze method" do
     before :each do
       @lines = <<-HERE
@@ -31,7 +33,7 @@ LinkTargetsController#authorize_user calls current_user.role multiple times (Dup
 NewlineController#some_method calls current_user.<< "new line\n" multiple times (Duplication)
       HERE
       MetricFu::Configuration.run {}
-      File.stub(:directory?).and_return(true)
+      allow(File).to receive(:directory?).and_return(true)
       reek = MetricFu::ReekGenerator.new
       reek.instance_variable_set(:@output, @lines)
       @matches = reek.analyze
@@ -39,30 +41,30 @@ NewlineController#some_method calls current_user.<< "new line\n" multiple times
 
     it "should find the code smell's method name" do
       smell = @matches.first[:code_smells].first
-      smell[:method].should == "ActivityReportsController#authorize_user"
+      expect(smell[:method]).to eq("ActivityReportsController#authorize_user")
     end
 
     it "should find the code smell's type" do
       smell = @matches[1][:code_smells].first
-      smell[:type].should == "Nested Iterators"
+      expect(smell[:type]).to eq("Nested Iterators")
     end
 
     it "should find the code smell's message" do
       smell = @matches[1][:code_smells].first
-      smell[:message].should == "is nested"
+      expect(smell[:message]).to eq("is nested")
     end
 
     it "should find the code smell's type" do
       smell = @matches.first
-      smell[:file_path].should == "app/controllers/activity_reports_controller.rb"
+      expect(smell[:file_path]).to eq("app/controllers/activity_reports_controller.rb")
     end
 
     it "should NOT insert nil smells into the array when there's a newline in the method call" do
-      @matches.last[:code_smells].should == @matches.last[:code_smells].compact
-      @matches.last.should == {:file_path=>"app/controllers/newline_controller.rb",
+      expect(@matches.last[:code_smells]).to eq(@matches.last[:code_smells].compact)
+      expect(@matches.last).to eq({:file_path=>"app/controllers/newline_controller.rb",
                                 :code_smells=>[{:type=>"Duplication",
                                                   :method=>"\"",
-                                                  :message=>"multiple times"}]}
+                                                  :message=>"multiple times"}]})
       # Note: hopefully a temporary solution until I figure out how to deal with newlines in the method call more effectively -Jake 5/11/2009
     end
   end
@@ -107,28 +109,28 @@ app/controllers/newline_controller.rb -- 1 warnings:
   context 'with Reek 1.1 output format' do
     it 'reports 1.1 style when the output is empty' do
       @reek.instance_variable_set(:@output, "")
-      @reek.should_not be_reek_12
+      expect(@reek).not_to be_reek_12
     end
     it 'detects 1.1 format output' do
       @reek.instance_variable_set(:@output, @lines11)
-      @reek.should_not be_reek_12
+      expect(@reek).not_to be_reek_12
     end
 
     it 'massages empty output to be unchanged' do
       @reek.instance_variable_set(:@output, "")
-      @reek.massage_for_reek_12.should be_empty
+      expect(@reek.massage_for_reek_12).to be_empty
     end
   end
 
   context 'with Reek 1.2 output format' do
     it 'detects 1.2 format output' do
       @reek.instance_variable_set(:@output, @lines12)
-      @reek.should be_reek_12
+      expect(@reek).to be_reek_12
     end
 
     it 'correctly massages 1.2 output' do
       @reek.instance_variable_set(:@output, @lines12)
-      @reek.massage_for_reek_12.should == @lines11
+      expect(@reek.massage_for_reek_12).to eq(@lines11)
     end
   end
 end

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

@@ -1,4 +1,5 @@
 require "spec_helper"
+MetricFu.metrics_require { 'roodi/roodi_grapher' }
 
 describe RoodiGrapher do
   before :each do
@@ -7,14 +8,14 @@ describe RoodiGrapher do
   end
 
   it "should respond to roodi_count and labels" do
-    @roodi_grapher.should respond_to(:roodi_count)
-    @roodi_grapher.should respond_to(:labels)
+    expect(@roodi_grapher).to respond_to(:roodi_count)
+    expect(@roodi_grapher).to respond_to(:labels)
   end
 
   describe "responding to #initialize" do
     it "should initialise roodi_count and labels" do
-      @roodi_grapher.roodi_count.should == []
-      @roodi_grapher.labels.should == {}
+      expect(@roodi_grapher.roodi_count).to eq([])
+      expect(@roodi_grapher.labels).to eq({})
     end
   end
 
@@ -26,12 +27,12 @@ describe RoodiGrapher do
       end
 
       it "should not push to roodi_count" do
-        @roodi_grapher.roodi_count.should_not_receive(:push)
+        expect(@roodi_grapher.roodi_count).not_to receive(:push)
         @roodi_grapher.get_metrics(@metrics, @date)
       end
 
       it "should not update labels with the date" do
-        @roodi_grapher.labels.should_not_receive(:update)
+        expect(@roodi_grapher.labels).not_to receive(:update)
         @roodi_grapher.get_metrics(@metrics, @date)
       end
     end
@@ -43,12 +44,12 @@ describe RoodiGrapher do
       end
 
       it "should push to roodi_count" do
-        @roodi_grapher.roodi_count.should_receive(:push).with(13)
+        expect(@roodi_grapher.roodi_count).to receive(:push).with(13)
         @roodi_grapher.get_metrics(@metrics, @date)
       end
 
       it "should update labels with the date" do
-        @roodi_grapher.labels.should_receive(:update).with({ 0 => "1/2" })
+        expect(@roodi_grapher.labels).to receive(:update).with({ 0 => "1/2" })
         @roodi_grapher.get_metrics(@metrics, @date)
       end
     end