teaspoon 0.7.9 → 0.8.0

data/spec/javascripts/fixtures/_body.html.erb

@@ -0,0 +1 @@
+This is a body partial.

data/spec/javascripts/jasmine_helper.coffee

@@ -1,3 +1,3 @@
 #= require jquery
-#= require support/jasmine-jquery
+#= require support/jasmine-jquery-1.7.0
 #= require ./spec_helper

data/spec/javascripts/teaspoon/base/fixture_spec.coffee

@@ -21,8 +21,8 @@ describe "Teaspoon.fixture", ->
 
     it "loads all of the files requested", ->
       fixture.load("fixture.html", "fixture.json")
-      expect(@xhrSpy).toHaveBeenCalledWith("GET", "/teaspoon/fixtures/fixture.html", false)
-      expect(@xhrSpy).toHaveBeenCalledWith("GET", "/teaspoon/fixtures/fixture.json", false)
+      expect(@xhrSpy).toHaveBeenCalledWith("GET", "#{Teaspoon.root}/fixtures/fixture.html", false)
+      expect(@xhrSpy).toHaveBeenCalledWith("GET", "#{Teaspoon.root}/fixtures/fixture.json", false)
 
     it "caches the type/contents of those files", ->
       fixture.load("fixture.html")
@@ -83,8 +83,8 @@ describe "Teaspoon.fixture", ->
 
     it "loads all of the files requested", ->
       fixture.preload("fixture.html", "fixture.json")
-      expect(@xhrSpy).toHaveBeenCalledWith("GET", "/teaspoon/fixtures/fixture.html", false)
-      expect(@xhrSpy).toHaveBeenCalledWith("GET", "/teaspoon/fixtures/fixture.json", false)
+      expect(@xhrSpy).toHaveBeenCalledWith("GET", "#{Teaspoon.root}/fixtures/fixture.html", false)
+      expect(@xhrSpy).toHaveBeenCalledWith("GET", "#{Teaspoon.root}/fixtures/fixture.json", false)
     expect(document.getElementById("teaspoon-fixtures")).toBe(null)
 
     it "caches the type/contents of those files", ->

data/spec/javascripts/teaspoon/base/reporters/html_spec.coffee

@@ -29,12 +29,11 @@ describe "Teaspoon.Reporters.HTML", ->
   describe "constructor", ->
 
     it "sets up the expected variables", ->
-
       expect(@reporter.start).toBeDefined()
       expect(@reporter.config).toEqual("use-catch": true, "build-full-report": false, "display-progress": true)
       expect(@reporter.total).toEqual({exist: 0, run: 0, passes: 0, failures: 0, skipped: 0})
       expect(@reporter.views).toEqual({specs: {}, suites: {}})
-      expect(@reporter.filters).toEqual(["by match: foo <a href='/teaspoon/default'>remove</a>"])
+      expect(@reporter.filters).toEqual(["by match: foo"])
 
     it "calls readConfig", ->
       expect(@readConfigSpy).toHaveBeenCalled()
@@ -110,7 +109,7 @@ describe "Teaspoon.Reporters.HTML", ->
     it "builds a select that displays the suites", ->
       result = @reporter.buildSuiteSelect()
       expect(result).toContain("select id=")
-      expect(result).toContain("selected='selected' value=\"foo\"")
+      expect(result).toContain("selected value=\"#{Teaspoon.root}/foo\"")
 
 
   describe "#buildProgress", ->
@@ -339,8 +338,8 @@ describe "Teaspoon.Reporters.HTML", ->
 
     it "sets a class and the html for the filter display", ->
       expect(@reporter.filters.length).toBe(2)
-      expect(@reporter.filters[0]).toBe("by file: _file_ <a href='/teaspoon/default'>remove</a>")
-      expect(@reporter.filters[1]).toBe("by match: _grep_ <a href='/teaspoon/default'>remove</a>")
+      expect(@reporter.filters[0]).toBe("by file: _file_")
+      expect(@reporter.filters[1]).toBe("by match: _grep_")
 
 
   describe "#readConfig", ->
@@ -348,26 +347,26 @@ describe "Teaspoon.Reporters.HTML", ->
     beforeEach ->
       @readConfigSpy.andCallThrough()
       @config = {}
-      @cookieSpy = spyOn(@reporter, "cookie").andReturn(@config)
+      @storeSpy = spyOn(@reporter, "store").andReturn(@config)
       @reporter.readConfig()
 
     it "reads the configuration from the cookie", ->
-      expect(@cookieSpy).toHaveBeenCalledWith("teaspoon")
+      expect(@storeSpy).toHaveBeenCalledWith("teaspoon")
       expect(@reporter.config).toEqual(@config)
 
 
   describe "#toggleConfig", ->
 
     beforeEach ->
-      @refreshSpy = spyOn(@reporter, "refresh")
-      @cookieSpy = spyOn(@reporter, "cookie")
+      @refreshSpy = spyOn(Teaspoon, "reload")
+      @storeSpy = spyOn(@reporter, "store")
       @reporter.toggleConfig(target: {tagName: "button", getAttribute: -> "teaspoon-use-catch"})
 
     it "toggles the configuration", ->
       expect(@reporter.config["use-catch"]).toBe(false)
 
     it "sets the cookie", ->
-      expect(@cookieSpy).toHaveBeenCalledWith("teaspoon", @reporter.config)
+      expect(@storeSpy).toHaveBeenCalledWith("teaspoon", @reporter.config)
 
     it "refreshes the page", ->
       expect(@refreshSpy).toHaveBeenCalled()

data/spec/javascripts/teaspoon/mocha/reporters/html_mspec.coffee

@@ -26,12 +26,6 @@ describe "Mocha Teaspoon.Reporters.HTML", ->
       expect(spec.err).to.eql(foo: "bar")
 
 
-  describe "#envInfo", ->
-
-    it "returns the version", ->
-      expect(@reporter.envInfo()).to.be("mocha 1.9.1")
-
-
 describe "Mocha Teaspoon.Reporters.HTML.SpecView", ->
 
   describe "#updateState", ->

data/spec/javascripts/teaspoon/phantomjs/runner_spec.coffee

@@ -93,8 +93,7 @@ describe "PhantomJS Runner", ->
 
     it "logs the error message", ->
       @runner.fail("_message_")
-      expect(@logSpy).toHaveBeenCalledWith("Error: _message_")
-      expect(@logSpy).toHaveBeenCalledWith('{"_teaspoon":true,"type":"exception"}')
+      expect(@logSpy).toHaveBeenCalledWith('{"_teaspoon":true,"type":"exception","message":"_message_"}')
 
     it "exits with the error code", ->
       spy = spyOn(phantom, "exit")
@@ -104,10 +103,6 @@ describe "PhantomJS Runner", ->
 
   describe "#finish", ->
 
-    it "logs an empty string (to fix line feeds in the console)", ->
-      @runner.finish()
-      expect(@logSpy).toHaveBeenCalledWith(" ")
-
     it "calls exit with a success code", ->
       spy = spyOn(phantom, "exit")
       @runner.finish()
@@ -133,6 +128,10 @@ describe "PhantomJS Runner", ->
         @callbacks.onError("_message_", ["trace1", "trace2"])
         expect(@logSpy).toHaveBeenCalledWith('{"_teaspoon":true,"type":"error","message":"_message_","trace":["trace1","trace2"]}')
 
+      it "calls #fail if the error is a TeaspoonError", ->
+        spyOn(@runner, "fail")
+        @callbacks.onError("TeaspoonError: _message_")
+        expect(@runner.fail).toHaveBeenCalledWith("Execution halted.")
 
     describe "#onConsoleMessage", ->
 

data/spec/javascripts/turbolinks_helper.coffee

@@ -1,2 +1,2 @@
 #= require turbolinks
-#= require ./spec_helper
+#= require ./spec_helper

data/spec/spec_helper.rb

@@ -2,22 +2,21 @@ ENV["RAILS_ENV"] ||= "test"
 ENV["RAILS_ROOT"] = File.expand_path("../dummy", __FILE__)
 require File.expand_path("../dummy/config/environment", __FILE__)
 
+require "coveralls"
+Coveralls.wear!
+
 require "rspec/rails"
 require "rspec/autorun"
 require "capybara/rails"
-#require 'capybara/poltergeist'
 require "aruba/api"
 
 require "ostruct"
 
 Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
 
-#Capybara.javascript_driver = :poltergeist
-
 RSpec.configure do |config|
   config.infer_base_class_for_anonymous_controllers = false
   config.order = "random"
 
-  config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 end

data/spec/teaspoon/command_line_spec.rb

@@ -2,47 +2,163 @@ require "spec_helper"
 require "teaspoon/command_line"
 require "teaspoon/console"
 
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end
+
 describe Teaspoon::CommandLine do
 
-  describe "#initialize" do
+  subject { Teaspoon::CommandLine }
 
-    let(:console) { double(execute: false) }
-    let(:parser) { double(parse!: ["file1", "file2"]) }
+  let(:console) { double(failures?: false) }
+  let(:parser) { double(parse!: ["file1", "file2"]) }
+
+  describe "#initialize" do
 
     before do
-      Teaspoon::CommandLine.any_instance.stub(:abort)
       Teaspoon::Console.stub(:new).and_return(console)
-      Teaspoon::CommandLine.any_instance.stub(:opt_parser).and_return(parser)
-    end
-
-    it "assigns @options" do
-      instance = Teaspoon::CommandLine.new
-      expect(instance.instance_variable_get(:@options)).to eq({})
+      subject.any_instance.stub(:abort)
+      subject.any_instance.stub(:opt_parser).and_return(parser)
     end
 
-    it "assigns @files" do
-      instance = Teaspoon::CommandLine.new
-      expect(instance.instance_variable_get(:@files)).to eq(["file1", "file2"])
+    it "assigns @options and adds the files that were parsed out" do
+      expect(subject.new.instance_variable_get(:@options)).to eq(files: ["file1", "file2"])
     end
 
     it "aborts with a message on Teaspoon::EnvironmentNotFound" do
       Teaspoon::Console.should_receive(:new).and_raise(Teaspoon::EnvironmentNotFound)
-      Teaspoon::CommandLine.any_instance.should_receive(:abort)
-      STDOUT.should_receive(:print).with("Unable to load Teaspoon environment in {spec/teaspoon_env.rb, test/teaspoon_env.rb, teaspoon_env.rb}.\n")
-      STDOUT.should_receive(:print).with("Consider using -r path/to/teaspoon_env\n")
-      Teaspoon::CommandLine.new
+      subject.any_instance.should_receive(:abort).with("Teaspoon::EnvironmentNotFound\nConsider using -r path/to/teaspoon_env\n")
+      subject.new
     end
 
     it "executes using Teaspoon::Console" do
-      Teaspoon::Console.should_receive(:new).with({}, ["file1", "file2"])
-      console.should_receive(:execute)
-      Teaspoon::CommandLine.new
+      Teaspoon::Console.should_receive(:new).with(files: ["file1", "file2"])
+      console.should_receive(:failures?)
+      subject.new
     end
 
     it "aborts if Teaspoon::Console fails" do
-      Teaspoon::CommandLine.any_instance.should_receive(:abort)
-      console.should_receive(:execute).and_return(true)
-      Teaspoon::CommandLine.new
+      subject.any_instance.should_receive(:abort)
+      console.should_receive(:failures?).and_return(true)
+      subject.new
+    end
+
+    it "logs a message and exits on abort" do
+      STDOUT.should_receive(:print).with("Teaspoon::EnvironmentNotFound\nConsider using -r path/to/teaspoon_env\n")
+      Teaspoon::Console.should_receive(:new).and_raise(Teaspoon::EnvironmentNotFound)
+      subject.any_instance.should_receive(:abort).and_call_original
+      expect { subject.new }.to raise_error SystemExit
+    end
+
+  end
+
+  describe "opt_parser" do
+
+    before do
+      @log = ""
+      STDOUT.stub(:print) { |s| @log << s }
+      Teaspoon::Console.stub(:new).and_return(console)
+    end
+
+    it "has --help" do
+      suppress_warnings { ARGV = ["--help"] }
+      expect { subject.new.opt_parser }.to raise_error SystemExit
+      expect(@log).to include <<-OUTPUT.strip_heredoc
+      Usage: teaspoon [options] [files]
+
+          -r, --require FILE               Require Teaspoon environment file.
+          -d, --driver DRIVER              Specify driver:
+                                             phantomjs (default)
+                                             selenium
+              --driver-options OPTIONS     Specify driver-specific options to pass into the driver.
+                                             e.g. "--ssl-protocol=any --ssl-certificates-path=/path/to/certs".
+                                             Driver options are only supported with phantomjs.
+              --driver-timeout SECONDS     Sets the timeout for the driver to wait before exiting.
+              --server SERVER              Sets server to use with Rack.
+                                             e.g. webrick, thin
+              --server-port PORT           Sets the server to use a specific port.
+              --server-timeout SECONDS     Sets the timeout that the server must start within.
+          -F, --[no-]fail-fast             Abort after the first failing suite.
+
+        **** Filtering ****
+
+          -s, --suite SUITE                Focus to a specific suite.
+          -g, --filter FILTER              Filter tests matching a specific filter.
+
+        **** Output ****
+
+          -q, --[no-]suppress-log          Suppress logs coming from console[log/debug/error].
+          -c, --[no-]color                 Enable/Disable color output.
+          -e, --export [OUTPUT_PATH]       Exports the test suite as the full HTML (requires wget).
+          -f, --format FORMATTERS          Specify formatters (comma separated)
+                                             dot (default) - dots
+                                             documentation - descriptive documentation
+                                             clean - like dots but doesn't log re-run commands
+                                             json - json formatter (raw teaspoon)
+                                             junit - junit compatible formatter
+                                             pride - yay rainbows!
+                                             snowday - makes you feel warm inside
+                                             swayze_or_oprah - quote from either Patrick Swayze or Oprah Winfrey
+                                             tap - test anything protocol formatter
+                                             tap_y - tap_yaml, format used by tapout
+                                             teamcity - teamcity compatible formatter
+
+        **** Coverage ****
+
+          -C, --coverage CONFIG_NAME       Generate coverage reports using a pre-defined coverage configuration.
+
+        **** Utility ****
+
+          -v, --version                    Display the version.
+          -h, --help                       You're looking at it.
+      OUTPUT
+    end
+
+    it "has --version" do
+      suppress_warnings { ARGV = ["--version"] }
+      expect { subject.new.opt_parser }.to raise_error SystemExit
+      expect(@log).to match(/\d+\.\d+\.\d+\n/)
+    end
+
+    it "has various other arguments" do
+      value_flags = {
+        environment: ["require", "_environment_"],
+        driver: ["driver", "_driver_"],
+        driver_options: ["driver-options", "_driver_options_"],
+        driver_timeout: ["driver-timeout", "_driver_timeout_"],
+        server: ["server", "_server_"],
+        server_port: ["server-port", "_server_port_"],
+        server_timeout: ["server-timeout", "_server_timeout_"],
+        suite: ["suite", "_suite_"],
+        filter: ["filter", "_filter_"],
+        export: ["export", "_export_"],
+        formatters: ["format", "_foo,bar_"],
+        use_coverage: ["coverage", "_coverage_"],
+      }
+
+      bool_flags = {
+        fail_fast: "fail-fast",
+        suppress_log: "suppress-log",
+        color: "color",
+      }
+
+      value_flags.each do |k, v|
+        suppress_warnings { ARGV = ["--#{v[0]}=#{v[1]}"] }
+        expect(subject.new.instance_variable_get(:@options)[k]).to eq(v[1])
+      end
+
+      bool_flags.each do |k, v|
+        suppress_warnings { ARGV = ["--#{v}"] }
+        expect(subject.new.instance_variable_get(:@options)[k]).to eq(true)
+        suppress_warnings { ARGV = ["--no-#{v}"] }
+        expect(subject.new.instance_variable_get(:@options)[k]).to eq(false)
+      end
     end
 
   end

data/spec/teaspoon/configuration_spec.rb

@@ -2,36 +2,38 @@ require "spec_helper"
 
 describe Teaspoon do
 
+  subject { Teaspoon }
+
   it "has a configuration property" do
-    expect(Teaspoon.configuration).to be(Teaspoon::Configuration)
+    expect(subject.configuration).to be(Teaspoon::Configuration)
   end
 
-  describe ".setup" do
+  describe ".configure" do
 
     it "yields configuration" do
       config = nil
-      Teaspoon.setup { |c| config = c }
+      subject.configure { |c| config = c }
       expect(config).to be(Teaspoon::Configuration)
     end
 
-  end
-
-  describe ".override_from_env" do
+    it "sets configured to true" do
+      subject.configured = false
+      subject.configure { }
+      expect(subject.configured).to be_true
+    end
 
-    after do
-      ENV["SUPPRESS_LOG"] = nil
-      ENV["FAIL_FAST"] = nil
-      ENV["FORMATTERS"] = nil
+    it "overrides configuration from ENV" do
+      subject.configuration.should_receive(:override_from_env).with(ENV)
+      subject.configure { }
     end
 
-    it "allows overriding of fail_fast and suppress_log from the env" do
-      ENV["SUPPRESS_LOG"] = "true"
-      ENV["FAIL_FAST"] = "false"
-      ENV["FORMATTERS"] = "something"
-      Teaspoon.configuration.should_receive(:suppress_log=).with(true)
-      Teaspoon.configuration.should_receive(:fail_fast=).with(false)
-      Teaspoon.configuration.should_receive(:formatters=).with("something")
-      Teaspoon.send(:override_from_env)
+  end
+
+  describe ".setup" do
+
+    it "calls configure" do
+      subject.should_receive(:configure).with(&block = proc{})
+      subject.setup(&block)
     end
 
   end
@@ -43,68 +45,184 @@ describe Teaspoon::Configuration do
 
   subject { Teaspoon::Configuration }
 
+  before do
+    @orig_root = subject.root
+    @orig_asset_paths = subject.asset_paths
+    @orig_formatters = subject.formatters
+  end
+
   after do
-    Teaspoon::Configuration.mount_at = "/teaspoon"
-    Teaspoon::Configuration.suites.delete("test_suite")
-    Teaspoon::Configuration.server = nil
+    subject.mount_at = "/teaspoon"
+    subject.suite_configs.delete("test_suite")
+    subject.server = nil
+    subject.root = @orig_root
+    subject.asset_paths = @orig_asset_paths
+    subject.formatters = @orig_formatters
   end
 
   it "has the default configuration" do
     expect(subject.mount_at).to eq("/teaspoon")
-    expect(subject.context).to eq(nil)
+    expect(subject.root).to eq(Rails.root.join('..', '..'))
     expect(subject.asset_paths).to include("spec/javascripts")
     expect(subject.asset_paths).to include("spec/javascripts/stylesheets")
-    expect(subject.fixture_path).to eq("spec/javascripts/fixtures")
-    expect(subject.formatters).to eq(['dot'])
-    expect(subject.server_timeout).to eq(20)
-    expect(subject.fail_fast).to eq(true)
-    expect(subject.suppress_log).to eq(false)
-    expect(subject.suites).to be_a(Hash)
-    expect(subject.coverage).to eq(false)
-    expect(subject.coverage_reports).to eq(["text-summary"])
-    expect(subject.coverage_output_dir).to eq("coverage")
+    expect(subject.fixture_paths).to eq(["spec/javascripts/fixtures", "test/javascripts/fixtures"])
+
+    expect(subject.driver).to eq("phantomjs")
+    expect(subject.driver_options).to be_nil
+    expect(subject.driver_timeout).to eq(180)
     expect(subject.server).to be_nil
-    expect(subject.statements_coverage_threshold).to be_nil
-    expect(subject.functions_coverage_threshold).to be_nil
-    expect(subject.branches_coverage_threshold).to be_nil
-    expect(subject.lines_coverage_threshold).to be_nil
+    expect(subject.server_port).to be_nil
+    expect(subject.server_timeout).to eq(20)
+    expect(subject.formatters).to eq(['dot'])
+    expect(subject.use_coverage).to be_nil
+    expect(subject.fail_fast).to be_true
+    expect(subject.suppress_log).to be_false
+    expect(subject.color).to be_true
+
+    expect(subject.suite_configs).to be_a(Hash)
+    expect(subject.coverage_configs).to be_a(Hash)
   end
 
   it "allows setting various configuration options" do
-    Teaspoon.configuration.mount_at = "/teaspoons_are_awesome"
+    subject.mount_at = "/teaspoons_are_awesome"
     expect(subject.mount_at).to eq("/teaspoons_are_awesome")
-    Teaspoon.configuration.server = :webrick
+    subject.server = :webrick
     expect(subject.server).to eq(:webrick)
   end
 
-  it "allows defining suites" do
+  it "allows defining suite configurations" do
     subject.suite(:test_suite) { }
-    expect(subject.suites["test_suite"]).to be_a(Proc)
+    expect(subject.suite_configs["test_suite"][:block]).to be_a(Proc)
+    expect(subject.suite_configs["test_suite"][:instance]).to be_a(Teaspoon::Configuration::Suite)
+  end
+
+  it "allows defining coverage configurations" do
+    subject.coverage(:test_coverage) { }
+    expect(subject.coverage_configs["test_coverage"][:block]).to be_a(Proc)
+    expect(subject.coverage_configs["test_coverage"][:instance]).to be_a(Teaspoon::Configuration::Coverage)
+  end
+
+  describe ".root=" do
+
+    it "forces the path provided into a Pathname" do
+      subject.root = "/path"
+      expect(subject.root).to be_a(Pathname)
+    end
+
+  end
+
+  describe ".formatters" do
+
+    it "returns the default dot formatter if nothing was set" do
+      expect(subject.formatters).to eq(["dot"])
+    end
+
+    it "returns an array of formatters if they were comma separated" do
+      subject.formatters = "dot,swayze_or_oprah"
+      expect(subject.formatters).to eq(["dot", "swayze_or_oprah"])
+    end
+
+  end
+
+  describe ".override_from_options" do
+
+    it "allows overriding from options" do
+      subject.should_receive(:fail_fast=).with(true)
+      subject.should_receive(:driver_timeout=).with(123)
+      subject.should_receive(:driver=).with("driver")
+
+      subject.send(:override_from_options, fail_fast: true, driver_timeout: 123, driver: "driver")
+    end
+
+  end
+
+  describe ".override_from_env" do
+
+    it "allows overriding from the env" do
+      subject.should_receive(:fail_fast=).with(true)
+      subject.should_receive(:driver_timeout=).with(123)
+      subject.should_receive(:driver=).with("driver")
+
+      subject.send(:override_from_env, "FAIL_FAST" => "true", "DRIVER_TIMEOUT" => "123", "DRIVER" => "driver")
+    end
+
   end
+
 end
 
 
 describe Teaspoon::Configuration::Suite do
 
+  subject { Teaspoon::Configuration::Suite.new &(@suite || proc{}) }
+
   it "has the default configuration" do
-    subject = Teaspoon::Configuration::Suite.new
     expect(subject.matcher).to eq("{spec/javascripts,spec/dummy/app/assets/javascripts/specs}/**/*_spec.{js,js.coffee,coffee,js.coffee.erb}")
     expect(subject.helper).to eq("spec_helper")
-    expect(subject.javascripts).to eq(["teaspoon/jasmine"])
+    expect(subject.javascripts).to eq(["jasmine/1.3.1", "teaspoon/jasmine"])
     expect(subject.stylesheets).to eq(["teaspoon"])
+    expect(subject.no_coverage).to eq([%r{/lib/ruby/gems/}, %r{/vendor/assets/}, %r{/support/}, %r{/(.+)_helper.}])
   end
 
   it "accepts a block that can override defaults" do
-    subject = Teaspoon::Configuration::Suite.new { |s| s.helper = "helper_file" }
+    @suite = proc{ |s| s.helper = "helper_file" }
     expect(subject.helper).to eq("helper_file")
   end
 
-
-  it "allows creating hooks" do
+  it "allows registering hooks" do
     expect(subject.hooks).to eq({})
-
     subject.hook {}
-
     expect(subject.hooks['default'].length).to eq(1)
   end
+
+  describe "specifying a framework" do
+
+    it "allows specifying mocha with a version" do
+      @suite = proc{ |s| s.use_framework :mocha, "1.10.0" }
+      expect(subject.javascripts).to eq(["mocha/1.10.0", "teaspoon-mocha"])
+    end
+
+    it "handles qunit specifically to set matcher and helper" do
+      @suite = proc{ |s| s.use_framework :qunit }
+      expect(subject.javascripts).to eq(["qunit/1.14.0", "teaspoon-qunit"])
+      expect(subject.matcher).to eq("{test/javascripts,app/assets}/**/*_test.{js,js.coffee,coffee}")
+      expect(subject.helper).to eq("test_helper")
+    end
+
+    describe "exceptions" do
+
+      it "shows an error for unknown frameworks" do
+        @suite = proc{ |s| s.use_framework :foo }
+        expect{ subject }.to raise_error Teaspoon::UnknownFramework, "Unknown framework \"foo\""
+      end
+
+      it "shows an error for unknown versions" do
+        @suite = proc{ |s| s.use_framework :qunit, "666" }
+        expect{ subject }.to raise_error Teaspoon::UnknownFramework, "Unknown framework \"qunit\" with version 666 -- available versions 1.12.0, 1.14.0"
+      end
+
+    end
+
+  end
+
+end
+
+
+describe Teaspoon::Configuration::Coverage do
+
+  subject { Teaspoon::Configuration::Coverage.new &(@coverage || proc{}) }
+
+  it "has the default configuration" do
+    expect(subject.reports).to eq(["text-summary"])
+    expect(subject.output_path).to eq("coverage")
+    expect(subject.statements).to be_nil
+    expect(subject.functions).to be_nil
+    expect(subject.branches).to be_nil
+    expect(subject.lines).to be_nil
+  end
+
+  it "accepts a block that can override defaults" do
+    @coverage = proc{ |s| s.reports = "report_format" }
+    expect(subject.reports).to eq("report_format")
+  end
+
 end