teaspoon 0.8.0 → 0.9.0

data/spec/teaspoon/result_spec.rb

@@ -4,29 +4,33 @@ require "teaspoon/result"
 describe Teaspoon::Result do
 
   subject { Teaspoon::Result.build_from_json(json) }
-  let(:suite_name) { 'My Suite' }
-  let(:json) {{
-    "type"     => "spec",
-    "suite"    => "_suite_name_",
-    "label"    => "_spec_name_",
-    "status"   => "failed",
-    "skipped"  => false,
-    "link"     => "?grep=_spec_description_",
-    "message"  => "_message_",
-    "trace"    => "_trace_",
-    "coverage" => "_coverage_",
-  }}
+  let(:suite_name) { "My Suite" }
+  let(:json) do
+    {
+      "type" => "spec",
+      "suite" => "_suite_name_",
+      "label" => "_spec_name_",
+      "status" => "failed",
+      "skipped" => false,
+      "link" => "?grep=_spec_description_",
+      "message" => "_message_",
+      "trace" => "_trace_",
+      "coverage" => "_coverage_",
+    }
+  end
 
   describe ".build_from_json" do
 
     describe "with a results object" do
 
-      let(:json) {{
-        "elapsed"  => 0.01,
-        "failures" => 10,
-        "pending"  => 1,
-        "total"    => 25
-      }}
+      let(:json) do
+        {
+          "elapsed" => 0.01,
+          "failures" => 10,
+          "pending" => 1,
+          "total" => 25
+        }
+      end
 
       it "assigns from the JSON hash" do
         expect(subject.elapsed).to eq(0.01)
@@ -38,16 +42,16 @@ describe Teaspoon::Result do
     describe "with a spec" do
 
       it "assigns from the JSON hash" do
-        expect(subject.type).to eq('spec')
-        expect(subject.suite).to eq('_suite_name_')
-        expect(subject.label).to eq('_spec_name_')
-        expect(subject.description).to eq('_suite_name_ _spec_name_')
-        expect(subject.status).to eq('failed')
-        expect(subject.skipped).to be_false
-        expect(subject.link).to eq('?grep=_spec_description_')
-        expect(subject.message).to eq('_message_')
-        expect(subject.trace).to eq('_trace_')
-        expect(subject.coverage).to eq('_coverage_')
+        expect(subject.type).to eq("spec")
+        expect(subject.suite).to eq("_suite_name_")
+        expect(subject.label).to eq("_spec_name_")
+        expect(subject.description).to eq("_suite_name_ _spec_name_")
+        expect(subject.status).to eq("failed")
+        expect(subject.skipped).to be_falsey
+        expect(subject.link).to eq("?grep=_spec_description_")
+        expect(subject.message).to eq("_message_")
+        expect(subject.trace).to eq("_trace_")
+        expect(subject.coverage).to eq("_coverage_")
       end
 
     end
@@ -58,13 +62,13 @@ describe Teaspoon::Result do
 
     it "returns a boolean based on status" do
       subject.status = "foo"
-      expect(subject.failing?).to be_true
+      expect(subject.failing?).to be_truthy
       subject.status = "bar"
-      expect(subject.failing?).to be_true
+      expect(subject.failing?).to be_truthy
       subject.status = "passed"
-      expect(subject.failing?).to be_false
+      expect(subject.failing?).to be_falsey
       subject.status = "pending"
-      expect(subject.failing?).to be_false
+      expect(subject.failing?).to be_falsey
     end
 
   end
@@ -73,9 +77,9 @@ describe Teaspoon::Result do
 
     it "returns a boolean based on status" do
       subject.status = "passed"
-      expect(subject.passing?).to be_true
+      expect(subject.passing?).to be_truthy
       subject.status = "foo"
-      expect(subject.passing?).to be_false
+      expect(subject.passing?).to be_falsey
     end
 
   end
@@ -84,9 +88,9 @@ describe Teaspoon::Result do
 
     it "returns a boolean based on status" do
       subject.status = "pending"
-      expect(subject.pending?).to be_true
+      expect(subject.pending?).to be_truthy
       subject.status = "foo"
-      expect(subject.pending?).to be_false
+      expect(subject.pending?).to be_falsey
     end
 
   end

data/spec/teaspoon/runner_spec.rb

@@ -6,7 +6,7 @@ require "teaspoon/coverage"
 describe Teaspoon::Runner do
 
   before do
-    Teaspoon.configuration.stub(:formatters).and_return([])
+    allow(Teaspoon.configuration).to receive(:formatters).and_return([])
   end
 
   describe "#initialize" do
@@ -18,7 +18,7 @@ describe Teaspoon::Runner do
     end
 
     it "instantiates formatters based on configuration" do
-      Teaspoon.configuration.stub(:formatters).and_return(["dot", "xml"])
+      allow(Teaspoon.configuration).to receive(:formatters).and_return(["dot", "xml"])
       Teaspoon::Formatters::XmlFormatter = Class.new do
         def initialize(_suite_name = :default, _output_file = nil) end
       end
@@ -27,7 +27,7 @@ describe Teaspoon::Runner do
     end
 
     it "raises a Teaspoon::UnknownFormatter exception when a formatter isn't found" do
-      Teaspoon.configuration.stub(:formatters).and_return(["bar"])
+      allow(Teaspoon.configuration).to receive(:formatters).and_return(["bar"])
       expect { Teaspoon::Runner.new(:foo) }.to raise_error Teaspoon::UnknownFormatter, "Unknown formatter: \"bar\""
     end
 
@@ -43,25 +43,25 @@ describe Teaspoon::Runner do
     end
 
     it "notifies formatters when it understands the log" do
-      formatter.should_receive(:foo)
-      formatter.should_not_receive(:bar)
+      expect(formatter).to receive(:foo)
+      expect(formatter).to_not receive(:bar)
       subject.process('{"_teaspoon":true,"type":"foo"}')
       subject.process('{"_teaspoon":false,"type":"bar"}')
     end
 
     it "notifies formatters of console output when it doesn't understand the log" do
-      formatter.should_receive(:console).with("_line_")
-      subject.should_receive(:result_from_line).and_return(false)
+      expect(formatter).to receive(:console).with("_line_")
+      expect(subject).to receive(:result_from_line).and_return(false)
       subject.process("_line_")
     end
 
     it "handles bad json" do
-      formatter.should_receive(:console).with("{bad: true}")
+      expect(formatter).to receive(:console).with("{bad: true}")
       subject.process("{bad: true}")
     end
 
     it "handles json when it's not intended for it" do
-      formatter.should_receive(:console).with('{"good": true}')
+      expect(formatter).to receive(:console).with('{"good": true}')
       subject.process('{"good": true}')
     end
 
@@ -77,8 +77,11 @@ describe Teaspoon::Runner do
     describe "with an exception" do
 
       it "notifies itself, and raises Teaspoon::RunnerException" do
-        subject.should_receive(:on_exception).and_call_original
-        expect { subject.process('{"_teaspoon":true,"type":"exception","message":"_message_"}') }.to raise_error Teaspoon::RunnerException, "_message_"
+        expect(subject).to receive(:on_exception).and_call_original
+        expect { subject.process('{"_teaspoon":true,"type":"exception","message":"_message_"}') }.to raise_error(
+          Teaspoon::RunnerException,
+          "_message_"
+        )
       end
 
     end
@@ -86,22 +89,22 @@ describe Teaspoon::Runner do
     describe "with a result" do
 
       before do
-        Teaspoon::Coverage.stub(:new).and_return(coverage)
+        allow(Teaspoon::Coverage).to receive(:new).and_return(coverage)
       end
 
       it "notifies itself" do
-        subject.should_receive(:on_result)
+        expect(subject).to receive(:on_result)
         subject.process('{"_teaspoon":true,"type":"result"}')
       end
 
       it "resolves coverage" do
-        Teaspoon.configuration.should_receive(:use_coverage).twice.and_return("_coverage_config_")
-        Teaspoon::Coverage.should_receive(:new).with(:default, "_coverage_config_", "_coverage_").and_return(coverage)
-        coverage.should_receive(:generate_reports).and_yield("_generated_reports_")
-        coverage.should_receive(:check_thresholds).and_yield("_threshold_failures_")
-        subject.should_receive(:notify_formatters).once.with("coverage", "_generated_reports_")
-        subject.should_receive(:notify_formatters).once.with("threshold_failure", "_threshold_failures_")
-        subject.should_receive(:notify_formatters).exactly(2).times.and_call_original
+        expect(Teaspoon.configuration).to receive(:use_coverage).twice.and_return("_config_")
+        expect(Teaspoon::Coverage).to receive(:new).with(:default, "_config_", "_coverage_").and_return(coverage)
+        expect(coverage).to receive(:generate_reports).and_yield("_generated_reports_")
+        expect(coverage).to receive(:check_thresholds).and_yield("_threshold_failures_")
+        expect(subject).to receive(:notify_formatters).once.with("coverage", "_generated_reports_")
+        expect(subject).to receive(:notify_formatters).once.with("threshold_failure", "_threshold_failures_")
+        expect(subject).to receive(:notify_formatters).exactly(2).times.and_call_original
         subject.process('{"_teaspoon":true,"type":"result","coverage":"_coverage_"}')
         expect(subject.failure_count).to eq(1)
       end

data/spec/teaspoon/server_spec.rb

@@ -11,31 +11,31 @@ describe Teaspoon::Server do
     let(:server) { double(start: nil) }
 
     before do
-      Thread.stub(:new) { |&b| @block = b; "_thread_" }
-      subject.stub(wait_until_started: nil)
+      allow(Thread).to receive(:new) { |&b| @block = b; "_thread_" }
+      allow(subject).to receive(:wait_until_started).and_return(nil)
     end
 
     it "spawns a thread" do
-      Thread.should_receive(:new)
+      expect(Thread).to receive(:new)
       subject.start
     end
 
     it "starts a rack server" do
-      Rack::Server.should_receive(:new).and_return(server)
-      server.should_receive(:start)
+      expect(Rack::Server).to receive(:new).and_return(server)
+      expect(server).to receive(:start)
 
       subject.start
       @block.call
     end
 
     it "waits until the server is started" do
-      Thread.should_receive(:new)
-      subject.should_receive(:wait_until_started).with("_thread_")
+      expect(Thread).to receive(:new)
+      expect(subject).to receive(:wait_until_started).with("_thread_")
       subject.start
     end
 
     it "rescues errors" do
-      Thread.should_receive(:new).and_raise("OMG!")
+      expect(Thread).to receive(:new).and_raise("OMG!")
       expect { subject.start }.to raise_error("Cannot start server: OMG!")
     end
 
@@ -48,16 +48,19 @@ describe Teaspoon::Server do
         Logger: Rails.logger,
         server: Teaspoon.configuration.server
       }
-      Rack::Server.should_receive(:new).with(expected_opts).and_return(server)
+      expect(Rack::Server).to receive(:new).with(expected_opts).and_return(server)
 
       subject.start
       @block.call
     end
 
     it "raises a ServerException if the timeout fails" do
-      subject.should_receive(:wait_until_started).and_call_original
-      Timeout.should_receive(:timeout).with(Teaspoon.configuration.server_timeout.to_i).and_raise(Timeout::Error)
-      expect{ subject.start }.to raise_error Teaspoon::ServerException
+      expect(subject).to receive(:wait_until_started).and_call_original
+      expect(Timeout).to receive(:timeout).with(Teaspoon.configuration.server_timeout.to_i).and_raise(Timeout::Error)
+      expect { subject.start }.to raise_error(
+        Teaspoon::ServerException,
+        "Server failed to start. You may need to increase the timeout configuration."
+      )
     end
 
   end
@@ -68,8 +71,8 @@ describe Teaspoon::Server do
 
     it "checks a local port to see if a server is running" do
       subject.port = 31337
-      TCPSocket.should_receive(:new).with("127.0.0.1", 31337).and_return(socket)
-      socket.should_receive(:close)
+      expect(TCPSocket).to receive(:new).with("127.0.0.1", 31337).and_return(socket)
+      expect(socket).to receive(:close)
       subject.responsive?
     end
 
@@ -87,8 +90,8 @@ describe Teaspoon::Server do
   describe "integration" do
 
     before do
-      Teaspoon.configuration.stub(:suite_configs).and_return("foo" => {block: proc{}})
-      Teaspoon.configuration.stub(:suppress_log).and_return(true)
+      allow(Teaspoon.configuration).to receive(:suite_configs).and_return("foo" => { block: proc {} })
+      allow(Teaspoon.configuration).to receive(:suppress_log).and_return(true)
     end
 
     it "really starts a server" do

data/spec/teaspoon/suite_spec.rb

@@ -3,14 +3,15 @@ require "spec_helper"
 describe Teaspoon::Suite do
 
   before do
-    Teaspoon.configuration.stub(:suite_configs).and_return("default" => {block: proc{}})
+    allow(Teaspoon.configuration).to receive(:suite_configs).and_return("default" => { block: proc {} })
   end
 
   describe ".all" do
 
     before do
       Teaspoon::Suite.instance_variable_set(:@all, nil)
-      Teaspoon.configuration.stub(:suite_configs).and_return("default" => {block: proc{}}, "foo" => {block: proc{}})
+      suites = { "default" => { block: proc {} }, "foo" => { block: proc {} } }
+      allow(Teaspoon.configuration).to receive(:suite_configs).and_return(suites)
     end
 
     it "returns all the suites" do
@@ -35,7 +36,11 @@ describe Teaspoon::Suite do
       result = Teaspoon::Suite.resolve_spec_for("base")
       expect(result[:suite]).to eq("default")
       dirs = ["base/fixture_spec.", "base/runner_spec.", "base/teaspoon_spec"]
-      expect(dirs.all? { |path| result[:path].grep(/#{path}/)[0] }).to be_true
+      expect(dirs.all? { |path| result[:path].grep(/#{path}/)[0] }).to be_truthy
+    end
+
+    it "returns false if the spec wasn't found" do
+      expect(Teaspoon::Suite.resolve_spec_for("foo")).to be_falsey
     end
 
   end
@@ -48,7 +53,8 @@ describe Teaspoon::Suite do
     end
 
     it "accepts a suite in the options" do
-      Teaspoon.configuration.should_receive(:suite_configs).and_return("test" => {block: proc{ |s| s.helper = "helper_file" }})
+      suite = { "test" => { block: proc { |s| s.helper = "helper_file" } } }
+      expect(Teaspoon.configuration).to receive(:suite_configs).and_return(suite)
       subject = Teaspoon::Suite.new(suite: :test)
       expect(subject.name).to eql("test")
       expect(subject.config.helper).to eq("helper_file")
@@ -60,12 +66,12 @@ describe Teaspoon::Suite do
 
     it "returns an array of hashes with the filename and the asset name" do
       file = Teaspoon::Engine.root.join("spec/javascripts/teaspoon/base/reporters/console_spec.js").to_s
-      subject.should_receive(:glob).and_return([file])
+      expect(subject).to receive(:glob).and_return([file])
       expect(subject.spec_files[0]).to eql(path: file, name: "teaspoon/base/reporters/console_spec.js")
     end
 
     it "raises an exception if the file isn't servable (in an asset path)" do
-      subject.should_receive(:glob).and_return(["/foo"])
+      expect(subject).to receive(:glob).and_return(["/foo"])
       expect { subject.spec_files[0] }.to raise_error Teaspoon::AssetNotServable
     end
 
@@ -79,13 +85,14 @@ describe Teaspoon::Suite do
       expect(result).to include("teaspoon/base/reporters/console_spec.js?body=1")
     end
 
-    it "returns just a file if one was requests" do
+    it "returns just a file if one was requested" do
       subject.instance_variable_set(:@options, file: "spec/javascripts/foo.js")
       result = subject.spec_assets(false)
       expect(result).to eql(["foo.js"])
     end
 
     it "returns the asset tree (all dependencies resolved) if we want coverage" do
+      allow(subject).to receive(:no_coverage).and_return([%r{support/}, "spec_helper.coffee"])
       subject.instance_variable_set(:@options, coverage: true)
       result = subject.spec_assets(true)
       expect(result).to include("support/json2.js?body=1")
@@ -93,6 +100,12 @@ describe Teaspoon::Suite do
       expect(result).to include("drivers/phantomjs/runner.js?body=1&instrument=1")
     end
 
+    it "returns only the top level assets in the asset tree if config/expand_assets is set to false" do
+      allow(subject.config).to receive(:expand_assets).and_return(false)
+      result = subject.spec_assets(true)
+      expect(result.any? { |file| file =~ /body=1/ }).to eq(false)
+    end
+
   end
 
   describe "#include_spec?" do
@@ -112,11 +125,12 @@ describe Teaspoon::Suite do
     end
 
     it "returns a list of specs when the file name looks like it could be a match" do
-      expect( subject.include_spec_for?('fixture_spec').any? { |file| file.include?('fixture_spec.coffee') }).to be_true
+      files = subject.include_spec_for?("fixture_spec")
+      expect(files.any? { |file| file.include?("fixture_spec.coffee") }).to be_truthy
     end
 
     it "returns false if a matching spec isn't found" do
-      expect(subject.include_spec_for?('_not_a_match_')).to eq(false)
+      expect(subject.include_spec_for?("_not_a_match_")).to eq(false)
     end
 
   end

data/spec/teaspoon_env.rb

@@ -6,10 +6,11 @@ end
 
 Teaspoon.configure do |config|
   config.root = Teaspoon::Engine.root
-  config.asset_paths << Teaspoon::Engine.root.join('lib/teaspoon')
+  config.asset_paths << Teaspoon::Engine.root.join("lib/teaspoon")
 
   config.suite do |suite|
-    suite.matcher = "{spec/javascripts,spec/dummy/app/assets/javascripts/specs}/**/*_spec.{js,js.coffee,coffee,js.coffee.erb}"
+    roots = "spec/javascripts,spec/dummy/app/assets/javascripts/specs"
+    suite.matcher = "{#{roots}}/**/*_spec.{js,js.coffee,coffee,js.coffee.erb}"
     suite.javascripts = ["jasmine/1.3.1", "teaspoon/jasmine"]
   end
 
@@ -31,14 +32,8 @@ Teaspoon.configure do |config|
     suite.helper = "qunit_helper"
   end
 
-  config.suite :angular do |suite|
-    suite.matcher = "spec/javascripts/**/*_aspec.{js,js.coffee,coffee}"
-    suite.javascripts = ["angular/1.0.5", "teaspoon/angular"]
-    suite.helper = "angular_helper"
-  end
-
-  #config.suite :integration do |suite|
-  #  suite.matcher = "spec/dummy/app/assets/javascripts/integration/*_spec.{js,js.coffee,coffee}"
-  #  suite.helper = nil
-  #end
+  # config.suite :integration do |suite|
+  #   suite.matcher = "spec/dummy/app/assets/javascripts/integration/*_spec.{js,js.coffee,coffee}"
+  #   suite.helper = nil
+  # end
 end

data/test/javascripts/teaspoon/qunit/models_test.coffee

@@ -3,6 +3,8 @@ module "QUnit Teaspoon.Spec",
     @mockAssertions = [
       {message: "_qunit_message1_", source: "_source1_"}
       {message: "_qunit_message2_", source: "_source2_"}
+      {source: "_source3_", expected: 1, actual: 2}
+      {source: "_source4_"}
     ]
     @mockSpec =
       module: "_full qunit name_"
@@ -23,11 +25,13 @@ test "constructor", 7, ->
   ok(spec.viewId == 420, "sets viewId")
   ok(spec.pending == false, "sets pending to false") # no pending support
 
-test "#errors", 3, ->
+test "#errors", 5, ->
   errors = new Teaspoon.Spec(@mockSpec).errors()
-  ok(errors.length == 2, "returns the correct length array")
+  ok(errors.length == 4, "returns the correct length array")
   equal(errors[0].message, "_qunit_message1_", "the first item in the returned array is correct")
   equal(errors[0].stack, "_source1_", "the first item in the returned array is correct")
+  equal(errors[2].message, "Expected 2 to equal 1", "a nice fallback message is provided if QUnit does not provide one")
+  equal(errors[3].message, "failed", "some fallback message is provided if QUnit does not provide any information")
 
 test "#getParents", 3, ->
   spec = new Teaspoon.Spec(@mockSpec)