fastruby-metric_fu 5.0.0

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

@@ -0,0 +1,71 @@
+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
+      common_columns = %w{metric}
+      granularities =  %w{file_path class_name method_name}
+      tool_analyzers = MetricFu::Hotspot.analyzers
+      analyzer_columns = common_columns + granularities + tool_analyzers.map(&:columns).flatten
+
+      analyzer_tables = MetricFu::AnalyzerTables.new(analyzer_columns)
+      tool_analyzers.each do |analyzer|
+        analyzer.generate_records(result_hash[analyzer.name], analyzer_tables.table)
+      end
+      analyzer_tables.generate_records
+      rankings = MetricFu::HotspotRankings.new(analyzer_tables.tool_tables)
+      rankings.calculate_scores(tool_analyzers, granularities)
+      @analyzer_tables[result_hash] = analyzer_tables
+      analyzer_tables
+    end
+  end
+
+  context "with Stats data" do
+    before do
+      @result_hash = HOTSPOT_DATA["stats.yml"]
+      @table = analyzer_table(@result_hash).table
+    end
+
+    it "should have codeLOC" do
+      row = @table.find { |row| row["stat_name"] == :codeLOC }
+      expect(row["stat_value"]).to eq(4222)
+    end
+
+    it "should have testLOC" do
+      row = @table.find { |row| row["stat_name"] == :testLOC }
+      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 }
+      expect(row["stat_value"]).to eq(2)
+    end
+  end
+
+  context "with three different path representations of file (from Saikuro, Flog, and Reek)" do
+    before do
+      @result_hash = HOTSPOT_DATA["three_metrics_on_same_file.yml"]
+      @table = analyzer_table(@result_hash).table
+    end
+
+    specify "all records should have full file_path" do
+      @table.each do |row|
+        expect(row["file_path"]).to eq("lib/client/client.rb")
+      end
+    end
+
+    specify "all records should have class name" do
+      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
+      expect(@table.select { |rows| rows.fetch(:method_name, :no_key) == nil }.size).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+MetricFu.metrics_require { "hotspots/analysis/ranking" }
+
+describe MetricFu::Ranking do
+  context "with many items" do
+    specify "#top" do
+      ranking = Ranking.new
+      ranking[:a] = 10
+      ranking[:b] = 50
+      ranking[:c] = 1
+      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
+      expect(ranking.percentile(:a)).to eq(0)
+    end
+
+    specify "highest item is at high percentile" do
+      ranking = Ranking.new
+      ranking[:a] = 10
+      ranking[:b] = 50
+      ranking[:c] = 0
+      ranking[:d] = 5
+      expect(ranking.percentile(:b)).to eq(0.75)
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+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
+      common_columns = %w{metric}
+      granularities =  %w{file_path class_name method_name}
+      tool_analyzers = MetricFu::Hotspot.analyzers
+      analyzer_columns = common_columns + granularities + tool_analyzers.map(&:columns).flatten
+
+      analyzer_tables = MetricFu::AnalyzerTables.new(analyzer_columns)
+      tool_analyzers.each do |analyzer|
+        analyzer.generate_records(result_hash[analyzer.name], analyzer_tables.table)
+      end
+      analyzer_tables.generate_records
+      rankings = MetricFu::HotspotRankings.new(analyzer_tables.tool_tables)
+      rankings.calculate_scores(tool_analyzers, granularities)
+      @rankings[result_hash] = rankings
+      rankings
+    end
+  end
+  context "with several types of data" do
+    it "gives all files, in order, from worst to best" do
+      expected = [
+        "lib/client/client.rb",
+        "lib/client/foo.rb"]
+      expect(rankings(result_hash).worst_files).to eq(expected)
+    end
+    def result_hash
+      @result_hash ||= HOTSPOT_DATA["several_metrics.yml"]
+    end
+  end
+  context "with Reek data" do
+    before do
+      @result_hash = HOTSPOT_DATA["reek.yml"]
+    end
+
+    it "gives worst method" do
+      expect(rankings(@result_hash).worst_methods[0]).to eq("Client#client_requested_sync")
+    end
+
+    it "gives worst class" do
+      expect(rankings(@result_hash).worst_classes[0]).to eq("Client")
+    end
+
+    it "gives worst file" do
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/client/client.rb")
+    end
+  end
+  context "with Saikuro data" do
+    before do
+      @result_hash = HOTSPOT_DATA["saikuro.yml"]
+    end
+
+    it "gives worst method" do
+      expect(rankings(@result_hash).worst_methods[0]).to eq("Supr#self.handle_full_or_hash_option")
+    end
+
+    it "gives worst class" do
+      expect(rankings(@result_hash).worst_classes[0]).to eq("Bitly")
+    end
+  end
+  context "with Flog data" do
+    before do
+      @result_hash = HOTSPOT_DATA["flog.yml"]
+    end
+
+    it "gives worst method" do
+      expect(rankings(@result_hash).worst_methods[0]).to eq("main#none")
+    end
+
+    it "gives worst class" do
+      expect(rankings(@result_hash).worst_classes[0]).to eq("main")
+    end
+
+    it "gives worst file" do
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/generators/rcov.rb:57")
+    end
+  end
+
+  context "with Roodi data" do
+    before do
+      @result_hash = HOTSPOT_DATA["roodi.yml"]
+    end
+
+    it "gives worst file" do
+      expect(rankings(@result_hash).worst_files[0]).to eq("lib/client/client.rb")
+    end
+  end
+end

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

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

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