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

data/Gemfile.lock

@@ -1,17 +1,32 @@
 PATH
   remote: .
   specs:
-    js-test-driver-rails (0.4.2)
+    js-test-driver-rails (0.4.3)
+      commander
       json
       rake
+      selenium-webdriver
 
 GEM
   remote: http://rubygems.org/
   specs:
-    json (1.4.6)
+    childprocess (0.1.9)
+      ffi (~> 1.0.6)
+    commander (4.0.4)
+      highline (>= 1.5.0)
+    ffi (1.0.9)
+    highline (1.6.2)
+    json (1.5.1)
+    json_pure (1.5.1)
     mocha (0.9.9)
       rake
     rake (0.8.7)
+    rubyzip (0.9.4)
+    selenium-webdriver (0.2.1)
+      childprocess (>= 0.1.7)
+      ffi (>= 1.0.7)
+      json_pure
+      rubyzip
 
 PLATFORMS
   ruby

data/TODO

@@ -0,0 +1,6 @@
+* add remote/selenium browser runner
+* add output coloring
+* add simple watchr integration
+* replace rake tasks with commandline runner
+* implement own output formatter (based on Eclipse/IntelliJ plugins)
+* clean up the whole test-output situation

data/bin/jstd

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'js_test_driver'
+
+require 'commander/import'
+
+def browser_option(c)
+  c.option '-b', '--browsers STRING', String, 'Comma-separated list of browsers to capture'
+end
+
+def tests_option(c)
+  c.option '-t', '--tests STRING', String, 'Test cases to run, defaults to all'
+end
+
+program :name, 'JS Test Driver'
+program :version, JsTestDriver::VERSION
+program :description, 'A Ruby Wrapper for Google js-test-driver'
+program :help, 'Author', 'Adam Pohorecki <adam@pohorecki.pl>'
+
+runtime_opts = {}
+
+global_option('-c', '--config FILE', 'path to Ruby configuration file') do |file|
+  runtime_opts[:config_path] = file
+end
+
+command :'start server' do |c|
+  c.description = 'Starts the js-test-driver server'
+  c.syntax = 'jstd [--config FILE] start server'
+
+  c.action do |args, opts|
+    JsTestDriver::Application.new(runtime_opts).start_server(opts.__hash__)
+  end
+end
+
+command :'capture browsers' do |c|
+  c.description = 'captures all the defined browsers in strict mode'
+  c.syntax = 'jstd [--config FILE] capture browsers [OPTIONS]'
+
+  browser_option(c)
+
+  c.action do |args, opts|
+    JsTestDriver::Application.new(runtime_opts).capture_browsers(opts.__hash__)
+  end
+end
+
+command :'run tests' do |c|
+  c.description = 'Runs the defined tests in an already running server'
+  c.syntax = 'jstd [--config FILE] run tests [OPTIONS]'
+
+  tests_option(c)
+
+  c.action do |args, opts|
+    JsTestDriver::Application.new(runtime_opts).run_tests(opts.__hash__)
+  end
+end
+
+command :run do |c|
+  c.description = 'Starts the server, captures browsers and runs tests'
+  c.syntax = 'jstd [--config FILE] run [OPTIONS]'
+
+  browser_option(c)
+  tests_option(c)
+  c.option '--[no-]output-xml', 'output test results in JUnit xml format'
+  c.option '--[no-]capture-console', 'capture browser console'
+  c.option '--[no-]verbose', 'verbose test output'
+  c.option '--runner-mode STRING', 'change runner mode to output more information'
+  c.option '--browser-timeout INT', Integer, 'number of seconds after which a browser is considered dead'
+
+  c.action do |args, opts|
+    JsTestDriver::Application.new(runtime_opts).run(opts.__hash__)
+  end
+end

data/js-test-driver-rails.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'json'
   s.add_dependency 'rake'
+  s.add_dependency 'commander'
+  s.add_dependency 'selenium-webdriver'
   s.add_development_dependency 'mocha'
 
   s.files         = `git ls-files`.split("\n")

data/lib/js_test_driver/application.rb

@@ -0,0 +1,52 @@
+module JsTestDriver
+
+  class Application
+
+    attr_reader :runtime_config
+
+    def initialize(opts = {})
+      @runtime_config = JsTestDriver::RuntimeConfig.new(opts)
+      @runtime_config.config_factory = config_factory
+    end
+
+    def config
+      runtime_config.config
+    end
+
+    def start_server(opts = {})
+      JsTestDriver::CLI::StartServer.new(jstd_jar_command, runner).run(opts)
+    end
+
+    def capture_browsers(opts = {})
+      JsTestDriver::CLI::CaptureBrowsers.new(config, runner).run(opts)
+    end
+
+    def run_tests(opts = {})
+      JsTestDriver::CLI::RunTests.new(jstd_jar_command, runner).run(opts)
+    end
+
+    def run(opts = {})
+      JsTestDriver::CLI::Run.new(jstd_jar_command, runner, config, coverage_command).run(opts)
+    end
+
+    def config_factory
+      JsTestDriver::ConfigFactory.new(runtime_config)
+    end
+
+    protected
+
+    def runner
+      JsTestDriver::Runner.new
+    end
+
+    def jstd_jar_command
+      JsTestDriver::Commands::JstdJarCommand.new(runtime_config, config)
+    end
+
+    def coverage_command
+      JsTestDriver::Commands::GenerateCoverageReport.new(runtime_config)
+    end
+
+  end
+
+end

data/lib/js_test_driver/cli/capture_browsers.rb

@@ -0,0 +1,34 @@
+module JsTestDriver
+  module CLI
+
+    class CaptureBrowsers
+
+      attr_reader :config, :runner
+
+      def initialize(config, runner)
+        @config = config
+        @runner = runner
+      end
+
+      def run(opts = {})
+        browsers = opts[:browsers] || ''
+        browsers = browsers.split(',')
+        browsers = config.browsers if browsers.empty?
+
+        url = config.server + "/capture?strict"
+
+        browsers.each do |name|
+          runner.runbg(browser_command(name, url))
+        end
+      end
+
+      protected
+
+      def browser_command(name, url)
+        JsTestDriver::Commands::BaseCommand.new(name).arg(url).to_s
+      end
+
+    end
+
+  end
+end

data/lib/js_test_driver/cli/run.rb

@@ -0,0 +1,56 @@
+module JsTestDriver
+  module CLI
+
+    class Run
+
+      attr_reader :command, :runner, :config, :coverage_command
+
+      def initialize(jstd_jar_command, runner, config, coverage_command)
+        @command = jstd_jar_command
+        @runner = runner
+        @config = config
+        @coverage_command = coverage_command
+      end
+
+      def run(opts = {})
+        result = run_jstd_command(opts)
+        generate_coverage_report(opts)
+        return result
+      end
+
+      protected
+
+      def run_jstd_command(opts)
+        command
+          .start_server
+          .with_config
+          .capture_browsers(opts[:browsers])
+          .run_tests(opts[:tests])
+
+        command.output_xml if opts[:output_xml]
+        command.capture_console if opts[:capture_console]
+        command.verbose if opts[:verbose]
+        command.run_mode(opts[:runner_mode]) if opts[:runner_mode]
+        command.browser_timeout(opts[:browser_timeout]) if opts[:browser_timeout]
+
+        return runner.run(command.to_s)
+      end
+
+      def generate_coverage_report(opts)
+        return unless config.measure_coverage? && opts[:output_xml]
+
+        if genhtml_installed?
+          runner.run(coverage_command.to_s)
+        else
+          puts "Could not find genhtml. You must install lcov (sudo apt-get install lcov)"
+        end
+      end
+
+      def genhtml_installed?
+        !%x[which genhtml].strip.empty?
+      end
+
+    end
+
+  end
+end

data/lib/js_test_driver/cli/run_tests.rb

@@ -0,0 +1,22 @@
+module JsTestDriver
+  module CLI
+
+    class RunTests
+
+      attr_reader :jstd_jar_command, :runner
+
+      def initialize(jstd_jar_command, runner)
+        @jstd_jar_command = jstd_jar_command
+        @runner = runner
+      end
+
+      def run(opts = {})
+        jstd_jar_command.with_config.run_tests(opts[:tests])
+
+        runner.run(jstd_jar_command.to_s)
+      end
+
+    end
+
+  end
+end

data/lib/js_test_driver/cli/start_server.rb

@@ -0,0 +1,20 @@
+module JsTestDriver
+  module CLI
+
+    class StartServer
+
+      attr_reader :jstd_jar_command, :runner
+
+      def initialize(jstd_jar_command, runner)
+        @jstd_jar_command = jstd_jar_command
+        @runner = runner
+      end
+
+      def run(opts = {})
+        runner.run(jstd_jar_command.start_server.to_s)
+      end
+
+    end
+
+  end
+end

data/lib/js_test_driver/commands/base_command.rb

@@ -0,0 +1,43 @@
+module JsTestDriver
+  module Commands
+
+    class BaseCommand
+      def initialize(executable)
+        @command = "#{executable}"
+        ensure_installed!
+
+        @options = []
+        @args = []
+      end
+
+      def option(name, value = nil)
+        @options << name
+        @options << escape(value)
+        self
+      end
+
+      def arg(value)
+        @args << escape(value)
+        self
+      end
+
+      def to_s
+        return ([@command] + @options + @args).compact.join(' ')
+      end
+
+      private
+
+      def ensure_installed!
+        if %x[which #{@command}].strip.empty?
+          raise JsTestDriver::MissingDependencyError.new("Could not find executable: #{@command}")
+        end
+      end
+
+      def escape(value)
+        return "'#{value}'" if value && value =~ /\s/
+        return value
+      end
+    end
+
+  end
+end

data/lib/js_test_driver/commands/generate_coverage_report.rb

@@ -0,0 +1,17 @@
+module JsTestDriver
+  module Commands
+
+    class GenerateCoverageReport < BaseCommand
+
+      attr_reader :runtime_config
+
+      def initialize(runtime_config)
+        super('genhtml')
+        option('-o', runtime_config.coverage_files_path)
+        arg(runtime_config.coverage_data_file)
+      end
+
+    end
+
+  end
+end

data/lib/js_test_driver/commands/jstd_jar_command.rb

@@ -0,0 +1,61 @@
+module JsTestDriver
+  module Commands
+
+    class JstdJarCommand < BaseCommand
+
+      attr_reader :runtime_config, :config
+
+      def initialize(runtime_config, config)
+        super('java')
+        @runtime_config = runtime_config
+        @config = config
+
+        option('-jar', runtime_config.jar_path)
+        option('--serverHandlerPrefix', 'jstd')
+      end
+
+      def with_config
+        return option('--config', runtime_config.config_yml_path)
+      end
+
+      def start_server
+        return option('--port', config.port)
+      end
+
+      def run_tests(tests = nil)
+        return option('--tests', tests || "all")
+      end
+
+      def capture_browsers(browsers = nil)
+        browsers ||= config.browsers.join(',')
+        raise ArgumentError.new("No browsers defined!") if browsers == ""
+        return option('--browser', browsers)
+      end
+
+      def output_directory(path)
+        return option('--testOutput', path)
+      end
+
+      def output_xml
+        return output_directory(runtime_config.test_xml_data_path)
+      end
+
+      def capture_console
+        return option('--captureConsole')
+      end
+
+      def verbose
+        return option('--verbose')
+      end
+
+      def runner_mode(mode)
+        return option('--runnerMode', mode)
+      end
+
+      def browser_timeout(timeout)
+        return option('--browserTimeout', timeout)
+      end
+    end
+
+  end
+end

data/lib/js_test_driver/config.rb

@@ -9,7 +9,8 @@ module JsTestDriver
   # user a significant amount of freedom in terms of what is and is not loaded, and so on
   class Config
 
-    def initialize(attributes = {})
+    def initialize(runtime_config, attributes = {})
+      @runtime_config = runtime_config
       self.attributes = attributes
     end
 
@@ -37,6 +38,16 @@ module JsTestDriver
       end
     end
 
+    # This allows you to control browsers on remote machines with Selenium
+    # To be able to use this, the remote server has to be running selenium-server
+    #
+    # Available options are: host and browser (as in WebDriver::Remote::Capabilities)
+    def remote_browser(host, opts = {})
+      remote_browser = JsTestDriver::RemoteBrowser.new(host, opts)
+      remote_browsers << remote_browser
+      browser remote_browser_file_name(remote_browser.name)
+    end
+
     # Defines a HTML fixture directory
     #
     # the first argument is the directory to scan for html fixtures
@@ -73,6 +84,11 @@ module JsTestDriver
       }
     end
 
+    # Adds a proxy matcher to configuration. This can be used for integration testing.
+    def proxy(pattern)
+      return Proxy.new(pattern, proxies)
+    end
+
     def measure_coverage?
       !!@measure_coverage
     end
@@ -82,6 +98,16 @@ module JsTestDriver
       @plugins ||= []
     end
 
+    def guess_local_ip
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+      UDPSocket.open do |s|
+        s.connect '64.233.187.99', 1
+        return s.addr.last
+      end
+    ensure
+      Socket.do_not_reverse_lookup = orig
+    end
+
     # config variable which has a regular setter,
     # but also can be set by calling the "getter" with an argument
     # and if called without an argument the getter will return the passed block
@@ -132,44 +158,78 @@ module JsTestDriver
       @html_fixtures ||= []
     end
 
+    def proxies
+      @proxies ||= []
+    end
+
     attr_writer :browsers
 
     def browsers
       @browsers ||= []
     end
 
+    attr_writer :remote_browsers
+
+    def remote_browsers
+      @remote_browsers ||= []
+    end
+
     def to_s
       hash = {'server' => server, 'basepath' => base_path}
       hash['load'] = loaded_files unless loaded_files.empty?
       hash['exclude'] = map_paths(excluded_files) unless excluded_files.empty?
       hash['plugin'] = plugins unless plugins.empty?
+      hash['proxy'] = proxies unless proxies.empty?
       return hash.to_yaml
     end
 
-    def self.parse(string)
-      config = new
-      config.instance_eval(string)
-      return config
+    # this is where the config files are saved (ex. RAILS_ROOT/.js_test_driver)
+    def config_dir
+      runtime_config.generated_files_dir
     end
 
-    attr_writer :config_dir
+    # this is where the config files are saved (ex. RAILS_ROOT/.js_test_driver/fixtures)
+    def fixture_dir
+      runtime_config.fixture_dir
+    end
 
-    # this is where the config files are saved (ex. RAILS_ROOT/.js_test_driver)
-    def config_dir
-      @config_dir ||= File.expand_path(".")
+    def save
+      File.open(runtime_config.config_yml_path, "w+") { |f| f.puts self.to_s }
+      save_fixtures
+      save_remote_browsers
+      return self
     end
 
+    private
+
+    attr_reader :runtime_config
+
     def save_fixtures
       html_fixtures.each do |fixture|
         path = fixture_file_name(fixture)
-        FileUtils.mkdir_p(File.dirname(path))
         File.open(path, "w+") do |f|
           f.puts fixture.to_s
         end
       end
     end
 
-    private
+    def save_remote_browsers
+      remote_browsers.each do |browser|
+        path = remote_browser_file_name(browser.name)
+        File.open(path, "w+") do |f|
+          f.puts browser.to_s
+        end
+        File.chmod(0755, path)
+      end
+    end
+
+    def fixture_file_name(fixture)
+      File.join(fixture_dir, fixture.namespace, "#{fixture.name}.js")
+    end
+
+    def remote_browser_file_name(name)
+      File.join(runtime_config.remote_browsers_dir, name)
+    end
 
     def vendor_directory
       this_directory = File.dirname(__FILE__)
@@ -181,10 +241,6 @@ module JsTestDriver
       return with_expanded_paths.map{|path| path.include?('*') ? Dir[path].sort : path}.flatten
     end
 
-    def fixture_file_name(fixture)
-      File.expand_path(File.join(config_dir, "fixtures", fixture.namespace, "#{fixture.name}.js"))
-    end
-
     def loaded_files
       files = included_files + html_fixtures.collect { |fixture| fixture_file_name(fixture) }
 
@@ -205,5 +261,18 @@ module JsTestDriver
       end
     end
 
+    class Proxy
+      attr_reader :pattern, :proxies
+
+      def initialize(pattern, proxies)
+        @pattern = pattern
+        @proxies = proxies
+      end
+
+      def to(server)
+        self.proxies << {'matcher' => pattern, 'server' => server}
+      end
+    end
+
   end
 end

data/lib/js_test_driver/config_factory.rb

@@ -0,0 +1,21 @@
+module JsTestDriver
+  class ConfigFactory
+
+    attr_reader :runtime_config
+
+    def initialize(runtime_config)
+      @runtime_config = runtime_config
+    end
+
+    def new(opts = {})
+      JsTestDriver::Config.new(runtime_config, opts)
+    end
+
+    def parse(string)
+      config = new
+      config.instance_eval(string)
+      return config
+    end
+
+  end
+end

data/lib/js_test_driver/missing_dependency_error.rb

@@ -0,0 +1,4 @@
+module JsTestDriver
+  class MissingDependencyError < StandardError
+  end
+end

data/lib/js_test_driver/remote_browser.rb

@@ -0,0 +1,57 @@
+module JsTestDriver
+
+  class RemoteBrowser
+
+    attr_reader :host, :browser, :driver
+
+    def initialize(host, opts = {})
+      @host = host
+      @browser = opts[:browser]
+    end
+
+    def name
+      ["remote-browser", host, browser].join('-') + '.rb'
+    end
+
+    def run(url)
+      trap_signals
+
+      opts = {:url => "http://#{host}/wd/hub"}
+      opts[:desired_capabilities] = browser if browser
+
+      @driver = Selenium::WebDriver.for(:remote, opts)
+      driver.navigate.to url
+
+      while(true) do
+        sleep(1)
+      end
+    end
+
+    def to_s
+      jstd_dir = File.expand_path(File.join('..', '..'), __FILE__)
+      <<RUBY
+#!/usr/bin/env ruby
+
+$:.push "#{jstd_dir}"
+
+require "rubygems"
+require "js_test_driver"
+
+JsTestDriver::RemoteBrowser.new(#{host.inspect}, :browser => #{browser.inspect}).run(ARGV[0])
+RUBY
+    end
+
+    private
+
+    def trap_signals
+      [:INT, :QUIT, :TERM].each do |sig|
+        trap(sig) do
+          driver.quit
+          exit(0)
+        end
+      end
+    end
+
+  end
+
+end