code_metric_fu 4.14.0

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

@@ -0,0 +1,169 @@
+require "spec_helper"
+MetricFu.metrics_require { "reek/generator" }
+
+describe MetricFu::ReekGenerator do
+  describe "emit" do
+    let(:options) { { dirs_to_reek: [] } }
+    let(:files_to_analyze) { ["lib/foo.rb", "lib/bar.rb"] }
+    let(:reek) { MetricFu::ReekGenerator.new(options) }
+
+    before :each do
+      allow(reek).to receive(:files_to_analyze).and_return(files_to_analyze)
+    end
+
+    it "includes config file pattern into reek parameters when specified" do
+      options.merge!(config_file_pattern: "lib/config/*.reek")
+
+      expect(reek).to receive(:run!) do |_files, config_files|
+        expect(config_files).to eq(["lib/config/*.reek"])
+      end.and_return("")
+
+      reek.emit
+    end
+
+    it "passes an empty array when no config file pattern is specified" do
+      expect(reek).to receive(:run!) do |_files, config_files|
+        expect(config_files).to eq([])
+      end.and_return("")
+
+      reek.emit
+    end
+
+    it "includes files to analyze into reek parameters" do
+      expect(reek).to receive(:run!) do |files, _config_files|
+        expect(files).to eq(["lib/foo.rb", "lib/bar.rb"])
+      end.and_return("")
+
+      reek.emit
+    end
+  end
+
+  describe "analyze method" do
+    before :each do
+      MetricFu::Configuration.run {}
+      allow(File).to receive(:directory?).and_return(true)
+      @reek = MetricFu::ReekGenerator.new
+      @examiner = @reek.send(:examiner)
+      @smell_warning = Reek.const_defined?(:SmellWarning) ? Reek.const_get(:SmellWarning) : Reek.const_get(:Smells).const_get(:SmellWarning)
+      if @smell_warning.instance_methods.include?(:subclass)
+        @smell_warning.send(:alias_method, :smell_type, :subclass)
+      end
+    end
+
+    context "with reek warnings" do
+      before :each do
+        @smells = [
+            instance_double(@smell_warning,
+                            source: "app/controllers/activity_reports_controller.rb",
+                            context: "ActivityReportsController#authorize_user",
+                            message: "calls current_user.primary_site_ids multiple times",
+                            smell_type: "Duplication",
+                            lines: [2, 4]),
+            instance_double(@smell_warning,
+                            source: "app/controllers/activity_reports_controller.rb",
+                            context: "ActivityReportsController#authorize_user",
+                            message: "calls params[id] multiple times",
+                            smell_type: "Duplication",
+                            lines: [5, 7]),
+            instance_double(@smell_warning,
+                            source: "app/controllers/activity_reports_controller.rb",
+                            context: "ActivityReportsController#authorize_user",
+                            message: "calls params[primary_site_id] multiple times",
+                            smell_type: "Duplication",
+                            lines: [11, 15]),
+            instance_double(@smell_warning,
+                            source: "app/controllers/activity_reports_controller.rb",
+                            context: "ActivityReportsController#authorize_user",
+                            message: "has approx 6 statements",
+                            smell_type: "Long Method",
+                            lines: [8]),
+
+            instance_double(@smell_warning,
+                            source: "app/controllers/application.rb",
+                            context: "ApplicationController#start_background_task/block/block",
+                            message: "is nested",
+                            smell_type: "Nested Iterators",
+                            lines: [23]),
+
+            instance_double(@smell_warning,
+                            source: "app/controllers/link_targets_controller.rb",
+                            context: "LinkTargetsController#authorize_user",
+                            message: "calls current_user.role multiple times",
+                            smell_type: "Duplication",
+                            lines: [8]),
+
+            instance_double(@smell_warning,
+                            source: "app/controllers/newline_controller.rb",
+                            context: "NewlineController#some_method",
+                            message: "calls current_user.<< \"new line\n\" multiple times",
+                            smell_type: "Duplication",
+                            lines: [6, 9])
+        ]
+        @lines = instance_double(@examiner, smells: @smells)
+        @reek.instance_variable_set(:@output, @lines)
+        @matches = @reek.analyze
+      end
+
+      it "should find the code smell's line numbers" do
+        smell = @matches.first[:code_smells].first
+        expect(smell[:lines]).to eq([2, 4])
+      end
+
+      it "should find the code smell's method name" do
+        smell = @matches.first[:code_smells].first
+        expect(smell[:method]).to eq("ActivityReportsController#authorize_user")
+      end
+
+      it "should find the code smell's type" do
+        smell = @matches[1][:code_smells].first
+        expect(smell[:type]).to eq("Nested Iterators")
+      end
+
+      it "should find the code smell's message" do
+        smell = @matches[1][:code_smells].first
+        expect(smell[:message]).to eq("is nested")
+      end
+
+      it "should find the code smell's type" do
+        smell = @matches.first
+        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
+        expect(@matches.last[:code_smells]).to eq(@matches.last[:code_smells].compact)
+      end
+    end
+
+    context "with reek 1.3 output" do
+      before :each do
+        @smells = [
+            double(source: "app/controllers/activity_reports_controller.rb",
+                   context: "ActivityReportsController#authorize_user",
+                   message: "calls current_user.primary_site_ids multiple times",
+                   subclass: "Duplication",
+                   lines: [2, 4]),
+        ]
+        @lines = instance_double(@examiner, smells: @smells)
+        @reek.instance_variable_set(:@output, @lines)
+        @matches = @reek.analyze
+      end
+
+      it "uses the subclass field to find the smell type" do
+        smell = @matches.first[:code_smells].first
+        expect(smell[:type]).to eq('Duplication')
+      end
+    end
+
+    context "without reek warnings" do
+      before :each do
+        @lines = instance_double(@examiner, smells: [])
+        @reek.instance_variable_set(:@output, @lines)
+        @matches = @reek.analyze
+      end
+
+      it "returns empty analysis" do
+        expect(@matches).to eq([])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require "spec_helper"
+MetricFu.metrics_require { "reek/grapher" }
+
+describe ReekGrapher do
+  before :each do
+    @reek_grapher = MetricFu::ReekGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to reek_count and labels" do
+    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
+      expect(@reek_grapher.reek_count).to eq({})
+      expect(@reek_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 set a hash of code smells to reek_count" do
+        @reek_grapher.get_metrics(@metrics, @date)
+        expect(@reek_grapher.reek_count).to eq({})
+      end
+
+      it "should not update labels with the date" do
+        expect(@reek_grapher.labels).not_to receive(:update)
+        @reek_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 set a hash of code smells to reek_count" do
+        @reek_grapher.get_metrics(@metrics, @date)
+        expect(@reek_grapher.reek_count).to eq(
+          "Uncommunicative Name" => [27],
+          "Feature Envy" => [20],
+          "Utility Function" => [15],
+          "Long Method" => [26],
+          "Nested Iterators" => [12],
+          "Control Couple" => [4],
+          "Duplication" => [48],
+          "Large Class" => [1]
+        )
+      end
+
+      it "should update labels with the date" do
+        expect(@reek_grapher.labels).to receive(:update).with(0 => "1/2")
+        @reek_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for roodi" do
+  it_behaves_like "configured" do
+    it "should set @roodi to {:dirs_to_roodi => @code_dirs}" do
+      load_metric "roodi"
+      expect(MetricFu::Metric.get_metric(:roodi).run_options).to eq(
+               dirs_to_roodi: directory("code_dirs"),
+               roodi_config: "#{directory('root_directory')}/config/roodi_config.yml"
+              )
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require "spec_helper"
+MetricFu.metrics_require { "roodi/generator" }
+
+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)
+      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)
+      allow(roodi).to receive(:run!)
+      expect(roodi).to receive(:run!).with(/-config/).never
+      roodi.emit
+    end
+  end
+
+  describe "analyze" do
+    context "when it has multiple failures" do
+      before :each do
+        lines = <<-HERE
+
+Running Roodi checks
+./app/models/some_model.rb:14 - Found = in conditional.  It should probably be an ==
+lib/some_file.rb:53 - Rescue block should not be empty.
+
+Checked 65 files
+        HERE
+
+        roodi = MetricFu::RoodiGenerator.new
+        roodi.instance_variable_set(:@output, lines)
+        @matches = roodi.analyze
+      end
+
+      it "should find all problems" do
+        problem_count = @matches[:problems].size
+        expect(problem_count).to eq(2)
+      end
+
+      it "should find the file of the problem" do
+        problem = @matches[:problems].first
+        expect(problem[:file]).to eq("./app/models/some_model.rb")
+      end
+
+      it "should find the line of the problem" do
+        problem = @matches[:problems].first
+        expect(problem[:line]).to eq("14")
+      end
+
+      it "should find the description of the problem" do
+        problem = @matches[:problems].first
+        expect(problem[:problem]).to eq("Found = in conditional.  It should probably be an ==")
+      end
+    end
+  end
+
+  context "when it has no failures" do
+    before :each do
+      lines = <<-HERE
+
+Running Roodi checks
+
+Checked 42 files
+Found 0 errors.
+
+      HERE
+
+      roodi = MetricFu::RoodiGenerator.new
+      roodi.instance_variable_set(:@output, lines)
+      @matches = roodi.analyze
+    end
+
+    it "should have no problems" do
+      problem_count = @matches[:problems].size
+      expect(problem_count).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+MetricFu.metrics_require { "roodi/grapher" }
+
+describe RoodiGrapher do
+  before :each do
+    @roodi_grapher = MetricFu::RoodiGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to roodi_count and labels" do
+    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
+      expect(@roodi_grapher.roodi_count).to eq([])
+      expect(@roodi_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 roodi_count" do
+        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
+        expect(@roodi_grapher.labels).not_to receive(:update)
+        @roodi_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 roodi_count" do
+        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
+        expect(@roodi_grapher.labels).to receive(:update).with(0 => "1/2")
+        @roodi_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for saikuro" do
+  it_behaves_like "configured" do
+    it "should set @saikuro to { :output_directory => @scratch_directory + '/saikuro',
+                                 :input_directory => @code_dirs,
+                                 :cyclo => '',
+                                 :filter_cyclo => '0',
+                                 :warn_cyclo => '5',
+                                 :error_cyclo => '7',
+                                 :formater => 'text' }" do
+      load_metric "saikuro"
+      expect(MetricFu::Metric.get_metric(:saikuro).run_options).to eq(
+               output_directory: "#{scratch_directory}/saikuro",
+               input_directory: ["lib"],
+               cyclo: "",
+               filter_cyclo: "0",
+               warn_cyclo: "5",
+               error_cyclo: "7",
+               formater: "text"
+                    )
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "spec_helper"
+MetricFu.metrics_require { "saikuro/generator" }
+
+describe MetricFu::SaikuroGenerator do
+  STUB_TEST_DATA = lambda do |generator|
+    # set test data dir; ensure it doesn't get cleared
+    def generator.metric_directory
+      FIXTURE.fixtures_path.join("saikuro").to_s
+    end
+    def generator.clear_scratch_files!
+      # no-op
+    end
+  end
+  describe "to_h method" do
+    before do
+      options = {}
+      saikuro = MetricFu::SaikuroGenerator.new(options)
+      STUB_TEST_DATA[saikuro]
+
+      saikuro.analyze
+      @output = saikuro.to_h
+    end
+
+    it "should find the filename of a file" do
+      expect(@output[:saikuro][:files].first[:filename]).to eq("app/controllers/users_controller.rb")
+    end
+
+    it "should find the name of the classes" do
+      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
+      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
+      expect(@output[:saikuro][:methods].first[:complexity]).to eq(4)
+    end
+
+    it "should find the lines of a method" do
+      expect(@output[:saikuro][:methods].first[:lines]).to eq(15)
+    end
+  end
+
+  describe "per_file_info method" do
+    before :all do
+      options = {}
+      @saikuro = MetricFu::SaikuroGenerator.new(options)
+      STUB_TEST_DATA[@saikuro]
+      @saikuro.analyze
+      @output = @saikuro.to_h
+    end
+
+    it "doesn't try to get information if the file does not exist" do
+      expect(@saikuro).to receive(:file_not_exists?).at_least(:once).and_return(true)
+      @saikuro.per_file_info("ignore_me")
+    end
+  end
+
+  describe MetricFu::SaikuroScratchFile do
+    describe "getting elements from a Saikuro result file" 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
+        expect(sfile.elements.map(&:complexity).sort).to eql(["0", "0", "2"])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require "spec_helper"
+MetricFu.metrics_require { "stats/generator" }
+
+describe StatsGenerator do
+  describe "emit method" do
+    it "should gather the raw data" do
+      ENV["CC_BUILD_ARTIFACTS"] = nil
+      MetricFu.configure.reset
+      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*/, "")
+      +----------------------+-------+-------+---------+---------+-----+-------+
+      | Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |
+      +----------------------+-------+-------+---------+---------+-----+-------+
+      | Controllers          |   470 |   382 |       7 |      53 |   7 |     5 |
+      | Helpers              |   128 |    65 |       0 |       6 |   0 |     8 |
+      | Models               |   351 |   285 |       9 |      31 |   3 |     7 |
+      | Libraries            |   305 |   183 |       2 |      30 |  15 |     4 |
+      | Model specs          |   860 |   719 |       0 |       2 |   0 |   357 |
+      | View specs           |     0 |     0 |       0 |       0 |   0 |     0 |
+      | Controller specs     |  1570 |  1308 |       1 |      10 |  10 |   128 |
+      | Helper specs         |   191 |   172 |       0 |       0 |   0 |     0 |
+      | Library specs        |    31 |    27 |       0 |       0 |   0 |     0 |
+      +----------------------+-------+-------+---------+---------+-----+-------+
+      | Total                |  3906 |  3141 |      19 |     132 |   6 |    21 |
+      +----------------------+-------+-------+---------+---------+-----+-------+
+        Code LOC: 915     Test LOC: 2226     Code to Test Ratio: 1:2.4
+
+      HERE
+      ENV["CC_BUILD_ARTIFACTS"] = nil
+      MetricFu.configure.reset
+      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
+      expect(@results[:codeLOC]).to eq(915)
+    end
+
+    it "should get test Lines Of Code" do
+      expect(@results[:testLOC]).to eq(2226)
+    end
+
+    it "should get code to test ratio" do
+      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" }
+      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
+      lines =  <<-HERE.gsub(/^\s*/, "")
+      +----------------------+-------+-------+---------+---------+-----+-------+
+      | Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |
+      +----------------------+-------+-------+---------+---------+-----+-------+
+      +----------------------+-------+-------+---------+---------+-----+-------+
+        Code LOC: 0     Test LOC: 0     Code to Test Ratio: 1:NaN
+
+      HERE
+      ENV["CC_BUILD_ARTIFACTS"] = nil
+      MetricFu.configure.reset
+      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
+      expect(@results[:code_to_test_ratio]).to eq(0.0)
+    end
+  end
+
+  describe "to_h method" do
+    it "should put things into a hash" do
+      ENV["CC_BUILD_ARTIFACTS"] = nil
+      MetricFu.configure.reset
+      allow(File).to receive(:directory?).and_return(true)
+      stats = MetricFu::StatsGenerator.new
+      stats.instance_variable_set(:@stats, "the_stats")
+      expect(stats.to_h[:stats]).to eq("the_stats")
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+MetricFu.metrics_require { "stats/grapher" }
+
+describe StatsGrapher do
+  before :each do
+    @stats_grapher = MetricFu::StatsGrapher.new
+    MetricFu.configuration
+  end
+
+  it "should respond to loc_counts and lot_counts and labels" do
+    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
+      expect(@stats_grapher.loc_counts).to eq([])
+      expect(@stats_grapher.lot_counts).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 loc_counts" do
+        expect(@stats_grapher.loc_counts).not_to receive(:push)
+        @stats_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should not push to lot_counts" do
+        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
+        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 loc_counts" do
+        expect(@stats_grapher.loc_counts).to receive(:push).with(15935)
+        @stats_grapher.get_metrics(@metrics, @date)
+      end
+
+      it "should push to lot_counts" do
+        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
+        expect(@stats_grapher.labels).to receive(:update).with(0 => "01022003")
+        @stats_grapher.get_metrics(@metrics, @date)
+      end
+    end
+  end
+end