teaspoon 0.7.9 → 0.8.0

data/spec/teaspoon/drivers/selenium_driver_spec.rb

@@ -1,57 +1,65 @@
 require "spec_helper"
-require "teaspoon/drivers/selenium_driver"
 
 describe Teaspoon::Drivers::SeleniumDriver do
 
-  describe "#run_specs" do
+  describe "#initialize" do
 
-    before do
-      @navigate = double(to: nil)
-      @driver = double(quit: nil, navigate: @navigate, execute_script: nil)
-      Selenium::WebDriver.stub(:for).and_return(@driver)
-      @wait = double(until: nil)
-      Selenium::WebDriver::Wait.stub(:new).and_return(@wait)
+    it "assigns @options" do
+      subject = Teaspoon::Drivers::SeleniumDriver.new(foo: "bar")
+      expect(subject.instance_variable_get(:@options)).to eq(foo: "bar")
+    end
+
+    it "accepts a string for options" do
+      subject = Teaspoon::Drivers::SeleniumDriver.new('{"foo":"bar"}')
+      expect(subject.instance_variable_get(:@options)).to eq("foo" => "bar")
+    end
+
+    it "raises a Teaspoon::UnknownDriverOptions exception if the options aren't understood" do
+      expect { Teaspoon::Drivers::SeleniumDriver.new(true) }.to raise_error(Teaspoon::UnknownDriverOptions)
     end
 
-    it "instantiates the formatter" do
-      runner = double(failure_count: nil)
-      Teaspoon::Runner.should_receive(:new).and_return(runner)
-      subject.run_specs(:default, "_url_")
+    it "raises a Teaspoon::UnknownDriverOptions exception if the options aren't parseable" do
+      expect { Teaspoon::Drivers::SeleniumDriver.new("{foo:bar}") }.to raise_error(Teaspoon::UnknownDriverOptions)
     end
 
-    it "returns the number of failures from the runner" do
-      runner = double(failure_count: 42)
-      Teaspoon::Runner.should_receive(:new).and_return(runner)
-      expect(subject.run_specs(:default, "_url_")).to be(42)
+  end
+
+  describe "#run_specs" do
+
+    let(:runner) { double }
+
+    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))
     end
 
     it "loads firefox for the webdriver" do
       Selenium::WebDriver.should_receive(:for).with(:firefox)
-      subject.run_specs(:default, "_url_")
+      subject.run_specs(runner, "_url_")
     end
 
     it "navigates to the correct url" do
       @navigate.should_receive(:to).with("_url_")
-      subject.run_specs(:default, "_url_")
+      subject.run_specs(runner, "_url_")
     end
 
     it "ensures quit is called on the driver" do
       @driver.should_receive(:quit)
-      subject.run_specs(:default, "_url_")
+      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(timeout: 180, interval: 0.01, message: "Timed out")
-      subject.run_specs(:default, "_url_")
+      Selenium::WebDriver::Wait.should_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
-      @block = nil
       @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_"])
-      Teaspoon::Runner.any_instance.should_receive(:process).with("_line_\n")
-      subject.run_specs(:default, "_url_")
+      runner.should_receive(:process).with("_line_\n")
+      subject.run_specs(runner, "_url_")
       @block.call
     end
 

data/spec/teaspoon/engine_spec.rb

@@ -2,13 +2,16 @@ require "spec_helper"
 
 describe Teaspoon::Engine do
 
-  it "is a class" do
-    Teaspoon::Engine.should be_a(Class)
-  end
+  subject { Teaspoon::Engine }
 
   it "has been isolated with a name" do
-    expect(Teaspoon::Engine.isolated?).to be(true)
-    expect(Teaspoon::Engine.railtie_name).to eql("teaspoon")
+    expect(subject.isolated?).to be(true)
+    expect(subject.railtie_name).to eql("teaspoon")
+  end
+
+  it "defaults the root path" do
+    # this has to add spec/dummy as we set it manually
+    expect(Teaspoon.configuration.root.join('spec/dummy').to_s).to eq(Rails.root.to_s)
   end
 
   it "adds asset paths from configuration" do

data/spec/teaspoon/environment_spec.rb

@@ -19,58 +19,81 @@ describe Teaspoon::Environment do
       expect{ Teaspoon::Environment.load }.to raise_error("Rails environment not found.")
     end
 
-    it "calls configure_from_options if the environment is ready" do
+    it "configures teaspoon from options if the environment is ready" do
       subject.should_receive(:rails_loaded?).and_return(true)
-      subject.should_receive(:configure_from_options)
-      Teaspoon::Environment.load
+      Teaspoon.configuration.should_receive(:override_from_options).with(foo: "bar")
+      Teaspoon::Environment.load(foo: "bar")
     end
 
   end
 
   describe ".require_environment" do
 
-    it "allows passing an override" do
-      subject.should_receive(:require_env).with(File.expand_path("override", Dir.pwd))
-      subject.require_environment("override")
+    before do
+      File.stub(:exists?)
+      subject.stub(:require_env)
+      Teaspoon.configured = false
+      @orig_teaspoon_env = ENV['TEASPOON_ENV']
+      ENV['TEASPOON_ENV'] = nil
     end
 
-    it "looks for the standard files" do
-      subject.stub(:require_env)
-      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))
-      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))
-      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))
-      subject.require_environment
+    after do
+      Teaspoon.configured = true
+      ENV['TEASPOON_ENV'] = @orig_teaspoon_env
     end
 
-    it "raises if no env file was found" do
-      File.stub(:exists?)
-      expect{ subject.require_environment }.to raise_error(Teaspoon::EnvironmentNotFound)
+    describe "when loading with an override" do
+
+      before do
+        subject.should_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)
+        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)
+        subject.require_environment("../../_override_file_")
+        expect(ENV["TEASPOON_ENV"]).to eq(expanded)
+      end
+
     end
-  end
 
-  describe ".standard_environments" 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))
+        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))
+        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))
+        subject.require_environment
+      end
+
+      it "raises if no env file was found" do
+        expect{ subject.require_environment }.to raise_error(Teaspoon::EnvironmentNotFound)
+      end
 
-    it "returns an array" do
-      expect(subject.standard_environments).to eql(["spec/teaspoon_env.rb", "test/teaspoon_env.rb", "teaspoon_env.rb"])
     end
 
   end
 
-  describe ".configure_from_options" do
+  describe ".standard_environments" do
 
-    it "allows overriding configuration directives from options" do
-      Teaspoon.configuration.should_receive(:color=).with(false)
-      Teaspoon::Environment.configure_from_options(color: false)
+    it "returns an array" do
+      expect(subject.standard_environments).to eql(["spec/teaspoon_env.rb", "test/teaspoon_env.rb", "teaspoon_env.rb"])
     end
 
   end

data/spec/teaspoon/exceptions_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Teaspoon::ExceptionHandling do
+
+  subject { Teaspoon::ExceptionHandling }
+
+  before do
+    @orig_debug = Rails.application.config.assets.debug
+    @orig_show_exceptions = Rails.application.config.action_dispatch.show_exceptions
+  end
+
+  after do
+    Rails.application.config.assets.debug = @orig_debug
+    Rails.application.config.action_dispatch.show_exceptions = @orig_show_exceptions
+  end
+
+  describe ".add_rails_handling" do
+
+    before do
+      subject.stub(: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
+    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
+    end
+
+    it "calls #render_exceptions_with_javascript" do
+      subject.should_receive(:render_exceptions_with_javascript)
+      subject.add_rails_handling
+    end
+
+  end
+
+  describe "ActionDispatch::DebugExceptions#render_exception mixin" do
+
+    before do
+      subject.add_rails_handling
+    end
+
+    let(:middleware) { ActionDispatch::DebugExceptions.new(app, nil) }
+    let(:app) { double(:app) }
+    let(:env) { double(:env, "[]" => []) }
+
+    it "responds with a javascript tag that raises the error" do
+      response = middleware.send(:render_exception, env, Exception.new("_message_"))
+      expect(response).to eq([200, {"Content-Type"=>"text/html;", "Content-Length"=>"54"}, ["<script>throw Error(\"Exception: _message_\\n\")</script>"]])
+    end
+
+  end
+
+end

data/spec/teaspoon/exporter_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "teaspoon/exporter"
+
+describe Teaspoon::Exporter do
+
+  subject { Teaspoon::Exporter.new(:suite_name, "http://666.420.42.0:31337/url/to/teaspoon", "_output_path_") }
+
+  describe "#initialize" do
+
+    it "assigns @suite and @url" do
+      expect(subject.instance_variable_get(:@suite)).to eq(:suite_name)
+      expect(subject.instance_variable_get(:@url)).to eq("http://666.420.42.0:31337/url/to/teaspoon")
+    end
+
+    it "expands the @output_path" do
+      expected = File.join(File.expand_path("_output_path_"), "suite_name")
+      expect(subject.instance_variable_get(:@output_path)).to eq(expected)
+    end
+
+  end
+
+  describe "#export" do
+
+    before do
+      Dir.should_receive(:mktmpdir).and_yield("_temp_path_")
+      subject.stub(:executable).and_return("/path/to/executable")
+      subject.stub(:`)
+    end
+
+    it "makes a temp directory and cds to it" do
+      Dir.should_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")
+      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 { 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 { subject.export }.to raise_error Teaspoon::MissingDependency, "Could not find wget for exporting."
+    end
+
+    describe "creating the export" 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)
+      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')
+        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"])
+        subject.export
+      end
+
+      it "moves the files into the output path" do
+        subject.stub(: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)
+        subject.export
+      end
+
+    end
+
+  end
+
+end

data/spec/teaspoon/formatters/base_spec.rb

@@ -0,0 +1,259 @@
+require "spec_helper"
+
+describe Teaspoon::Formatters::Base do
+
+  let(:passing_spec) { double(passing?: true) }
+  let(:pending_spec) { double(passing?: false, pending?: true) }
+  let(:failing_spec) { double(passing?: false, pending?: false) }
+  let(:result) { double }
+
+  before do
+    @log = ""
+    STDOUT.stub(:print) { |s| @log << s }
+  end
+
+  describe "#initialize" do
+
+    subject { Teaspoon::Formatters::Base.new(:foo, "_output_file_") }
+
+    before do
+      File.stub(:open)
+    end
+
+    it "assigns various instance vars" do
+      expect(subject.instance_variable_get(:@suite_name)).to eq("foo")
+      expect(subject.instance_variable_get(:@output_file)).to eq("_output_file_")
+      expect(subject.instance_variable_get(:@stdout)).to eq("")
+      expect(subject.instance_variable_get(:@suite)).to eq(nil)
+      expect(subject.instance_variable_get(:@last_suite)).to eq(nil)
+    end
+
+    it "assigns @total_count, @run_count, and arrays for tracking results" do
+      expect(subject.total_count).to eq(0)
+      expect(subject.run_count).to eq(0)
+      expect(subject.passes).to eq([])
+      expect(subject.pendings).to eq([])
+      expect(subject.failures).to eq([])
+      expect(subject.errors).to eq([])
+    end
+
+    it "writes a new output file if one is specified" do
+      File.should_receive(:open).with("_output_file_", "w")
+      subject
+    end
+
+  end
+
+  describe "#runner" do
+
+    let(:result) { double(total: 666) }
+
+    it "sets @total_count" do
+      subject.runner(result)
+      expect(subject.total_count).to eq(666)
+    end
+
+    it "calls #log_runner when appropriate" do
+      subject.should_receive(:log_runner).with(result)
+      subject.runner(result)
+
+      subject.should_not_receive(:log_runner)
+      subject.runner(result, false)
+    end
+
+  end
+
+  describe "#suite" do
+
+    it "sets @suite, and @last_suite to the result" do
+      subject.suite(result)
+      expect(subject.instance_variable_get(:@suite)).to eq(result)
+      expect(subject.instance_variable_get(:@last_suite)).to eq(result)
+    end
+
+    it "calls #log_suite when appropriate" do
+      subject.should_receive(:log_suite).with(result)
+      subject.suite(result)
+
+      subject.should_not_receive(:log_suite)
+      subject.suite(result, false)
+    end
+
+  end
+
+  describe "#spec" do
+
+    it "increments the run count" do
+      subject.spec(failing_spec)
+      expect(subject.run_count).to eq(1)
+      subject.spec(failing_spec)
+      expect(subject.run_count).to eq(2)
+    end
+
+    it "adds to the correct array on passing results" do
+      subject.spec(passing_spec)
+      expect(subject.run_count).to eq(1)
+      expect(subject.passes).to eq([passing_spec])
+    end
+
+    it "adds to the correct array on pending results" do
+      subject.spec(pending_spec)
+      expect(subject.run_count).to eq(1)
+      expect(subject.pendings).to eq([pending_spec])
+    end
+
+    it "adds to the correct array on failing results" do
+      subject.spec(failing_spec)
+      expect(subject.run_count).to eq(1)
+      expect(subject.failures).to eq([failing_spec])
+    end
+
+    it "calls #log_spec when appropriate" do
+      subject.should_receive(:log_spec).with(failing_spec)
+      subject.spec(failing_spec)
+
+      subject.should_not_receive(:log_spec)
+      subject.spec(failing_spec, false)
+    end
+
+    it "clears @stdout" do
+      subject.instance_variable_set(:@stdout, "----")
+      subject.spec(failing_spec)
+      expect(subject.instance_variable_get(:@stdout)).to eq("")
+    end
+
+  end
+
+  describe "#error" do
+
+    it "tracks the error" do
+      subject.error(result)
+      expect(subject.errors).to eq([result])
+    end
+
+    it "calls #log_error when appropriate" do
+      subject.should_receive(:log_error).with(result)
+      subject.error(result)
+
+      subject.should_not_receive(:log_error)
+      subject.error(result, false)
+    end
+
+  end
+
+  describe "#exception" do
+
+    it "calls #log_exception when appropriate" do
+      subject.should_receive(:log_exception).with(result)
+      subject.exception(result)
+
+      subject.should_not_receive(:log_exception)
+      subject.exception(result, false)
+    end
+
+  end
+
+  describe "#console" do
+
+    it "adds the string to @stdout" do
+      subject.console("_message1_")
+      subject.console("_message2_")
+      expect(subject.instance_variable_get(:@stdout)).to eq("_message1__message2_")
+    end
+
+    it "calls #log_console when appropriate" do
+      subject.should_receive(:log_console).with("_message_")
+      subject.console("_message_")
+
+      subject.should_not_receive(:log_console)
+      subject.console("_message_", false)
+    end
+
+  end
+
+  describe "#result" do
+
+    let(:result) { double(coverage: nil) }
+
+    it "calls #log_result when appropriate" do
+      subject.should_receive(:log_result).with(result)
+      subject.result(result)
+
+      subject.should_not_receive(:log_result)
+      subject.result(result, false)
+    end
+
+  end
+
+  describe "#coverage" do
+
+    it "calls #log_coverage when appropriate" do
+      subject.should_receive(:log_coverage).with("_message_")
+      subject.coverage("_message_")
+
+      subject.should_receive(:log_coverage).with("_message_")
+      subject.coverage("_message_")
+    end
+
+  end
+
+  describe "#threshold_failure" do
+
+    it "calls #log_threshold_failure when appropriate" do
+      subject.should_receive(:log_threshold_failure).with("_message_")
+      subject.threshold_failure("_message_")
+
+      subject.should_receive(:log_threshold_failure).with("_message_")
+      subject.threshold_failure("_message_")
+    end
+
+  end
+
+  describe "#complete" do
+
+    it "calls #log_complete when appropriate" do
+      subject.should_receive(:log_complete).with(42)
+      subject.complete(42)
+
+      subject.should_receive(:log_complete).with(0)
+      subject.complete(0)
+    end
+
+  end
+
+  describe "#log_spec" do
+
+    it "calls #log_passing_spec on passing results" do
+      subject.should_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)
+      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)
+      subject.send(:log_spec, failing_spec)
+    end
+
+  end
+
+  describe "logging to file" 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_")
+      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 { subject.send(:log_to_file, "_str_", "_output_file_") }.to raise_error(Teaspoon::FileNotWritable, "_io_error_message_")
+    end
+
+  end
+
+end