teaspoon 0.7.9 → 0.8.0

data/spec/teaspoon/console_spec.rb

@@ -1,111 +1,206 @@
 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") }
-  subject {
-    Teaspoon::Console.any_instance.stub(:start_server)
-    instance = Teaspoon::Console.new
-    instance.instance_variable_set(:@server, server)
-    instance
-  }
+  let(:runner) { double(failure_count: 2) }
 
   before do
-    subject.instance_variable_set(:@server, server)
     Teaspoon::Environment.stub(:load)
+    Teaspoon::Server.stub(:new).and_return(server)
+    Teaspoon::Runner.stub(:new).and_return(runner)
+
+    Teaspoon::Console.any_instance.stub(:driver).and_return(driver)
+    Teaspoon::Console.any_instance.stub(:log)
   end
 
   describe "#initialize" do
 
     it "assigns @options" do
-      options = {foo: "bar"}
-      instance = Teaspoon::Console.new(options)
-      expect(instance.instance_variable_get(:@options)).to eql(options)
+      subject = Teaspoon::Console.new(foo: "bar")
+      expect(subject.instance_variable_get(:@options)).to eql(foo: "bar")
     end
 
     it "loads the environment" do
-      Teaspoon::Environment.should_receive(:load).once
-      Teaspoon::Console.new()
+      Teaspoon::Environment.should_receive(:load)
+      Teaspoon::Console.new
     end
 
     it "starts the server" do
+      Teaspoon::Console.any_instance.should_receive(:log).with("Starting the Teaspoon server...")
       Teaspoon::Console.any_instance.should_receive(:start_server).and_call_original
       Teaspoon::Server.should_receive(:new).and_return(server)
       server.should_receive(:start)
-      subject.start_server
-      Teaspoon::Console.new()
+      Teaspoon::Console.new
     end
 
-    it "resolves the files" do
-      files = ["file1"]
-      Teaspoon::Console.any_instance.should_receive(:resolve).with(files)
-      Teaspoon::Console.new(nil, files)
+    it "aborts (displaying a message) on Teaspoon::ServerException" do
+      STDOUT.should_receive(:print).with("_message_\n")
+      Teaspoon::Console.any_instance.should_receive(:log).and_call_original
+      Teaspoon::Console.any_instance.should_receive(:start_server).and_raise(Teaspoon::ServerException, "_message_")
+      Teaspoon::Console.any_instance.should_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
+      subject.should_receive(:execute).and_return(false)
+      expect(subject.failures?).to be_true
+
+      subject.should_receive(:execute).and_return(true)
+      expect(subject.failures?).to be_false
     end
 
   end
 
   describe "#execute" do
 
+    it "calls #execute_without_handling and returns its value" do
+      subject.should_receive(:execute_without_handling).with(foo: "bar").and_return(true)
+      expect(subject.execute(foo: "bar")).to be_true
+    end
+
+    it "handles Teaspoon::Error exceptions" do
+      subject.should_receive(:abort).with("_unknown_error_")
+      subject.should_receive(:execute_without_handling).and_raise(Teaspoon::Error, "_unknown_error_")
+      subject.execute
+    end
+
+    it "returns false on Teaspoon::Failure" do
+      subject.should_receive(:execute_without_handling).and_raise(Teaspoon::Failure)
+      expect(subject.execute).to be_false
+    end
+
+  end
+
+  describe "#execute_without_handling" do
+
     before do
-      STDOUT.stub(:print)
       subject.stub(:run_specs).and_return(0)
+      subject.stub(:export)
     end
 
-    it "assigns @options" do
-      options = {foo: "bar"}
-      instance = Teaspoon::Console.new(options)
-      expect(instance.instance_variable_get(:@options)).to eql(options)
+    it "merges @options" do
+      subject.instance_variable_set(:@options, foo: "bar")
+      subject.execute_without_handling(bar: "baz")
+      expect(subject.instance_variable_get(:@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
-      files = ["file2"]
-      Teaspoon::Suite.should_receive(:resolve_spec_for).with("file2").and_return(suite: "foo", path: "file2")
-      subject.execute(nil, files)
-      expect(subject.instance_variable_get(:@files)).to eq(files)
+      Teaspoon::Suite.should_receive(:resolve_spec_for).with("file").and_return(suite: "foo", path: "file2")
+      subject.execute_without_handling(files: ["file"])
 
-      suites = subject.send(:suites)
-      expect(suites).to eq(["foo"])
+      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
-      directory = [ "test/javascripts" ]
       resolve_spec_for_output = ['test/javascripts/foo.coffee', 'test/javascripts/bar.coffee']
-      Teaspoon::Suite.should_receive(:resolve_spec_for).with("test/javascripts").and_return(suite: "foo", path: resolve_spec_for_output)
-      subject.execute(nil, directory)
-      expect(subject.instance_variable_get(:@files)).to eq(directory)
-
-      suites = subject.send(:suites)
-      expect(suites).to eq(["foo"])
+      Teaspoon::Suite.should_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
       subject.should_receive(:suites).and_return([:default, :foo])
-      STDOUT.should_receive(:print).with("Teaspoon running default suite at http://url.com/teaspoon/default\n")
-      STDOUT.should_receive(:print).with("Teaspoon running foo suite at http://url.com/teaspoon/foo\n")
       subject.should_receive(:run_specs).twice.and_return(2)
-      result = subject.execute
-      expect(result).to be(true)
+      expect(subject.execute_without_handling).to be_false
     end
 
-    it "tracks the failure count" do
+    it "returns true if no failure count" do
       subject.should_receive(:suites).and_return([:default, :foo])
       subject.should_receive(:run_specs).twice.and_return(0)
-      result = subject.execute
-      expect(result).to be(false)
+      expect(subject.execute_without_handling).to be_true
+    end
+
+    it "returns true if there were failures" do
+      subject.should_receive(:suites).and_return([:default])
+      subject.should_receive(:run_specs).once.and_return(1)
+      expect(subject.execute_without_handling).to be_false
+    end
+
+    it "calls export if the options include :export" do
+      subject.should_receive(:suites).and_return([:default, :foo])
+      subject.instance_variable_set(:@options, export: true)
+      subject.should_receive(:export).with(:default)
+      subject.should_receive(:export).with(:foo)
+      subject.execute
     end
 
   end
 
   describe "#run_specs" do
 
-    it "calls run_specs on the driver" do
-      driver = double(run_specs: nil)
+    before do
+      Teaspoon.configuration.stub(:fail_fast).and_return(false)
+      Teaspoon.configuration.should_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
+    end
+
+    it "logs that the suite is being run" do
+      subject.should_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
       subject.should_receive(:driver).and_return(driver)
-      driver.should_receive(:run_specs).with(:suite_name, "http://url.com/teaspoon/suite_name?reporter=Console", nil)
-      subject.run_specs(:suite_name)
+      driver.should_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
+      Teaspoon.configuration.stub(: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
+      Teaspoon.configuration.should_receive(:driver).twice.and_return(:foo)
+      subject.should_receive(:driver).and_call_original
+      expect { subject.run_specs(:suite_name) }.to raise_error Teaspoon::UnknownDriver
+    end
+
+  end
+
+  describe "#export" do
+
+    before do
+      Teaspoon.configuration.should_receive(:suite_configs).and_return("_suite_" => proc{}, "suite_name" => proc{})
+      Teaspoon::Exporter.stub(: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
+      subject.should_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(:@options, export: "_output_path_")
+      exporter = double(export: nil)
+      Teaspoon::Exporter.should_receive(:new).with("_suite_", "http://url.com/teaspoon/_suite_", "_output_path_").and_return(exporter)
+      exporter.should_receive(:export)
+      subject.export("_suite_")
     end
 
   end

data/spec/teaspoon/coverage_spec.rb

@@ -3,44 +3,114 @@ require "teaspoon/coverage"
 
 describe Teaspoon::Coverage do
 
-  subject { Teaspoon::Coverage.new({"foo" => "bar"}, "default") }
+  subject { Teaspoon::Coverage.new("_suite_", "default", data) }
+  let(:data) { {foo: "bar"} }
+  let(:config) { double }
 
-  describe "#reports" do
+  before do
+    Teaspoon::Instrumentation.stub(:executable).and_return("/path/to/executable")
+    subject.stub(:`).and_return("")
+    subject.stub(:input_path).and_yield("/temp_path/coverage.json")
+    subject.instance_variable_set(:@config, config)
+  end
 
-    before do
-      Teaspoon.configuration.should_receive(:coverage_reports).and_return(["text", "text-summary", "html"])
-      subject.stub(:generate_report) { |i, f| "_#{f}_report_" }
-      File.stub(:open)
+  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
+      Teaspoon::Coverage.any_instance.should_receive(:coverage_configuration).with("default")
+      subject = Teaspoon::Coverage.new("_suite_", :default, data)
+    end
+
+  end
+
+  describe "#generate_reports" do
 
-      @check_coverage = double('check_coverage')
-      Teaspoon::CheckCoverage.stub(:new).and_return(@check_coverage)
+    let(:config) { double(reports: ["html", "text", "text-summary"], output_path: "output/path") }
 
-      path = nil
-      Dir.mktmpdir { |p| path = p }
-      Dir.stub(:mktmpdir).and_yield(path)
-      @output = File.join(path, "coverage.json")
+    it "generates reports using istanbul and passes them to the block provided" do
+      `(exit 0)`
+      html_report = "/path/to/executable report html /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
+      text1_report = "/path/to/executable report text /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
+      text2_report = "/path/to/executable report text-summary /temp_path/coverage.json --dir output/path/_suite_ 2>&1"
+      subject.should_receive(:`).with(html_report).and_return("_html_report_")
+      subject.should_receive(:`).with(text1_report).and_return("_text1_report_")
+      subject.should_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 "writes the data to a file" do
-      file = double('file')
-      File.should_receive(:open).with(@output, "w").and_yield(file)
-      file.should_receive(:write).with('{"foo":"bar"}')
-      @check_coverage.should_receive(:check_coverage)
-      subject.reports
+    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
 
-    it "collects the results and returns them" do
-      subject.should_receive(:generate_report).with(@output, "text")
-      subject.should_receive(:generate_report).with(@output, "text-summary")
-      subject.should_receive(:generate_report).with(@output, "html")
-      @check_coverage.should_receive(:check_coverage)
-      expect(subject.reports).to eq("\n_text_report_\n\n_text-summary_report_\n")
+  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
+      subject.should_receive(:threshold_args).and_return(nil)
+      subject.should_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"
+      subject.should_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)`
+      subject.should_receive(:`).and_return("ERROR: _failure1_")
+      subject.check_thresholds { |r| @called = true }
+      expect(@called).to be_false
+    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)
+      Teaspoon::Instrumentation.should_receive(:executable).and_call_original
+      subject.should_receive(:input_path).and_call_original
+      subject.should_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 "executes coverage checks" do
-      Teaspoon::CheckCoverage.should_receive(:new).with(@output)
-      @check_coverage.should_receive(:check_coverage)
-      subject.reports
+    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

data/spec/teaspoon/drivers/base_spec.rb

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

data/spec/teaspoon/drivers/phantomjs_driver_spec.rb

@@ -1,28 +1,47 @@
 require "spec_helper"
-require "teaspoon/drivers/phantomjs_driver"
 
 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
         subject.stub(:run)
       end
 
-      it "instantiates the runner" do
-        runner = double(failure_count: nil)
-        Teaspoon::Runner.should_receive(:new).and_return(runner)
-        subject.run_specs(:default, "_url_")
-      end
-
-      it "calls run and logs the results of each line using the formatter" do
-        args = [Teaspoon::Engine.root.join("lib/teaspoon/drivers/phantomjs/runner.js").to_s, "_url_"]
-        Teaspoon::Runner.any_instance.should_receive(:process).with("_line_")
+      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_")
         @block = nil
         subject.should_receive(:run).with(*args) { |&b| @block = b }
-        subject.run_specs(:default, "_url_")
+        subject.run_specs(runner, "_url_")
         @block.call("_line_")
       end
 
@@ -30,10 +49,9 @@ describe Teaspoon::Drivers::PhantomjsDriver do
 
     context "without phantomjs" do
 
-      it "tells you that it couldn't find phantomjs and exits" do
+      it "raises a MissingDependency exception" do
         subject.should_receive(:which).and_return(nil)
-        STDOUT.should_receive(:print).with("Could not find PhantomJS. Install phantomjs or try the phantomjs gem.")
-        expect { subject.run_specs(:default, "_url_") }.to raise_error SystemExit
+        expect { subject.run_specs(:default, "_url_") }.to raise_error Teaspoon::MissingDependency
       end
 
     end