sayso-js-test-driver-rails 0.4.3

data/lib/js_test_driver/runner.rb

@@ -0,0 +1,232 @@
+module JsTestDriver
+  # The Runner class is used
+  class Runner
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    # configuration, by default it's parsed from config_path
+    attr_writer :config
+
+    def config
+      @config ||= parse_config
+    end
+
+    attr_writer :generated_files_dir
+
+    # this is where the generated files will be saved, by default this is `pwd`/.js_test_driver
+    #
+    # the generated files are the config yml file and the fixture files
+    def generated_files_dir
+      @generated_files_dir || default_generated_files_dir
+    end
+
+    # this is the path of the config file, by default its `pwd`/config/js_test_driver.rb
+    attr_writer :config_path
+
+    def config_path
+      @config_path ||= default_config_path
+    end
+
+    # this is the path to the js test driver jar file, by default it's stored relatively to this file
+    attr_writer :jar_path
+
+    def jar_path
+      @jar_path ||= default_jar_path
+    end
+
+    # this is where the config yml file will be saved, by default its saved in the generated files
+    # directory under the name jsTestDriver.conf
+    attr_writer :tmp_path
+
+    def config_yml_path
+      @tmp_path ||= default_config_yml_path
+    end
+
+    # starts the server on the default port specified in the config file
+    def start_server
+      command = execute_jar
+
+      add_start_server(command)
+
+      command.run
+    end
+
+    # captures the browsers
+    #
+    # by default it will capture the browsers specified in the config,
+    # but you can pass an argument like 'opera,chrome,firefox' to capture opera, chrome and firefox
+    def capture_browsers(browsers = nil)
+      browsers ||= ''
+      browsers = browsers.split(',')
+      browsers = config.browsers if browsers.empty?
+
+      url = config.server + "/capture"
+
+      browsers.each do |browser|
+        spawn("#{browser} \'#{url}\'")
+      end
+    end
+
+    # runs the tests specified by the argument
+    #
+    # by default it will run all the tests, but you can pass a string like:
+    # 'TestCase' or 'TestCase.test'
+    # to run either a single test case or a single test
+    def run_tests(tests = nil)
+      command = execute_jar
+
+      add_with_config(command)
+      add_run_tests(command, tests)
+
+      command.run
+    end
+
+    def start_server_capture_and_run(tests = nil, browsers = nil, output_xml_path = nil, console = nil)
+      command = execute_jar
+
+      add_start_server(command)
+			add_runner_mode(command)
+      add_with_config(command)
+      add_capture_browsers(command, browsers)
+      add_run_tests(command, tests)
+      add_output_directory(command, output_xml_path) if output_xml_path
+      add_capture_console(command) if console
+
+      result = command.run
+
+      if config.measure_coverage? && output_xml_path
+        generate_html_coverage_report(output_xml_path)
+      end
+
+      return result
+    end
+
+    def add_start_server(command)
+      command.option('--port', config.port)
+    end
+
+    def add_runner_mode(command)
+      command.option('--runnerMode', ENV['RUNNER_MODE']) unless ENV['RUNNER_MODE'].nil? || ENV['RUNNER_MODE'].empty?
+    end
+
+    def add_run_tests(command, tests)
+      command.option('--tests', tests || "all")
+    end
+
+    def add_capture_browsers(command, browsers)
+      browsers ||= config.browsers.join(',')
+      raise ArgumentError.new("No browsers defined!") if browsers == ""
+      command.option('--browser', browsers)
+    end
+
+    def add_output_directory(command, path)
+      path = File.expand_path(path)
+      FileUtils.mkdir_p(path) unless File.exists?(path)
+      command.option('--testOutput', path)
+    end
+
+    def add_capture_console(command)
+      command.option('--captureConsole')
+    end
+
+    def add_with_config(command)
+      save_config_file(config_yml_path)
+      command.option('--config', config_yml_path)
+    end
+
+    def execute_jar
+      Command.new('java').option('-jar', jar_path)
+    end
+
+    def generate_html_coverage_report(output_path)
+      unless genhtml_installed?
+        puts "Could not find genhtml. You must install lcov (sudo apt-get install lcov)"
+        return
+      end
+
+      output_path = File.expand_path(output_path)
+
+      config_file_name = File.basename(config_yml_path)
+      coverage_file_name = config_file_name + '-coverage.dat'
+      coverage_file_path = File.join(output_path, coverage_file_name)
+      coverage_out_dir = File.join(output_path, 'coverage')
+
+      system("genhtml -o #{coverage_out_dir} #{coverage_file_path}")
+    end
+
+    protected
+
+    def genhtml_installed?
+      !%x[which genhtml].strip.empty?
+    end
+
+    def parse_config
+      source = ""
+      if File.exist?(config_path)
+        source = File.read(config_path)
+      else
+        warn("Could not find JS Test Driver config: '#{config_path}', assuming empty config file!")
+      end
+      config = JsTestDriver::Config.parse(source)
+      config.config_dir = generated_files_dir
+      return config
+    end
+
+    def default_config_path
+      root = defined?(::Rails) ? ::Rails.root.to_s : '.'
+      return File.expand_path(File.join(root, 'config', 'js_test_driver.rb'))
+    end
+
+    def default_jar_path
+      current_dir = File.dirname(__FILE__)
+      path = File.join(current_dir, '..', '..', 'vendor', 'js_test_driver.jar')
+      return File.expand_path(path)
+    end
+
+    def default_config_yml_path
+      return File.expand_path("jsTestDriver.conf", generated_files_dir)
+    end
+
+    def default_generated_files_dir
+      return File.expand_path(".js_test_driver")
+    end
+
+    private
+
+    def save_config_file(path)
+      Dir.mkdir(generated_files_dir) unless File.exists?(generated_files_dir)
+      File.open(path, "w+") { |f| f.puts config.to_s }
+      config.save_fixtures
+    end
+
+    def attributes=(values)
+      values.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+    end
+
+    class Command
+      def initialize(executable)
+        @command = "#{executable}"
+      end
+
+      def option(name, value = nil)
+        value = "'#{value}'" if value && value =~ /\s/
+        @command = [@command, name, value].compact.join(' ')
+        self
+      end
+
+      def run
+        system(self.to_s)
+      end
+
+      def to_s
+        return @command
+      end
+    end
+
+  end
+
+end

data/lib/js_test_driver/tasks.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'js_test_driver'))
+
+namespace :js_test_driver do
+
+  desc "Starts the server using the provided configuration variables"
+  task :start_server do
+    JsTestDriver::Runner.new.start_server
+  end
+
+  desc "Runs the javascript tests"
+  task :run_tests do
+    exit(1) unless JsTestDriver::Runner.new.run_tests(ENV['TESTS'])
+  end
+
+  desc "Capture the browsers defined in config"
+  task :capture_browsers do
+    JsTestDriver::Runner.new.capture_browsers(ENV['BROWSERS'])
+  end
+
+  desc "Starts the server, captures the browsers, runs the tests - all at the same time"
+  task :run do
+    config = JsTestDriver::Runner.new
+    output_path = ENV['OUTPUT_PATH']
+    output_path = File.join(config.generated_files_dir, 'tests') if ENV['OUTPUT_XML']
+    config.start_server_capture_and_run(ENV['TESTS'], ENV['BROWSERS'], output_path, ENV['CAPTURE_CONSOLE'])
+  end
+
+end

data/lib/js_test_driver/version.rb

@@ -0,0 +1,3 @@
+module JsTestDriver
+  VERSION = "0.4.3"
+end

data/test/fixtures/a.html

@@ -0,0 +1 @@
+<p>This is the file <b>a.html</b></p>

data/test/fixtures/b.html

@@ -0,0 +1 @@
+<p>This is the file <b>b.html</b></p>

data/test/fixtures/baz/a.html

@@ -0,0 +1 @@
+<p>This is the file <b>baz/a.html</b></p>

data/test/fixtures/c.html

@@ -0,0 +1 @@
+<p>This is the file <b>c.html</b></p>

data/test/fixtures/foo/a.html

@@ -0,0 +1 @@
+<p>This is the file <b>foo/a.html</b></p>

data/test/fixtures/foo/bar/a.html

@@ -0,0 +1 @@
+<p>This is the file <b>foo/bar/a.html</b></p>

data/test/fixtures/hello.txt

@@ -0,0 +1 @@
+This file is not a HTML file, so it will not be used as a fixture.

data/test/integration/sample_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+module JsTestDriver
+  class SampleTest < Test::Unit::TestCase
+
+    def test_running_sample_specs
+      config = JsTestDriver::Runner.new(:config_path => File.expand_path('../../sample/config/js_test_driver.rb', __FILE__))
+
+      output_path = File.expand_path('../../../.js_test_driver/', __FILE__)
+
+      assert config.start_server_capture_and_run(nil, nil, output_path), 'running tests should return a success'
+    end
+
+  end
+end

data/test/sample/config/js_test_driver.rb

@@ -0,0 +1,11 @@
+includes 'test/sample/lib/*.js'
+
+['google-chrome', 'firefox', 'chromium-browser'].select{|b| !%x[which #{b}].strip.empty? }.each do |b|
+  browser b
+end
+
+enable_jasmine
+measure_coverage
+
+includes 'test/sample/specs/spec_helper.js'
+includes 'test/sample/specs/**/*_spec.js'

data/test/sample/lib/calculator.js

@@ -0,0 +1,15 @@
+function Calculator(initialValue) {
+  this.value = initialValue;
+}
+
+Calculator.prototype = {
+  add: function(val) {
+    this.value += val;
+  },
+  multiply: function(val) {
+    this.value *= val;
+  },
+  sub: function(val) {
+    this.value -= val;
+  }
+};

data/test/sample/specs/calculator_spec.js

@@ -0,0 +1,19 @@
+describe('Calculator', function () {
+  var calc;
+
+  beforeEach(function () {
+    calc = new Calculator(2);
+  });
+
+  it('adds values', function() {
+    calc.add(2);
+
+    expect(calc.value).toEqual(4);
+  });
+
+  it('multiplies values', function() {
+    calc.multiply(3);
+
+    expect(calc.value).toEqual(6);
+  });
+});

data/test/sample/specs/spec_helper.js

@@ -0,0 +1,4 @@
+// nothing to see here
+
+function hello() {
+}

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'js_test_driver'))
+
+require 'test/unit'
+require 'mocha'
+
+class Test::Unit::TestCase
+
+  def setup
+    clean_up_saved_config_files
+  end
+
+  def fixture_dir
+    File.expand_path('fixtures', File.dirname(__FILE__))
+  end
+
+  def clean_up_saved_config_files
+    root_dir = File.expand_path('..', File.dirname(__FILE__))
+    Dir["#{root_dir}/**/.js_test_driver"].each do |file|
+      FileUtils.rm_rf(file)
+    end
+  end
+
+end

data/test/unit/config_test.rb

@@ -0,0 +1,270 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+module JsTestDriver
+  class ConfigTest < Test::Unit::TestCase
+
+    def default_result
+      {'server' => 'http://localhost:4224', 'basepath' => '/'}
+    end
+
+    def path(relative_file_name)
+      return File.expand_path(relative_file_name).gsub(/^\//, '')
+    end
+
+    def paths(arr)
+      arr.map{|s| path(s)}.sort
+    end
+
+    def assert_config_includes(config, hash)
+      expected = default_result.merge(hash)
+      assert_equal expected, YAML::load(config.to_s)
+    end
+
+    def given_an_empty_config
+      JsTestDriver::Config.new
+    end
+
+    def test_empty_config
+      # given
+      config = given_an_empty_config
+
+      # then
+      assert_config_includes(config, default_result)
+    end
+
+    def test_custom_port
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.port 666
+
+      # then
+      assert_config_includes config, 'server' => 'http://localhost:666'
+    end
+
+    def test_custom_host
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.host 'example.com'
+
+      # then
+      assert_config_includes config, 'server' => 'http://example.com:4224'
+    end
+
+    def test_custom_server
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.server 'https://example.com:443'
+
+      # then
+      assert_config_includes config, 'server' => 'https://example.com:443'
+    end
+
+    def test_server_should_override_host_and_port
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.port 666
+      config.host 'test.com'
+      config.server 'https://example.com:443'
+
+      # then
+      assert_config_includes config, 'server' => 'https://example.com:443'
+    end
+
+    def test_config_with_includes
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.includes('src/foo.js')
+
+      # then
+      assert_config_includes config, 'load' => paths(['src/foo.js'])
+    end
+
+    def test_config_with_includes_with_globbing
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.includes('test/fixtures/foo/**/*.html')
+
+      # then
+      assert_config_includes config, 'load' => paths(['test/fixtures/foo/bar/a.html', 'test/fixtures/foo/a.html'])
+    end
+
+    def test_config_with_browsers
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.browser('firefox')
+      config.browser('chrome')
+
+      # then
+      assert_equal ['firefox', 'chrome'], config.browsers
+    end
+
+    def test_config_with_multiple_includes
+      # given
+      config = given_an_empty_config
+
+      # when
+      ['a', 'b', 'c'].each do |name|
+        config.includes(name)
+      end
+
+      # then
+      assert_config_includes config, 'load' => paths(['a', 'b', 'c'])
+    end
+
+    def test_config_with_excludes
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.excludes('test/fixtures/foo/**/*.html')
+
+      # then
+      assert_config_includes config, 'exclude' => paths(['test/fixtures/foo/bar/a.html', 'test/fixtures/foo/a.html'])
+    end
+
+    def test_config_with_excludes_with_globbing
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.excludes('src/foo.js')
+
+      # then
+      assert_config_includes config, 'exclude' => paths(['src/foo.js'])
+    end
+
+    def test_empty_config_file
+      # given
+      str = ""
+
+      # when
+      config = JsTestDriver::Config.parse(str)
+
+      # then
+      assert_equal [], config.included_files
+      assert_equal [], config.excluded_files
+      assert_equal "http://localhost:4224", config.server
+    end
+
+    def test_sample_config_file
+      # given
+      str = <<-CONFIG
+      includes 'a', 'b'
+      includes 'c'
+
+      excludes 'd'
+
+      server 'http://example.com:666'
+      CONFIG
+
+      # when
+      config = JsTestDriver::Config.parse(str)
+
+      # then
+      assert_equal ['a', 'b', 'c'].map{|p| File.expand_path(p)}, config.included_files
+      assert_equal [File.expand_path('d')], config.excluded_files
+      assert_equal 'http://example.com:666', config.server
+    end
+
+    def test_given_a_config_path_should_expand_the_includes
+      # given
+      config = given_an_empty_config
+      config.config_dir = "/foo/bbb/ccc"
+      pwd = File.expand_path('.')
+      config.includes "a/a", "/b/b", "../c"
+
+      # then
+      assert_config_includes config, 'load' => ["a/a", '/b/b', "../c"].map{|p| path(p)}
+    end
+
+    def test_config_with_html_fixtures
+      # given
+      config = given_an_empty_config
+      config.config_dir = File.expand_path("configs")
+
+      # when
+      config.fixtures "fixture/directory", :name => "fixture_name", :namespace => "fixture_namespace"
+
+      # then
+      assert_config_includes config, 'load' => paths(["configs/fixtures/fixture_namespace/fixture_name.js"])
+    end
+
+    def test_should_save_fixtures
+      # given
+      config = given_an_empty_config
+      config.config_dir = "tmp/stuff"
+      config.fixtures fixture_dir, :name => "fixture_name", :namespace => "fixture_namespace"
+
+      # when
+      config.save_fixtures
+
+      # then
+      name = "tmp/stuff/fixtures/fixture_namespace/fixture_name.js"
+      assert File.exists?(name)
+      assert_equal File.read(name), config.html_fixtures.first.to_s
+    ensure
+      FileUtils.rm_rf("tmp/stuff")
+    end
+
+    def test_should_raise_argument_error_if_the_same_fixture_defined_twice
+      # given
+      config = given_an_empty_config
+      config.fixtures "fixture/directory"
+
+      assert_raises(ArgumentError) do
+        config.fixtures "fixture/some_other_directory"
+      end
+    end
+
+    def test_should_not_raise_argument_error_for_two_fixtures_with_different_names
+      # given
+      config = given_an_empty_config
+      config.fixtures "fixture/directory"
+
+      assert_nothing_raised do
+        config.fixtures "fixture/some_other_directory", :name => "some_other_name"
+      end
+    end
+
+    def test_enable_jasmine_adds_jasmine_and_jasmine_adapter
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.enable_jasmine
+
+      # then
+      assert_equal 2, config.included_files.size
+      assert File.exists?(config.included_files[0])
+      assert Dir[config.included_files[1]].size > 0
+    end
+
+    def test_with_coverage_measuring_enabled
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.measure_coverage
+
+      # then
+      assert_config_includes config, 'plugin' => [{'name' => 'coverage',
+        'jar' => File.expand_path('../../../vendor/coverage.jar', __FILE__),
+        'module' => 'com.google.jstestdriver.coverage.CoverageModule'}]
+    end
+
+  end
+end