code_metric_fu 4.14.0

data/spec/support/usage_test.rb

@@ -0,0 +1,150 @@
+# usage_test = UsageTest.new
+# usage_test.test_files(EXAMPLE_FILES)
+
+# puts "SUCCESS!"
+# Process.exit! 0
+require "open3"
+
+class UsageTest
+  CodeBlock = Struct.new(:matchdata) do
+    # From kramdown-1.2.0/lib/kramdown/parser/gfm.rb
+    FENCED_CODEBLOCK_MATCH = /^(([~`]){3,})\s*?(\w+)?\s*?\n(.*?)^\1\2*\s*?\n/m
+    def code
+      matchdata[3].strip
+    end
+
+    def language
+      matchdata[2].strip
+    end
+    def self.find_code_blocks(markdown)
+      markdown.scan(FENCED_CODEBLOCK_MATCH).map do |matchdata|
+        new(matchdata)
+      end
+    end
+  end
+
+  def test_files(paths)
+    in_test_directory do
+      Array(paths).each do |path|
+        puts "Testing #{path}"
+        CodeBlock.find_code_blocks(File.read(path)).each do |code_block|
+          test_code_block!(code_block)
+        end
+        puts
+      end
+    end
+    puts "SUCCESS!"
+    Process.exit! 0
+  end
+
+  def test_code_block!(code_block)
+    SnippetRunner.new(code_block.code, code_block.language).test!
+  end
+
+  private
+
+  def in_test_directory
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) {
+        `git init; touch README; git add README; git commit -m 'first'`
+        yield
+      }
+    end
+  end
+end
+SnippetRunner = Struct.new(:code, :language) do
+  SystemCommandError = Class.new(StandardError)
+  TestResult = Struct.new(:success, :captured_output)
+
+  def test!
+    time = Time.now
+    test_result = run_code
+    mf_debug "#{Time.now - time} seconds"
+    if test_result.success
+      print "."
+    else
+      puts "x"
+      puts "Red :( language: #{language}, code #{code}, #{test_result.captured_output}"
+      Process.exit! 1
+    end
+  end
+
+  def run_code(test_result = TestResult.new(:no_result, ""))
+    test_result.captured_output = case language
+                                  when "ruby" then eval_ruby
+                                  when "sh"   then run_system_command
+                                  else mf_debug "Cannot test language: #{language.inspect}"
+                                  end
+    test_result.success = true
+    test_result
+  rescue StandardError => run_error
+    test_result.captured_output = exception_message(run_error)
+    test_result.success =  false
+    test_result
+  rescue SystemExit => system_exit
+    mf_debug "I am a system exit"
+    test_result.captured_output = exception_message(system_exit)
+    test_result.success = system_exit.success?
+    test_result
+  end
+
+  def eval_ruby(fail_on_empty = false)
+    capture_output(fail_on_empty) do
+      instance_eval(code)
+    end
+  end
+
+  def run_system_command(_fail_on_empty = true)
+    out = ""
+    err = ""
+    pid = :not_set
+    exit_status = :not_set
+    Open3.popen3(code) do |_stdin, stdout, stderr, wait_thr|
+      out << stdout.read.chomp
+      err << stderr.read.chomp
+      pid = wait_thr.pid
+      exit_status = wait_thr.value
+    end
+    exit_code = exit_status.exitstatus
+    case exit_code
+    when 0  then  "Ran with exit status #{exit_code}"
+    when (1..Float::INFINITY) then fail SystemCommandError.new("Failed with exit status #{exit_code}. #{err}----#{out}")
+    else fail SystemCommandError.new("Execution failed with exit status #{exit_code}. #{err}----#{out}")
+    end
+  end
+
+  def exception_message(e)
+    "#{e.class}\t#{e.message}"
+  end
+
+  def capture_output(fail_on_empty)
+    exception = nil
+    stderr = :not_set
+    stdout = :not_set
+    MetricFu::Utility.capture_output(STDOUT) do
+      stdout =
+      MetricFu::Utility.capture_output(STDERR) do
+        begin
+          stderr = yield
+        rescue Exception => e
+          exception  = e
+        end
+      end
+    end
+    if [nil, "", :not_set].none? { |c| c == stderr }
+      mf_debug "Captured STDERR"
+      stderr
+    elsif [nil, "", :not_set].none? { |c| c == stdout }
+      mf_debug "Captured STDOUT"
+      stdout
+    elsif exception
+      mf_debug "Captured Exception"
+      raise exception
+    else
+      mf_debug "Captured Nothing"
+      if fail_on_empty
+        fail SystemCommandError.new "No output generated or exception caught"
+      end
+    end
+  end
+end

data/spec/usage_test_spec.rb

@@ -0,0 +1,93 @@
+describe "usage test" do
+  ROOT_PATH    = File.expand_path("..", File.dirname(__FILE__))
+  require File.join(ROOT_PATH, "spec/support/usage_test")
+
+  it "extracts fenced code blocks, identifying the code and language" do
+    ruby_code = "puts 'This is ruby'"
+    shell_code = %(ruby -e "puts 'This is shell'")
+    ruby_block, shell_block = UsageTest::CodeBlock.find_code_blocks(<<-README
+This is not code
+
+```ruby
+#{ruby_code}
+```
+
+Nope. Not code.
+
+```sh
+#{shell_code}
+```
+
+Not code, either.
+README
+)
+    expect(ruby_block.language).to eq("ruby")
+    expect(ruby_block.code).to eq(ruby_code)
+
+    expect(shell_block.language).to eq("sh")
+    expect(shell_block.code).to eq(shell_code)
+  end
+
+  context "evaluating ruby code" do
+    specify "succeeds when the code runs without errors" do
+      code = "1 + 1"
+      test_result = SnippetRunner.new(code, "ruby").run_code
+      expect(test_result.captured_output).to eq(2)
+      expect(test_result.success).to eq(true)
+    end
+    specify "fails when the code raises a standard error" do
+      code = "fail NameError.new('no name')"
+      test_result = SnippetRunner.new(code, "ruby").run_code
+      expect(test_result.captured_output).to match("NameError")
+      expect(test_result.captured_output).to match("no name")
+      expect(test_result.success).to eq(false)
+    end
+    specify "succeeds when the code exits with a zero exit status" do
+      code = "puts 1 + 1; exit 0"
+      test_result = SnippetRunner.new(code, "ruby").run_code
+      expect(test_result.captured_output).to match("SystemExit")
+      expect(test_result.success).to eq(true)
+    end
+    specify "fails when the code exits with a non-zero exit status" do
+      code = "puts 1 + 1; exit 1"
+      test_result = SnippetRunner.new(code, "ruby").run_code
+      expect(test_result.captured_output).to match("SystemExit")
+      expect(test_result.success).to eq(false)
+    end
+  end
+  context "evaluating shell commands" do
+    specify "succeeds when the command runs without errors" do
+      code = "which ruby"
+      test_result = SnippetRunner.new(code, "sh").run_code
+      expect(test_result.captured_output).to match("exit status 0")
+      expect(test_result.success).to eq(true)
+    end
+    specify "fails when the command runs with an error" do
+      code = "sandwhich_fu ruby"
+      test_result = SnippetRunner.new(code, "sh").run_code
+      expect(test_result.captured_output).to match(failed_command_error)
+      expect(test_result.success).to eq(false)
+    end
+    specify "succeeds when the code exits with a zero exit status" do
+      code = "sh '#{fixtures_path.join('exit0.sh').to_path}'"
+      test_result = SnippetRunner.new(code, "sh").run_code
+      expect(test_result.captured_output).to match("exit status 0")
+      expect(test_result.success).to eq(true)
+    end
+    specify "fails when the code exits with a non-zero exit status" do
+      code = "sh '#{fixtures_path.join('exit1.sh').to_path}'"
+      test_result = SnippetRunner.new(code, "sh").run_code
+      expect(test_result.captured_output).to match("exit status 1")
+      expect(test_result.success).to eq(false)
+    end
+  end
+
+  def failed_command_error
+    defined?(JRUBY_VERSION) ? "IOError" : "Errno::ENOENT"
+  end
+
+  def fixtures_path
+    fixtures_dir = File.join(File.expand_path("..", File.dirname(__FILE__)), "spec", "fixtures")
+    Pathname(fixtures_dir)
+  end
+end