teaspoon 0.8.0 → 0.9.0

data/spec/teaspoon/drivers/capybara_webkit_driver_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Teaspoon::Drivers::CapybaraWebkitDriver do
+
+  describe "#run_specs" do
+
+    let(:runner) { double }
+    let(:document) { double }
+    let(:session) { instance_double(Capybara::Session) }
+
+    before do
+      allow(subject).to receive(:session).and_return session
+      allow(session).to receive(:visit)
+      allow(session).to receive(:document).and_return(document)
+      allow(session).to receive(:evaluate_script)
+      allow(document).to receive(:synchronize).and_yield
+    end
+
+    it "navigates to the correct url" do
+      expect(session).to receive(:visit).with("_url_")
+      subject.run_specs(runner, "_url_")
+    end
+
+    it "waits for the specs to complete setting the timeout" do
+      expect(document).to receive(:synchronize).with(180).and_yield
+      subject.run_specs(runner, "_url_")
+    end
+
+    it "waits until it's done (checking Teaspoon.finished) and processes each line" do
+      expect(document).to receive(:synchronize).with(180).and_yield
+      expect(session).to receive(:evaluate_script).with("window.Teaspoon && window.Teaspoon.finished").and_return(true)
+      expect(session).to receive(:evaluate_script).with("window.Teaspoon && window.Teaspoon.getMessages()").and_return(["_line_"])
+      expect(runner).to receive(:process).with("_line_\n")
+      subject.run_specs(runner, "_url_")
+    end
+
+  end
+
+end

data/spec/teaspoon/drivers/phantomjs_driver_spec.rb

@@ -32,15 +32,20 @@ describe Teaspoon::Drivers::PhantomjsDriver do
       let(:runner) { double }
 
       before do
-        subject.stub(:run)
+        allow(subject).to receive(:run)
       end
 
       it "calls #run and calls runner.process with each line of output" do
         subject.instance_variable_set(:@options, ["--foo", "--bar"])
-        args = ["--foo", "--bar", Teaspoon::Engine.root.join("lib/teaspoon/drivers/phantomjs/runner.js").to_s, "_url_", 180]
-        runner.should_receive(:process).with("_line_")
+        args = [
+          "--foo",
+          "--bar",
+          %{"#{Teaspoon::Engine.root.join("lib/teaspoon/drivers/phantomjs/runner.js").to_s}"},
+          '"_url_"',
+          180]
+        expect(runner).to receive(:process).with("_line_")
         @block = nil
-        subject.should_receive(:run).with(*args) { |&b| @block = b }
+        expect(subject).to receive(:run).with(*args) { |&b| @block = b }
         subject.run_specs(runner, "_url_")
         @block.call("_line_")
       end
@@ -50,7 +55,7 @@ describe Teaspoon::Drivers::PhantomjsDriver do
     context "without phantomjs" do
 
       it "raises a MissingDependency exception" do
-        subject.should_receive(:which).and_return(nil)
+        expect(subject).to receive(:which).and_return(nil)
         expect { subject.run_specs(:default, "_url_") }.to raise_error Teaspoon::MissingDependency
       end
 

data/spec/teaspoon/drivers/selenium_driver_spec.rb

@@ -30,35 +30,35 @@ describe Teaspoon::Drivers::SeleniumDriver do
 
     before do
       @driver = double(quit: nil, navigate: @navigate = double(to: nil), execute_script: nil)
-      Selenium::WebDriver.stub(:for).and_return(@driver)
-      Selenium::WebDriver::Wait.stub(:new).and_return(@wait = double(until: nil))
+      allow(Selenium::WebDriver).to receive(:for).and_return(@driver)
+      allow(Selenium::WebDriver::Wait).to receive(:new).and_return(@wait = double(until: nil))
     end
 
     it "loads firefox for the webdriver" do
-      Selenium::WebDriver.should_receive(:for).with(:firefox)
+      expect(Selenium::WebDriver).to receive(:for).with(:firefox)
       subject.run_specs(runner, "_url_")
     end
 
     it "navigates to the correct url" do
-      @navigate.should_receive(:to).with("_url_")
+      expect(@navigate).to receive(:to).with("_url_")
       subject.run_specs(runner, "_url_")
     end
 
     it "ensures quit is called on the driver" do
-      @driver.should_receive(:quit)
+      expect(@driver).to receive(:quit)
       subject.run_specs(runner, "_url_")
     end
 
     it "waits for the specs to complete, setting the interval, timeout and message" do
-      Selenium::WebDriver::Wait.should_receive(:new).with(HashWithIndifferentAccess.new(client_driver: :firefox, timeout: 180, interval: 0.01, message: "Timed out"))
+      expect(Selenium::WebDriver::Wait).to receive(:new).with(HashWithIndifferentAccess.new(client_driver: :firefox, timeout: 180, interval: 0.01, message: "Timed out"))
       subject.run_specs(runner, "_url_")
     end
 
     it "waits until it's done (checking Teaspoon.finished) and processes each line" do
-      @wait.should_receive(:until) { |&b| @block = b }
-      @driver.should_receive(:execute_script).with("return window.Teaspoon && window.Teaspoon.finished").and_return(true)
-      @driver.should_receive(:execute_script).with("return window.Teaspoon && window.Teaspoon.getMessages() || []").and_return(["_line_"])
-      runner.should_receive(:process).with("_line_\n")
+      expect(@wait).to receive(:until) { |&b| @block = b }
+      expect(@driver).to receive(:execute_script).with("return window.Teaspoon && window.Teaspoon.finished").and_return(true)
+      expect(@driver).to receive(:execute_script).with("return window.Teaspoon && window.Teaspoon.getMessages() || []").and_return(["_line_"])
+      expect(runner).to receive(:process).with("_line_\n")
       subject.run_specs(runner, "_url_")
       @block.call
     end

data/spec/teaspoon/environment_spec.rb

@@ -8,20 +8,20 @@ describe Teaspoon::Environment do
   describe ".load" do
 
     it "calls require_environment" do
-      subject.should_receive(:require_environment)
-      subject.should_receive(:rails_loaded?).and_return(true)
+      expect(subject).to receive(:require_environment)
+      expect(subject).to receive(:rails_loaded?).and_return(true)
       Teaspoon::Environment.load
     end
 
     it "raises if Rails can't be found" do
-      subject.should_receive(:require_environment)
-      subject.should_receive(:rails_loaded?).and_return(false)
+      expect(subject).to receive(:require_environment)
+      expect(subject).to receive(:rails_loaded?).and_return(false)
       expect{ Teaspoon::Environment.load }.to raise_error("Rails environment not found.")
     end
 
     it "configures teaspoon from options if the environment is ready" do
-      subject.should_receive(:rails_loaded?).and_return(true)
-      Teaspoon.configuration.should_receive(:override_from_options).with(foo: "bar")
+      expect(subject).to receive(:rails_loaded?).and_return(true)
+      expect(Teaspoon.configuration).to receive(:override_from_options).with(foo: "bar")
       Teaspoon::Environment.load(foo: "bar")
     end
 
@@ -30,8 +30,8 @@ describe Teaspoon::Environment do
   describe ".require_environment" do
 
     before do
-      File.stub(:exists?)
-      subject.stub(:require_env)
+      allow(File).to receive(:exists?)
+      allow(subject).to receive(:require_env)
       Teaspoon.configured = false
       @orig_teaspoon_env = ENV['TEASPOON_ENV']
       ENV['TEASPOON_ENV'] = nil
@@ -45,18 +45,18 @@ describe Teaspoon::Environment do
     describe "when loading with an override" do
 
       before do
-        subject.should_receive(:require_env).and_call_original
+        expect(subject).to receive(:require_env).and_call_original
       end
 
       it "allows passing an override" do
         expanded = File.expand_path("_override_", Dir.pwd)
-        ::Kernel.should_receive(:load).with(expanded)
+        expect(::Kernel).to receive(:load).with(expanded)
         subject.require_environment("_override_")
       end
 
       it "sets the TEASPOON_ENV" do
         expanded = File.expand_path("../../_override_file_", Dir.pwd)
-        ::Kernel.should_receive(:load).with(expanded)
+        expect(::Kernel).to receive(:load).with(expanded)
         subject.require_environment("../../_override_file_")
         expect(ENV["TEASPOON_ENV"]).to eq(expanded)
       end
@@ -66,19 +66,19 @@ describe Teaspoon::Environment do
     describe "when loading from defaults" do
 
       it "looks for the standard files" do
-        File.should_receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(true)
-        subject.should_receive(:require_env).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd))
+        expect(File).to receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(true)
+        expect(subject).to receive(:require_env).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd))
         subject.require_environment
 
-        File.should_receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(false)
-        File.should_receive(:exists?).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd)).and_return(true)
-        subject.should_receive(:require_env).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd))
+        expect(File).to receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(false)
+        expect(File).to receive(:exists?).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd)).and_return(true)
+        expect(subject).to receive(:require_env).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd))
         subject.require_environment
 
-        File.should_receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(false)
-        File.should_receive(:exists?).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd)).and_return(false)
-        File.should_receive(:exists?).with(File.expand_path("teaspoon_env.rb", Dir.pwd)).and_return(true)
-        subject.should_receive(:require_env).with(File.expand_path("teaspoon_env.rb", Dir.pwd))
+        expect(File).to receive(:exists?).with(File.expand_path("spec/teaspoon_env.rb", Dir.pwd)).and_return(false)
+        expect(File).to receive(:exists?).with(File.expand_path("test/teaspoon_env.rb", Dir.pwd)).and_return(false)
+        expect(File).to receive(:exists?).with(File.expand_path("teaspoon_env.rb", Dir.pwd)).and_return(true)
+        expect(subject).to receive(:require_env).with(File.expand_path("teaspoon_env.rb", Dir.pwd))
         subject.require_environment
       end
 
@@ -98,4 +98,12 @@ describe Teaspoon::Environment do
 
   end
 
+  describe ".rails_loaded?" do
+
+    it "returns a boolean based on if Rails is defined" do
+      expect(subject.send(:rails_loaded?)).to be_truthy
+    end
+
+  end
+
 end

data/spec/teaspoon/exceptions_spec.rb

@@ -17,21 +17,21 @@ describe Teaspoon::ExceptionHandling do
   describe ".add_rails_handling" do
 
     before do
-      subject.stub(:render_exceptions_with_javascript)
+      allow(subject).to receive(:render_exceptions_with_javascript)
     end
 
     it "sets config.assets.debug to false" do
       subject.add_rails_handling
-      expect(Rails.application.config.assets.debug).to be_false
+      expect(Rails.application.config.assets.debug).to be_falsey
     end
 
     it "sets config.action_dispatch.show_exceptions to true" do
       subject.add_rails_handling
-      expect(Rails.application.config.action_dispatch.show_exceptions).to be_true
+      expect(Rails.application.config.action_dispatch.show_exceptions).to be_truthy
     end
 
     it "calls #render_exceptions_with_javascript" do
-      subject.should_receive(:render_exceptions_with_javascript)
+      expect(subject).to receive(:render_exceptions_with_javascript)
       subject.add_rails_handling
     end
 

data/spec/teaspoon/exporter_spec.rb

@@ -22,34 +22,34 @@ describe Teaspoon::Exporter do
   describe "#export" do
 
     before do
-      Dir.should_receive(:mktmpdir).and_yield("_temp_path_")
-      subject.stub(:executable).and_return("/path/to/executable")
-      subject.stub(:`)
+      expect(Dir).to receive(:mktmpdir).and_yield("_temp_path_")
+      allow(subject).to receive(:executable).and_return("/path/to/executable")
+      allow(subject).to receive(:`)
     end
 
     it "makes a temp directory and cds to it" do
-      Dir.should_receive(:chdir).with("_temp_path_")
+      expect(Dir).to receive(:chdir).with("_temp_path_")
       subject.export
     end
 
     it "executes the wget call and creates the export" do
       `(exit 0)`
-      Dir.should_receive(:chdir).with("_temp_path_").and_yield
-      subject.should_receive(:`).with("/path/to/executable --convert-links --adjust-extension --page-requisites --span-hosts http://666.420.42.0:31337/url/to/teaspoon 2>&1")
-      subject.should_receive(:create_export).with("_temp_path_/666.420.42.0:31337")
+      expect(Dir).to receive(:chdir).with("_temp_path_").and_yield
+      expect(subject).to receive(:`).with("/path/to/executable --convert-links --adjust-extension --page-requisites --span-hosts http://666.420.42.0:31337/url/to/teaspoon 2>&1")
+      expect(subject).to receive(:create_export).with("_temp_path_/666.420.42.0:31337")
       subject.export
     end
 
     it "raises a Teaspoon::ExporterException if the command failed for some reason" do
       `(exit 1)`
-      Dir.should_receive(:chdir).with("_temp_path_").and_yield
+      expect(Dir).to receive(:chdir).with("_temp_path_").and_yield
       expect { subject.export }.to raise_error Teaspoon::ExporterException, "Unable to export suite_name suite."
     end
 
     it "raises a Teaspoon::MissingDependency if wget wasn't found" do
-      Dir.should_receive(:chdir).with("_temp_path_").and_yield
-      subject.should_receive(:executable).and_call_original
-      subject.should_receive(:which).with("wget").and_return(nil)
+      expect(Dir).to receive(:chdir).with("_temp_path_").and_yield
+      expect(subject).to receive(:executable).and_call_original
+      expect(subject).to receive(:which).with("wget").and_return(nil)
       expect { subject.export }.to raise_error Teaspoon::MissingDependency, "Could not find wget for exporting."
     end
 
@@ -57,35 +57,35 @@ describe Teaspoon::Exporter do
 
       before do
         `(exit 0)`
-        Dir.should_receive(:chdir).with("_temp_path_").and_yield
-        Dir.should_receive(:chdir).with("_temp_path_/666.420.42.0:31337").and_yield
-
-        File.stub(:read).and_return("")
-        File.stub(:write)
-        FileUtils.stub(:mkdir_p)
-        FileUtils.stub(:rm_r)
-        FileUtils.stub(:mv)
+        expect(Dir).to receive(:chdir).with("_temp_path_").and_yield
+        expect(Dir).to receive(:chdir).with("_temp_path_/666.420.42.0:31337").and_yield
+
+        allow(File).to receive(:read).and_return("")
+        allow(File).to receive(:write)
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(FileUtils).to receive(:rm_r)
+        allow(FileUtils).to receive(:mv)
       end
 
       it "updates the relative paths" do
-        File.should_receive(:read).with(".#{Teaspoon.configuration.mount_at}/suite_name.html").and_return('"../../path/to/asset')
-        File.should_receive(:write).with("index.html", '"../path/to/asset')
+        expect(File).to receive(:read).with(".#{Teaspoon.configuration.mount_at}/suite_name.html").and_return('"../../path/to/asset')
+        expect(File).to receive(:write).with("index.html", '"../path/to/asset')
         subject.export
       end
 
       it "cleans up the old files" do
-        subject.stub(:move_output)
-        Dir.should_receive(:[]).once.with("{.#{Teaspoon.configuration.mount_at},robots.txt.html}").and_return(["./teaspoon", "robots.txt.html"])
-        FileUtils.should_receive(:rm_r).with(["./teaspoon", "robots.txt.html"])
+        allow(subject).to receive(:move_output)
+        expect(Dir).to receive(:[]).once.with("{.#{Teaspoon.configuration.mount_at},robots.txt.html}").and_return(["./teaspoon", "robots.txt.html"])
+        expect(FileUtils).to receive(:rm_r).with(["./teaspoon", "robots.txt.html"])
         subject.export
       end
 
       it "moves the files into the output path" do
-        subject.stub(:cleanup_output)
+        allow(subject).to receive(:cleanup_output)
         output_path = subject.instance_variable_get(:@output_path)
-        Dir.should_receive(:[]).and_return(["1", "2"])
-        FileUtils.should_receive(:mkdir_p).with(output_path)
-        FileUtils.should_receive(:mv).with(["1", "2"], output_path, force: true)
+        expect(Dir).to receive(:[]).and_return(["1", "2"])
+        expect(FileUtils).to receive(:mkdir_p).with(output_path)
+        expect(FileUtils).to receive(:mv).with(["1", "2"], output_path, force: true)
         subject.export
       end
 

data/spec/teaspoon/formatters/base_spec.rb

@@ -9,7 +9,7 @@ describe Teaspoon::Formatters::Base do
 
   before do
     @log = ""
-    STDOUT.stub(:print) { |s| @log << s }
+    allow(STDOUT).to receive(:print) { |s| @log << s }
   end
 
   describe "#initialize" do
@@ -17,7 +17,7 @@ describe Teaspoon::Formatters::Base do
     subject { Teaspoon::Formatters::Base.new(:foo, "_output_file_") }
 
     before do
-      File.stub(:open)
+      allow(File).to receive(:open)
     end
 
     it "assigns various instance vars" do
@@ -38,7 +38,7 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "writes a new output file if one is specified" do
-      File.should_receive(:open).with("_output_file_", "w")
+      expect(File).to receive(:open).with("_output_file_", "w")
       subject
     end
 
@@ -54,10 +54,10 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "calls #log_runner when appropriate" do
-      subject.should_receive(:log_runner).with(result)
+      expect(subject).to receive(:log_runner).with(result)
       subject.runner(result)
 
-      subject.should_not_receive(:log_runner)
+      expect(subject).to_not receive(:log_runner)
       subject.runner(result, false)
     end
 
@@ -72,10 +72,10 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "calls #log_suite when appropriate" do
-      subject.should_receive(:log_suite).with(result)
+      expect(subject).to receive(:log_suite).with(result)
       subject.suite(result)
 
-      subject.should_not_receive(:log_suite)
+      expect(subject).to_not receive(:log_suite)
       subject.suite(result, false)
     end
 
@@ -109,10 +109,10 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "calls #log_spec when appropriate" do
-      subject.should_receive(:log_spec).with(failing_spec)
+      expect(subject).to receive(:log_spec).with(failing_spec)
       subject.spec(failing_spec)
 
-      subject.should_not_receive(:log_spec)
+      expect(subject).to_not receive(:log_spec)
       subject.spec(failing_spec, false)
     end
 
@@ -132,10 +132,10 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "calls #log_error when appropriate" do
-      subject.should_receive(:log_error).with(result)
+      expect(subject).to receive(:log_error).with(result)
       subject.error(result)
 
-      subject.should_not_receive(:log_error)
+      expect(subject).to_not receive(:log_error)
       subject.error(result, false)
     end
 
@@ -144,10 +144,10 @@ describe Teaspoon::Formatters::Base do
   describe "#exception" do
 
     it "calls #log_exception when appropriate" do
-      subject.should_receive(:log_exception).with(result)
+      expect(subject).to receive(:log_exception).with(result)
       subject.exception(result)
 
-      subject.should_not_receive(:log_exception)
+      expect(subject).to_not receive(:log_exception)
       subject.exception(result, false)
     end
 
@@ -162,10 +162,10 @@ describe Teaspoon::Formatters::Base do
     end
 
     it "calls #log_console when appropriate" do
-      subject.should_receive(:log_console).with("_message_")
+      expect(subject).to receive(:log_console).with("_message_")
       subject.console("_message_")
 
-      subject.should_not_receive(:log_console)
+      expect(subject).to_not receive(:log_console)
       subject.console("_message_", false)
     end
 
@@ -176,10 +176,10 @@ describe Teaspoon::Formatters::Base do
     let(:result) { double(coverage: nil) }
 
     it "calls #log_result when appropriate" do
-      subject.should_receive(:log_result).with(result)
+      expect(subject).to receive(:log_result).with(result)
       subject.result(result)
 
-      subject.should_not_receive(:log_result)
+      expect(subject).to_not receive(:log_result)
       subject.result(result, false)
     end
 
@@ -188,10 +188,10 @@ describe Teaspoon::Formatters::Base do
   describe "#coverage" do
 
     it "calls #log_coverage when appropriate" do
-      subject.should_receive(:log_coverage).with("_message_")
+      expect(subject).to receive(:log_coverage).with("_message_")
       subject.coverage("_message_")
 
-      subject.should_receive(:log_coverage).with("_message_")
+      expect(subject).to receive(:log_coverage).with("_message_")
       subject.coverage("_message_")
     end
 
@@ -200,10 +200,10 @@ describe Teaspoon::Formatters::Base do
   describe "#threshold_failure" do
 
     it "calls #log_threshold_failure when appropriate" do
-      subject.should_receive(:log_threshold_failure).with("_message_")
+      expect(subject).to receive(:log_threshold_failure).with("_message_")
       subject.threshold_failure("_message_")
 
-      subject.should_receive(:log_threshold_failure).with("_message_")
+      expect(subject).to receive(:log_threshold_failure).with("_message_")
       subject.threshold_failure("_message_")
     end
 
@@ -212,10 +212,10 @@ describe Teaspoon::Formatters::Base do
   describe "#complete" do
 
     it "calls #log_complete when appropriate" do
-      subject.should_receive(:log_complete).with(42)
+      expect(subject).to receive(:log_complete).with(42)
       subject.complete(42)
 
-      subject.should_receive(:log_complete).with(0)
+      expect(subject).to receive(:log_complete).with(0)
       subject.complete(0)
     end
 
@@ -224,17 +224,17 @@ describe Teaspoon::Formatters::Base do
   describe "#log_spec" do
 
     it "calls #log_passing_spec on passing results" do
-      subject.should_receive(:log_passing_spec).with(passing_spec)
+      expect(subject).to receive(:log_passing_spec).with(passing_spec)
       subject.send(:log_spec, passing_spec)
     end
 
     it "calls #log_pending_spec on pending results" do
-      subject.should_receive(:log_pending_spec).with(pending_spec)
+      expect(subject).to receive(:log_pending_spec).with(pending_spec)
       subject.send(:log_spec, pending_spec)
     end
 
     it "calls #log_failing_spec on failing results" do
-      subject.should_receive(:log_failing_spec).with(failing_spec)
+      expect(subject).to receive(:log_failing_spec).with(failing_spec)
       subject.send(:log_spec, failing_spec)
     end
 
@@ -244,13 +244,13 @@ describe Teaspoon::Formatters::Base do
 
     it "logs to a file" do
       handle = double(write: nil)
-      File.should_receive(:open).with("_output_file_", "a").and_yield(handle)
-      handle.should_receive(:write).with("_str_")
+      expect(File).to receive(:open).with("_output_file_", "a").and_yield(handle)
+      expect(handle).to receive(:write).with("_str_")
       subject.send(:log_to_file, "_str_", "_output_file_")
     end
 
     it "raises a Teaspoon::FileNotWritable exception if the file can't be written to" do
-      File.should_receive(:open).and_raise(IOError, "_io_error_message_")
+      expect(File).to receive(:open).and_raise(IOError, "_io_error_message_")
       expect { subject.send(:log_to_file, "_str_", "_output_file_") }.to raise_error(Teaspoon::FileNotWritable, "_io_error_message_")
     end