code_metric_fu 4.14.0

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

@@ -0,0 +1,105 @@
+require "spec_helper"
+MetricFu.metrics_require { "flay/generator" }
+
+describe MetricFu::FlayGenerator do
+  describe "emit method" do
+    it "should look at the dirs" do
+      options = { dirs_to_flay: ["app", "lib"] }
+      allow(File).to receive(:directory?).and_return(true)
+      @flay = MetricFu::FlayGenerator.new(options)
+
+      expect(@flay).to receive(:run!).with(" app lib")
+      output = @flay.emit
+    end
+
+    it "should limit flay scores by the minimum_score" do
+      options = { dirs_to_flay: [], minimum_score: 99 }
+      allow(File).to receive(:directory?).and_return(true)
+      @flay = MetricFu::FlayGenerator.new(options)
+
+      expect(@flay).to receive(:run!).with("--mass 99  ")
+      output = @flay.emit
+    end
+  end
+
+  describe "analyze method" do
+    before :each do
+      lines = <<-HERE
+Total score (lower is better) = 246
+
+
+1) IDENTICAL code found in :or (mass*2 = 68)
+  app/controllers/link_targets_controller.rb:57
+  app/controllers/primary_sites_controller.rb:138
+
+2) Similar code found in :if (mass = 64)
+  app/controllers/primary_sites_controller.rb:75
+  app/controllers/primary_sites_controller.rb:76
+  app/controllers/primary_sites_controller.rb:88
+  app/controllers/primary_sites_controller.rb:89
+      HERE
+      MetricFu::Configuration.run {}
+      allow(File).to receive(:directory?).and_return(true)
+      @flay = MetricFu::FlayGenerator.new("base_dir")
+      @flay.instance_variable_set(:@output, lines)
+    end
+
+    it "should analyze and return matches" do
+      expect(@flay.analyze).to eq([["Total score (lower is better) = 246"],
+                                   ["\n1) IDENTICAL code found in :or (mass*2 = 68)",
+                                    "app/controllers/link_targets_controller.rb:57",
+                                    "app/controllers/primary_sites_controller.rb:138"],
+                                   ["2) Similar code found in :if (mass = 64)",
+                                    "app/controllers/primary_sites_controller.rb:75",
+                                    "app/controllers/primary_sites_controller.rb:76",
+                                    "app/controllers/primary_sites_controller.rb:88",
+                                    "app/controllers/primary_sites_controller.rb:89"]])
+    end
+  end
+
+  describe "to_h method" do
+    before :each do
+      lines = [["Total score (lower is better) = 284"],
+               ["\n1) IDENTICAL code found in :or (mass*2 = 68)",
+                "app/controllers/link_targets_controller.rb:57",
+                "app/controllers/primary_sites_controller.rb:138"],
+               ["2) Similar code found in :if (mass = 64)",
+                "app/controllers/primary_sites_controller.rb:75",
+                "app/controllers/primary_sites_controller.rb:76",
+                "app/controllers/primary_sites_controller.rb:88",
+                "app/controllers/primary_sites_controller.rb:89"],
+               ["3) Similar code found in :defn (mass = 40)",
+                "app/controllers/link_targets_controller.rb:40",
+                "app/controllers/primary_sites_controller.rb:98"],
+               ["4) Similar code found in :defn (mass = 38)",
+                "app/controllers/link_targets_controller.rb:13",
+                "app/controllers/primary_sites_controller.rb:50"],
+               ["5) Similar code found in :defn (mass = 38)",
+                "app/models/primary_site.rb:104",
+                "app/models/primary_site.rb:109"],
+               ["6) Similar code found in :call (mass = 36)",
+                "app/controllers/bookmarklet_integration_controller.rb:6",
+                "app/controllers/bookmarklet_integration_controller.rb:17"]]
+
+      MetricFu::Configuration.run {}
+      allow(File).to receive(:directory?).and_return(true)
+      flay = MetricFu::FlayGenerator.new("base_dir")
+      flay.instance_variable_set(:@matches, lines)
+      @results = flay.to_h
+    end
+
+    it "should find the total_score" do
+      expect(@results[:flay][:total_score]).to eq("284")
+    end
+
+    it "should have 6 matches" do
+      expect(@results[:flay][:matches].size).to eq(6)
+    end
+
+    it "should capture info for match" do
+      expect(@results[:flay][:matches].first[:reason]).to match(/IDENTICAL/)
+      expect(@results[:flay][:matches].first[:matches].first[:name]).to match(/link_targets_controller/)
+      expect(@results[:flay][:matches].first[:matches].first[:line]).to eq("57")
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+MetricFu.metrics_require { "flay/grapher" }
+
+describe FlayGrapher do
+  before :each do
+    @flay_grapher = MetricFu::FlayGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to flay_score and labels" do
+    expect(@flay_grapher).to respond_to(:flay_score)
+    expect(@flay_grapher).to respond_to(:labels)
+  end
+
+  describe "responding to #initialize" do
+    it "should initialise flay_score and labels" do
+      expect(@flay_grapher.flay_score).to eq([])
+      expect(@flay_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 flay_score" do
+        expect(@flay_grapher.flay_score).not_to receive(:push)
+        @flay_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should not update labels with the date" do
+        expect(@flay_grapher.labels).not_to receive(:update)
+        @flay_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 flay_score" do
+        expect(@flay_grapher.flay_score).to receive(:push).with(476)
+        @flay_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should update labels with the date" do
+        expect(@flay_grapher.labels).to receive(:update).with(0 => "1/2")
+        @flay_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for flog" do
+  it_behaves_like "configured" do
+    if MetricFu.configuration.mri?
+      it "should set @flog to {:dirs_to_flog => @code_dirs}" do
+        load_metric "flog"
+        expect(MetricFu::Metric.get_metric(:flog).run_options).to eq(
+          all: true,
+          continue: true,
+          dirs_to_flog: ["lib"],
+          quiet: true
+         )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require "spec_helper"
+MetricFu.metrics_require { "flog/generator" }
+
+describe MetricFu::FlogGenerator do
+  break if metric_not_activated?(:flog)
+
+  before :each do
+    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
+      expect(FlogCLI).to receive(:parse_options).with(["--all", "--continue"]).and_return("options")
+      expect(FlogCLI).to receive(:new).with("options").and_return(flogger = double("flogger"))
+      files_to_flog = Dir[File.join('lib', '**/*.{rb,rake}')]
+      expect(flogger).to receive(:flog).with(*files_to_flog)
+      @flog.emit
+    end
+  end
+
+  describe "analyze method" do
+    it "should harvest the flog information and put it into method_containers" do
+      first_full_method_name = "ClassName#first_method_name"
+      second_full_method_name = "ClassName#second_method_name"
+
+      flogger = double("flogger", method_locations: { first_full_method_name => "/file/location.rb:11",
+                                                      second_full_method_name => "/file/location.rb:22" },
+                                  totals: { first_full_method_name => 11.11,
+                                            second_full_method_name => 22.22 })
+      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
+      )
+      @flog.instance_variable_set(:@flogger, flogger)
+      @flog.analyze
+      method_containers = @flog.instance_variable_get(:@method_containers)
+      expect(method_containers.size).to eq(1)
+
+      expected = { methods: { "ClassName#first_method_name" => { path: "/file/location.rb:11",
+                                                                 score: 11.11,
+                                                                 operators: { branch: 11.1,
+                                                                              puts: 1.1 } },
+                              "ClassName#second_method_name" => { path: "/file/location.rb:22",
+                                                                  score: 22.22,
+                                                                  operators: { branch: 22.2,
+                                                                               puts: 2.2 } } },
+                   path: "/file/location.rb",
+                   average_score: ((11.11 + 22.22) / 2.0),
+                   total_score: 33.33,
+                   highest_score: 22.22,
+                   name: "ClassName" }
+
+      expect(method_containers["ClassName"].to_h).to eq(expected)
+    end
+  end
+
+  describe "to_h method" do
+    it "should make-a nice hash" do
+      flogger = double("flogger", total_score: 111.1, average: 7.3)
+      @flog.instance_variable_set(:@flogger, flogger)
+      method_containers = { ignore_me_1: double("container_1", highest_score: 11.1, to_h: "container_1"),
+                            ignore_me_2: double("container_2", highest_score: 33.3, to_h: "container_2"),
+                            ignore_me_3: double("container_3", highest_score: 22.2, to_h: "container_3") }
+      @flog.instance_variable_set(:@method_containers, method_containers)
+
+      expected = { flog: { total: 111.1,
+                           average: 7.3,
+                           method_containers: ["container_2", "container_3", "container_1"] } }
+
+      expect(@flog.to_h).to eq(expected)
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require "spec_helper"
+MetricFu.metrics_require { "flog/grapher" }
+
+describe MetricFu::FlogGrapher do
+  before :each do
+    MetricFu.configuration
+    @flog_grapher = MetricFu::FlogGrapher.new
+  end
+
+  it "should respond to flog_total, flog_average and labels" do
+    expect(@flog_grapher).to respond_to(:flog_average)
+    expect(@flog_grapher).to respond_to(:labels)
+    expect(@flog_grapher).to respond_to(:top_five_percent_average)
+  end
+
+  describe "responding to #initialize" do
+    it "should initialize top_five_percent_average, flog_average and labels" do
+      expect(@flog_grapher.flog_average).to eq([])
+      expect(@flog_grapher.labels).to eq({})
+      expect(@flog_grapher.top_five_percent_average).to eq([])
+    end
+  end
+
+  describe "responding to #get_metrics" do
+    before(:each) do
+      methods = {}
+      100.times do |i|
+        methods["method_name_#{i}"] = { score: i.to_f }
+      end
+
+      @metrics = { flog: { total: 111.1,
+                           average: 7.7,
+                           method_containers: [{ methods: methods }] } }
+      @date = "1/2"
+    end
+
+    it "should push to top_five_percent_average" do
+      average = (99.0 + 98.0 + 97.0 + 96.0 + 95.0) / 5.0
+      expect(@flog_grapher.top_five_percent_average).to receive(:push).with(average)
+      @flog_grapher.get_metrics(@metrics, @date)
+    end
+
+    it "should push 9.9 to flog_average" do
+      expect(@flog_grapher.flog_average).to receive(:push).with(7.7)
+      @flog_grapher.get_metrics(@metrics, @date)
+    end
+
+    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 top_five_percent_average" do
+        expect(@flog_grapher.top_five_percent_average).not_to receive(:push)
+        @flog_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should not push to flog_average" do
+        expect(@flog_grapher.flog_average).not_to receive(:push)
+        @flog_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should not update labels with the date" do
+        expect(@flog_grapher.labels).not_to receive(:update)
+        @flog_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 top_five_percent_average" do
+        average = (73.6 + 68.5 + 66.1 + 46.6 + 44.8 + 44.1 + 41.2 + 36.0) / 8.0
+        expect(@flog_grapher.top_five_percent_average).to receive(:push).with(average)
+        @flog_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should push to flog_average" do
+        expect(@flog_grapher.flog_average).to receive(:push).with(9.9)
+        @flog_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should update labels with the date" do
+        expect(@flog_grapher.labels).to receive(:update).with(0 => "1/2")
+        @flog_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+
+  describe "responding to #get_metrics with legacy data" do
+    before(:each) do
+      @metrics = FIXTURE.load_metric("20090630.yml")
+
+      @date = "1/2"
+    end
+
+    it "should push to top_five_percent_average" do
+      average = (73.6 + 68.5 + 66.1 + 46.6 + 44.8 + 44.1 + 41.2 + 36.0) / 8.0
+      expect(@flog_grapher.top_five_percent_average).to receive(:push).with(average)
+      @flog_grapher.get_metrics(@metrics, @date)
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+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
+      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)
+      analyzed_problems = MetricFu::HotspotAnalyzedProblems.new(rankings, analyzer_tables)
+      @analyzed_problems[result_hash] = analyzed_problems
+      analyzed_problems
+    end
+  end
+
+  context "with several types of data" do
+    before do
+      @result_hash = HOTSPOT_DATA["several_metrics.yml"]
+      @analyzed_problems = analyzed_problems(@result_hash)
+      @worst_items = @analyzed_problems.worst_items
+    end
+
+    it "gives all issues for a class" do
+      expected = {
+        reek: "found 2 code smells",
+        flog: "complexity is 37.9"
+      }
+      # TODO Unsure if we want to make problems_with and location public or private at this point
+      expect(@worst_items[:classes].first.problems).to eq(expected)
+    end
+
+    it "gives all issues for a method" do
+      expected = {
+        reek: "found 1 code smells",
+        flog: "complexity is 37.9" }
+      expect(@worst_items[:methods].first.problems).to eq(expected)
+    end
+
+    it "gives all issues for a file" do
+      expected = {
+        reek: "found 2 code smells",
+        flog: "complexity is 37.9",
+        churn: "detected high level of churn (changed 54 times)" }
+      expect(@worst_items[:files].first.problems).to eq(expected)
+    end
+
+    it "provide location for a method" do
+      expected = MetricFu::Location.new("lib/client/client.rb",
+                                        "Client",
+                                        "Client#client_requested_sync")
+      expect(@worst_items[:methods].first.location).to eq(expected)
+    end
+
+    it "provides location for a class" do
+      expected = MetricFu::Location.new("lib/client/client.rb",
+                                        "Client",
+                                        nil)
+      expect(@worst_items[:classes].first.location).to eq(expected)
+    end
+
+    it "provides location for a file" do
+      expected = MetricFu::Location.new("lib/client/client.rb",
+                                        nil,
+                                        nil)
+      expect(@worst_items[:files].first.location).to eq(expected)
+    end
+  end
+
+  context "with Saikuro data" do
+    before do
+      @result_hash = HOTSPOT_DATA["saikuro.yml"]
+      @analyzed_problems = analyzed_problems(@result_hash)
+      @worst_items = @analyzed_problems.worst_items
+    end
+
+    it "gives complexity for method" do
+      expected = {
+        saikuro: "complexity is 1.0"
+      }
+      expect(@worst_items[:methods].last.problems).to eq(expected)
+    end
+
+    it "gives average complexity for class" do
+      expected = {
+        saikuro: "average complexity is 5.0"
+      }
+      expect(@worst_items[:classes].last.problems).to eq(expected)
+    end
+  end
+end

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