teaspoon 0.7.9 → 0.8.0

data/lib/teaspoon/deprecated.rb

@@ -0,0 +1,65 @@
+module Teaspoon
+
+  def self.setup(&block)
+    Teaspoon.dep("Teaspoon.setup is deprecated, use Teaspoon.configure instead. The /initializer/teaspoon.rb file should be removed, and a new teaspoon_env.rb file should be created by running the install generator.")
+    configure(&block)
+  end
+
+  @dep_notified = {}
+  def self.dep(message, category = nil)
+    return if Teaspoon.configured
+    if category
+      return if @dep_notified[category]
+      @dep_notified[category] = true if category
+    end
+    puts "WARNING: Deprecated - #{message}"
+  end
+
+  class Configuration
+
+    def self.context=(*args)
+      Teaspoon.dep("the teaspoon context directive is no longer used, remove it from your configuration.")
+    end
+
+    def self.fixture_path=(*args)
+      Teaspoon.dep("the teaspoon fixture_path directive has been changed to fixture_paths, which expects an array, please update your configuration.")
+      self.fixture_paths = args
+    end
+
+    def self.driver_cli_options=(val)
+      Teaspoon.dep("the teaspoon driver_cli_options directive is no longer used, use driver_options instead.")
+      self.driver_options = val
+    end
+
+    @coverage_dep_message = <<-MESSAGE
+teaspoon coverage directive has changed and is now more flexible, define coverage using a block instead:
+  config.coverage :CI do |coverage|
+    coverage.reports = ["html", "text-summary"]
+    coverage.output_path = "coverage"
+    coverage.statements = 50 # statement threshold required
+    coverage.functions = 50 # function threshold required
+    coverage.branches = 50 # branch threshold required
+    coverage.lines = nil # no line threshold
+  end
+  > run: teaspoon --coverage=CI --suite=default
+  > set: config.use_coverage = "CI"
+    MESSAGE
+
+    for method in %w{coverage coverage_reports coverage_output_dir statements_coverage_threshold functions_coverage_threshold branches_coverage_threshold lines_coverage_threshold}
+      define_singleton_method("#{method}=") do |val|
+        Teaspoon.dep(@coverage_dep_message, :coverage)
+      end
+    end
+
+    class Suite
+
+      def js_config=(*args)
+        Teaspoon.dep("the teaspoon suite js_config directive is no longer used, use the install generator to install the boot partial and customize it instead.", :js_config)
+      end
+
+      def normalize_asset_path=(*args)
+        Teaspoon.dep("the teaspoon suite normalize_asset_path directive is no longer used, reopen Teaspoon::Suite and define a normalize_js_extension method instead.", :normalize_asset_path)
+      end
+    end
+  end
+end

data/lib/teaspoon/drivers/base.rb

@@ -0,0 +1,10 @@
+module Teaspoon
+  module Drivers
+
+    autoload :PhantomjsDriver, "teaspoon/drivers/phantomjs_driver"
+    autoload :SeleniumDriver,  "teaspoon/drivers/selenium_driver"
+
+    class Base
+    end
+  end
+end

data/lib/teaspoon/drivers/phantomjs/runner.js

@@ -26,15 +26,11 @@
     };
 
     Runner.prototype.loadPage = function() {
-      var method, name, _ref, _results;
       this.page.open(this.url);
-      _ref = this.pageCallbacks();
-      _results = [];
-      for (name in _ref) {
-        method = _ref[name];
-        _results.push(this.page[name] = method);
+      var callbacks = this.pageCallbacks();
+      for (var name in callbacks) {
+        this.page[name] = callbacks[name];
       }
-      return _results;
     };
 
     Runner.prototype.waitForResults = function() {
@@ -46,17 +42,16 @@
     Runner.prototype.fail = function(msg, errno) {
       if (msg == null) msg = null;
       if (errno == null) errno = 1;
-      if (msg) console.log("Error: " + msg);
 
       console.log(JSON.stringify({
         _teaspoon: true,
-        type: "exception"
+        type: "exception",
+        message: msg
       }));
       phantom.exit(errno);
     };
 
     Runner.prototype.finish = function() {
-      console.log(" ");
       phantom.exit(0);
     };
 
@@ -71,6 +66,9 @@
             trace: trace
           }));
           _this.errored = true;
+          if (/^TeaspoonError: /.test(message || "")) {
+            _this.fail("Execution halted.");
+          }
         },
 
         onConsoleMessage: function(msg) {
@@ -78,7 +76,7 @@
           if (_this.errorTimeout) clearTimeout(_this.errorTimeout);
           if (_this.errored) {
             _this.errorTimeout = setTimeout((function() {
-              return _this.fail('Javascript error has cause a timeout.');
+              return _this.fail("Javascript error has cause a timeout.");
             }), 1000);
             return _this.errored = false;
           }

data/lib/teaspoon/drivers/phantomjs_driver.rb

@@ -1,46 +1,46 @@
-require "teaspoon/runner"
-require 'teaspoon/utility'
-
 begin
   require "phantomjs"
 rescue LoadError
+  # if we can't load phantomjs, assume the cli is installed and in the path
 end
 
 module Teaspoon
   module Drivers
-    class PhantomjsDriver < BaseDriver
+    class PhantomjsDriver < Base
       include Teaspoon::Utility
 
-      def run_specs(suite, url, cli_options = nil)
-        runner = Teaspoon::Runner.new(suite)
+      def initialize(options = nil)
+        options ||= []
+        case options
+        when Array  then @options = options
+        when String then @options = options.split(" ")
+        when Hash   then @options = options.map { |k, v| "--#{k}=#{v}" }
+        else raise Teaspoon::UnknownDriverOptions, "Unknown driver options -- supply a string, array or hash"
+        end
+      end
 
-        run(*cli_arguments(url, cli_options)) do |line|
+      def run_specs(runner, url)
+        run(*driver_options(url)) do |line|
           runner.process(line) if line && line.strip != ""
         end
-
-        runner.failure_count
       end
 
       protected
 
       def run(*args, &block)
-        IO.popen([executable, *args]) { |io|
-          io.each(&block)
-        }
+        IO.popen([executable, *args].join(' ')) { |io| io.each(&block) }
       end
 
-      def cli_arguments(url, cli_options)
-        [cli_options.to_s.split(" "), script, url].flatten.compact
+      def driver_options(url)
+        [@options, script, url.shellescape, Teaspoon.configuration.driver_timeout].flatten.compact
       end
 
       def executable
-        executable ||= which('phantomjs')
-        executable = Phantomjs.path if executable.blank? && defined?(::Phantomjs)
-        if executable.blank?
-          STDOUT.print("Could not find PhantomJS. Install phantomjs or try the phantomjs gem.")
-          exit(1)
-        end
-        executable
+        return @executable if @executable
+        @executable = which("phantomjs")
+        @executable = Phantomjs.path if @executable.blank? && defined?(::Phantomjs)
+        return @executable unless @executable.blank?
+        raise Teaspoon::MissingDependency, "Could not find PhantomJS. Install phantomjs or try the phantomjs gem."
       end
 
       def script

data/lib/teaspoon/drivers/selenium_driver.rb

@@ -1,32 +1,51 @@
-require "selenium-webdriver"
-require "teaspoon/runner"
+begin
+  require "selenium-webdriver"
+rescue LoadError
+  STDOUT.print("Could not find Selenium Webdriver. Install the selenium-webdriver gem.\n")
+  exit(1)
+end
 
 module Teaspoon
   module Drivers
-    class SeleniumDriver < BaseDriver
+    class SeleniumDriver < Base
+
+      def initialize(options = nil)
+        options ||= {}
+        case options
+        when Hash   then @options = options
+        when String then @options = JSON.parse(options)
+        else raise Teaspoon::UnknownDriverOptions, "Unknown driver options -- supply a hash or json string"
+        end
 
-      # note: driver_cli_options which is meant to be used for CLI options to pass into the driver is 
-      #       currently ignored. We use the Selenium Ruby binding, so the Selenium command-line options
-      #       aren't used. There are a variety of Selenium options and browser-specific options
-      #       supported by the binding that will take more thought and design to configure cleanly.
-      def run_specs(suite, url, driver_cli_options = nil)
-        runner = Teaspoon::Runner.new(suite)
+      rescue JSON::ParserError
+        raise Teaspoon::UnknownDriverOptions, "Malformed driver options -- supply a hash or json string"
+      end
 
-        driver = Selenium::WebDriver.for(:firefox)
+      def run_specs(runner, url)
+        driver = Selenium::WebDriver.for(driver_options[:client_driver])
         driver.navigate.to(url)
 
-        Selenium::WebDriver::Wait.new(timeout: 180, interval: 0.01, message: "Timed out").until do
+        Selenium::WebDriver::Wait.new(driver_options).until do
           done = driver.execute_script("return window.Teaspoon && window.Teaspoon.finished")
           driver.execute_script("return window.Teaspoon && window.Teaspoon.getMessages() || []").each do |line|
             runner.process("#{line}\n")
           end
           done
         end
-
-        runner.failure_count
       ensure
         driver.quit if driver
       end
+
+      protected
+
+      def driver_options
+        @driver_options ||= HashWithIndifferentAccess.new({
+          client_driver: :firefox,
+          timeout: Teaspoon.configuration.driver_timeout.to_i,
+          interval: 0.01,
+          message: "Timed out"
+        }).merge(@options)
+      end
     end
   end
 end

data/lib/teaspoon/engine.rb

@@ -1,30 +1,50 @@
-require File.expand_path(__FILE__, '../../../app/controllers/teaspoon/spec_controller')
+require "teaspoon/environment"
+require "teaspoon/suite"
+require "teaspoon/instrumentation"
 
 module Teaspoon
   class Engine < ::Rails::Engine
 
     isolate_namespace Teaspoon
 
-    initializer :assets, :group => :all do |app|
-      # default the root if it's not set
-      Teaspoon.configuration.root ||= app.root
+    initializer :assets, group: :all do |app|
+      begin
+        Teaspoon::Environment.require_environment
+      rescue Teaspoon::EnvironmentNotFound
+        # it's ok for this to fail sometimes, like before the initializer is run etc
+      end
+
+      Teaspoon::Engine.default_root_path(app.root)           # default the root if it's not set
+      Teaspoon::Engine.append_asset_paths(app.config.assets) # append the asset paths from the configuration
+    end
+
+    config.after_initialize do |app|
+      Teaspoon::Engine.inject_instrumentation                # inject our sprockets hack for instrumenting javascripts
+      Teaspoon::Engine.prepend_routes(app)                   # prepend routes so a catchall doesn't get in the way
+    end
 
-      # set proper root url
-      Teaspoon.configuration.context ||= app.config.relative_url_root
+    private
 
-      # append the asset paths from the configuration
+    def self.default_root_path(root)
+      Teaspoon.configuration.root ||= root
+    end
+
+    def self.append_asset_paths(assets)
       Teaspoon.configuration.asset_paths.each do |path|
-        app.config.assets.paths << Teaspoon.configuration.root.join(path).to_s
+        assets.paths << Teaspoon.configuration.root.join(path).to_s
       end
     end
 
-    config.after_initialize do |app|
-      # inject our sprockets hack for instrumenting javascripts
+    def self.inject_instrumentation
       Sprockets::Environment.send(:include, Teaspoon::SprocketsInstrumentation)
+    end
+
+    def self.prepend_routes(app)
+      return if Teaspoon::Engine.routes.recognize_path('/') rescue nil
+      require Teaspoon::Engine.root.join("app/controllers/teaspoon/suite_controller")
 
-      # prepend routes so a catchall doesn't get in the way
       app.routes.prepend do
-        mount Teaspoon::Engine => Teaspoon.configuration.mount_at
+        mount Teaspoon::Engine => Teaspoon.configuration.mount_at, as: "teaspoon"
       end
     end
   end

data/lib/teaspoon/environment.rb

@@ -8,41 +8,45 @@ module Teaspoon
       raise "Rails environment not found." unless rails_loaded?
 
       require "teaspoon"
-      require "teaspoon/suite"
       require "teaspoon/server"
-      require "teaspoon/exception_handling"
+      require "teaspoon/runner"
+      require "teaspoon/coverage"
+      require "teaspoon/exporter"
 
-      configure_from_options(options)
+      Teaspoon.configuration.override_from_options(options)
+      Teaspoon::ExceptionHandling.add_rails_handling
     end
 
     def self.require_environment(override = nil)
-      return require_env(File.expand_path(override, Dir.pwd)) if override
+      override ||= ENV["TEASPOON_ENV"]
+      if override
+        override = File.expand_path(override, Dir.pwd)
+        ENV["TEASPOON_ENV"] = override
+        return require_env(override)
+      end
 
       standard_environments.each do |filename|
         file = File.expand_path(filename, Dir.pwd)
         return require_env(file) if File.exists?(file)
+        #file = File.expand_path(filename, File.join(Dir.pwd, '../..'))
+        #return require_env(file) if File.exists?(file)
       end
 
-      raise Teaspoon::EnvironmentNotFound
+      raise Teaspoon::EnvironmentNotFound, "Unable to load Teaspoon environment in {#{standard_environments.join(', ')}}"
     end
 
     def self.standard_environments
       ["spec/teaspoon_env.rb", "test/teaspoon_env.rb", "teaspoon_env.rb"]
     end
 
-    def self.configure_from_options(options)
-      options.each do |key, value|
-        Teaspoon.configuration.send("#{key.downcase}=", value) if Teaspoon.configuration.respond_to?("#{key.downcase}=")
-      end
-    end
+    private
 
     def self.require_env(file)
-      require(file)
+      ::Kernel.load(file)
     end
 
     def self.rails_loaded?
       defined?(Rails)
     end
-
   end
 end

data/lib/teaspoon/exceptions.rb

@@ -1,7 +1,43 @@
 module Teaspoon
-  class Failure < Exception; end
-  class UnknownSuite < Exception; end
-  class RunnerException < Exception; end
-  class AssetNotServable < Exception; end
-  class EnvironmentNotFound < Exception; end
+  class Error < Exception; end
+  class EnvironmentNotFound < Teaspoon::Error; end
+  class MissingDependency < Teaspoon::Error; end
+  class ServerException < Teaspoon::Error; end
+  class RunnerException < Teaspoon::Error; end
+  class ExporterException < Teaspoon::Error; end
+  class UnknownFramework < Teaspoon::Error; end
+  class UnknownDriver < Teaspoon::Error; end
+  class UnknownDriverOptions < Teaspoon::Error; end
+  class UnknownFormatter < Teaspoon::Error; end
+  class UnknownSuite < Teaspoon::Error; end
+  class AssetNotServable < Teaspoon::Error; end
+  class Failure < Teaspoon::Error; end
+  class DependencyFailure < Teaspoon::Error; end
+  class ThresholdNotMet < Teaspoon::Error; end
+  class FileNotWritable < Teaspoon::Error; end
+
+  module ExceptionHandling
+
+    def self.add_rails_handling
+      return unless Teaspoon.configuration.driver == "phantomjs"
+
+      #Rails.application.config.assets.debug = false # debugging should be off to display errors in the suite_controller
+      Rails.application.config.action_dispatch.show_exceptions = true # we want rails to display exceptions
+
+      # override the render exception method in ActionDispatch to raise a javascript exception
+      render_exceptions_with_javascript
+    end
+
+    private
+
+    def self.render_exceptions_with_javascript
+      ActionDispatch::DebugExceptions.class_eval do
+        def render_exception(env, exception)
+          message = "#{exception.class.name}: #{exception.message}"
+          body = "<script>throw Error(#{[message, exception.backtrace].join("\n").inspect})</script>"
+          [200, {'Content-Type' => "text/html;", 'Content-Length' => body.bytesize.to_s}, [body]]
+        end
+      end
+    end
+  end
 end

data/lib/teaspoon/exporter.rb

@@ -0,0 +1,52 @@
+module Teaspoon
+  class Exporter
+    include Teaspoon::Utility
+
+    def initialize(suite, url, output_path)
+      @suite = suite
+      @url = url
+      @output_path = File.join(File.expand_path(output_path || "export"), @suite.to_s)
+    end
+
+    def export
+      Dir.mktmpdir do |temp_path|
+        Dir.chdir(temp_path) do
+          %x{#{executable} --convert-links --adjust-extension --page-requisites --span-hosts #{@url.shellescape} 2>&1}
+          raise Teaspoon::ExporterException, "Unable to export #{@suite} suite." unless $?.exitstatus == 0
+          create_export(File.join(temp_path, @url.match(/^http:\/\/([^\/]+).*/)[1]))
+        end
+      end
+    end
+
+    private
+
+    def executable
+      return @executable if @executable
+      @executable = which("wget")
+      return @executable unless @executable.blank?
+      raise Teaspoon::MissingDependency, "Could not find wget for exporting."
+    end
+
+    def create_export(path)
+      Dir.chdir(path) do
+        update_relative_paths
+        cleanup_output
+        move_output
+      end
+    end
+
+    def update_relative_paths
+      html = File.read(".#{Teaspoon.configuration.mount_at}/#{@suite}.html")
+      File.write("index.html", html.gsub!('"../', '"'))
+    end
+
+    def cleanup_output
+      FileUtils.rm_r(Dir["{.#{Teaspoon.configuration.mount_at},robots.txt.html}"])
+    end
+
+    def move_output
+      FileUtils.mkdir_p(@output_path)
+      FileUtils.mv(Dir["*"], @output_path, force: true)
+    end
+  end
+end