js-test-driver-rails 0.4.3 → 0.5.0.pre1

data/lib/js_test_driver/runner.rb

@@ -1,225 +1,13 @@
 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_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_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
+  class Runner
 
-    def attributes=(values)
-      values.each do |attr, value|
-        self.send("#{attr}=", value)
-      end
+    def run(command)
+      system(command.to_s)
     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
+    def runbg(command)
+      spawn(command.to_s)
     end
 
   end

data/lib/js_test_driver/runtime_config.rb

@@ -0,0 +1,155 @@
+module JsTestDriver
+  # The RuntimeConfig class holds the various paths that the application
+  # uses, as well as the actual JsTestDriver configuration
+  class RuntimeConfig
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    attr_accessor :config_factory
+
+    # 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
+      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
+      file(@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
+      file(@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
+      file(@tmp_path ||= default_config_yml_path)
+    end
+
+    # This is the directory where the coverage HTML files will be saved
+    attr_writer :coverage_files_path
+
+    def coverage_files_path
+      dir(@coverage_files_path ||= default_coverage_files_path)
+    end
+
+    # This is the file in which js-test-driver saves coverage data
+    # it is not configurable
+    def coverage_data_file
+      file_name = File.basename(config_yml_path + '-coverage.dat')
+      return file(file_name, test_xml_data_path)
+    end
+
+    # This is where the XML files with test results will be saved
+    attr_writer :test_xml_data_path
+
+    def test_xml_data_path
+      dir(@test_xml_data_path ||= default_test_xml_data_path)
+    end
+
+    # This is where the fixtures will be saved
+    attr_writer :fixture_dir
+
+    def fixture_dir
+      dir(@fixture_dir ||= default_fixture_dir)
+    end
+
+    # This is where the remote browser scripts will be saved
+    attr_writer :remote_browsers_dir
+
+    def remote_browsers_dir
+      dir(@remote_browsers_dir ||= default_remote_browsers_dir)
+    end
+
+    protected
+
+    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
+      return config_factory.parse(source).save
+    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("jsTestDriver.conf", generated_files_dir)
+    end
+
+    def default_generated_files_dir
+      return dir(".js_test_driver")
+    end
+
+    def default_coverage_files_path
+      return dir('coverage', generated_files_dir)
+    end
+
+    def default_test_xml_data_path
+      return dir('tests', generated_files_dir)
+    end
+
+    def default_fixture_dir
+      return dir('fixtures', generated_files_dir)
+    end
+
+    def default_remote_browsers_dir
+      return dir('browsers', generated_files_dir)
+    end
+
+    private
+
+    def dir(name, parent = nil)
+      path = File.expand_path(name, parent)
+      FileUtils.mkdir_p(path) unless File.exist?(path)
+      return path
+    end
+
+    def file(name, parent = nil)
+      path = File.expand_path(name, parent)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      return path
+    end
+
+    def attributes=(values)
+      values.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+    end
+
+  end
+
+end

data/lib/js_test_driver/tasks.rb

@@ -4,25 +4,27 @@ namespace :js_test_driver do
 
   desc "Starts the server using the provided configuration variables"
   task :start_server do
-    JsTestDriver::Runner.new.start_server
+    JsTestDriver::Application.new.start_server
   end
 
   desc "Runs the javascript tests"
   task :run_tests do
-    exit(1) unless JsTestDriver::Runner.new.run_tests(ENV['TESTS'])
+    exit(1) unless JsTestDriver::Application.new.run_tests(:tests => ENV['TESTS'])
   end
 
   desc "Capture the browsers defined in config"
   task :capture_browsers do
-    JsTestDriver::Runner.new.capture_browsers(ENV['BROWSERS'])
+    JsTestDriver::Application.new.capture_browsers(: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'])
+    app = JsTestDriver::Application.new
+
+    exit(1) unless app.run(:tests => ENV['TESTS'],
+                           :browsers => ENV['BROWSERS'],
+                           :output_xml => !!ENV['OUTPUT_XML'],
+                           :capture_console => ENV['CAPTURE_CONSOLE'])
   end
 
-end
+end

data/lib/js_test_driver/version.rb

@@ -1,3 +1,3 @@
 module JsTestDriver
-  VERSION = "0.4.3"
+  VERSION = "0.5.0.pre1"
 end

data/lib/js_test_driver.rb

@@ -1,6 +1,30 @@
 require 'json'
+require 'yaml'
 require 'fileutils'
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'js_test_driver', 'config'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'js_test_driver', 'runner'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'js_test_driver', 'html_fixture'))
+require 'selenium-webdriver'
+
+module JsTestDriver
+  autoload :Application, 'js_test_driver/application'
+  autoload :Config, 'js_test_driver/config'
+  autoload :ConfigFactory, 'js_test_driver/config_factory'
+  autoload :HtmlFixture, 'js_test_driver/html_fixture'
+  autoload :MissingDependencyError, 'js_test_driver/missing_dependency_error'
+  autoload :RemoteBrowser, 'js_test_driver/remote_browser'
+  autoload :Runner, 'js_test_driver/runner'
+  autoload :RuntimeConfig, 'js_test_driver/runtime_config'
+  autoload :VERSION, 'js_test_driver/version'
+
+  module CLI
+    autoload :CaptureBrowsers, 'js_test_driver/cli/capture_browsers'
+    autoload :Run, 'js_test_driver/cli/run'
+    autoload :RunTests, 'js_test_driver/cli/run_tests'
+    autoload :StartServer, 'js_test_driver/cli/start_server'
+  end
+
+  module Commands
+    autoload :BaseCommand, 'js_test_driver/commands/base_command'
+    autoload :GenerateCoverageReport, 'js_test_driver/commands/generate_coverage_report'
+    autoload :JstdJarCommand, 'js_test_driver/commands/jstd_jar_command'
+  end
+end

data/test/integration/sample_test.rb

@@ -4,11 +4,10 @@ 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__))
+      config_path = File.expand_path('../../sample/config/js_test_driver.rb', __FILE__)
+      app = JsTestDriver::Application.new(:config_path => config_path)
 
-      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'
+      assert app.run(:output_xml => true), 'running tests should return a success'
     end
 
   end

data/test/sample/config/js_test_driver.rb

@@ -1,9 +1,13 @@
+host guess_local_ip
+
 includes 'test/sample/lib/*.js'
 
 ['google-chrome', 'firefox', 'chromium-browser'].select{|b| !%x[which #{b}].strip.empty? }.each do |b|
   browser b
 end
 
+remote_browser '192.168.1.106:4444', :browser => :ie
+
 enable_jasmine
 measure_coverage
 

data/test/test_helper.rb

@@ -8,9 +8,44 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'js_test
 require 'test/unit'
 require 'mocha'
 
+class FakeRunner
+
+  attr_reader :commands_run, :commands_run_in_bg
+
+  def initialize
+    @commands_run = []
+    @commands_run_in_bg = []
+  end
+
+  def run(command)
+    @commands_run << command.to_s
+  end
+
+  def runbg(command)
+    @commands_run_in_bg << command.to_s
+  end
+
+  def has_run?(command)
+    @commands_run.include?(command.to_s)
+  end
+
+  def has_run_in_bg?(command)
+    @commands_run_in_bg.include?(command.to_s)
+  end
+end
+
 class Test::Unit::TestCase
 
+  attr_reader :application, :runner
+
   def setup
+    @application = JsTestDriver::Application.new
+    runtime_config.config = runtime_config.config_factory.new
+    @runner = FakeRunner.new
+    @application.stubs(:runner => @runner)
+  end
+
+  def teardown
     clean_up_saved_config_files
   end
 
@@ -18,6 +53,22 @@ class Test::Unit::TestCase
     File.expand_path('fixtures', File.dirname(__FILE__))
   end
 
+  def config
+    application.config
+  end
+
+  def runtime_config
+    application.runtime_config
+  end
+
+  def assert_run(cmd)
+    assert runner.has_run?(cmd), "Expected to have run:\n#{cmd}\nbut only commands run were:\n#{runner.commands_run.join("\n")}"
+  end
+
+  def assert_run_in_bg(cmd)
+    assert runner.has_run_in_bg?(cmd), "Expected to have run in bg:\n#{cmd}\nbut only commands run were:\n#{runner.commands_run_in_bg.join("\n")}"
+  end
+
   def clean_up_saved_config_files
     root_dir = File.expand_path('..', File.dirname(__FILE__))
     Dir["#{root_dir}/**/.js_test_driver"].each do |file|
@@ -25,4 +76,4 @@ class Test::Unit::TestCase
     end
   end
 
-end
+end

data/test/unit/capture_browsers_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+module JsTestDriver
+  class CaptureBrowsersTest < Test::Unit::TestCase
+
+    def test_should_capture_default_browsers
+      config.browser 'foo', 'bar', 'baz'
+      JsTestDriver::Commands::BaseCommand.any_instance.stubs(:ensure_installed!)
+
+      application.capture_browsers
+
+      ['foo', 'bar', 'baz'].each do |browser|
+        assert_run_in_bg("#{browser} http://localhost:4224/capture?strict")
+      end
+    end
+
+    def test_should_capture_given_browsers
+      config.browser 'foo', 'bar', 'baz'
+      JsTestDriver::Commands::BaseCommand.any_instance.stubs(:ensure_installed!)
+
+      application.capture_browsers(:browsers => 'aaa,bbb')
+
+      ['aaa', 'bbb'].each do |browser|
+        assert_run_in_bg("#{browser} http://localhost:4224/capture?strict")
+      end
+    end
+
+  end
+end
+

data/test/unit/config_test.rb

@@ -21,7 +21,7 @@ module JsTestDriver
     end
 
     def given_an_empty_config
-      JsTestDriver::Config.new
+      application.config_factory.new
     end
 
     def test_empty_config
@@ -152,7 +152,7 @@ module JsTestDriver
       str = ""
 
       # when
-      config = JsTestDriver::Config.parse(str)
+      config = application.config_factory.parse(str)
 
       # then
       assert_equal [], config.included_files
@@ -172,7 +172,7 @@ module JsTestDriver
       CONFIG
 
       # when
-      config = JsTestDriver::Config.parse(str)
+      config = application.config_factory.parse(str)
 
       # then
       assert_equal ['a', 'b', 'c'].map{|p| File.expand_path(p)}, config.included_files
@@ -183,8 +183,6 @@ module JsTestDriver
     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
@@ -194,7 +192,7 @@ module JsTestDriver
     def test_config_with_html_fixtures
       # given
       config = given_an_empty_config
-      config.config_dir = File.expand_path("configs")
+      runtime_config.generated_files_dir = File.expand_path("configs")
 
       # when
       config.fixtures "fixture/directory", :name => "fixture_name", :namespace => "fixture_namespace"
@@ -203,23 +201,6 @@ module JsTestDriver
       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
@@ -266,5 +247,32 @@ module JsTestDriver
         'module' => 'com.google.jstestdriver.coverage.CoverageModule'}]
     end
 
+    def test_with_proxies
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.proxy('/hello/*').to('http://localhost:3111')
+      config.proxy('*').to('http://localhost:3222')
+
+      # then
+      assert_config_includes config, 'proxy' => [
+        {'matcher' => '/hello/*', 'server' => 'http://localhost:3111'},
+        {'matcher' => '*', 'server' => 'http://localhost:3222'}
+      ]
+    end
+
+    def test_config_with_remote_browsers
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.browser 'foo'
+      config.remote_browser('192.168.1.12:4444', :browser => :internet_explorer)
+
+      # then
+      assert_equal ['foo', File.join(runtime_config.remote_browsers_dir, 'remote-browser-192.168.1.12:4444-internet_explorer.rb')], config.browsers
+    end
+
   end
 end