teaspoon 0.8.0 → 0.9.0

data/spec/teaspoon/configuration_spec.rb

@@ -19,11 +19,11 @@ describe Teaspoon do
     it "sets configured to true" do
       subject.configured = false
       subject.configure { }
-      expect(subject.configured).to be_true
+      expect(subject.configured).to be_truthy
     end
 
     it "overrides configuration from ENV" do
-      subject.configuration.should_receive(:override_from_env).with(ENV)
+      expect(subject.configuration).to receive(:override_from_env).with(ENV)
       subject.configure { }
     end
 
@@ -32,7 +32,8 @@ describe Teaspoon do
   describe ".setup" do
 
     it "calls configure" do
-      subject.should_receive(:configure).with(&block = proc{})
+      block = proc{}
+      expect(subject).to receive(:configure).with(no_args) { |&arg| expect(arg).to eq(block) }
       subject.setup(&block)
     end
 
@@ -75,9 +76,9 @@ describe Teaspoon::Configuration do
     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.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)
@@ -127,9 +128,9 @@ describe Teaspoon::Configuration do
   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")
+      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
@@ -139,9 +140,9 @@ describe Teaspoon::Configuration do
   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")
+      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
@@ -161,6 +162,7 @@ describe Teaspoon::Configuration::Suite do
     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
@@ -192,12 +194,18 @@ describe Teaspoon::Configuration::Suite 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\""
+        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"
+        expect{ subject }.to raise_error(
+          Teaspoon::UnknownFramework,
+          "Unknown framework \"qunit\" with version 666 -- available versions 1.12.0, 1.14.0"
+        )
       end
 
     end

data/spec/teaspoon/console_spec.rb

@@ -7,44 +7,51 @@ require "teaspoon/exporter"
 describe Teaspoon::Console do
 
   let(:driver) { double(run_specs: 0) }
-  let(:server) { double(start: nil, url: "http://url.com") }
+  let(:server) { double(start: nil, url: "http://url.com", responsive?: false) }
   let(:runner) { double(failure_count: 2) }
 
   before do
-    Teaspoon::Environment.stub(:load)
-    Teaspoon::Server.stub(:new).and_return(server)
-    Teaspoon::Runner.stub(:new).and_return(runner)
+    allow(Teaspoon::Environment).to receive(:load)
+    allow(Teaspoon::Server).to receive(:new).and_return(server)
+    allow(Teaspoon::Runner).to receive(:new).and_return(runner)
 
-    Teaspoon::Console.any_instance.stub(:driver).and_return(driver)
-    Teaspoon::Console.any_instance.stub(:log)
+    allow_any_instance_of(Teaspoon::Console).to receive(:driver).and_return(driver)
+    allow_any_instance_of(Teaspoon::Console).to receive(:log)
   end
 
   describe "#initialize" do
 
-    it "assigns @options" do
+    it "assigns @default_options" do
       subject = Teaspoon::Console.new(foo: "bar")
-      expect(subject.instance_variable_get(:@options)).to eql(foo: "bar")
+      expect(subject.instance_variable_get(:@default_options)).to eql(foo: "bar")
     end
 
     it "loads the environment" do
-      Teaspoon::Environment.should_receive(:load)
+      expect(Teaspoon::Environment).to receive(:load)
       Teaspoon::Console.new
     end
 
     it "starts the server" do
-      Teaspoon::Console.any_instance.should_receive(:log).with("Starting the Teaspoon server...")
-      Teaspoon::Console.any_instance.should_receive(:start_server).and_call_original
-      Teaspoon::Server.should_receive(:new).and_return(server)
-      server.should_receive(:start)
+      expect_any_instance_of(Teaspoon::Console).to receive(:log).with("Starting the Teaspoon server...")
+      expect_any_instance_of(Teaspoon::Console).to receive(:start_server) .and_call_original
+      expect(Teaspoon::Server).to receive(:new).and_return(server)
+      expect(server).to receive(:start)
       Teaspoon::Console.new
     end
 
+    it "does not log a message about starting the server if one has already been started" do
+      allow(server).to receive(:responsive?).and_return(true)
+      expect_any_instance_of(Teaspoon::Console).not_to receive(:log).with("Starting the Teaspoon server...")
+      Teaspoon::Console.new
+    end
+
+
     it "aborts (displaying a message) on Teaspoon::ServerException" do
-      STDOUT.should_receive(:print).with("_message_\n")
-      Teaspoon::Console.any_instance.should_receive(:log).and_call_original
-      Teaspoon::Console.any_instance.should_receive(:start_server).and_raise(Teaspoon::ServerException, "_message_")
-      Teaspoon::Console.any_instance.should_receive(:abort).with("_message_").and_call_original
-      expect{ Teaspoon::Console.new }.to raise_error SystemExit
+      expect(STDOUT).to receive(:print).with("_message_\n")
+      expect_any_instance_of(Teaspoon::Console).to receive(:log).and_call_original
+      expect_any_instance_of(Teaspoon::Console).to receive(:start_server).and_raise(Teaspoon::ServerException, "_message_")
+      expect_any_instance_of(Teaspoon::Console).to receive(:abort).with("_message_").and_call_original
+      expect{ Teaspoon::Console.new }.to raise_error(SystemExit)
     end
 
   end
@@ -52,11 +59,11 @@ describe Teaspoon::Console do
   describe "#failures?" do
 
     it "calls #execute and returns the inverse of #executes return value" do
-      subject.should_receive(:execute).and_return(false)
-      expect(subject.failures?).to be_true
+      expect(subject).to receive(:execute).and_return(false)
+      expect(subject.failures?).to be_truthy
 
-      subject.should_receive(:execute).and_return(true)
-      expect(subject.failures?).to be_false
+      expect(subject).to receive(:execute).and_return(true)
+      expect(subject.failures?).to be_falsey
     end
 
   end
@@ -64,19 +71,25 @@ describe Teaspoon::Console do
   describe "#execute" do
 
     it "calls #execute_without_handling and returns its value" do
-      subject.should_receive(:execute_without_handling).with(foo: "bar").and_return(true)
-      expect(subject.execute(foo: "bar")).to be_true
+      expect(subject).to receive(:execute_without_handling).with(foo: "bar").and_return(true)
+      expect(subject.execute(foo: "bar")).to be_truthy
+    end
+
+    it "handles Teaspoon::RunnerException exceptions" do
+      expect(subject).to receive(:log).with("_runner_error_")
+      expect(subject).to receive(:execute_without_handling).and_raise(Teaspoon::RunnerException, "_runner_error_")
+      expect(subject.execute).to be_falsey
     end
 
     it "handles Teaspoon::Error exceptions" do
-      subject.should_receive(:abort).with("_unknown_error_")
-      subject.should_receive(:execute_without_handling).and_raise(Teaspoon::Error, "_unknown_error_")
+      expect(subject).to receive(:abort).with("_unknown_error_")
+      expect(subject).to receive(:execute_without_handling).and_raise(Teaspoon::Error, "_unknown_error_")
       subject.execute
     end
 
     it "returns false on Teaspoon::Failure" do
-      subject.should_receive(:execute_without_handling).and_raise(Teaspoon::Failure)
-      expect(subject.execute).to be_false
+      expect(subject).to receive(:execute_without_handling).and_raise(Teaspoon::Failure)
+      expect(subject.execute).to be_falsey
     end
 
   end
@@ -84,14 +97,14 @@ describe Teaspoon::Console do
   describe "#execute_without_handling" do
 
     before do
-      subject.stub(:run_specs).and_return(0)
-      subject.stub(:export)
+      allow(subject).to receive(:run_specs).and_return(0)
+      allow(subject).to receive(:export)
     end
 
-    it "merges @options" do
-      subject.instance_variable_set(:@options, foo: "bar")
+    it "merges options" do
+      subject.instance_variable_set(:@default_options, foo: "bar")
       subject.execute_without_handling(bar: "baz")
-      expect(subject.instance_variable_get(:@options)).to eql(foo: "bar", bar: "baz")
+      expect(subject.options).to eql(foo: "bar", bar: "baz")
     end
 
     it "clears any @suites" do
@@ -101,7 +114,7 @@ describe Teaspoon::Console do
     end
 
     it "resolves the files" do
-      Teaspoon::Suite.should_receive(:resolve_spec_for).with("file").and_return(suite: "foo", path: "file2")
+      expect(Teaspoon::Suite).to receive(:resolve_spec_for).with("file").and_return(suite: "foo", path: "file2")
       subject.execute_without_handling(files: ["file"])
 
       expect(subject.send(:suites)).to eq(["foo"])
@@ -110,35 +123,35 @@ describe Teaspoon::Console do
 
     it "resolves the files if a directory was given" do
       resolve_spec_for_output = ['test/javascripts/foo.coffee', 'test/javascripts/bar.coffee']
-      Teaspoon::Suite.should_receive(:resolve_spec_for).with("full/path").and_return(suite: "foo", path: resolve_spec_for_output)
+      expect(Teaspoon::Suite).to receive(:resolve_spec_for).with("full/path").and_return(suite: "foo", path: resolve_spec_for_output)
       subject.execute_without_handling(files: ["full/path"])
       expect(subject.send(:suites)).to eq(["foo"])
       expect(subject.send(:filter, "foo")).to eq("file[]=#{resolve_spec_for_output.join('&file[]=')}")
     end
 
     it "runs the tests" do
-      subject.should_receive(:suites).and_return([:default, :foo])
-      subject.should_receive(:run_specs).twice.and_return(2)
-      expect(subject.execute_without_handling).to be_false
+      expect(subject).to receive(:suites).and_return([:default, :foo])
+      expect(subject).to receive(:run_specs).twice.and_return(2)
+      expect(subject.execute_without_handling).to be_falsey
     end
 
     it "returns true if no failure count" do
-      subject.should_receive(:suites).and_return([:default, :foo])
-      subject.should_receive(:run_specs).twice.and_return(0)
-      expect(subject.execute_without_handling).to be_true
+      expect(subject).to receive(:suites).and_return([:default, :foo])
+      expect(subject).to receive(:run_specs).twice.and_return(0)
+      expect(subject.execute_without_handling).to be_truthy
     end
 
     it "returns true if there were failures" do
-      subject.should_receive(:suites).and_return([:default])
-      subject.should_receive(:run_specs).once.and_return(1)
-      expect(subject.execute_without_handling).to be_false
+      expect(subject).to receive(:suites).and_return([:default])
+      expect(subject).to receive(:run_specs).once.and_return(1)
+      expect(subject.execute_without_handling).to be_falsey
     end
 
     it "calls export if the options include :export" do
-      subject.should_receive(:suites).and_return([:default, :foo])
-      subject.instance_variable_set(:@options, export: true)
-      subject.should_receive(:export).with(:default)
-      subject.should_receive(:export).with(:foo)
+      expect(subject).to receive(:suites).and_return([:default, :foo])
+      subject.instance_variable_set(:@default_options, export: true)
+      expect(subject).to receive(:export).with(:default)
+      expect(subject).to receive(:export).with(:foo)
       subject.execute
     end
 
@@ -147,33 +160,36 @@ describe Teaspoon::Console do
   describe "#run_specs" do
 
     before do
-      Teaspoon.configuration.stub(:fail_fast).and_return(false)
-      Teaspoon.configuration.should_receive(:suite_configs).and_return("_suite_" => proc{}, "suite_name" => proc{})
+      allow(Teaspoon.configuration).to receive(:fail_fast).and_return(false)
+      expect(Teaspoon.configuration).to receive(:suite_configs).and_return("_suite_" => proc{}, "suite_name" => proc{})
     end
 
     it "raises a Teaspoon::UnknownSuite exception when the suite isn't known" do
-      expect { subject.run_specs("_unknown_") }.to raise_error Teaspoon::UnknownSuite
+      expect { subject.run_specs("_unknown_") }.to raise_error(
+        Teaspoon::UnknownSuite,
+        %{Unknown suite: "_unknown_"}
+      )
     end
 
     it "logs that the suite is being run" do
-      subject.should_receive(:log).with("Teaspoon running _suite_ suite at http://url.com/teaspoon/_suite_")
+      expect(subject).to receive(:log).with("Teaspoon running _suite_ suite at http://url.com/teaspoon/_suite_")
       subject.run_specs("_suite_")
     end
 
     it "calls #run_specs on the driver" do
-      subject.should_receive(:driver).and_return(driver)
-      driver.should_receive(:run_specs).with(runner, "http://url.com/teaspoon/suite_name?reporter=Console")
+      expect(subject).to receive(:driver).and_return(driver)
+      expect(driver).to receive(:run_specs).with(runner, "http://url.com/teaspoon/suite_name?reporter=Console")
       expect(subject.run_specs(:suite_name)).to eq(2)
     end
 
     it "raises a Teaspoon::Failure exception on failures when set to fail_fast" do
-      Teaspoon.configuration.stub(:fail_fast).and_return(true)
+      allow(Teaspoon.configuration).to receive(:fail_fast).and_return(true)
       expect { subject.run_specs(:suite_name) }.to raise_error Teaspoon::Failure
     end
 
     it "raises a Teaspoon:UnknownDriver when an unknown driver is being used" do
-      Teaspoon.configuration.should_receive(:driver).twice.and_return(:foo)
-      subject.should_receive(:driver).and_call_original
+      expect(Teaspoon.configuration).to receive(:driver).twice.and_return(:foo)
+      expect(subject).to receive(:driver).and_call_original
       expect { subject.run_specs(:suite_name) }.to raise_error Teaspoon::UnknownDriver
     end
 
@@ -182,8 +198,8 @@ describe Teaspoon::Console do
   describe "#export" do
 
     before do
-      Teaspoon.configuration.should_receive(:suite_configs).and_return("_suite_" => proc{}, "suite_name" => proc{})
-      Teaspoon::Exporter.stub(:new).and_return(double(export: nil))
+      expect(Teaspoon.configuration).to receive(:suite_configs).and_return("_suite_" => proc{}, "suite_name" => proc{})
+      allow(Teaspoon::Exporter).to receive(:new).and_return(double(export: nil))
     end
 
     it "raises a Teaspoon::UnknownSuite exception when the suite isn't known" do
@@ -191,15 +207,15 @@ describe Teaspoon::Console do
     end
 
     it "logs that the suite is being exported" do
-      subject.should_receive(:log).with("Teaspoon exporting _suite_ suite at http://url.com/teaspoon/_suite_")
+      expect(subject).to receive(:log).with("Teaspoon exporting _suite_ suite at http://url.com/teaspoon/_suite_")
       subject.export("_suite_")
     end
 
     it "calls #export on the exporter" do
-      subject.instance_variable_set(:@options, export: "_output_path_")
+      subject.instance_variable_set(:@default_options, export: "_output_path_")
       exporter = double(export: nil)
-      Teaspoon::Exporter.should_receive(:new).with("_suite_", "http://url.com/teaspoon/_suite_", "_output_path_").and_return(exporter)
-      exporter.should_receive(:export)
+      expect(Teaspoon::Exporter).to receive(:new).with("_suite_", "http://url.com/teaspoon/_suite_", "_output_path_").and_return(exporter)
+      expect(exporter).to receive(:export)
       subject.export("_suite_")
     end
 

data/spec/teaspoon/coverage_spec.rb

@@ -8,9 +8,9 @@ describe Teaspoon::Coverage do
   let(:config) { double }
 
   before do
-    Teaspoon::Instrumentation.stub(:executable).and_return("/path/to/executable")
-    subject.stub(:`).and_return("")
-    subject.stub(:input_path).and_yield("/temp_path/coverage.json")
+    allow(Teaspoon::Instrumentation).to receive(:executable).and_return("/path/to/executable")
+    allow(subject).to receive(:`).and_return("")
+    allow(subject).to receive(:input_path).and_yield("/temp_path/coverage.json")
     subject.instance_variable_set(:@config, config)
   end
 
@@ -25,8 +25,8 @@ describe Teaspoon::Coverage do
     end
 
     it "gets the coverage configuration" do
-      Teaspoon::Coverage.any_instance.should_receive(:coverage_configuration).with("default")
-      subject = Teaspoon::Coverage.new("_suite_", :default, data)
+      expect_any_instance_of(Teaspoon::Coverage).to receive(:coverage_configuration).with("default")
+      Teaspoon::Coverage.new("_suite_", :default, data)
     end
 
   end
@@ -37,12 +37,12 @@ describe Teaspoon::Coverage do
 
     it "generates reports using istanbul and passes them to the block provided" do
       `(exit 0)`
-      html_report = "/path/to/executable report html /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
-      text1_report = "/path/to/executable report text /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
-      text2_report = "/path/to/executable report text-summary /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
-      subject.should_receive(:`).with(html_report).and_return("_html_report_")
-      subject.should_receive(:`).with(text1_report).and_return("_text1_report_")
-      subject.should_receive(:`).with(text2_report).and_return("_text2_report_")
+      html_report = "/path/to/executable report --include=/temp_path/coverage.json --dir output/path/_suite_ html 2>&1"
+      text1_report = "/path/to/executable report --include=/temp_path/coverage.json --dir output/path/_suite_ text 2>&1"
+      text2_report = "/path/to/executable report --include=/temp_path/coverage.json --dir output/path/_suite_ text-summary 2>&1"
+      expect(subject).to receive(:`).with(html_report).and_return("_html_report_")
+      expect(subject).to receive(:`).with(text1_report).and_return("_text1_report_")
+      expect(subject).to receive(:`).with(text2_report).and_return("_text2_report_")
       subject.generate_reports { |r| @result = r }
       expect(@result).to eq("_text1_report_\n\n_text2_report_")
     end
@@ -59,24 +59,24 @@ describe Teaspoon::Coverage do
     let(:config) { double(statements: 42, functions: 66.6, branches: 0, lines: 100) }
 
     it "does nothing if there are no threshold checks to make" do
-      subject.should_receive(:threshold_args).and_return(nil)
-      subject.should_not_receive(:input_path)
+      expect(subject).to receive(:threshold_args).and_return(nil)
+      expect(subject).to_not receive(:input_path)
       subject.check_thresholds {}
     end
 
     it "checks the coverage using istanbul and passes them to the block provided" do
       `(exit 1)`
       check_coverage = "/path/to/executable check-coverage --statements=42 --functions=66.6 --branches=0 --lines=100 /temp_path/coverage.json 2>&1"
-      subject.should_receive(:`).with(check_coverage).and_return("some mumbo jumbo\nERROR: _failure1_\nmore garbage\nERROR: _failure2_")
+      expect(subject).to receive(:`).with(check_coverage).and_return("some mumbo jumbo\nERROR: _failure1_\nmore garbage\nERROR: _failure2_")
       subject.check_thresholds { |r| @result = r }
       expect(@result).to eq("_failure1_\n_failure2_")
     end
 
     it "doesn't call the callback if the exit status is 0" do
       `(exit 0)`
-      subject.should_receive(:`).and_return("ERROR: _failure1_")
+      expect(subject).to receive(:`).and_return("ERROR: _failure1_")
       subject.check_thresholds { |r| @called = true }
-      expect(@called).to be_false
+      expect(@called).to be_falsey
     end
 
   end
@@ -88,9 +88,9 @@ describe Teaspoon::Coverage do
     before do
       Teaspoon::Instrumentation.instance_variable_set(:@executable, nil)
       Teaspoon::Instrumentation.instance_variable_set(:@executable_checked, nil)
-      Teaspoon::Instrumentation.should_receive(:executable).and_call_original
-      subject.should_receive(:input_path).and_call_original
-      subject.should_receive(:`).and_call_original
+      expect(Teaspoon::Instrumentation).to receive(:executable).and_call_original
+      expect(subject).to receive(:input_path).and_call_original
+      expect(subject).to receive(:`).and_call_original
 
       executable = Teaspoon::Instrumentation.executable
       pending('needs istanbul to be installed') unless executable
@@ -101,15 +101,15 @@ describe Teaspoon::Coverage do
     it "generates coverage reports" do
       subject.generate_reports { |r| @report = r }
       expect(@report).to eq <<-RESULT.strip_heredoc + "\n"
-        -------------------------+-----------+-----------+-----------+-----------+
+        -------------------------|-----------|-----------|-----------|-----------|
         File                     |   % Stmts |% Branches |   % Funcs |   % Lines |
-        -------------------------+-----------+-----------+-----------+-----------+
+        -------------------------|-----------|-----------|-----------|-----------|
            integration/          |     90.91 |       100 |        75 |     90.91 |
               integration.coffee |        75 |       100 |        50 |        75 |
               spec_helper.coffee |       100 |       100 |       100 |       100 |
-        -------------------------+-----------+-----------+-----------+-----------+
+        -------------------------|-----------|-----------|-----------|-----------|
         All files                |     90.91 |       100 |        75 |     90.91 |
-        -------------------------+-----------+-----------+-----------+-----------+
+        -------------------------|-----------|-----------|-----------|-----------|
       RESULT
     end