code_metric_fu 4.14.0

data/spec/metric_fu/reporter_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+MetricFu.lib_require { "reporter" }
+
+describe MetricFu::Reporter do
+  context "given a single formatter" do
+    before do
+      @formatter = double("formatter")
+      allow(@formatter).to receive(:to_a).and_return([@formatter])
+      @reporter = Reporter.new(@formatter)
+    end
+
+    it "notifies the formatter" do
+      expect(@formatter).to receive(:start)
+      expect(@formatter).to receive(:finish)
+      @reporter.start
+      @reporter.finish
+    end
+
+    it "only sends notifications when supported by formatter" do
+      allow(@formatter).to receive(:respond_to?).with(:display_results).and_return(false)
+      expect(@formatter).not_to receive(:display_results)
+      @reporter.display_results
+    end
+  end
+
+  context "given multiple formatters" do
+    before do
+      @formatters = [double("formatter"), double("formatter")]
+      @reporter = Reporter.new(@formatters)
+    end
+
+    it "notifies all formatters" do
+      @formatters.each do |formatter|
+        expect(formatter).to receive(:start)
+        expect(formatter).to receive(:finish)
+      end
+      @reporter.start
+      @reporter.finish
+    end
+  end
+end

data/spec/metric_fu/reporting/graphs/graph_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+MetricFu.reporting_require { "graphs/graph" }
+
+describe MetricFu do
+  describe "responding to #graph" do
+    it "should return an instance of Graph" do
+      expect(MetricFu.graph).to be_a(Graph)
+    end
+  end
+end
+
+describe MetricFu::Graph do
+  before(:each) do
+    @graph = MetricFu::Graph.new
+  end
+
+  describe "setting the date on the graph" do
+    # TODO better test
+    it "should set the date once for one data point" do
+      metric_file = "metric_fu/tmp/_data/20101105.yml"
+      expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
+      expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
+      double_grapher = double
+      expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
+      expect(double_grapher).to receive(:graph!)
+
+      @graph.graphers = [double_grapher]
+      @graph.generate
+    end
+
+    # TODO better test
+    it "should set the date when the data directory isn't in the default place" do
+      metric_file = "/some/kind/of/weird/directory/somebody/configured/_data/20101105.yml"
+      expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
+      expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
+      double_grapher = double
+      expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
+      expect(double_grapher).to receive(:graph!)
+
+      @graph.graphers = [double_grapher]
+      @graph.generate
+    end
+  end
+end

data/spec/metric_fu/reporting/graphs/grapher_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "Bluff graphers responding to #graph!" do
+  before do
+    setup_fs
+  end
+  after do
+    cleanup_fs
+  end
+  it "should write chart file" do
+    graphs = {}
+    available_graphs = MetricFu::Metric.enabled_metrics.select(&:has_graph?).map(&:name)
+    available_graphs.each do |graph|
+      grapher_name = graph.to_s.gsub("MetricFu::", "").gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      grapher_name =  grapher_name + "Grapher"
+      graphs[graph] = MetricFu.const_get(grapher_name).new
+    end
+    graphs.each do |key, val|
+      val.graph!
+      output_dir = File.expand_path(File.join(MetricFu::Io::FileSystem.directory("output_directory")))
+      expect { File.read(File.join(output_dir, "#{key.to_s.downcase}.js")) }.not_to raise_error
+    end
+  end
+end

data/spec/metric_fu/reporting/result_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+MetricFu.reporting_require { "result" }
+
+describe MetricFu do
+  describe "#result" do
+    it "should return an instance of Result" do
+      expect(MetricFu.result.instance_of?(Result)).to be(true)
+    end
+  end
+end
+
+describe MetricFu::Result do
+  before(:each) do
+    @result = MetricFu::Result.new
+  end
+
+  describe "#as_yaml" do
+    it "should call #result_hash" do
+      result_hash = double("result_hash")
+      expect(result_hash).to receive(:to_yaml)
+
+      expect(@result).to receive(:result_hash).and_return(result_hash)
+      @result.as_yaml
+    end
+  end
+
+  describe "#result_hash" do
+  end
+
+  describe "#add" do
+    it "should add a passed hash to the result_hash instance variable" do
+      result_type = double("result_type")
+      allow(result_type).to receive(:to_s).and_return("type")
+
+      result_inst = double("result_inst")
+      expect(result_type).to receive(:new).and_return(result_inst)
+
+      expect(result_inst).to receive(:generate_result).and_return(a: "b")
+      expect(result_inst).to receive(:respond_to?).and_return(false)
+
+      expect(MetricFu::Generator).to receive(:get_generator).
+        with(result_type).and_return(result_type)
+      result_hash = double("result_hash")
+      expect(result_hash).to receive(:merge!).with(a: "b")
+      expect(@result).to receive(:result_hash).and_return(result_hash)
+      expect(@result).to receive(:metric_options_for_result_type).with(result_type)
+      @result.add(result_type)
+    end
+  end
+end

data/spec/metric_fu/run_spec.rb

@@ -0,0 +1,197 @@
+require "spec_helper"
+require "metric_fu/cli/client"
+
+describe MetricFu do
+  let(:helper)  { MetricFu::Cli::Helper.new }
+
+  before do
+    setup_fs
+  end
+
+  def base_directory
+    directory("base_directory")
+  end
+
+  def output_directory
+    directory("output_directory")
+  end
+
+  def data_directory
+    directory("data_directory")
+  end
+
+  context "given configured metrics, when run" do
+    before do
+      # TODO: Should probably use some sort of fake metric
+      # to speed up tests. For now, just configuring with a
+      # limited set, so we can test the basic functionality
+      # without significantly slowing down the specs.
+      MetricFu.configuration.configure_metrics do |metric|
+        if metric.name == :cane
+          metric.enable
+          metric.activated = true
+          # so this doesn't seem to always be true
+          # @bf4 adding that line you thought I didn't need made tests pass for me
+          # but they failed on one of the travis builds.
+          # swapping this line all seem to pass every run
+          # I don't understand what is happening in run_external well enough
+          # need some help debugging
+          # but tests seem more stable without it.
+          # metric.should_receive(:run_external).and_return('')
+          allow(metric).to receive(:run_external).and_return("")
+        else
+          metric.enabled = false
+        end
+      end
+    end
+
+    it "creates a report yaml file" do
+      expect { metric_fu }.to create_file("#{base_directory}/report.yml")
+    end
+
+    it "creates a data yaml file" do
+      expect { metric_fu }.to create_file("#{data_directory}/#{MetricFu.report_id}.yml")
+    end
+
+    it "creates a report html file" do
+      expect { metric_fu }.to create_file("#{output_directory}/index.html")
+    end
+
+    context "with configured formatter" do
+      it "outputs using configured formatter" do
+        expect {
+          MetricFu::Configuration.run do |config|
+            config.configure_formatter(:yaml)
+          end
+          metric_fu
+        }.to create_file("#{base_directory}/report.yml")
+      end
+
+      it "doesn't output using formatters not configured" do
+        expect {
+          MetricFu::Configuration.run do |config|
+            config.configure_formatter(:yaml)
+          end
+          metric_fu
+        }.to_not create_file("#{output_directory}/index.html")
+      end
+    end
+
+    context "with command line formatter" do
+      it "outputs using command line formatter" do
+        expect { metric_fu "--format yaml" }.to create_file("#{base_directory}/report.yml")
+      end
+
+      it "doesn't output using formatters not configured" do
+        expect { metric_fu "--format yaml" }.to_not create_file("#{output_directory}/index.html")
+      end
+    end
+
+    context "with configured and command line formatter" do
+      before do
+        MetricFu::Configuration.run do |config|
+          config.configure_formatter(:html)
+        end
+      end
+
+      it "outputs using command line formatter" do
+        expect { metric_fu "--format yaml" }.to create_file("#{base_directory}/report.yml")
+      end
+
+      it "doesn't output using configured formatter (cli takes precedence)" do
+        expect { metric_fu "--format yaml" }.to_not create_file("#{output_directory}/index.html")
+      end
+    end
+
+    context "with configured specified out" do
+      it "outputs using configured out" do
+        expect {
+          MetricFu::Configuration.run do |config|
+            config.configure_formatter(:yaml, "customreport.yml")
+          end
+          metric_fu
+        }.to create_file("#{base_directory}/customreport.yml")
+      end
+
+      it "doesn't output using formatters not configured" do
+        expect {
+          MetricFu::Configuration.run do |config|
+            config.configure_formatter(:yaml, "customreport.yml")
+          end
+          metric_fu
+        }.to_not create_file("#{base_directory}/report.yml")
+      end
+    end
+
+    context "with command line specified formatter + out" do
+      it "outputs to the specified path" do
+        expect { metric_fu "--format yaml --out customreport.yml" }.to create_file("#{base_directory}/customreport.yml")
+      end
+
+      it "doesn't output to default path" do
+        expect { metric_fu "--format yaml --out customreport.yml" }.to_not create_file("#{base_directory}/report.yml")
+      end
+    end
+
+    context "with command line specified out only" do
+      it "outputs to the specified path" do
+        expect { metric_fu "--out customdir --no-open" }.to create_file("#{base_directory}/customdir/index.html")
+      end
+
+      it "doesn't output to default path" do
+        expect { metric_fu "--out customdir --no-open" }.to_not create_file("#{output_directory}/index.html")
+      end
+    end
+
+    after do
+      MetricFu::Configuration.run do |config|
+        config.formatters.clear
+      end
+    end
+  end
+
+  context "given other options" do
+    it "displays help" do
+      out = metric_fu "--help"
+      expect(out).to include helper.banner
+    end
+
+    it "displays version" do
+      out = metric_fu "--version"
+      expect(out).to include "#{MetricFu::VERSION}"
+    end
+
+    it "errors on unknown flags" do
+      failure = false
+      out = metric_fu "--asdasdasda" do |_message|
+        # swallow the error message
+        failure = true
+      end
+      expect(out).to include "invalid option"
+      expect(failure).to be_truthy
+    end
+  end
+
+  after do
+    cleanup_fs
+  end
+
+  def metric_fu(options = "--no-open")
+    message = ""
+    out = MetricFu::Utility.capture_output {
+      begin
+        argv = Shellwords.shellwords(options)
+        MetricFu::Cli::Client.new.run(argv)
+        # Catch system exit so that it doesn't halt spec.
+      rescue SystemExit => system_exit
+        status =  system_exit.success? ? "SUCCESS" : "FAILURE"
+        message << "#{status} with code #{system_exit.status}: "
+        message << "#{system_exit.message} #{system_exit.backtrace}"
+      end
+    }
+    if message.start_with?("FAILURE")
+      block_given? ? yield(message) : STDERR.puts(message)
+    end
+    out
+  end
+end

data/spec/metric_fu/templates/configuration_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+require "shared/configured"
+
+describe MetricFu::Configuration, "for templates" do
+  it_behaves_like "configured" do
+    describe "when there is no CC_BUILD_ARTIFACTS environment variable" do
+      before(:each) do
+        ENV["CC_BUILD_ARTIFACTS"] = nil
+        get_new_config
+      end
+
+      it "should set @template_directory to the lib/templates relative " +         "to @metric_fu_root_directory" do
+        expected_template_dir = MetricFu.root.join("lib", "templates").to_s
+        expect(template_directory).to eq(expected_template_dir)
+      end
+
+      it "should set @template_class to MetricFu::Templates::MetricsTemplate by default" do
+        expect(template_class).to eq(MetricFu::Templates::MetricsTemplate)
+      end
+
+      describe "when a templates configuration is given" do
+        before do
+          class DummyTemplate; end
+
+          @config.templates_configuration do |config|
+            config.template_class = DummyTemplate
+            config.link_prefix = "http:/"
+            config.syntax_highlighting = false
+            config.darwin_txmt_protocol_no_thanks = false
+          end
+        end
+
+        it "should set given template_class" do
+          expect(template_class).to eq(DummyTemplate)
+        end
+
+        it "should set given link_prefix" do
+          expect(MetricFu::Formatter::Templates.option("link_prefix")).to eq("http:/")
+        end
+
+        it "should set given darwin_txmt_protocol_no_thanks" do
+          expect(MetricFu::Formatter::Templates.option("darwin_txmt_protocol_no_thanks")).to be_falsey
+        end
+
+        it "should set given syntax_highlighting" do
+          expect(MetricFu::Formatter::Templates.option("syntax_highlighting")).to be_falsey
+        end
+      end
+    end
+  end
+end

data/spec/metric_fu/templates/metrics_template_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe MetricFu::Templates::MetricsTemplate do
+  let(:template) { Templates::MetricsTemplate.new }
+
+  describe "#html_filename" do
+    it "returns the hashed filename ending with .html" do
+      expect(template.html_filename("some_file.rb")).to eq("10580a1fcbe74a931db8210462a584.html")
+    end
+  end
+end

data/spec/metric_fu/templates/report_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+MetricFu.lib_require { "templates/report" }
+
+describe MetricFu::Templates::Report do
+  # TODO: This test only shows how the code works and that it doesn't blow up.
+  # Perhaps it should test something more specific?
+  it "Reads in a source file, and produces an annotated HTML report" do
+    lines = { "2" => [{ type: :reek, description: "Bad Param Names" }] }
+    source_file = File.join(MetricFu.root_dir, "spec", "dummy", "lib", "bad_encoding.rb")
+    report = MetricFu::Templates::Report.new(source_file, lines)
+    expect {
+      rendered_report = report.render
+    }.not_to raise_error
+  end
+end

data/spec/metric_fu/templates/template_spec.rb

@@ -0,0 +1,233 @@
+require "spec_helper"
+require "tempfile"
+require "erb"
+
+describe MetricFu::Template do
+  before(:each) do
+    @template =  Template.new
+  end
+
+  describe "#erbify" do
+    it "should evaluate a erb doc" do
+      section = "section"
+      erb = double("erb")
+      expect(erb).to receive(:result)
+      expect(@template).to receive(:template).and_return("foo")
+      expect(@template).to receive(:erb_template_source).with("foo").and_return(erb)
+      @template.send(:erbify, section)
+    end
+  end
+
+  describe "#template_exists? " do
+    before(:each) do
+      @section = double("section")
+    end
+
+    describe "if the template exists" do
+      it "should return true" do
+        Tempfile.open("file") do |file|
+          expect(@template).to receive(:template).with(@section).and_return(file.path)
+          result = @template.send(:template_exists?, @section)
+          expect(result).to be_truthy
+        end
+      end
+    end
+
+    describe "if the template does not exist" do
+      it "should return false" do
+        path = "path"
+        expect(@template).to receive(:template).with(@section).and_return(path)
+        result = @template.send(:template_exists?, @section)
+        expect(result).to be_falsey
+      end
+    end
+  end
+
+  describe "#create_instance_var" do
+    it "should set an instance variable with the passed contents" do
+      section = "section"
+      contents = "contents"
+      @template.send(:create_instance_var, section, contents)
+      expect(@template.instance_variable_get(:@section)).to eq(contents)
+    end
+  end
+
+  describe "#template" do
+    it "should generate the filename of the template file" do
+      section = double("section")
+      allow(section).to receive(:to_s).and_return("section")
+      expect(@template).to receive(:template_directory).and_return("dir")
+      result = @template.send(:template, section)
+      expect(result).to eq("dir/section.html.erb")
+    end
+  end
+
+  describe "#output_filename" do
+    it "should generate the filename of the output file" do
+      section = double("section")
+      expect(section).to receive(:to_s).and_return("section")
+      result = @template.send(:output_filename, section)
+      expect(result).to eq("section.html")
+    end
+  end
+
+  describe "#inline_css" do
+    it "should return the contents of a css file" do
+      css = "mycss.css"
+      dir = File.join(MetricFu.lib_dir, "templates", css)
+      contents = "css contents"
+      expect(MetricFu::Utility).to receive(:binread).with(dir).and_return(contents)
+      result = @template.send(:inline_css, css)
+      expect(result).to eq(contents)
+    end
+  end
+
+  describe "#link_to_filename " do
+    describe "when on OS X" do
+      before(:each) do
+        config = double("configuration")
+        allow(config).to receive(:osx?).and_return(true)
+        allow(config).to receive(:platform).and_return("universal-darwin-9.0")
+        allow(config).to receive(:templates_option).with("darwin_txmt_protocol_no_thanks").and_return(false)
+        allow(config).to receive(:templates_option).with("link_prefix").and_return(nil)
+        allow(MetricFu).to receive(:configuration).and_return(config)
+      end
+
+      it "should return a textmate protocol link" do
+        expect(@template).to receive(:complete_file_path).with("filename").and_return("/expanded/filename")
+        result = @template.send(:link_to_filename, "filename")
+        expect(result).to eql("<a href='txmt://open/?url=file://" \
+                         + "/expanded/filename'>filename</a>")
+      end
+
+      it "should do the right thing with a filename that starts with a slash" do
+        expect(@template).to receive(:complete_file_path).with("/filename").and_return("/expanded/filename")
+        result = @template.send(:link_to_filename, "/filename")
+        expect(result).to eql("<a href='txmt://open/?url=file://" \
+                         + "/expanded/filename'>/filename</a>")
+      end
+
+      it "should include a line number" do
+        expect(@template).to receive(:complete_file_path).with("filename").and_return("/expanded/filename")
+        result = @template.send(:link_to_filename, "filename", 6)
+        expect(result).to eql("<a href='txmt://open/?url=file://" \
+                         + "/expanded/filename&line=6'>filename:6</a>")
+      end
+
+      describe "but no thanks for txtmt" do
+        before(:each) do
+          config = double("configuration")
+          allow(config).to receive(:osx?).and_return(true)
+          allow(config).to receive(:platform).and_return("universal-darwin-9.0")
+          allow(config).to receive(:templates_option).with("darwin_txmt_protocol_no_thanks").and_return(true)
+          allow(config).to receive(:templates_option).with("link_prefix").and_return("file:/")
+          allow(MetricFu).to receive(:configuration).and_return(config)
+          expect(@template).to receive(:complete_file_path).and_return("filename")
+        end
+
+        it "should return a file protocol link" do
+          name = "filename"
+          result = @template.send(:link_to_filename, name)
+          expect(result).to eq("<a href='file://filename'>filename</a>")
+        end
+      end
+
+      describe "and given link text" do
+        it "should use the submitted link text" do
+          expect(@template).to receive(:complete_file_path).with("filename").and_return("/expanded/filename")
+          result = @template.send(:link_to_filename, "filename", 6, "link content")
+          expect(result).to eql("<a href='txmt://open/?url=file://" \
+                           + "/expanded/filename&line=6'>link content</a>")
+        end
+      end
+    end
+
+    describe "when on other platforms"  do
+      before(:each) do
+        config = double("configuration")
+        expect(config).to receive(:osx?).and_return(false)
+        allow(config).to receive(:templates_option).with("link_prefix").and_return("file:/")
+        allow(MetricFu).to receive(:configuration).and_return(config)
+        expect(@template).to receive(:complete_file_path).and_return("filename")
+      end
+
+      it "should return a file protocol link" do
+        name = "filename"
+        result = @template.send(:link_to_filename, name)
+        expect(result).to eq("<a href='file://filename'>filename</a>")
+      end
+    end
+    describe "when configured with a link_prefix" do
+      before(:each) do
+        config = double("configuration")
+        allow(config).to receive(:templates_option).with("darwin_txmt_protocol_no_thanks").and_return(true)
+        allow(config).to receive(:templates_option).with("link_prefix").and_return("http://example.org/files")
+        allow(config).to receive(:osx?).and_return(true)
+        allow(MetricFu).to receive(:configuration).and_return(config)
+        expect(@template).to receive(:complete_file_path).and_return("filename")
+      end
+
+      it "should return a http protocol link" do
+        name = "filename"
+        result = @template.send(:link_to_filename, name)
+        expect(result).to eq("<a href='http://example.org/files/filename'>filename</a>")
+      end
+    end
+
+    context "given an absolute path" do
+      it "returns a link with that absolute path" do
+        name = "/some/file.rb"
+        result = @template.send(:link_to_filename, name)
+        expect(result).to match("<a href='file://(.:)?/some/file.rb'>/some/file.rb</a>")
+      end
+    end
+
+    context "given a relative path" do
+      it "returns a link with the absolute path" do
+        name = "./some/file.rb"
+        expected = File.expand_path(name)
+        result = @template.send(:link_to_filename, name)
+        expect(result).to eq("<a href='file://#{expected}'>./some/file.rb</a>")
+      end
+    end
+  end
+
+  describe "#cycle" do
+    it "should return the first_value passed if iteration passed is even" do
+      first_val = "first"
+      second_val = "second"
+      iter = 2
+      result = @template.send(:cycle, first_val, second_val, iter)
+      expect(result).to eq(first_val)
+    end
+
+    it "should return the second_value passed if iteration passed is odd" do
+      first_val = "first"
+      second_val = "second"
+      iter = 1
+      result = @template.send(:cycle, first_val, second_val, iter)
+      expect(result).to eq(second_val)
+    end
+  end
+
+  describe "#render_partial" do
+    it "should erbify a partial with the name prefixed with an underscore" do
+      expect(@template).to receive(:erbify).with("_some_partial")
+      @template.send(:render_partial, "some_partial")
+    end
+
+    it "should set the given instance variables" do
+      variables = { answer: 42 }
+      allow(@template).to receive(:erbify)
+      expect(@template).to receive(:create_instance_vars).with(variables)
+      @template.send(:render_partial, "some_partial", variables)
+    end
+  end
+
+  describe "#create_instance_vars" do
+    it "should set the given instance variables" do
+      @template.send(:create_instance_vars, answer: 42)
+      expect(@template.instance_variable_get(:@answer)).to eq(42)
+    end
+  end
+end

data/spec/metric_fu/utility_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "metric_fu/utility"
+
+describe MetricFu::Utility do
+  it "strips ANSI escape codes from text" do
+    text = "\e[31m./app/models/account.rb:64 - Found = in conditional.  It should probably be an ==\e[0m"
+    output = "./app/models/account.rb:64 - Found = in conditional.  It should probably be an =="
+
+    result = MetricFu::Utility.strip_escape_codes(text)
+    expect(result).to eq(output)
+  end
+end