sayso-js-test-driver-rails 0.4.3

data/.gitignore

@@ -0,0 +1,7 @@
+.idea
+.rvmrc
+.bundle
+jsTestDriver.conf
+pkg/*
+tags
+.js_test_driver

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/jasmine"]
+	path = vendor/jasmine
+	url = git://github.com/pivotal/jasmine.git
+[submodule "vendor/jasmine-jstd-adapter"]
+	path = vendor/jasmine-jstd-adapter
+	url = git://github.com/ibolmo/jasmine-jstd-adapter.git

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in js-test-driver-rails.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    js-test-driver-rails (0.4.2)
+      json
+      rake
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.4.6)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  js-test-driver-rails!
+  mocha

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.markdown

@@ -0,0 +1,118 @@
+JS Test Driver Rails
+====================
+
+js-test-driver-rails is a thin wrapper for the JsTestDriver library: http://code.google.com/p/js-test-driver/
+
+Configuration
+------------
+
+To take advantage of js-test-driver-rails, you should create a js_test_driver.rb file in your RAILS_ROOT/config/ directory.
+
+The file may contain following directives:
+
+    # the paths are relative to the current directory, but you can use absolute paths too
+    # this is different from the JsTestDriver which does not allow you to use absolute paths in the config file 
+
+    # files to be included
+    # you can use Ruby globbing syntax (spec/js/**/*_spec.js), which will be automatically expanded
+    includes 'foo', 'bar', 'public/javascripts/*.js'
+
+    # files to be excluded, useful with globbing
+    excludes 'public/javascripts/fail.js'
+
+    # the host to which the test runner will connect, by default 'localhost'
+    host 'my-laptop'
+
+    # the port to which test runner will connect, and on which the test server will start, by default 4224
+    port 6666
+
+    # you can specify the default browsers which will be captured
+    browser 'firefox'
+
+Note, that this is a ruby file, so the file/browser list can be generated dynamically - it's completely up to you.
+
+For example in our project we examine a list of known browsers to determine the ones installed on the developer's system, and define only those that were found.
+
+Similarly we get the list of .js files to include from our asset packaging solution.
+
+HTML Fixtures
+-------------
+
+js-test-driver-rails also allows you to define HTML fixtures easily.
+
+Imagine you have a directory structure like this:
+
+    RAILS_ROOT:
+      test/
+        js/
+          fixtures/
+            foo/
+              a.html
+            a.html
+
+Then by defining the fixtures directory in your config file:
+
+    fixtures "test/js/fixtures"
+
+At runtime, your tests will have access to the contents of the fixture files:
+
+    htmlFixtures.all["a"] // contents of the test/js/fixtures/a.html
+    htmlFixtures.all["foo/a"] // contents of the test/js/fixtures/foo/a.html
+
+You can customize the namespace and fixture container name:
+
+    # the fixtures will be accessible through myApp.html["<fixture name goes here>"]
+    fixtures "test/js/fixtures", :name => "html", :namespace => "myApp"
+
+Using Jasmine
+-------------
+
+By default JsTestDriver comes with a pretty simple Test::Unit like testing framework.
+However it supports a couple of other frameworks, including Jasmine (http://pivotal.github.com/jasmine/), which is an RSpec-like BDD framework.
+
+If you want to user Jasmine, simply add:
+
+    enable_jasmine
+
+in your config file, somewhere before including your test files and you are golden:)
+
+Measuring code coverage
+-----------------------
+
+JsTestDriver has a pretty cool feature of being able to measure code coverage. To enable this in your config, you just need to add:
+
+    measure_coverage
+
+in your config file.
+
+You need to have lcov installed for the HTML report to be generated:
+
+    sudo apt-get install lcov
+
+The HTML coverage report will be saved in the .js_test_driver/tests/coverage directory.
+
+Rake tasks
+----------
+
+This gem comes with some rake tasks, which you should require in your Rake file:
+
+    require "js_test_driver/tasks"
+
+To start the js test driver server:
+
+    rake js_test_driver:start_server
+
+To capture the default (or specified) browsers
+
+    rake js_test_driver:capture_browsers [BROWSERS=foo,bar,baz]
+
+To run the tests (all or the specified ones)
+
+    rake js_test_driver:run_tests [TESTS=TestCase[.testMethod]]
+
+To run the server, capture the browsers and run tests all in one command
+
+    rake js_test_driver:run [TESTS=TestCase[.testMethod]] [BROWSERS=foo,bar,baz] [OUTPUT_XML=1 | OUTPUT_PATH=/some/dir] [CAPTURE_CONSOLE=1]
+
+This last task is mostly useful on CI, because it's much faster to run the server and capture the browsers once and then run the tests again and again in development mode.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+
+Rake::TestTask.new("test") do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/js-test-driver-rails.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "js_test_driver/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sayso-js-test-driver-rails"
+  s.version     = JsTestDriver::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["SaySo"]
+  s.email       = ["sayso@truvolabs.com"]
+  s.homepage    = "http://github.com/sayso/js-test-driver-rails"
+  s.summary     = "A wrapper for JsTestDriver for use with ruby/rails projects"
+  s.description = "Use ruby to configure JsTestDriver, capture browsers and run tests."
+
+  s.rubyforge_project = "js-test-driver-rails"
+
+  s.add_dependency 'json'
+  s.add_dependency 'rake'
+  s.add_development_dependency 'mocha'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/js_test_driver.rb

@@ -0,0 +1,6 @@
+require 'json'
+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'))

data/lib/js_test_driver/config.rb

@@ -0,0 +1,209 @@
+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 root_dir (which is the current dir by default)
+    #
+    # JsTestDriver supports globbing
+    def includes(*paths)
+      self.included_files.concat(expand_globs(paths))
+    end
+
+    # Files specified here will not be loaded, it's useful when combined with globbing in includes
+    #
+    # paths should be relative to root_dir
+    def excludes(*paths)
+      self.excluded_files.concat(expand_globs(paths))
+    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
+
+    # Defines a HTML fixture directory
+    #
+    # the first argument is the directory to scan for html fixtures
+    # you can pass also :name and :namespace arguments to define the name and the namespace of the fixture
+    #
+    # the fixtures will be accessible through:
+    # namespace.name["file_name_without the html extension"]
+    #
+    # by default the namespace is called htmlFixtures
+    # and the fixture name is called all
+    def fixtures(directory, opts = {})
+      fixture = JsTestDriver::HtmlFixture.new(directory, opts[:name], opts[:namespace])
+      if html_fixtures.detect{|f| f.name == fixture.name && f.namespace == fixture.namespace}
+        raise ArgumentError.new("Fixture #{fixture.namespace}.#{fixture.name} already defined!")
+      end
+      html_fixtures << fixture
+    end
+
+    # Includes the bundled with the gem jasmine js file and an adapter for jasmine
+    #
+    # There's no hacks or modifications here, so this method is just for the users convenience
+    def enable_jasmine
+      includes File.join(vendor_directory, "jasmine.js")
+      includes File.join(vendor_directory, "JasmineAdapter.js")
+    end
+
+    # Adds a JsTestDriver plugin for measuring coverage to the configuration
+    def measure_coverage
+      @measure_coverage = true
+      self.plugins << {
+        'name' => 'coverage',
+        'jar' => File.join(vendor_directory, 'coverage.jar'),
+        'module' => 'com.google.jstestdriver.coverage.CoverageModule'
+      }
+    end
+
+    def measure_coverage?
+      !!@measure_coverage
+    end
+
+    # Plugins to include in the config
+    def plugins
+      @plugins ||= []
+    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}" }
+
+    # the base path to which all of the paths in the config file are relative
+    define_config_variable(:base_path) { @base_path ||= '/' }
+
+    def included_files
+      @includes ||= []
+    end
+
+    def excluded_files
+      @excludes ||= []
+    end
+
+    def html_fixtures
+      @html_fixtures ||= []
+    end
+
+    attr_writer :browsers
+
+    def browsers
+      @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?
+      return hash.to_yaml
+    end
+
+    def self.parse(string)
+      config = new
+      config.instance_eval(string)
+      return config
+    end
+
+    attr_writer :config_dir
+
+    # this is where the config files are saved (ex. RAILS_ROOT/.js_test_driver)
+    def config_dir
+      @config_dir ||= File.expand_path(".")
+    end
+
+    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 vendor_directory
+      this_directory = File.dirname(__FILE__)
+      return File.expand_path(File.join('..', '..', 'vendor'), this_directory)
+    end
+
+    def expand_globs(paths)
+      with_expanded_paths = paths.map{|path| File.expand_path(path)}
+      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) }
+
+      map_paths(files)
+    end
+
+    def path_relative_to_base_path(path)
+      path.gsub(/^#{Regexp.escape(base_path)}/, '')
+    end
+
+    def map_paths(files)
+      files.map{|file| path_relative_to_base_path(file)}
+    end
+
+    def attributes=(values)
+      values.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+    end
+
+  end
+end

data/lib/js_test_driver/html_fixture.rb

@@ -0,0 +1,40 @@
+module JsTestDriver
+  # This is a class that given a directory name, puts all its *.html children
+  # into a javascript file, so that they can later be used in the tests
+  class HtmlFixture
+
+    attr_reader :name, :namespace
+
+    def initialize(directory_name, name = nil, namespace = nil)
+      @name = name || "all"
+      @namespace = namespace || "htmlFixtures"
+      @data = {}
+
+      load_data(directory_name)
+    end
+
+    def to_h
+      @data
+    end
+
+    def to_s
+      <<JS
+if (typeof(#{namespace}) === 'undefined') { #{namespace} = {}; }
+#{namespace}.#{name} = #{self.to_h.to_json};
+JS
+    end
+
+    private
+
+    def load_data(directory_name)
+      full_path = File.expand_path(directory_name)
+      files = Dir["#{full_path}/**/*.html"]
+
+      files.each do |file|
+        name = file.gsub(/^#{full_path}\//, '').gsub(/\.html$/, '')
+        @data[name] = File.read(file)
+      end
+    end
+
+  end
+end