js-test-driver-rails 0.1.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "bundler", "~> 0.9.26"
+gem "jeweler"
+gem "mocha"
+gem "rake"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 by Adam Pohorecki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,28 @@
+js-test-driver-rails is a thin wrapper for the JsTestDriver library: http://code.google.com/p/js-test-driver/
+
+To take advantage of it, you should create a js_test_driver.rb file in your RAILS_ROOT/config/ directory.
+
+The file may contain following directives:
+
+includes 'foo', 'bar', 'public/javascripts/*.js' # files to be included
+excludes 'public/javascripts/fail.js' # files to be excluded, useful with globbing
+
+host 'my-laptop' # the host to which the test runner will connect, by default 'localhost'
+port 6666 # the port to which test runner will connect, and on which the test server will start, by default 4224
+
+browser 'firefox' # you can specify the default browsers which will be captured
+
+Note, that this is a ruby file, so the file/browser list can be generated dynamically - it's completely up to you.
+
+This gem comes with 3 rake tasks:
+
+# start the js test driver server
+rake js_test_driver:start_server
+
+# capture the default (or specified) browsers
+rake js_test_driver:capture_browsers [BROWSERS=foo,bar,baz]
+
+# run the tests (all or the specified ones)
+rake js_test_driver:run_tests [TESTS=TestCase[.testMethod]]
+
+You can add these tasks by requiring "js_test_driver/tasks"

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'rake'
+require 'rake/testtask'
+require 'jeweler'
+
+Rake::TestTask.new("test") do |test|
+  test.libs << 'test'
+  test.pattern = 'test/unit/**/*_test.rb'
+  test.verbose = true
+end
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "js-test-driver-rails"
+  gem.summary = "A wrapper for JsTestDriver for use with ruby/rails projects"
+  gem.description = "Use ruby to configure JsTestDriver, capture browsers and run tests."
+  gem.email = "adam@pohorecki.pl"
+  gem.homepage = "http://github.com/psyho/js-test-driver-rails"
+  gem.authors = ["Adam Pohorecki"]
+  gem.rubyforge_project = "js-test-driver-rails"
+  gem.add_development_dependency "jeweler"
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "jeweler"
+  gem.add_dependency "rake"
+  gem.files = FileList["[A-Z]*", "{bin,generators,lib,test,vendor}/**/*"]
+end
+
+Jeweler::GemcutterTasks.new
+Jeweler::RubyforgeTasks.new do |rubyforge|
+  rubyforge.doc_task = "rdoc"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/js_test_driver.rb

@@ -0,0 +1,2 @@
+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'))

data/lib/js_test_driver/config.rb

@@ -0,0 +1,116 @@
+module JsTestDriver
+  # The Config class represents the YAML config file that is passed to JsTestDriver
+  #
+  # includes corresponds to load
+  # excludes corresponds to exclude
+  # server can be configures either using server, or host and port
+  #
+  # The configuration is very basic, however the fact that it is done in Ruby, gives the
+  # user a significant amount of freedom in terms of what is and is not loaded, and so on
+  class Config
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    # Adds a file to be loaded, the path *must* be relative to the yml config file (which is placed in the RAILS_ROOT
+    # by default)
+    #
+    # JsTestDriver supports globbing
+    def includes(*paths)
+      paths.each do |path|
+        self.included_files << path
+      end
+    end
+
+    # Files specified here will not be loaded, it's useful when combined with globbing in includes 
+    #
+    # paths should be relative to RAILS_ROOT
+    def excludes(*paths)
+      paths.each do |path|
+        self.excluded_files << path
+      end
+    end
+
+    # Defines a browser to be captured by default
+    #
+    # This should be a string with no spaces (if you need to pass parameters to the browser you will
+    # need to create a shell script ans put it's name here)
+    def browser(browsers)
+      browsers.each do |browser|
+        self.browsers << browser
+      end
+    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
+    #
+    # Ex.
+    # A.define_config_variable(:foo) { @foo || "hello" }
+    # a = A.new
+    # a.foo # returns "hello"
+    # a.foo "foo"
+    # a.foo # returns "foo"
+    # a.foo = "bar"
+    # a.foo # returns "bar"
+    def self.define_config_variable(name, &block)
+      attr_writer name
+
+      define_method(name) do |*values|
+        unless values.empty?
+          self.send("#{name}=", values.first)
+        else
+          instance_eval(&block)
+        end
+      end
+    end
+
+    # the port the server will use, by default 4224
+    define_config_variable(:port) { @port ||= 4224 }
+
+    # the host of the server, by default localhost
+    define_config_variable(:host) { @host ||= 'localhost' }
+
+    # the whole server string - unless overwritten will be constructed from host and port,
+    # if you specify server, host and port will be ignored
+    # but you still need to specify port for starting the server
+    define_config_variable(:server) { @server || "http://#{host}:#{port}" }
+
+    def included_files
+      @includes ||= []
+    end
+
+    def excluded_files
+      @excludes ||= []
+    end
+
+    attr_writer :browsers
+
+    def browsers
+      @browsers ||= []
+    end
+
+    def to_s
+      hash = {'server' => server}
+      hash['load'] = included_files unless included_files.empty?
+      hash['exclude'] = excluded_files unless excluded_files.empty?
+      return hash.to_yaml
+    end
+
+    def self.parse(string)
+      config = new
+      config.instance_eval(string)
+      return config
+    end
+
+    private
+
+    def attributes=(values)
+      values.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+    end 
+
+  end
+end

data/lib/js_test_driver/runner.rb

@@ -0,0 +1,143 @@
+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
+
+    # 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 /tmp/js_test_driver.(contents MD5).yml
+    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
+      start_server_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)
+      capture_browsers_command(browsers).run
+    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)
+      run_tests_command(tests).run  
+    end
+
+    protected
+
+    def start_server_command
+      execute_jar_command.option('--port', config.port)
+    end
+
+    def run_tests_command(tests)
+      run_with_config.option('--tests', tests || "all") #.option('--runnerMode', 'DEBUG')
+    end
+
+    def capture_browsers_command(browsers)
+      browsers ||= config.browsers.join(',')
+      raise ArgumentError.new("No browsers defined!") if browsers == ""
+      run_with_config.option('--browser', browsers)
+    end
+
+    def run_with_config
+      save_config_file(config_yml_path)
+      execute_jar_command.option('--config', config_yml_path)
+    end
+
+    def execute_jar_command
+      Command.new('java').option('-jar', jar_path)
+    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
+      JsTestDriver::Config.parse(source)
+    end
+
+    def default_config_path
+      root = defined?(RAILS_ROOT) ? RAILS_ROOT : '.'
+      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")
+    end
+
+    private
+
+    def save_config_file(path)
+      File.open(path, "w+") { |f| f.puts config.to_s }
+    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,20 @@
+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
+
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'js_test_driver'))
+
+require 'test/unit'
+require 'mocha'

data/test/unit/config_test.rb

@@ -0,0 +1,154 @@
+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'}
+    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/*.js')
+
+      # then
+      assert_config_includes config, 'load' => ['src/*.js']
+    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' => ['a', 'b', 'c']
+    end
+
+    def test_config_with_excludes
+      # given
+      config = given_an_empty_config
+
+      # when
+      config.excludes('src/*.js')
+
+      # then
+      assert_config_includes config, 'exclude' => ['src/*.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'], config.included_files
+      assert_equal ['d'], config.excluded_files
+      assert_equal 'http://example.com:666', config.server
+    end
+
+  end
+end

data/test/unit/jsTestDriver.conf

@@ -0,0 +1,2 @@
+--- 
+server: http://localhost:4224

data/test/unit/runner_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+module JsTestDriver
+  class RunnerTest < Test::Unit::TestCase
+
+    def given_a_runner(opts = {})
+      return JsTestDriver::Runner.new(opts)  
+    end
+
+    def test_should_have_default_config_path
+      # given
+      runner = given_a_runner
+
+      # then
+      assert runner.config_path
+    end
+
+    def test_should_have_default_jar_path
+      # given
+      runner = given_a_runner
+
+      # then
+      assert runner.jar_path
+    end
+
+    def test_should_have_default_tmp_path
+      # given
+      runner = given_a_runner
+
+      # then
+      assert runner.config_yml_path
+    end
+
+    def expect_command_to_be_executed(cmd)
+      JsTestDriver::Runner::Command.any_instance.expects(:system).with(cmd)
+    end
+
+    def test_should_run_server_with_given_port_number
+      config = JsTestDriver::Config.new(:port => 6666)
+      runner = given_a_runner(:config => config)
+
+      expect_command_to_be_executed("java -jar #{runner.jar_path} --port #{config.port}")
+
+      runner.start_server
+    end
+
+    def test_should_run_all_tests_by_default
+      runner = given_a_runner(:config => JsTestDriver::Config.new)
+
+      expect_command_to_be_executed("java -jar #{runner.jar_path} --config #{runner.config_yml_path} --tests all")
+
+      runner.run_tests
+    end
+
+    def test_should_run_selected_tests
+      runner = given_a_runner(:config => JsTestDriver::Config.new)
+
+      expect_command_to_be_executed("java -jar #{runner.jar_path} --config #{runner.config_yml_path} --tests MyTestCase.some_test")
+
+      runner.run_tests('MyTestCase.some_test')
+    end
+
+    def test_should_raise_exception_if_no_browsers_defined_to_capture
+      runner = given_a_runner(:config => JsTestDriver::Config.new)
+
+      assert_raises(ArgumentError) do
+        runner.capture_browsers
+      end
+    end
+
+    def test_should_capture_default_browsers
+      runner = given_a_runner(:config => JsTestDriver::Config.new(:browsers => ['foo', 'bar', 'baz']))
+
+      expect_command_to_be_executed("java -jar #{runner.jar_path} --config #{runner.config_yml_path} --browser foo,bar,baz")
+
+      runner.capture_browsers
+    end
+
+    def test_should_capture_given_browsers
+      runner = given_a_runner(:config => JsTestDriver::Config.new(:browsers => ['foo', 'bar', 'baz']))
+
+      expect_command_to_be_executed("java -jar #{runner.jar_path} --config #{runner.config_yml_path} --browser aaa,bbb")
+
+      runner.capture_browsers('aaa,bbb')
+    end
+
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: js-test-driver-rails
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Adam Pohorecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: mocha
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rake
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  type: :runtime
+description: Use ruby to configure JsTestDriver, capture browsers and run tests.
+email: adam@pohorecki.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/js_test_driver.rb
+- lib/js_test_driver/config.rb
+- lib/js_test_driver/runner.rb
+- lib/js_test_driver/tasks.rb
+- test/test_helper.rb
+- test/unit/config_test.rb
+- test/unit/jsTestDriver.conf
+- test/unit/runner_test.rb
+- vendor/js_test_driver.jar
+has_rdoc: true
+homepage: http://github.com/psyho/js-test-driver-rails
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: js-test-driver-rails
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A wrapper for JsTestDriver for use with ruby/rails projects
+test_files: 
+- test/unit/runner_test.rb
+- test/unit/config_test.rb
+- test/test_helper.rb