code_metric_fu 4.14.0

data/spec/metric_fu_spec.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+require "spec_helper"
+
+describe MetricFu do
+  specify "the default report_name is the run directory base name" do
+    expect(MetricFu.report_name).to eq("dummy")
+  end
+
+  specify "the user can set the report_name" do
+    original_report_name = MetricFu.report_name
+
+    MetricFu.report_name = "override"
+    expect(MetricFu.report_name).to eq("override")
+
+    MetricFu.report_name = original_report_name
+  end
+
+  it "has a global report time (corresponding to the time of the VCS code state)" do
+    expect(MetricFu.report_time - Time.now).to be_within(0.1).of(0)
+  end
+
+  it "has a global current time (corresponding to report generation time)" do
+    expect(MetricFu.current_time - Time.now).to be_within(0.1).of(0)
+  end
+
+  it "has a global report id" do
+    expect(MetricFu.report_id).to eq(Time.now.strftime("%Y%m%d"))
+  end
+
+  it "has a global report fingerprint (corresponding to VCS code state)" do
+    expect(MetricFu.report_fingerprint.to_i - Time.now.to_i).to be_within(0.1).of(0)
+  end
+end

data/spec/quality_spec.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+# from https://github.com/vcr/vcr/blob/master/spec/quality_spec.rb
+# from https://raw.githubusercontent.com/bundler/bundler/master/spec/quality_spec.rb
+require "spec_helper"
+
+if defined?(Encoding) && Encoding.default_external != "UTF-8"
+  Encoding.default_external = "UTF-8"
+end
+
+RSpec.describe "The library itself" do
+  # For some reason RSpec may expect this to be defined
+  # and crash really bad without it
+  def self.uses_transaction?(*)
+    false
+  end
+
+  def encode_utf8!(string)
+    string.encode!(Encoding::UTF_8,
+                   invalid: :replace,
+                   undef: :replace,
+                   replace: "<?>".freeze
+                  )
+  end
+
+  def ignore_whitespace?(filename)
+    @whitespace_regex ||=
+      /\.gitmodules|fixtures|vendor|LICENSE|etc|db|public|reports/
+    !!(filename =~ @whitespace_regex)
+  end
+
+  def check_for_spec_defs_with_single_quotes(filename)
+    failing_lines = []
+
+    File.readlines(filename).each_with_index do |line, number|
+      encode_utf8!(line)
+      failing_lines << number + 1 if line =~ /^ *(describe|it|context) {1}'{1}/
+    end
+
+    if failing_lines.any?
+      # Prevent rubocop from looping infinitely
+      # rubocop:disable Style/StringLiterals
+      "#{filename} uses inconsistent single quotes "\
+      "on lines #{failing_lines.join(', ')}"
+      # rubocop:enable Style/StringLiterals
+    end
+  end
+
+  def check_for_tab_characters(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line, number|
+      encode_utf8!(line)
+      failing_lines << number + 1 if line =~ /\t/
+    end
+
+    unless failing_lines.empty?
+      # Prevent rubocop from looping infinitely
+      # rubocop:disable Style/StringLiterals
+      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+      # rubocop:enable Style/StringLiterals
+    end
+  end
+
+  def check_for_extra_spaces(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line, number|
+      encode_utf8!(line)
+      next if line =~ /^\s+#.*\s+\n$/
+      failing_lines << number + 1 if line =~ /\s+\n$/
+    end
+
+    unless failing_lines.empty?
+      # Prevent rubocop from looping infinitely
+      # rubocop:disable Style/StringLiterals
+      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+      # rubocop:enable Style/StringLiterals
+    end
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    failure_message do |actual|
+      actual.join("\n")
+    end
+
+    match(&:empty?)
+  end
+
+  it "has no malformed whitespace" do
+    error_messages = []
+    Dir.chdir(File.expand_path("../..", __FILE__)) do
+      `git ls-files -z`.split("\x0").each do |filename|
+        next if !File.exist?(filename)
+        next if ignore_whitespace?(filename)
+        error_messages << check_for_tab_characters(filename)
+        error_messages << check_for_extra_spaces(filename)
+      end
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+
+  it "uses double-quotes consistently in specs" do
+    included = /spec/
+    error_messages = []
+    Dir.chdir(File.expand_path("../", __FILE__)) do
+      `git ls-files -z spec`.split("\x0").each do |filename|
+        next unless filename =~ included
+        error_messages << check_for_spec_defs_with_single_quotes(filename)
+      end
+    end
+    error_messages.compact.each do |error_message|
+      warn error_message
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+end

data/spec/shared/configured.rb

@@ -0,0 +1,45 @@
+shared_examples "configured" do
+  def get_new_config
+    ENV["CC_BUILD_ARTIFACTS"] = nil
+    @config = MetricFu.configuration
+    @config.reset
+    MetricFu.configuration.configure_metric(:rcov) do |rcov|
+      rcov.enabled = true
+    end
+    MetricFu.configure
+    allow(MetricFu::Io::FileSystem).to receive(:create_directories) # no need to create directories for the tests
+    @config
+  end
+
+  def directory(name)
+    MetricFu::Io::FileSystem.directory(name)
+  end
+
+  def base_directory
+    directory("base_directory")
+  end
+
+  def output_directory
+    directory("output_directory")
+  end
+
+  def scratch_directory
+    directory("scratch_directory")
+  end
+
+  def template_directory
+    directory("template_directory")
+  end
+
+  def template_class
+    MetricFu::Formatter::Templates.option("template_class")
+  end
+
+  def metric_fu_root
+    directory("root_directory")
+  end
+
+  def load_metric(metric)
+    load File.join(MetricFu.metrics_dir, metric, "metric.rb")
+  end
+end

data/spec/shared/test_coverage.rb

@@ -0,0 +1,95 @@
+shared_examples "rcov test coverage generator" do |metric_name|
+  before do
+    setup_fs
+    MetricFu::Configuration.run do |config|
+      config.configure_metric(metric_name) do |rcov|
+        rcov.enabled = true
+      end
+    end
+  end
+
+  before :each do
+    @default_options = MetricFu::Metric.get_metric(metric_name).run_options
+  end
+
+  describe "emit" do
+    before :each do
+      options = { external: nil }
+      @rcov = MetricFu::RcovGenerator.new(@default_options.merge(options))
+    end
+
+    # TODO: should this be true of this metric?
+    it "should clear out previous output and make output folder" 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)
+      @rcov.reset_output_location
+    end
+  end
+
+  def rcov_output
+    FIXTURE.load_file("rcov_output.txt")
+  end
+
+  describe "with rcov_output fed into" do
+    before :each do
+      options = { external: nil }
+      @rcov = MetricFu::RcovGenerator.new(@default_options.merge(options))
+      expect(@rcov).to receive(:load_output).and_return(rcov_output)
+      @files = @rcov.analyze
+    end
+
+    describe "analyze" do
+      it "should compute percent of lines run" do
+        expect(@files["./lib/metric_fu/metrics/hotspots/analysis/record.rb"][:percent_run]).to eq(94)
+        expect(@files["./lib/metric_fu/metrics/hotspots/analysis/table.rb"][:percent_run]).to eq(93)
+      end
+
+      it "should know which lines were run" do
+        expect(@files["./lib/metric_fu/metrics/hotspots/analysis/record.rb"][:lines].any? {|line|
+          line[:content].strip == "@data[key]" &&
+          line[:was_run] == 1
+        }).to be_truthy
+      end
+
+      it "should know which lines NOT were run" do
+        expect(@files["./lib/metric_fu/metrics/hotspots/analysis/record.rb"][:lines].any? {|line|
+          line[:content].strip == "super(name, *args, &block)" &&
+          line[:was_run] == 0
+        }).to be_truthy
+      end
+
+      it "should know which lines were ignored" do
+        expect(@files["./lib/metric_fu/metrics/hotspots/analysis/record.rb"][:lines].any? {|line|
+          line[:content].strip == "end" &&
+          line[:was_run] == nil
+        }).to be_truthy
+      end
+    end
+
+    describe "to_h" do
+      it "should calculate total percentage for all files" do
+        expect(@rcov.to_h[:rcov][:global_percent_run]).to eq(93.3)
+      end
+    end
+  end
+  describe "with external configuration option set" do
+    before :each do
+      options = { external: "coverage/rcov.txt" }
+      @rcov = MetricFu::RcovGenerator.new(@default_options.merge(options))
+    end
+
+    it "should emit nothing if external configuration option is set" do
+      expect(MetricFu::Utility).not_to receive(:rm_rf)
+      @rcov.emit
+    end
+
+    it "should open the external rcov analysis file" do
+      expect(@rcov).to receive(:load_output).and_return(rcov_output)
+      @files = @rcov.analyze
+    end
+  end
+
+  after do
+    cleanup_fs
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+# add lib to the load path just like rubygems does
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "simplecov"
+
+require "date"
+require "test_construct"
+require "json"
+require "pry-nav"
+
+require "metric_fu"
+include MetricFu
+def mf_log(msg); mf_debug(msg); end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[MetricFu.root_dir + "/spec/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  # Skip specs tagged `:slow` unless SLOW_SPECS is set
+  config.filter_run_excluding :slow unless ENV["SLOW_SPECS"]
+  # End specs on first failure if FAIL_FAST is set
+  config.fail_fast = ENV.include?("FAIL_FAST")
+  config.order = :rand
+  config.color = true
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  # :suite after/before all specs
+  # :each every describe block
+  # :all every it block
+
+  def run_dir
+    File.expand_path("dummy", File.dirname(__FILE__))
+  end
+
+  config.before(:suite) do
+    MetricFu.run_dir = run_dir
+  end
+
+  config.after(:suite) do
+    cleanup_fs
+  end
+
+  config.after(:each) do
+    MetricFu.reset
+  end
+end

data/spec/support/deferred_garbaged_collection.rb

@@ -0,0 +1,33 @@
+class DeferredGarbageCollection
+  DEFERRED_GC_THRESHOLD = (ENV["DEFER_GC"] || 15.0).to_f
+
+  @@last_gc_run = Time.now
+
+  def self.start
+    GC.disable if DEFERRED_GC_THRESHOLD > 0
+  end
+
+  def self.reconsider
+    if DEFERRED_GC_THRESHOLD > 0 && Time.now - @@last_gc_run >= DEFERRED_GC_THRESHOLD
+      GC.enable
+      GC.start
+      GC.disable
+      @@last_gc_run = Time.now
+    end
+  end
+
+  def self.configure(config)
+    return if defined?(JRUBY_VERSION)
+    config.before(:all) do
+      DeferredGarbageCollection.start
+    end
+
+    config.after(:all) do
+      DeferredGarbageCollection.reconsider
+    end
+  end
+end
+
+RSpec.configure do |config|
+  DeferredGarbageCollection.configure(config)
+end

data/spec/support/helper_methods.rb

@@ -0,0 +1,32 @@
+def enable_hotspots
+  MetricFu.configure
+  hotspot_metrics = MetricFu::Metric.metrics.map(&:name)
+  hotspot_metrics.each do |metric_name|
+    path = "#{metric_name}/hotspot"
+    begin
+      MetricFu.metrics_require { path }
+    rescue LoadError
+      # No hotspot, but that's ok
+    end
+  end
+end
+
+def metric_not_activated?(metric_name)
+  MetricFu.configuration.configure_metrics
+  metric = MetricFu::Metric.get_metric(metric_name.intern)
+  if (metric.activate rescue false) # may fail if ripper not supported
+    false
+  else
+    p "Skipping #{metric_name} tests, not activated"
+    true
+  end
+end
+
+def breaks_when?(bool)
+  p "Skipping tests in #{caller[0]}. They unnecessarily break the build." if bool
+  bool
+end
+
+def compare_paths(path1, path2)
+  expect(File.join(MetricFu.root_dir, path1)).to eq(File.join(MetricFu.root_dir, path2))
+end

data/spec/support/matcher_create_file.rb

@@ -0,0 +1,37 @@
+RSpec::Matchers.define :create_file do |expected|
+  match do |block|
+    @before = exists?(expected)
+    block.call
+    @after = exists?(expected)
+    !@before && @after
+  end
+
+  failure_message do |_block|
+    existed_before_message expected do
+      "The file #{expected.inspect} was not created"
+    end
+  end
+
+  failure_message_when_negated do |_block|
+    existed_before_message expected do
+      "The file #{expected.inspect} was created"
+    end
+  end
+
+  def supports_block_expectations?
+    true
+  end
+
+  def exists?(expected)
+    # Allows us to use wildcard checks for existence.
+    !Dir.glob(expected).empty?
+  end
+
+  def existed_before_message(expected)
+    if @before
+      "The file #{expected.inspect} existed before, so this test doesn't work"
+    else
+      yield
+    end
+  end
+end

data/spec/support/matcher_create_files.rb

@@ -0,0 +1,43 @@
+RSpec::Matchers.define :create_files do |expected|
+  match do |block|
+    @before = false
+    @after = true
+    expected.each do |file|
+      @before |= exists?(file)
+    end
+    block.call
+    expected.each do |file|
+      @after &= exists?(file)
+    end
+    !@before && @after
+  end
+
+  failure_message do |_block|
+    existed_before_message expected do
+      "One or more files in [#{expected.inspect}] was not created."
+    end
+  end
+
+  failure_message_when_negated do |_block|
+    existed_before_message expected do
+      "The files in [#{expected.inspect}] were created."
+    end
+  end
+
+  def supports_block_expectations?
+    true
+  end
+
+  def exists?(expected)
+    # Allows us to use wildcard checks for existence.
+    !Dir.glob(expected).empty?
+  end
+
+  def existed_before_message(expected)
+    if @before
+      "One or more files in  [#{expected.inspect}] existed before, so this test doesn't work"
+    else
+      yield
+    end
+  end
+end

data/spec/support/suite.rb

@@ -0,0 +1,26 @@
+require "fileutils"
+def directory(name)
+  MetricFu::Io::FileSystem.directory(name)
+end
+
+def scratch_directory(name)
+  File.join(MetricFu::Io::FileSystem.artifact_dir, "scratch", name)
+end
+
+def artifact_test_dir
+  File.join(MetricFu::APP_ROOT, "tmp", "metric_fu", "test")
+end
+
+# Let's shift the output directories so that we don't interfere with
+#   existing historical metric data.
+MetricFu::Io::FileSystem.artifact_dir = artifact_test_dir
+MetricFu::Io::FileSystem.set_directories
+
+def setup_fs
+  cleanup_fs
+  MetricFu::Io::FileSystem.set_directories
+end
+
+def cleanup_fs
+  FileUtils.rm_rf(artifact_test_dir)
+end

data/spec/support/test_fixtures.rb

@@ -0,0 +1,37 @@
+require "pathname"
+class TestFixtures
+  attr_reader :fixtures_path
+
+  def initialize
+    @loaded_data = {}
+    @fixtures_path = Pathname(MetricFu.root_dir).join("spec", "fixtures")
+  end
+
+  def load_metric(path)
+    retrieve_data(path) do |path|
+      YAML.load_file(fixture_path(path))
+    end
+  end
+
+  def load_file(path)
+    retrieve_data(path) do |path|
+      File.read(fixture_path(path))
+    end
+  end
+
+  def fixture_path(path)
+    fixtures_path.join(*Array(path))
+  end
+
+  private
+
+  def retrieve_data(path)
+    @loaded_data.fetch(path) do
+      @loaded_data[path] = yield(path)
+    end
+  end
+end
+FIXTURE = TestFixtures.new
+HOTSPOT_DATA = ->(paths) {
+  FIXTURE.load_metric(["hotspots"].concat(Array(paths)))
+}

data/spec/support/timeout.rb

@@ -0,0 +1,7 @@
+require "timeout"
+# No spec should run longer than this
+#   (define here to support the closure)
+p "setting timeout #{timeout = 15.0} seconds"
+RSpec.configuration.around(:each) do |example|
+  Timeout.timeout(timeout, &example)
+end