teaspoon 0.9.1 → 1.0.0

data/spec/teaspoon/console_spec.rb

@@ -1,224 +0,0 @@
-require "spec_helper"
-require "teaspoon/console"
-require "teaspoon/server"
-require "teaspoon/runner"
-require "teaspoon/exporter"
-
-describe Teaspoon::Console do
-
-  let(:driver) { double(run_specs: 0) }
-  let(:server) { double(start: nil, url: "http://url.com", responsive?: false) }
-  let(:runner) { double(failure_count: 2) }
-
-  before do
-    allow(Teaspoon::Environment).to receive(:load)
-    allow(Teaspoon::Server).to receive(:new).and_return(server)
-    allow(Teaspoon::Runner).to receive(:new).and_return(runner)
-
-    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 @default_options" do
-      subject = Teaspoon::Console.new(foo: "bar")
-      expect(subject.instance_variable_get(:@default_options)).to eql(foo: "bar")
-    end
-
-    it "loads the environment" do
-      expect(Teaspoon::Environment).to receive(:load)
-      Teaspoon::Console.new
-    end
-
-    it "starts the server" do
-      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
-      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
-
-  describe "#failures?" do
-
-    it "calls #execute and returns the inverse of #executes return value" do
-      expect(subject).to receive(:execute).and_return(false)
-      expect(subject.failures?).to be_truthy
-
-      expect(subject).to receive(:execute).and_return(true)
-      expect(subject.failures?).to be_falsey
-    end
-
-  end
-
-  describe "#execute" do
-
-    it "calls #execute_without_handling and returns its value" do
-      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
-      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
-      expect(subject).to receive(:execute_without_handling).and_raise(Teaspoon::Failure)
-      expect(subject.execute).to be_falsey
-    end
-
-  end
-
-  describe "#execute_without_handling" do
-
-    before do
-      allow(subject).to receive(:run_specs).and_return(0)
-      allow(subject).to receive(:export)
-    end
-
-    it "merges options" do
-      subject.instance_variable_set(:@default_options, foo: "bar")
-      subject.execute_without_handling(bar: "baz")
-      expect(subject.options).to eql(foo: "bar", bar: "baz")
-    end
-
-    it "clears any @suites" do
-      subject.instance_variable_set(:@suites, foo: "bar")
-      subject.execute_without_handling
-      expect(subject.instance_variable_get(:@suites)).to eql({})
-    end
-
-    it "resolves the files" do
-      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"])
-      expect(subject.send(:filter, "foo")).to eq("file[]=file2")
-    end
-
-    it "resolves the files if a directory was given" do
-      resolve_spec_for_output = ['test/javascripts/foo.coffee', 'test/javascripts/bar.coffee']
-      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
-      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
-      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
-      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
-      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
-
-  end
-
-  describe "#run_specs" do
-
-    before do
-      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,
-        %{Unknown suite: "_unknown_"}
-      )
-    end
-
-    it "logs that the suite is being run" do
-      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
-      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
-      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
-      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
-
-  end
-
-  describe "#export" do
-
-    before do
-      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
-      expect { subject.export("_unknown_") }.to raise_error Teaspoon::UnknownSuite
-    end
-
-    it "logs that the suite is being exported" do
-      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(:@default_options, export: "_output_path_")
-      exporter = double(export: nil)
-      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
-
-  end
-
-end

data/spec/teaspoon/coverage_spec.rb

@@ -1,118 +0,0 @@
-require "spec_helper"
-require "teaspoon/coverage"
-
-describe Teaspoon::Coverage do
-
-  subject { Teaspoon::Coverage.new("_suite_", "default", data) }
-  let(:data) { {foo: "bar"} }
-  let(:config) { double }
-
-  before do
-    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
-
-  describe "#initialize" do
-
-    it "sets @suite_name" do
-      expect(subject.instance_variable_get(:@suite_name)).to eq("_suite_")
-    end
-
-    it "finds the executable from instrumentation" do
-      expect(subject.instance_variable_get(:@executable)).to eq("/path/to/executable")
-    end
-
-    it "gets the coverage configuration" do
-      expect_any_instance_of(Teaspoon::Coverage).to receive(:coverage_configuration).with("default")
-      Teaspoon::Coverage.new("_suite_", :default, data)
-    end
-
-  end
-
-  describe "#generate_reports" do
-
-    let(:config) { double(reports: ["html", "text", "text-summary"], output_path: "output/path") }
-
-    it "generates reports using istanbul and passes them to the block provided" do
-      `(exit 0)`
-      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
-
-    it "raises a Teaspoon::DependencyFailure if the command doesn't exit cleanly" do
-      `(exit 1)`
-      expect { subject.generate_reports }.to raise_error Teaspoon::DependencyFailure, "Could not generate coverage report for html"
-    end
-
-  end
-
-  describe "#check_thresholds" 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
-      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"
-      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)`
-      expect(subject).to receive(:`).and_return("ERROR: _failure1_")
-      subject.check_thresholds { |r| @called = true }
-      expect(@called).to be_falsey
-    end
-
-  end
-
-  describe "integration" do
-
-    let(:config) { double(reports: ["text", "text-summary"], output_path: "output/path") }
-
-    before do
-      Teaspoon::Instrumentation.instance_variable_set(:@executable, nil)
-      Teaspoon::Instrumentation.instance_variable_set(:@executable_checked, nil)
-      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
-      subject.instance_variable_set(:@executable, executable)
-      subject.instance_variable_set(:@data, JSON.parse(IO.read(Teaspoon::Engine.root.join('spec/fixtures/coverage.json'))))
-    end
-
-    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
-
-  end
-
-end

data/spec/teaspoon/drivers/base_spec.rb

@@ -1,5 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon::Drivers::Base do
-
-end

data/spec/teaspoon/drivers/capybara_webkit_driver_spec.rb

@@ -1,39 +0,0 @@
-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

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe Teaspoon::Drivers::PhantomjsDriver do
-
-  describe "#initialize" do
-
-    it "assigns @options" do
-      subject = Teaspoon::Drivers::PhantomjsDriver.new(foo: "bar")
-      expect(subject.instance_variable_get(:@options)).to eq(["--foo=bar"])
-    end
-
-    it "accepts a string for options" do
-      subject = Teaspoon::Drivers::PhantomjsDriver.new("--foo=bar --bar=baz")
-      expect(subject.instance_variable_get(:@options)).to eq(["--foo=bar", "--bar=baz"])
-    end
-
-    it "accepts an array for options" do
-      subject = Teaspoon::Drivers::PhantomjsDriver.new(["--foo=bar", "--bar=baz"])
-      expect(subject.instance_variable_get(:@options)).to eq(["--foo=bar", "--bar=baz"])
-    end
-
-    it "raises a Teaspoon::UnknownDriverOptions exception if the options aren't understood" do
-      expect { Teaspoon::Drivers::PhantomjsDriver.new(true) }.to raise_error(Teaspoon::UnknownDriverOptions)
-    end
-
-  end
-
-  describe "#run_specs" do
-
-    context "with phantomjs" do
-
-      let(:runner) { double }
-
-      before do
-        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]
-        expect(runner).to receive(:process).with("_line_")
-        @block = nil
-        expect(subject).to receive(:run).with(*args) { |&b| @block = b }
-        subject.run_specs(runner, "_url_")
-        @block.call("_line_")
-      end
-
-    end
-
-    context "without phantomjs" do
-
-      it "raises a MissingDependency exception" do
-        expect(subject).to receive(:which).and_return(nil)
-        expect { subject.run_specs(:default, "_url_") }.to raise_error Teaspoon::MissingDependency
-      end
-
-    end
-
-  end
-
-end