code_metric_fu 4.14.0

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

@@ -0,0 +1,46 @@
+require "spec_helper"
+MetricFu.metrics_require { "hotspots/generator" }
+
+describe MetricFu::HotspotsGenerator do
+  describe "analyze method" do
+    it "should be empty on error" do
+      hotspots = MetricFu::HotspotsGenerator.new
+      hotspots.instance_variable_set(:@analyzer, nil)
+      result = hotspots.analyze
+      expect(result).to eq(files: [], classes: [], methods: [])
+    end
+
+    it "should put the changes into a hash" do
+      hotspots = MetricFu::HotspotsGenerator.new
+      hotspots.analyze
+      result = hotspots.to_h[:hotspots]
+      expected = HOTSPOT_DATA["generator_analysis.yml"]
+      # ensure expected granularities
+      expect(result.keys).to eq(expected.keys)
+
+      # for each granularity's location details
+      result.each do |granularity, location_details|
+        # map 2d array for this granularity of [details, location]
+        expected_result = expected.fetch(granularity).map { |ld| [ld.fetch("details"), ld.fetch("location")] }
+        # verify all the location details for this granularity match elements of expected_result
+        location_details.each do |location_detail|
+          location = location_detail.fetch("location")
+          details  = location_detail.fetch("details")
+          # get the location_detail array where the  where the locations (second element) match
+          expected_location_details = expected_result.rassoc(location)
+          # get the details (first element) from the expected location_details array
+          expected_details = expected_location_details[0]
+          expect(details).to eq(expected_details)
+        end
+      end
+    end
+
+    # really testing the output of analyzed_problems#worst_items
+    it "should return the worst item granularities: files, classes, methods" do
+      hotspots = MetricFu::HotspotsGenerator.new
+      yaml = HOTSPOT_DATA["generator.yml"]
+      analyzer = HotspotAnalyzer.new(yaml)
+      expect(hotspots.analyze.keys).to eq([:files, :classes, :methods])
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for rails_best_practices" do
+  it_behaves_like "configured" do
+    describe "if #rails? is true " do
+      before(:each) do
+        @config = MetricFu.configuration
+        allow(@config).to receive(:rails?).and_return(true)
+        @config.reset
+        MetricFu.configure
+        %w(rails_best_practices).each do |metric|
+          load_metric metric
+        end
+      end
+
+      describe "#set_graphs " do
+        it "should set the graphs to include rails_best_practices" do
+          expect(MetricFu::Metric.get_metric(:rails_best_practices).has_graph?).to be_truthy
+        end
+      end
+
+      it "should default @rails_best_practices to { :silent => true }" do
+        load_metric "rails_best_practices"
+        rbp = MetricFu::MetricRailsBestPractices.new
+        expect(rbp.run_options).to eq(exclude: [], silent: true)
+      end
+
+      it "can configure @rails_best_practices 'exclude' using the sugar" do
+        load_metric "rails_best_practices"
+        rbp = MetricFu::Metric.get_metric(:rails_best_practices)
+        rbp.exclude = ["config/chef"]
+        expect(rbp.run_options).to eq(
+                                     exclude: ["config/chef"],
+                                     silent: true
+                                   )
+
+      end
+    end
+
+    describe "if #rails? is false " do
+      before(:each) do
+        get_new_config
+        allow(@config).to receive(:rails?).and_return(false)
+        %w(rails_best_practices).each do |metric|
+          load_metric metric
+        end
+      end
+
+      it "should set the registered code_dirs to ['lib']" do
+        expect(directory("code_dirs")).to eq(["lib"])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+MetricFu.metrics_require { "rails_best_practices/generator" }
+
+describe RailsBestPracticesGenerator do
+  break if metric_not_activated?(:rails_best_practices)
+
+  describe "emit method" do
+    let(:analyzer) { ::RailsBestPractices::Analyzer.new(".",  "silent" => true) }
+    context "RailsBestPractices provides the expected API" do
+      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 { 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
+
+  describe "to_h method" do
+    it "should put things into a hash" do
+      MetricFu::Configuration.run {}
+      practices = MetricFu::RailsBestPracticesGenerator.new
+      practices.instance_variable_set(:@rails_best_practices_results, "the_practices")
+      expect(practices.to_h[:rails_best_practices]).to eq("the_practices")
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require "spec_helper"
+MetricFu.metrics_require { "rails_best_practices/grapher" }
+
+describe RailsBestPracticesGrapher do
+  before :each do
+    @stats_grapher = MetricFu::RailsBestPracticesGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to rails_best_practices_count and labels" do
+    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
+      expect(@stats_grapher.rails_best_practices_count).to eq([])
+      expect(@stats_grapher.labels).to eq({})
+    end
+  end
+
+  describe "responding to #get_metrics" do
+    context "when metrics were not generated" do
+      before(:each) do
+        @metrics = FIXTURE.load_metric("metric_missing.yml")
+        @date = "01022003"
+      end
+
+      it "should not push to rails_best_practices_count" do
+        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
+        expect(@stats_grapher.labels).not_to receive(:update)
+        @stats_grapher.get_metrics(@metrics, @date)
+      end
+    end
+
+    context "when metrics have been generated" do
+      before(:each) do
+        @metrics = FIXTURE.load_metric("20090630.yml")
+        @date = "01022003"
+      end
+
+      it "should push to rails_best_practices_count" do
+        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
+        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
+        expect(@stats_grapher.labels).to receive(:update).with(0 => "01022003")
+        @stats_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for rcov" do
+  it_behaves_like "configured" do
+    it "should set rcov run_options" do
+      load_metric "rcov"
+      expect(
+        MetricFu::Metric.get_metric(:rcov).run_options
+      ).to eq(
+
+        environment: "test",
+        external: nil,
+        test_files: Dir["{spec,test}/**/*_{spec,test}.rb"],
+        rcov_opts: [
+          "--sort coverage",
+          "--no-html",
+          "--text-coverage",
+          "--no-color",
+          "--profile",
+          "--exclude-only '.*'",
+          '--include-file "\Aapp,\Alib"',
+          "-Ispec"
+        ],
+      )
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require "spec_helper"
+MetricFu.metrics_require { "rcov/generator" }
+require "shared/test_coverage"
+
+describe MetricFu::RcovGenerator, "configured as rcov" do
+  it_behaves_like "rcov test coverage generator", :rcov do
+    describe "emit" do
+      before :each do
+        options = { external: nil }
+        @test_coverage = MetricFu::RcovGenerator.new(@default_options.merge(options))
+      end
+
+      it "should set the RAILS_ENV" do
+        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 }
+        @test_coverage = MetricFu::RcovGenerator.new(@default_options.merge(options))
+        expect(@test_coverage.command).to include("RAILS_ENV=metrics")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+MetricFu.metrics_require { "rcov/grapher" }
+
+describe RcovGrapher do
+  before :each do
+    @rcov_grapher = MetricFu::RcovGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to rcov_percent and labels" do
+    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
+      expect(@rcov_grapher.rcov_percent).to eq([])
+      expect(@rcov_grapher.labels).to eq({})
+    end
+  end
+
+  describe "responding to #get_metrics" do
+    context "when metrics were not generated" do
+      before(:each) do
+        @metrics = FIXTURE.load_metric("metric_missing.yml")
+        @date = "1/2"
+      end
+
+      it "should not push to rcov_percent" do
+        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
+        expect(@rcov_grapher.labels).not_to receive(:update)
+        @rcov_grapher.get_metrics(@metrics, @date)
+      end
+    end
+
+    context "when metrics have been generated" do
+      before(:each) do
+        @metrics = FIXTURE.load_metric("20090630.yml")
+        @date = "1/2"
+      end
+
+      it "should push to rcov_percent" do
+        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
+        expect(@rcov_grapher.labels).to receive(:update).with(0 => "1/2")
+        @rcov_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require "spec_helper"
+MetricFu.metrics_require { "hotspots/metric" }
+MetricFu.metrics_require { "hotspots/hotspot" }
+MetricFu.metrics_require { "hotspots/analysis/record" }
+MetricFu.metrics_require { "rcov/hotspot" }
+
+describe MetricFu::RcovHotspot do
+  describe "map" do
+    let(:zero_row) do
+      MetricFu::Record.new({ "percentage_uncovered" => 0.0 }, nil)
+    end
+
+    let(:non_zero_row) do
+      MetricFu::Record.new({ "percentage_uncovered" => 0.75 }, nil)
+    end
+
+    it { expect(subject.map(zero_row)).to eql(0.0) }
+    it { expect(subject.map(non_zero_row)).to eql(0.75) }
+  end
+end

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

@@ -0,0 +1,89 @@
+require "spec_helper"
+require "metric_fu/metrics/rcov/rcov_line"
+
+describe MetricFu::RCovLine do
+  describe "#to_h" do
+    it "returns a hash with the content and was_run" do
+      rcov_line = RCovLine.new("some content", 1)
+
+      expect(rcov_line.to_h).to eq(content: "some content", was_run: 1)
+    end
+  end
+
+  describe "#covered?" do
+    it "returns true if was_run is 1" do
+      rcov_line = RCovLine.new("", 1)
+
+      expect(rcov_line.covered?).to eq(true)
+    end
+
+    it "returns false if was_run is 0" do
+      rcov_line = RCovLine.new("", 0)
+
+      expect(rcov_line.covered?).to eq(false)
+    end
+
+    it "returns false if was_run is nil" do
+      rcov_line = RCovLine.new("", nil)
+
+      expect(rcov_line.covered?).to eq(false)
+    end
+  end
+
+  describe "#missed?" do
+    it "returns true if was_run is 0" do
+      rcov_line = RCovLine.new("", 0)
+
+      expect(rcov_line.missed?).to eq(true)
+    end
+
+    it "returns false if was_run is 1" do
+      rcov_line = RCovLine.new("", 1)
+
+      expect(rcov_line.missed?).to eq(false)
+    end
+
+    it "returns false if was_run is nil" do
+      rcov_line = RCovLine.new("", nil)
+
+      expect(rcov_line.missed?).to eq(false)
+    end
+  end
+
+  describe "#ignored?" do
+    it "returns true if was_run is nil" do
+      rcov_line = RCovLine.new("", nil)
+
+      expect(rcov_line.ignored?).to eq(true)
+    end
+
+    it "returns false if was_run is 1" do
+      rcov_line = RCovLine.new("", 1)
+
+      expect(rcov_line.ignored?).to eq(false)
+    end
+
+    it "returns false if was_run is 0" do
+      rcov_line = RCovLine.new("", 0)
+
+      expect(rcov_line.ignored?).to eq(false)
+    end
+  end
+
+  describe "#css_class" do
+    it "returns 'rcov_run' for an ignored line" do
+      rcov_line = RCovLine.new("", nil)
+      expect(rcov_line.css_class).to eq("rcov_run")
+    end
+
+    it "returns 'rcov_not_run' for a missed line" do
+      rcov_line = RCovLine.new("", 0)
+      expect(rcov_line.css_class).to eq("rcov_not_run")
+    end
+
+    it "returns 'rcov_run' for a covered line" do
+      rcov_line = RCovLine.new("", 1)
+      expect(rcov_line.css_class).to eq("rcov_run")
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require "spec_helper"
+require "simplecov"
+require "metric_fu/metrics/rcov/simplecov_formatter"
+require "metric_fu/metrics/rcov/generator"
+
+describe SimpleCov::Formatter::MetricFu do
+  before do
+    @rcov_file =  subject.coverage_file_path
+    File.delete(@rcov_file) if File.exists?(@rcov_file)
+
+    @result = SimpleCov::Result.new(
+
+       FIXTURE.fixtures_path.join("coverage.rb").expand_path.to_s =>
+        [1, 1, 1, 1, nil, 1, 0, 1, 1, nil, 0, 1, 1]
+
+    )
+  end
+
+  it "test_format" do
+    SimpleCov::Formatter::MetricFu.new.format(@result)
+
+    expect(File.exists?(@rcov_file)).to be_truthy
+  end
+
+  if SimpleCov.running
+    MetricFu.logger.info "Skipping specs while SimpleCov is running"
+  else
+    it "test_create_content" do
+      content = SimpleCov::Formatter::MetricFu::FormatLikeRCov.new(@result).format
+      test = "\=" * 80
+
+      expect(content).to match(/#{test}/)
+      expect(content).to match(/!!     value \* value/)
+    end
+
+    if defined?(JRUBY_VERSION)
+      STDOUT.puts "Skipping spec 'cause JRuby doesn't do Coverage right"
+    else
+      it "calculates the same coverage from an RCov report as from SimpleCov" do
+        SimpleCov.start # start coverage
+        require "fixtures/coverage-153"
+        result = SimpleCov.result # end coverage
+        source_file = result.source_files.first
+
+        # formatter ouputs this from simplecov result
+        rcov_text = SimpleCov::Formatter::MetricFu::FormatLikeRCov.new(result).format
+
+        # generator analyzes the rcov text
+        analyzed_rcov_text = MetricFu::RCovFormatCoverage.new(rcov_text).to_h
+        # [:lines, :percent_run, :methods]
+        covered_lines_from_rcov_text = analyzed_rcov_text["./spec/fixtures/coverage-153.rb"][:lines]
+        # https://github.com/colszowka/simplecov/blob/master/lib/simplecov/source_file.rb
+        expect(source_file.coverage.count).to eq(covered_lines_from_rcov_text.count)
+
+        line_coverage_from_rcov_text = covered_lines_from_rcov_text.map { |line| line[:was_run] }
+        expect(source_file.coverage).to eq(line_coverage_from_rcov_text)
+
+        expect(source_file.covered_percent).to eq(MetricFu::RCovFormatCoverage::TestCoverage.percent_run(covered_lines_from_rcov_text))
+
+        source_file.lines.each_with_index do |line, index|
+          expect(line.coverage).to eq(line_coverage_from_rcov_text[index])
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for reek" do
+  it_behaves_like "configured" do
+    it "should set @reek to {:dirs_to_reek => @code_dirs}" do
+      load_metric "reek"
+      expect(MetricFu::Metric.get_metric(:reek).run_options).to eq(
+              config_file_pattern: nil, dirs_to_reek: ["lib"]
+      )
+    end
+  end
+end