teaspoon 0.9.1 → 1.0.0

data/spec/teaspoon/drivers/selenium_driver_spec.rb

@@ -1,68 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon::Drivers::SeleniumDriver do
-
-  describe "#initialize" do
-
-    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 "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
-
-  end
-
-  describe "#run_specs" do
-
-    let(:runner) { double }
-
-    before do
-      @driver = double(quit: nil, navigate: @navigate = double(to: nil), execute_script: 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
-      expect(Selenium::WebDriver).to receive(:for).with(:firefox)
-      subject.run_specs(runner, "_url_")
-    end
-
-    it "navigates to the correct url" do
-      expect(@navigate).to receive(:to).with("_url_")
-      subject.run_specs(runner, "_url_")
-    end
-
-    it "ensures quit is called on the driver" do
-      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
-      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
-      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
-
-  end
-
-end

data/spec/teaspoon/engine_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon::Engine do
-
-  subject { Teaspoon::Engine }
-
-  it "has been isolated with a name" do
-    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
-    expect(Rails.application.config.assets.paths).to include(Teaspoon.configuration.root.join("spec/javascripts").to_s)
-    expect(Rails.application.config.assets.paths).to include(Teaspoon.configuration.root.join("spec/javascripts/stylesheets").to_s)
-  end
-
-end

data/spec/teaspoon/environment_spec.rb

@@ -1,109 +0,0 @@
-require "spec_helper"
-require "teaspoon/environment"
-
-describe Teaspoon::Environment do
-
-  subject { Teaspoon::Environment }
-
-  describe ".load" do
-
-    it "calls require_environment" do
-      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
-      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
-      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
-
-  end
-
-  describe ".require_environment" do
-
-    before do
-      allow(File).to receive(:exists?)
-      allow(subject).to receive(:require_env)
-      Teaspoon.configured = false
-      @orig_teaspoon_env = ENV['TEASPOON_ENV']
-      ENV['TEASPOON_ENV'] = nil
-    end
-
-    after do
-      Teaspoon.configured = true
-      ENV['TEASPOON_ENV'] = @orig_teaspoon_env
-    end
-
-    describe "when loading with an override" do
-
-      before do
-        expect(subject).to receive(:require_env).and_call_original
-      end
-
-      it "allows passing an override" do
-        expanded = File.expand_path("_override_", Dir.pwd)
-        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)
-        expect(::Kernel).to receive(:load).with(expanded)
-        subject.require_environment("../../_override_file_")
-        expect(ENV["TEASPOON_ENV"]).to eq(expanded)
-      end
-
-    end
-
-    describe "when loading from defaults" do
-
-      it "looks for the standard files" do
-        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
-
-        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
-
-        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
-
-      it "raises if no env file was found" do
-        expect{ subject.require_environment }.to raise_error(Teaspoon::EnvironmentNotFound)
-      end
-
-    end
-
-  end
-
-  describe ".standard_environments" do
-
-    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 ".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

@@ -1,57 +0,0 @@
-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
-      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_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_truthy
-    end
-
-    it "calls #render_exceptions_with_javascript" do
-      expect(subject).to 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

@@ -1,96 +0,0 @@
-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
-      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
-      expect(Dir).to receive(:chdir).with("_temp_path_")
-      subject.export
-    end
-
-    it "executes the wget call and creates the export" do
-      `(exit 0)`
-      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)`
-      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
-      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
-
-    describe "creating the export" do
-
-      before do
-        `(exit 0)`
-        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
-        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
-        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
-        allow(subject).to receive(:cleanup_output)
-        output_path = subject.instance_variable_get(:@output_path)
-        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
-
-    end
-
-  end
-
-end

data/spec/teaspoon/formatters/base_spec.rb

@@ -1,259 +0,0 @@
-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 = ""
-    allow(STDOUT).to receive(:print) { |s| @log << s }
-  end
-
-  describe "#initialize" do
-
-    subject { Teaspoon::Formatters::Base.new(:foo, "_output_file_") }
-
-    before do
-      allow(File).to receive(: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
-      expect(File).to 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
-      expect(subject).to receive(:log_runner).with(result)
-      subject.runner(result)
-
-      expect(subject).to_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
-      expect(subject).to receive(:log_suite).with(result)
-      subject.suite(result)
-
-      expect(subject).to_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
-      expect(subject).to receive(:log_spec).with(failing_spec)
-      subject.spec(failing_spec)
-
-      expect(subject).to_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
-      expect(subject).to receive(:log_error).with(result)
-      subject.error(result)
-
-      expect(subject).to_not receive(:log_error)
-      subject.error(result, false)
-    end
-
-  end
-
-  describe "#exception" do
-
-    it "calls #log_exception when appropriate" do
-      expect(subject).to receive(:log_exception).with(result)
-      subject.exception(result)
-
-      expect(subject).to_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
-      expect(subject).to receive(:log_console).with("_message_")
-      subject.console("_message_")
-
-      expect(subject).to_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
-      expect(subject).to receive(:log_result).with(result)
-      subject.result(result)
-
-      expect(subject).to_not receive(:log_result)
-      subject.result(result, false)
-    end
-
-  end
-
-  describe "#coverage" do
-
-    it "calls #log_coverage when appropriate" do
-      expect(subject).to receive(:log_coverage).with("_message_")
-      subject.coverage("_message_")
-
-      expect(subject).to receive(:log_coverage).with("_message_")
-      subject.coverage("_message_")
-    end
-
-  end
-
-  describe "#threshold_failure" do
-
-    it "calls #log_threshold_failure when appropriate" do
-      expect(subject).to receive(:log_threshold_failure).with("_message_")
-      subject.threshold_failure("_message_")
-
-      expect(subject).to receive(:log_threshold_failure).with("_message_")
-      subject.threshold_failure("_message_")
-    end
-
-  end
-
-  describe "#complete" do
-
-    it "calls #log_complete when appropriate" do
-      expect(subject).to receive(:log_complete).with(42)
-      subject.complete(42)
-
-      expect(subject).to receive(:log_complete).with(0)
-      subject.complete(0)
-    end
-
-  end
-
-  describe "#log_spec" do
-
-    it "calls #log_passing_spec on passing results" do
-      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
-      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
-      expect(subject).to 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)
-      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
-      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
-
-  end
-
-end