jasmine-coverage-kikuchiyo-patch 0.0.1

data/lib/jasmine/coverage/version.rb

@@ -0,0 +1,5 @@
+module Jasmine
+  module Coverage
+    VERSION = '0.1.5'
+  end
+end

data/lib/jasmine/coverage.rb

@@ -0,0 +1,3 @@
+require_relative 'coverage/version'
+
+load 'tasks/jasmine_coverage.rake'

data/lib/tasks/coverage_output_generator.js

@@ -0,0 +1,127 @@
+/**
+ * Note, strictly speaking this isn't a spec.
+ * But we must run it like one so it occurs in the same context
+ * as the other tests that have run. In that way, we can
+ * call out in javascript and get the resulting coverage reports from the instrumented
+ * files.
+ *
+ * Further, when we log the results to console, the file logger captures that.
+ */
+describe("jasmine-coverage", function () {
+
+    it("is generating a coverage report", function () {
+        // Output the complete line by line coverage report for capture by the file logger
+        generateEncodedCoverage();
+
+        // Get the simple percentages for each file
+        coverageForAllFiles();
+    });
+
+});
+
+String.prototype.lpad = function (padString, length) {
+    var str = this;
+    while (str.length < length)
+        str = padString + str;
+    return str;
+};
+
+function generateEncodedCoverage() {
+    var rv = {};
+    for (var file_name in window._$jscoverage) {
+        var jscov = window._$jscoverage[ file_name ];
+        var file_report = rv[ file_name ] = {
+            coverage:new Array(jscov.length),
+            source:new Array(jscov.length)
+        };
+        for (var i = 0; i < jscov.length; ++i) {
+            var hit_count = jscov[ i ] !== undefined ? jscov[ i ] : null;
+
+            file_report.coverage[ i ] = hit_count;
+            file_report.source[ i ] = jscov.source[ i ];
+        }
+    }
+    console.log("ENCODED-COVERAGE-EXPORT-STARTS:" + Base64.encode(JSON.stringify(rv)));
+    console.log("\nENCODED-COVERAGE-EXPORT-ENDS\n");
+}
+
+function coverageForAllFiles() {
+
+    var totals = { files:0, statements:0, executed:0 };
+
+    var output = "Coverage was:\n";
+
+    for (var file_name in window._$jscoverage) {
+        var jscov = window._$jscoverage[ file_name ];
+        var simple_file_coverage = coverageForFile(jscov);
+
+        totals['files']++;
+        totals['statements'] += simple_file_coverage['statements'];
+        totals['executed'] += simple_file_coverage['executed'];
+
+        var fraction = (simple_file_coverage['executed']+"/"+simple_file_coverage['statements']).lpad(' ', 10);
+        output += fraction + (" = " + simple_file_coverage['percentage'] + "").lpad(' ', 3) + "% for " + file_name + "\n";
+    }
+
+    var coverage = parseInt(100 * totals['executed'] / totals['statements']);
+    if (isNaN(coverage)) {
+        coverage = 0;
+    }
+
+    if (totals['statements'] === 0) {
+        log("No Javascript was found to test coverage for.");
+    } else {
+        output += ( totals['executed'] +"/"+totals['statements']+ " = "+ coverage + "").lpad(' ', 15) + "% Total\n";
+        log(output);
+    }
+
+    return coverage;
+}
+
+
+function coverageForFile(fileCC) {
+    var lineNumber;
+    var num_statements = 0;
+    var num_executed = 0;
+    var missing = [];
+    var length = fileCC.length;
+    var currentConditionalEnd = 0;
+    var conditionals = null;
+    if (fileCC.conditionals) {
+        conditionals = fileCC.conditionals;
+    }
+    for (lineNumber = 0; lineNumber < length; lineNumber++) {
+        var n = fileCC[lineNumber];
+
+        if (lineNumber === currentConditionalEnd) {
+            currentConditionalEnd = 0;
+        }
+        else if (currentConditionalEnd === 0 && conditionals && conditionals[lineNumber]) {
+            currentConditionalEnd = conditionals[lineNumber];
+        }
+
+        if (currentConditionalEnd !== 0) {
+            continue;
+        }
+
+        if (n === undefined || n === null) {
+            continue;
+        }
+
+        if (n === 0) {
+            missing.push(lineNumber);
+        }
+        else {
+            num_executed++;
+        }
+        num_statements++;
+    }
+
+    var percentage = ( num_statements === 0 ? 0 : parseInt(100 * num_executed / num_statements) );
+
+    return {
+        statements:num_statements,
+        executed:num_executed,
+        percentage:percentage
+    };
+}

data/lib/tasks/jasmine_coverage.rake

@@ -0,0 +1,136 @@
+env = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+if env =~ /^(development|test)$/
+  require 'rake'
+  require 'base64'
+
+  namespace :jasmine do
+    desc 'Runs jasmine with a coverage report'
+    task :coverage do
+
+      require 'jasmine-headless-webkit'
+      # Instill our patches for jasmine-headless to work
+      require_relative 'jasmine_headless_coverage_patches'
+
+      # We use jasmine-headless-webkit, since it has excellent programmatic integration with Jasmine
+      # But... the 'headless' part of it doesn't work on TeamCity, so we use the headless gem
+      require 'headless'
+
+      headless = Headless.new
+      headless.start
+
+      # Preprocess the JS files to add instrumentation
+      output_dir = File.expand_path('target/jscoverage/')
+      instrumented_dir = output_dir+'/instrumented/'
+      FileUtils.rm_rf output_dir
+      FileUtils.mkdir_p instrumented_dir
+
+      # The reprocessing folder map
+      files_map = {
+          File.expand_path('app/assets/javascripts') => instrumented_dir+'app',
+          File.expand_path('lib/assets/javascripts') => instrumented_dir+'lib',
+          File.expand_path('public/javascripts') => instrumented_dir+'public'
+      }
+
+      # Instrument the source files into the instrumented folders
+      files_map.keys.each do |folder|
+        instrument(folder, files_map[folder])
+        # Also hoist up the eventual viewing files
+        FileUtils.mv(Dir.glob(files_map[folder]+'/jscoverage*'), output_dir)
+      end
+
+      Jasmine::Coverage.resources = files_map
+      Jasmine::Coverage.output_dir = output_dir
+
+      puts "\nCoverage will now be run. Expect a large block of compiled coverage data. This will be processed for you into target/jscoverage.\n\n"
+
+      # Run Jasmine using the original config.
+      status_code = Jasmine::Headless::Runner.run(
+          # Any options from the options.rb file in jasmine-headless-webkit can be used here.
+
+          :reporters => [['File', "#{output_dir}/rawreport.txt"]]
+      )
+      errStr = "JSCoverage exited with error code: #{status_code}.\nThis implies one of five things:\n"
+      errStr = errStr +"0) Your JS files had exactly zero instructions. Are they all blank or just comments?\n"
+      errStr = errStr +"1) A test failed (run bundle exec jasmine:headless to see a better error)\n"
+      errStr = errStr +"2) The sourcecode has a syntax error (which JSLint should find)\n"
+      errStr = errStr +"3) An error occurred in a deferred block, eg a setTimeout or underscore _.defer. This caused a window error which Jasmine will never see.\n"
+      errStr = errStr +"4) The source files are being loaded out of sequence (so global variables are not being declared in order)\n"
+      errStr = errStr +"   To check this, run bundle exec jasmine-headless-webkit -l to see the ordering\n"
+      errStr = errStr +"\nIn any case, try running the standard jasmine command to get better errors:\n\nbundle exec jasmine:headless\n"
+      errStr = errStr +"\nFinally, try opening the testrig in firefox to see the tests run in a browser and get a stacktrace. "
+      errStr = errStr +"Chrome has strict security settings that make this difficult since it accesses the local filesystem from Javascript (but you can switch the settings off at the command line)\n\n"
+      errStr = errStr +"\n**********************************************************************************************\n"
+      errStr = errStr +"\nThe test rig file needs to load JS directly off disk, which Chrome prevents by default. Your best bet is to open the rig in Firefox.\n"
+      errStr = errStr +"\nThe file can be found here: #{Jasmine::Coverage.output_dir}/testrig/jscoverage-test-rig.html\n"
+      errStr = errStr +"\n**********************************************************************************************\n"
+      fail errStr if status_code == 1
+
+      # Obtain the console log, which includes the coverage report encoded within it
+      contents = File.open("#{output_dir}/rawreport.txt") { |f| f.read }
+      # Get our Base64.
+      json_report_enc = contents.split(/ENCODED-COVERAGE-EXPORT-STARTS:/m)[1]
+      # Remove the junk at the end
+      json_report_enc_stripped = json_report_enc[0, json_report_enc.index("\"")]
+
+      # Unpack it from Base64
+      json_report = Base64.decode64(json_report_enc_stripped)
+
+      # Save the coverage report where the GUI html expects it to be
+      File.open("#{output_dir}/jscoverage.json", 'w') { |f| f.write(json_report) }
+
+      # Modify the jscoverage.html so it knows it is showing a report, not running a test
+      File.open("#{output_dir}/jscoverage.js", 'a') { |f| f.write("\njscoverage_isReport = true;") }
+
+      if json_report_enc.index("No Javascript was found to test coverage for").nil?
+        # Check for coverage failure
+        total_location = json_report_enc.index("% Total")
+        coverage_pc = json_report_enc[total_location-3, 3].to_i
+
+        conf = (ENV['JSCOVERAGE_MINIMUM'] || ENV['JASMINE_COVERAGE_MINIMUM'])
+        fail "Coverage Fail: Javascript coverage was less than #{conf}%. It was #{coverage_pc}%." if conf && coverage_pc < conf.to_i
+      end
+
+    end
+
+    def instrument folder, instrumented_sub_dir
+      return if !File.directory? folder
+      FileUtils.mkdir_p instrumented_sub_dir
+      puts "Locating jscoverage..."
+      system "which jscoverage"
+      puts "Instrumenting JS files..."
+      jsc_status = system "jscoverage -v #{folder} #{instrumented_sub_dir}"
+      if jsc_status != true
+        puts "jscoverage failed with status '#{jsc_status}'. Is jscoverage on your path? Path follows:"
+        system "echo $PATH"
+        puts "Result of calling jscoverage with no arguments follows:"
+        system "jscoverage"
+        fail "Unable to use jscoverage"
+      end
+    end
+  end
+
+  module Jasmine
+    module Coverage
+      @resources
+
+      def self.resources= resources
+        @resources = resources
+      end
+
+      def self.resources
+        @resources
+      end
+
+      @output_dir
+
+      def self.output_dir= output_dir
+        @output_dir = output_dir
+      end
+
+      def self.output_dir
+        @output_dir
+      end
+    end
+  end
+
+end

data/lib/tasks/jasmine_headless_coverage_patches.rb

@@ -0,0 +1,99 @@
+# This file holds the monkeypatches to open up jasmine headless for jasmine coverage.
+
+
+# This patch writes out a copy of the file that was loaded into the JSCoverage context for testing.
+# You can look at it to see if it included all the files and tests you expect.
+require 'jasmine/headless/template_writer'
+module Jasmine::Headless
+  class TemplateWriter
+    alias old_write :write
+
+    def write
+      ret = old_write
+      str = File.open(all_tests_filename, "rb").read
+
+      testrigfolder = Jasmine::Coverage.output_dir+"/testrig"
+      FileUtils.mkdir_p testrigfolder
+
+      p "\nCopying all view files and potential javascript fixture folders so the JS has access to the html fixtures.\n"
+      FileUtils.copy_entry("#{Jasmine::Coverage.output_dir}/../../spec", "#{testrigfolder}/spec")
+      FileUtils.copy_entry("#{Jasmine::Coverage.output_dir}/../../app", "#{testrigfolder}/app")
+      FileUtils.mkdir_p "#{testrigfolder}/target/fixtures"
+      FileUtils.copy_entry("#{Jasmine::Coverage.output_dir}/../fixtures", "#{testrigfolder}/target/fixtures")
+      FileUtils.mkdir_p "#{testrigfolder}/target/views"
+      FileUtils.copy_entry("#{Jasmine::Coverage.output_dir}/../views", "#{testrigfolder}/target/views")
+
+      jss = str.scan(/<script type="text\/javascript" src="(.*)"><\/script>/)
+      jss << str.scan(/<link rel="stylesheet" href="(.*)" type="text\/css" \/>/)
+      jss << str.scan(/\.coffee\.js'\] = '(.*)';<\/script>/)
+      jss.flatten!
+      jss.each { |s|
+        js = File.basename(s)
+        str.sub!(s, js)
+        if File.exists?("#{testrigfolder}/#{js}") && js != 'index.js'
+          s = "\n\n*******************************************************************\n"
+          s = s + "Cannot copy file '#{js}' into jasmine coverage test rig folder.\n"
+          s = s + "There is already another file of that name. You either have two files with the same name (but in different paths)\n"
+          s = s + "or your filename is the same as that from a third party vendor.\n"
+          s = s + "*******************************************************************\n\n"
+          raise s
+        end
+        FileUtils.cp(s, testrigfolder)
+      }
+
+      outfile = "#{testrigfolder}/jscoverage-test-rig.html"
+      aFile = File.new(outfile, "w")
+      aFile.write(str)
+      aFile.close
+
+      puts "A copy of the complete page that was used as the test environment can be found here:"
+      puts "#{outfile}"
+      ret
+    end
+  end
+end
+
+# Here we patch the resource handler to output the location of our instrumented files
+module Jasmine::Headless
+  class FilesList
+
+    alias old_to_html :to_html
+
+    def to_html(files)
+      # Declare our test runner files
+      cov_files = ['/jscoverage.js', '/coverage_output_generator.js']
+
+      # Add the original files, remapping to instrumented where necessary
+      tags = []
+      (old_to_html files).each do |path|
+        files_map = Jasmine::Coverage.resources
+        files_map.keys.each do |folder|
+          path = path.sub(folder, files_map[folder])
+
+          # Here we must check the supplied config hasn't pulled in our jscoverage runner file.
+          # If it has, the tests will fire too early, capturing only minimal coverage
+          if cov_files.select { |f| path.include?(f) }.length > 0
+            fail "Assets defined by jasmine.yml must not include any of #{cov_files}: #{path}"
+          end
+
+        end
+        tags << path
+      end
+
+      # Attach the "in context" test runners
+      tags = tags + old_to_html(cov_files.map { |f| File.dirname(__FILE__)+f })
+
+      tags
+    end
+
+    alias old_sprockets_environment :sprockets_environment
+
+    def sprockets_environment
+      return @sprockets_environment if @sprockets_environment
+      old_sprockets_environment
+      # Add the location of our jscoverage.js
+      @sprockets_environment.append_path(File.dirname(__FILE__))
+      @sprockets_environment
+    end
+  end
+end