teaspoon 0.9.1 → 1.0.0

data/spec/javascripts/teaspoon/mocha/runner_mspec.coffee

@@ -1,23 +0,0 @@
-describe "Mocha Teaspoon.Runner", ->
-
-  beforeEach ->
-    @runSpy = mocha.run = sinon.spy()
-    @runner = new Teaspoon.Runner()
-
-  describe "constructor", ->
-
-    it "calls run on the mocha env", ->
-      @runner.setup = sinon.stub()
-      assert.calledOnce(@runSpy)
-
-
-  describe "#setup", ->
-
-    it "adds the reporter to the env", ->
-#      spy = mocha.setup = sinon.spy()
-#      @runner.params = {grep: "foo"}
-#      @runner.setup()
-#      if window.navigator.userAgent.match(/PhantomJS/)
-#        assert.calledOnce(spy, reporter: Teaspoon.Reporters.Console)
-#      else
-#        assert.calledOnce(spy, reporter: Teaspoon.Reporters.HTML)

data/spec/javascripts/teaspoon/mocha/spec_mspec.coffee

@@ -1,9 +0,0 @@
-describe "Teaspoon running Mocha", ->
-
-  it "allows pending specs"
-
-  it "displays spec times", ->
-
-  it "can delay assertions", (run) ->
-    setTimeout((-> run()), 1800)
-

data/spec/javascripts/teaspoon/other/erb_spec.js.coffee.erb

@@ -1,4 +0,0 @@
-describe "erb", ->
-
-  it "tests", ->
-    expect(true).toBe(true)

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

@@ -1,161 +0,0 @@
-#= require_self
-#= require drivers/phantomjs/runner
-
-# stub out phantomjs
-window.phantom = {exit: ->}
-window.require = (file) ->
-  switch file
-    when "system" then {args: ["runner.js", "http://host:port/path", "200"]}
-    when "webpage" then create: -> {
-      open: -> {}
-      evaluate: -> {}
-    }
-
-describe "PhantomJS Runner", ->
-
-  beforeEach ->
-    @logSpy = spyOn(window.console, "log")
-    @runner = new Runner()
-
-  describe "constructor", ->
-
-    it "sets the url from system.args", ->
-      expect(@runner.url).toBe("http://host:port/path")
-
-    it "sets the timeout from system.args", ->
-      expect(@runner.timeout).toBe(200 * 1000)
-
-
-  describe "#run", ->
-
-    beforeEach ->
-      @initSpy = spyOn(@runner, "initPage")
-      @loadSpy = spyOn(@runner, "loadPage")
-
-    it "calls initPage", ->
-      @runner.run()
-      expect(@initSpy).toHaveBeenCalled()
-
-    it "calls loadPage", ->
-      @runner.run()
-      expect(@loadSpy).toHaveBeenCalled()
-
-
-  describe "#initPage", ->
-
-    it "creates a webpage and assigns it to @page", ->
-      @runner.initPage()
-      expect(typeof(@runner.page["open"])).toBe("function")
-
-
-  describe "#loadPage", ->
-
-    beforeEach ->
-      @runner.initPage()
-
-    it "opens the url in the page", ->
-      spy = spyOn(@runner.page, "open")
-      @runner.loadPage()
-      expect(spy).toHaveBeenCalledWith(@runner.url)
-
-    it "attaches all the methods to page", ->
-      spyOn(@runner, "pageCallbacks").andCallFake -> {callback1: "method1", callback2: "method2"}
-      @runner.loadPage()
-      expect(@runner.page.callback1).toBe("method1")
-      expect(@runner.page.callback2).toBe("method2")
-
-
-  describe "#waitForResults", ->
-
-    beforeEach ->
-      @timeoutSpy = spyOn(window, "setTimeout")
-      @runner.initPage()
-
-    it "evaluates in the context of the page", ->
-      spy = spyOn(@runner.page, "evaluate").andReturn(false)
-      @runner.waitForResults()
-      expect(spy).toHaveBeenCalled()
-
-    it "sets a timeout of 100ms if not finished", ->
-      spyOn(@runner.page, "evaluate").andReturn(false)
-      @runner.waitForResults()
-      expect(@timeoutSpy).toHaveBeenCalled()
-
-    it "calls finish if Teaspoon says that it's finished", ->
-      spyOn(@runner.page, "evaluate").andCallFake (f) -> f()
-      spy = spyOn(@runner, "finish")
-      window.Teaspoon.finished = true
-      @runner.waitForResults()
-      expect(spy).toHaveBeenCalled()
-
-
-  describe "#fail", ->
-
-    it "logs the error message", ->
-      @runner.fail("_message_")
-      expect(@logSpy).toHaveBeenCalledWith('{"_teaspoon":true,"type":"exception","message":"_message_"}')
-
-    it "exits with the error code", ->
-      spy = spyOn(phantom, "exit")
-      @runner.fail("_message_", 2)
-      expect(spy).toHaveBeenCalledWith(2)
-
-
-  describe "#finish", ->
-
-    it "calls exit with a success code", ->
-      spy = spyOn(phantom, "exit")
-      @runner.finish()
-      expect(spy).toHaveBeenCalledWith(0)
-
-
-  describe "#pageCallbacks", ->
-
-    it "returns an object with the expected methods", ->
-      return unless Object.keys
-      object = @runner.pageCallbacks()
-      expect(Object.keys(object)).toEqual(["onError", "onConsoleMessage", "onLoadFinished"])
-
-
-  describe "callback method", ->
-
-    beforeEach ->
-      @callbacks = @runner.pageCallbacks()
-
-    describe "#onError", ->
-
-      it "logs the json of a message and trace", ->
-        @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", ->
-
-      it "logs the message", ->
-        @callbacks.onConsoleMessage("_message_")
-        expect(@logSpy).toHaveBeenCalledWith("_message_")
-
-
-    describe "#onLoadFinish", ->
-
-      beforeEach ->
-        @runner.initPage()
-        @waitSpy = spyOn(@runner, "waitForResults")
-
-      it "fails if the status was not success", ->
-        spy = spyOn(@runner, "fail")
-        evalSpy = spyOn(@runner.page, "evaluate").andReturn(true)
-        @callbacks.onLoadFinished("failure")
-        expect(spy).toHaveBeenCalledWith("Failed to load: #{@runner.url}")
-        expect(evalSpy).toHaveBeenCalled()
-        expect(@waitSpy).wasNotCalled()
-
-
-      it "calls waitForResults", ->
-        @callbacks.onLoadFinished("success")
-        expect(@waitSpy).toHaveBeenCalled()
-

data/spec/javascripts/turbolinks_helper.coffee

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

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-
-ENV["RAILS_ENV"] ||= "test"
-ENV["RAILS_ROOT"] = File.expand_path("../dummy", __FILE__)
-require File.expand_path("../dummy/config/environment", __FILE__)
-
-require "rspec/rails"
-require "capybara/rails"
-require "aruba/api"
-
-require "ostruct"
-
-Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
-
-RSpec.configure do |config|
-  config.infer_base_class_for_anonymous_controllers = false
-  config.order = "random"
-
-  config.run_all_when_everything_filtered = true
-
-  config.mock_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/support/aruba.rb

@@ -1,15 +0,0 @@
-RSpec.configure do |config|
-  config.include Aruba::Api
-
-  config.before(:each, aruba: true) do
-    @aruba_timeout_seconds = 180
-    FileUtils.rm_rf(current_dir)
-    @__aruba_original_paths = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
-    ENV['PATH'] = ([File.expand_path('bin')] + @__aruba_original_paths).join(File::PATH_SEPARATOR)
-  end
-
-  config.after(:each, aruba: true) do
-    ENV['PATH'] = @__aruba_original_paths.join(File::PATH_SEPARATOR)
-    restore_env
-  end
-end

data/spec/teaspoon/command_line_spec.rb

@@ -1,157 +0,0 @@
-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
-
-  subject { Teaspoon::CommandLine }
-
-  let(:console) { double(failures?: false) }
-  let(:parser) { double(parse!: ["file1", "file2"]) }
-
-  describe "#initialize" do
-
-    before do
-      allow(Teaspoon::Console).to receive(:new).and_return(console)
-      allow_any_instance_of(subject).to receive(:abort)
-      allow_any_instance_of(subject).to receive(:opt_parser).and_return(parser)
-    end
-
-    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
-      expect(Teaspoon::Console).to receive(:new).and_raise(Teaspoon::EnvironmentNotFound)
-      expect_any_instance_of(subject).to receive(:abort).with("Teaspoon::EnvironmentNotFound\nConsider using -r path/to/teaspoon_env\n")
-      subject.new
-    end
-
-    it "executes using Teaspoon::Console" do
-      expect(Teaspoon::Console).to receive(:new).with(files: ["file1", "file2"])
-      expect(console).to receive(:failures?)
-      subject.new
-    end
-
-    it "aborts if Teaspoon::Console fails" do
-      expect_any_instance_of(subject).to receive(:abort)
-      expect(console).to receive(:failures?).and_return(true)
-      subject.new
-    end
-
-    it "logs a message and exits on abort" do
-      expect(STDOUT).to receive(:print).with("Teaspoon::EnvironmentNotFound\nConsider using -r path/to/teaspoon_env\n")
-      expect(Teaspoon::Console).to receive(:new).and_raise(Teaspoon::EnvironmentNotFound)
-      expect_any_instance_of(subject).to receive(:abort).and_call_original
-      expect { subject.new }.to raise_error(SystemExit)
-    end
-
-  end
-
-  describe "opt_parser" do
-
-    before do
-      @log = ""
-      allow(STDOUT).to receive(:print) { |s| @log << s }
-      allow(Teaspoon::Console).to receive(: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
-                                             capybara_webkit
-              --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)
-                                           #{Teaspoon::Formatters.known_formatters.map(&:cli_help).join("\n" + (" " * 43))}
-
-        **** 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
-
-end

data/spec/teaspoon/configuration_spec.rb

@@ -1,236 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon do
-
-  subject { Teaspoon }
-
-  it "has a configuration property" do
-    expect(subject.configuration).to be(Teaspoon::Configuration)
-  end
-
-  describe ".configure" do
-
-    it "yields configuration" do
-      config = nil
-      subject.configure { |c| config = c }
-      expect(config).to be(Teaspoon::Configuration)
-    end
-
-    it "sets configured to true" do
-      subject.configured = false
-      subject.configure { }
-      expect(subject.configured).to be_truthy
-    end
-
-    it "overrides configuration from ENV" do
-      expect(subject.configuration).to receive(:override_from_env).with(ENV)
-      subject.configure { }
-    end
-
-  end
-
-  describe ".setup" do
-
-    it "calls configure" do
-      block = proc{}
-      expect(subject).to receive(:configure).with(no_args) { |&arg| expect(arg).to eq(block) }
-      subject.setup(&block)
-    end
-
-  end
-
-end
-
-
-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
-    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.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_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.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_truthy
-    expect(subject.suppress_log).to be_falsey
-    expect(subject.color).to be_truthy
-
-    expect(subject.suite_configs).to be_a(Hash)
-    expect(subject.coverage_configs).to be_a(Hash)
-  end
-
-  it "allows setting various configuration options" do
-    subject.mount_at = "/teaspoons_are_awesome"
-    expect(subject.mount_at).to eq("/teaspoons_are_awesome")
-    subject.server = :webrick
-    expect(subject.server).to eq(:webrick)
-  end
-
-  it "allows defining suite configurations" do
-    subject.suite(:test_suite) { }
-    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
-      expect(subject).to receive(:fail_fast=).with(true)
-      expect(subject).to receive(:driver_timeout=).with(123)
-      expect(subject).to 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
-      expect(subject).to receive(:fail_fast=).with(true)
-      expect(subject).to receive(:driver_timeout=).with(123)
-      expect(subject).to 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
-    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(["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.}])
-    expect(subject.expand_assets).to eq(true)
-  end
-
-  it "accepts a block that can override defaults" do
-    @suite = proc{ |s| s.helper = "helper_file" }
-    expect(subject.helper).to eq("helper_file")
-  end
-
-  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