teaspoon 0.9.1 → 1.0.0

data/lib/teaspoon/console.rb

@@ -5,11 +5,12 @@ module Teaspoon
     def initialize(options = {})
       @default_options = options
       @suites = {}
+      Teaspoon::Environment.check_env!(options[:environment])
       Teaspoon::Environment.load(options)
 
       @server = start_server
-    rescue Teaspoon::ServerException => e
-      abort(e.message)
+    rescue Teaspoon::ServerError => e
+      Teaspoon.abort(e.message)
     end
 
     def options
@@ -26,11 +27,11 @@ module Teaspoon
       execute_without_handling(options)
     rescue Teaspoon::Failure
       false
-    rescue Teaspoon::RunnerException => e
+    rescue Teaspoon::RunnerError => e
       log(e.message)
       false
     rescue Teaspoon::Error => e
-      abort(e.message)
+      Teaspoon.abort(e.message)
     end
 
     def execute_without_handling(execute_options = {})
@@ -47,9 +48,7 @@ module Teaspoon
     end
 
     def run_specs(suite)
-      unless Teaspoon.configuration.suite_configs[suite.to_s]
-        raise Teaspoon::UnknownSuite, "Unknown suite: \"#{suite}\""
-      end
+      raise Teaspoon::UnknownSuite.new(name: suite) unless Teaspoon.configuration.suite_configs[suite.to_s]
 
       log("Teaspoon running #{suite} suite at #{base_url_for(suite)}")
       runner = Teaspoon::Runner.new(suite)
@@ -59,9 +58,7 @@ module Teaspoon
     end
 
     def export(suite)
-      unless Teaspoon.configuration.suite_configs[suite.to_s]
-        raise Teaspoon::UnknownSuite, "Unknown suite: \"#{suite}\""
-      end
+      raise Teaspoon::UnknownSuite.new(name: suite) unless Teaspoon.configuration.suite_configs[suite.to_s]
 
       log("Teaspoon exporting #{suite} suite at #{base_url_for(suite)}")
       Teaspoon::Exporter.new(suite, url_for(suite, false), options[:export]).export
@@ -94,10 +91,8 @@ module Teaspoon
 
     def driver
       return @driver if @driver
-      klass = "#{Teaspoon.configuration.driver.to_s.camelize}Driver"
-      @driver = Teaspoon::Drivers.const_get(klass).new(Teaspoon.configuration.driver_options)
-    rescue NameError
-      raise Teaspoon::UnknownDriver, "Unknown driver: \"#{Teaspoon.configuration.driver}\""
+      driver = Teaspoon::Driver.fetch(Teaspoon.configuration.driver)
+      @driver = driver.new(Teaspoon.configuration.driver_options)
     end
 
     def base_url_for(suite)
@@ -117,13 +112,8 @@ module Teaspoon
       "#{parts.join('&')}" if parts.present?
     end
 
-    def log(str, force = false)
-      STDOUT.print("#{str}\n") if force || !Teaspoon.configuration.suppress_log
-    end
-
-    def abort(message = nil)
-      log(message, true) if message
-      exit(1)
+    def log(str)
+      STDOUT.print("#{str}\n") unless Teaspoon.configuration.suppress_log
     end
   end
 end

data/lib/teaspoon/coverage.rb

@@ -1,10 +1,18 @@
 module Teaspoon
   class Coverage
-    def initialize(suite_name, config_name, data)
+    def self.configuration(name = Teaspoon.configuration.use_coverage)
+      name = normalize_config_name(name)
+      config = Teaspoon.configuration.coverage_configs[name]
+
+      raise Teaspoon::UnknownCoverage.new(name: name) unless config.present?
+      config[:instance] ||= Teaspoon::Configuration::Coverage.new(&config[:block])
+    end
+
+    def initialize(suite_name, data)
       @suite_name = suite_name
       @data = data
       @executable = Teaspoon::Instrumentation.executable
-      @config = coverage_configuration(config_name.to_s)
+      @config = self.class.configuration
     end
 
     def generate_reports(&block)
@@ -31,10 +39,9 @@ module Teaspoon
 
     private
 
-    def coverage_configuration(name)
-      config = Teaspoon.configuration.coverage_configs[name]
-      raise Teaspoon::UnknownCoverage, "Unknown coverage configuration \"#{name}\"" unless config.present?
-      config[:instance] ||= Teaspoon::Configuration::Coverage.new(&config[:block])
+    def self.normalize_config_name(name)
+      return "default" if name == true
+      name.to_s
     end
 
     def input_path(&block)
@@ -49,7 +56,7 @@ module Teaspoon
       output_path = File.join(@config.output_path, @suite_name)
       result = %x{#{@executable} report --include=#{input.shellescape} --dir #{output_path} #{format} 2>&1}
       return result.gsub("Done", "").gsub("Using reporter [#{format}]", "").strip if $?.exitstatus == 0
-      raise Teaspoon::DependencyFailure, "Could not generate coverage report for #{format}"
+      raise Teaspoon::DependencyError.new("Unable to generate #{format} coverage report.")
     end
 
     def threshold_args

data/lib/teaspoon/deprecated.rb

@@ -1,6 +1,9 @@
 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.")
+    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
 
@@ -20,7 +23,10 @@ module Teaspoon
     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.")
+      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
 
@@ -59,12 +65,24 @@ teaspoon coverage directive has changed and is now more flexible, define coverag
 
     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)
+        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)
+        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
+
+      def no_coverage(*)
+        Teaspoon.dep("suite.no_coverage has been removed in Teaspoon 1.0. Please use coverage.ignore instead. https://github.com/modeset/teaspoon/blob/master/CHANGELOG.md")
+        []
+      end
+      alias_method :no_coverage=, :no_coverage
     end
   end
 end

data/lib/teaspoon/driver.rb

@@ -0,0 +1,15 @@
+require "teaspoon/registry"
+require "teaspoon/registry/has_default"
+
+module Teaspoon
+  module Driver
+    extend Teaspoon::Registry
+    extend Teaspoon::Registry::HasDefault
+
+    not_found_in_registry Teaspoon::UnknownDriver
+  end
+end
+
+Teaspoon::Driver.register(:phantomjs, "Teaspoon::Driver::Phantomjs", "teaspoon/driver/phantomjs", default: true)
+Teaspoon::Driver.register(:selenium, "Teaspoon::Driver::Selenium", "teaspoon/driver/selenium")
+Teaspoon::Driver.register(:capybara_webkit, "Teaspoon::Driver::CapybaraWebkit", "teaspoon/driver/capybara_webkit")

data/lib/teaspoon/driver/base.rb

@@ -0,0 +1,7 @@
+module Teaspoon
+  module Driver
+    class Base
+      # Here in case we need it.
+    end
+  end
+end

data/lib/teaspoon/{drivers/capybara_webkit_driver.rb → driver/capybara_webkit.rb}

@@ -1,14 +1,17 @@
+# :nocov:
 begin
   require "capybara-webkit"
 rescue LoadError
-  STDOUT.print("Could not find Capybara Webkit. Install the capybara-webkit gem.\n")
-  exit(1)
+  Teaspoon.abort("Could not find Capybara Webkit. Install the capybara-webkit gem.")
 end
+# :nocov:
+
+require "teaspoon/driver/base"
 
 module Teaspoon
-  module Drivers
-    class CapybaraWebkitDriver < Base
-      def initialize(_ = nil)
+  module Driver
+    class CapybaraWebkit < Base
+      def initialize(_options = nil)
       end
 
       def run_specs(runner, url)

data/lib/teaspoon/{drivers/phantomjs_driver.rb → driver/phantomjs.rb}

@@ -1,12 +1,16 @@
+# :nocov:
 begin
   require "phantomjs"
 rescue LoadError
   # if we can't load phantomjs, assume the cli is installed and in the path
 end
+# :nocov:
+
+require "teaspoon/driver/base"
 
 module Teaspoon
-  module Drivers
-    class PhantomjsDriver < Base
+  module Driver
+    class Phantomjs < Base
       include Teaspoon::Utility
 
       def initialize(options = nil)
@@ -15,7 +19,7 @@ module Teaspoon
         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"
+        else raise Teaspoon::DriverOptionsError.new(types: "string, array or hash")
         end
       end
 
@@ -49,7 +53,7 @@ module Teaspoon
         @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."
+        raise Teaspoon::MissingDependencyError.new("Unable to locate phantomjs. Install it or use the phantomjs gem.")
       end
 
       def script

data/lib/teaspoon/{drivers/selenium_driver.rb → driver/selenium.rb}

@@ -1,30 +1,32 @@
+# :nocov:
 begin
   require "selenium-webdriver"
 rescue LoadError
-  STDOUT.print("Could not find Selenium Webdriver. Install the selenium-webdriver gem.\n")
-  exit(1)
+  Teaspoon.abort("Could not find Selenium Webdriver. Install the selenium-webdriver gem.")
 end
+# :nocov:
+
+require "teaspoon/driver/base"
 
 module Teaspoon
-  module Drivers
-    class SeleniumDriver < Base
+  module Driver
+    class Selenium < 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"
+        else raise Teaspoon::DriverOptionsError.new(types: "hash or json string")
         end
-
       rescue JSON::ParserError
-        raise Teaspoon::UnknownDriverOptions, "Malformed driver options -- supply a hash or json string"
+        raise Teaspoon::DriverOptionsError.new(types: "hash or json string")
       end
 
       def run_specs(runner, url)
-        driver = Selenium::WebDriver.for(driver_options[:client_driver])
+        driver = ::Selenium::WebDriver.for(driver_options[:client_driver])
         driver.navigate.to(url)
 
-        Selenium::WebDriver::Wait.new(driver_options).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")

data/lib/teaspoon/engine.rb

@@ -6,34 +6,11 @@ module Teaspoon
   class Engine < ::Rails::Engine
     isolate_namespace Teaspoon
 
-    ASSET_MANIFEST = [
-      # core library
-      'teaspoon.css',
-      'teaspoon-teaspoon.js',
-
-      # framework ties
-      'teaspoon/*.js',
-      'teaspoon-jasmine.js',
-      'teaspoon-mocha.js',
-      'teaspoon-qunit.js',
-
-      # frameworks
-      'jasmine/1.3.1.js',
-      'jasmine/2.0.0.js',
-      'mocha/1.10.0.js',
-      'mocha/1.17.1.js',
-      'qunit/1.12.0.js',
-      'qunit/1.14.0.js',
-
-      # all support libraries
-      'support/*.js'
-    ]
-
     routes do
       root to: "suite#index"
       match "/fixtures/*filename", to: "suite#fixtures", via: :get, as: "fixture"
       match "/:suite", to: "suite#show", via: :get, as: "suite", defaults: { suite: "default" }
-      match "/:suite/:hook", to: "suite#hook", via: :post, as: "suite_hook", defaults: { suite: "default", hook: "default" }
+      match "/:suite/:hook", to: "suite#hook", via: :post, defaults: { suite: "default", hook: "default" }
     end
 
     initializer :assets, group: :all do |app|
@@ -61,10 +38,15 @@ module Teaspoon
       Teaspoon.configuration.asset_paths.each do |path|
         assets.paths << Teaspoon.configuration.root.join(path).to_s
       end
+
+      # TODO: This breaks lazy loading of frameworks. Another way to avoid this?
+      Teaspoon::Framework.available.keys.each do |framework|
+        assets.paths += Teaspoon::Framework.fetch(framework).asset_paths
+      end
     end
 
     def self.add_precompiled_assets(assets)
-      assets.precompile += ASSET_MANIFEST
+      assets.precompile += Teaspoon.configuration.asset_manifest
     end
 
     def self.inject_instrumentation
@@ -80,5 +62,36 @@ module Teaspoon
 
       app.routes.prepend { mount Teaspoon::Engine => mount_at, as: "teaspoon" }
     end
+
+    module ExceptionHandling
+      def self.add_rails_handling
+        return unless using_phantomjs?
+
+        # debugging should be off to display errors in the suite_controller
+        # Rails.application.config.assets.debug = false
+
+        # we want rails to display exceptions
+        Rails.application.config.action_dispatch.show_exceptions = true
+
+        # override the render exception method in ActionDispatch to raise a javascript exception
+        render_exceptions_with_javascript
+      end
+
+      private
+
+      def self.using_phantomjs?
+        Teaspoon::Driver.equal?(Teaspoon.configuration.driver, :phantomjs)
+      end
+
+      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
 end

data/lib/teaspoon/environment.rb

@@ -3,8 +3,8 @@ require "teaspoon/exceptions"
 module Teaspoon
   module Environment
     def self.load(options = {})
-      require_environment(options[:environment])
-      raise "Rails environment not found." unless rails_loaded?
+      load_rails
+      Teaspoon.abort("Rails environment not found.", 1) unless rails_loaded?
 
       require "teaspoon"
       require "teaspoon/server"
@@ -13,38 +13,47 @@ module Teaspoon
       require "teaspoon/exporter"
 
       Teaspoon.configuration.override_from_options(options)
-      Teaspoon::ExceptionHandling.add_rails_handling
+      Teaspoon::Engine::ExceptionHandling.add_rails_handling
     end
 
     def self.require_environment(override = nil)
+      require_env(find_env(override))
+    end
+
+    def self.check_env!(override = nil)
+      find_env(override)
+    end
+
+    private
+
+    def self.find_env(override = nil)
       override ||= ENV["TEASPOON_ENV"]
-      if override
-        override = File.expand_path(override, Dir.pwd)
-        ENV["TEASPOON_ENV"] = override
-        return require_env(override)
-      end
+      env_files = override ? [override] : standard_environments
 
-      standard_environments.each do |filename|
+      env_files.each do |filename|
         file = File.expand_path(filename, Dir.pwd)
-        return require_env(file) if File.exists?(file)
+        ENV["TEASPOON_ENV"] = file if override
+        return file if File.exists?(file)
       end
 
-      raise Teaspoon::EnvironmentNotFound,
-            "Unable to load Teaspoon environment in {#{standard_environments.join(', ')}}"
+      raise Teaspoon::EnvironmentNotFound.new(searched: env_files.join(", "))
     end
 
     def self.standard_environments
       ["spec/teaspoon_env.rb", "test/teaspoon_env.rb", "teaspoon_env.rb"]
     end
 
-    private
-
     def self.require_env(file)
       ::Kernel.load(file)
     end
 
     def self.rails_loaded?
-      defined?(Rails)
+      !!defined?(Rails)
+    end
+
+    def self.load_rails
+      rails_env = ENV["TEASPOON_RAILS_ENV"] || File.expand_path("config/environment", Dir.pwd)
+      require rails_env
     end
   end
 end