teaspoon 0.7.9 → 0.8.0

data/spec/teaspoon/formatters/teamcity_formatter_spec.rb

@@ -1,9 +1,13 @@
 require "spec_helper"
-require "teaspoon/formatters/teamcity_formatter"
-require "teaspoon/result"
 
 describe Teaspoon::Formatters::TeamcityFormatter do
 
+  let(:suite) { double(label: "_suite_")}
+  let(:passing_spec) { double(passing?: true, description: "_passing_[desc]\rip|'o\n_") }
+  let(:pending_spec) { double(passing?: false, pending?: true, description: "_pending_[desc]_") }
+  let(:failing_spec) { double(passing?: false, pending?: false, description: "_failing_[desc]_", message: "_failure_[mess]age_") }
+  let(:result) { double }
+
   before do
     @log = ""
     STDOUT.stub(:print) { |s| @log << s }
@@ -11,79 +15,132 @@ describe Teaspoon::Formatters::TeamcityFormatter do
 
   describe "#runner" do
 
-    let(:json) { {"start" => "_start_", "total" => 20} }
+    let(:result) { double(total: 42, start: "_start_") }
 
-    it "logs the information" do
-      result = Teaspoon::Result.build_from_json(json)
-      subject.should_receive(:log).with("##teamcity[testSuiteStarted name='Jasmine']")
+    it "starts the suite" do
+      Time.should_receive(:now).and_return(double(to_json: "_json_time_"))
       subject.runner(result)
+      expect(@log).to include("##teamcity[enteredTheMatrix timestamp='_json_time_']\n")
+      expect(@log).to include("##teamcity[testCount count='42' timestamp='_start_']\n")
     end
 
   end
 
-  describe "#spec" do
+  describe "#suite" do
+
+    it "logs the suite" do
+      subject.suite(suite)
+      expect(@log).to include(%Q{##teamcity[testSuiteStarted name='_suite_']})
+    end
+
+    it "closes the last suite if there was one" do
+      subject.instance_variable_set(:@last_suite, suite)
+      subject.suite(suite)
+      expect(@log).to include(%Q{##teamcity[testSuiteFinished name='_suite_']})
+    end
+
+  end
 
-    describe "passing spec" do
+  describe "#spec" do
 
-      let(:json) { {"status" => "passed", "suite" => "My Suite", "label" => "My Label"} }
+    it "logs a passing testcase on passing results" do
+      subject.spec(passing_spec)
+      expect(@log).to include(%Q{##teamcity[testStarted name='_passing_|[desc|]|rip|||'o|n_' captureStandardOutput='true']\n})
+      expect(@log).to include(%Q{##teamcity[testFinished name='_passing_|[desc|]|rip|||'o|n_']\n})
+    end
 
-      it "calls passing_spec" do
-        result = Teaspoon::Result.build_from_json(json)
-        subject.spec(result)
+    it "logs a skipped testcase on pending results" do
+      subject.spec(pending_spec)
+      expect(@log).to include(%Q{##teamcity[testIgnored name='_pending_|[desc|]_' captureStandardOutput='true']\n})
+      expect(@log).to include(%Q{##teamcity[testFinished name='_pending_|[desc|]_']\n})
+    end
 
-        @log.should include "##teamcity[testStarted name='My Suite My Label' captureStandardOutput='false']
-##teamcity[testFinished name='My Suite My Label']"
-      end
+    it "logs a failing testcase with the message on failing results" do
+      subject.spec(failing_spec)
+      expect(@log).to include(%Q{##teamcity[testStarted name='_failing_|[desc|]_' captureStandardOutput='true']\n})
+      expect(@log).to include(%Q{##teamcity[testFailed name='_failing_|[desc|]_' message='_failure_|[mess|]age_']\n})
+      expect(@log).to include(%Q{##teamcity[testFinished name='_failing_|[desc|]_']\n})
+    end
 
+    it "captures stdout and puts it in the right place" do
+      subject.instance_variable_set(:@stdout, "_stdout_\n")
+      subject.spec(pending_spec)
+      expect(@log).to include(%Q{##teamcity[testIgnored name='_pending_|[desc|]_' captureStandardOutput='true']\n})
+      expect(@log).to include(%Q{_stdout_\n})
+      expect(@log).to include(%Q{##teamcity[testFinished name='_pending_|[desc|]_']\n})
     end
 
-    describe "pending spec" do
+  end
 
-      let(:json) { {"status" => "pending", "suite" => "My Suite", "label" => "My Label"} }
+  describe "#error" do
 
-      it "calls pending_spec" do
-        result = Teaspoon::Result.build_from_json(json)
-        subject.spec(result)
-        @log.should include "##teamcity[testStarted name='My Suite My Label' captureStandardOutput='false']
-##teamcity[testFinished name='My Suite My Label']"
-      end
+    let(:result) { double(message: "_error_message_", trace: [{"file" => "myfile.js", "line" => "420"}, {"file" => "myfile.js", "line" => "666"}]) }
 
+    it "logs the error" do
+      subject.error(result)
+      expect(@log).to include(%Q{##teamcity[message text='_error_message_' errorDetails='myfile.js:420|nmyfile.js:666' status='ERROR']\n})
     end
 
-    describe "failing spec" do
+  end
 
-      let(:json) { {"status" => "fail", "suite" => "My Suite", "label" => "My Label", "message" => "Error, oh no"} }
+  describe "#result" do
 
-      it "calls failing_spec" do
-        result = Teaspoon::Result.build_from_json(json)
-        subject.spec(result)
-        @log.should include "##teamcity[testStarted name='My Suite My Label' captureStandardOutput='false']
-##teamcity[testFailed name='My Suite My Label' message='Error, oh no']
-##teamcity[testFinished name='My Suite My Label']"
-      end
+    it "closes any open suites" do
+      subject.instance_variable_set(:@last_suite, double(label: "_last_suite_label_"))
+      subject.result(result)
+      expect(@log).to include(%Q{##teamcity[testSuiteFinished name='_last_suite_label_']})
+    end
 
+    it "assigns @result" do
+      subject.result(result)
+      expect(subject.instance_variable_get(:@result)).to eq(result)
     end
 
   end
 
-  describe "#error" do
+  describe "#coverage" do
+
+    it "logs the coverage" do
+      subject.coverage("_text_\n\n_text_summary_")
+      expect(@log).to include(%Q{##teamcity[testSuiteStarted name='Coverage summary']\n})
+      expect(@log).to include(%Q{_text_\n\n_text_summary_\n})
+      expect(@log).to include(%Q{##teamcity[testSuiteFinished name='Coverage summary']\n})
+    end
+
+  end
 
-    let(:json) { {"status" => "error", "message" => "Error, oh no", "trace" => [{"file" => "myfile.js", "line" => "33"}] } }
+  describe "#threshold_failure" do
 
-    it "logs error" do
-      error = Teaspoon::Result.build_from_json(json)
-      subject.error(error)
-      @log.should include "##teamcity[message text='Error, oh no' errorDetails='myfile.js:33' status='ERROR']"
+    it "logs the threshold failures" do
+      subject.threshold_failure("_was_not_met_\n_was_not_met_")
+      expect(@log).to include(%Q{##teamcity[testSuiteStarted name='Coverage thresholds']\n})
+      expect(@log).to include(%Q{##teamcity[testStarted name='Coverage thresholds' captureStandardOutput='true']\n})
+      expect(@log).to include(%Q{##teamcity[testFailed name='Coverage thresholds' message='were not met']\n})
+      expect(@log).to include(%Q{_was_not_met_\n_was_not_met_\n})
+      expect(@log).to include(%Q{##teamcity[testFinished name='Coverage thresholds']\n})
+      expect(@log).to include(%Q{##teamcity[testSuiteFinished name='Coverage thresholds']\n})
     end
 
   end
 
-  describe "#result" do
+  describe "#complete" do
 
-    it "ends the suite" do
-      subject.result('result')
+    let(:result) { double(elapsed: 3.1337, coverage: nil) }
+
+    before do
+      subject.instance_variable_set(:@result, result)
 
-      @log.should include "##teamcity[testSuiteFinished name='Jasmine']"
+      subject.run_count = 6
+      subject.passes = [1, 2]
+      subject.failures = [1]
+      subject.errors = [1]
+      subject.pendings = [1, 2]
+    end
+
+    it "ends the suite" do
+      subject.complete(1)
+      expect(@log).to include(%Q{Finished in 3.1337 seconds\n})
+      expect(@log).to include(%Q{6 examples, 1 failure, 2 pending\n\n})
     end
 
   end

data/spec/teaspoon/instrumentation_spec.rb

@@ -7,24 +7,47 @@ describe Teaspoon::Instrumentation do
 
   subject { Teaspoon::Instrumentation }
 
-  let(:asset) { double('asset', source: nil, pathname: 'path/to/instrument.js') }
+  let(:asset) { double(source: source, pathname: 'path/to/instrument.js') }
+  let(:source) { "function add(a, b) { return a + b } // ☃ " }
   let(:response) { [200, {"Content-Type" => "application/javascript"}, asset] }
   let(:env) { {"QUERY_STRING" => "instrument=true"} }
 
-  before do
-    Teaspoon::Instrumentation.stub(:istanbul).and_return("/path/to/istanbul")
-    Teaspoon::Instrumentation.instance_variable_set(:@executable, nil)
-  end
+  describe ".add_to" do
 
-  after do
-    Teaspoon::Instrumentation.instance_variable_set(:@executable, nil)
-  end
+    before do
+      Teaspoon::Instrumentation.stub(:executable).and_return("/path/to/istanbul")
+    end
+
+    before do
+      Teaspoon::Instrumentation.stub(:add?).and_return(true)
+      asset.should_receive(:clone).and_return(asset)
 
-  describe ".executable" do
+      File.stub(:open)
+      subject.any_instance.stub(:instrument).and_return(source + " // instrumented")
 
-    it "returns the executable" do
-      expect(subject.executable).to eq("/path/to/istanbul")
-      expect(subject.instance_variable_get(:@executable)).to eq("/path/to/istanbul")
+      path = nil
+      Dir.mktmpdir { |p| path = p }
+      Dir.stub(:mktmpdir).and_yield(path)
+      @output = File.join(path, "instrument.js")
+    end
+
+    it "writes the file to a tmp path" do
+      file = double('file')
+      File.should_receive(:open).with(@output, "w").and_yield(file)
+      file.should_receive(:write).with("function add(a, b) { return a + b } // ☃ ")
+      subject.add_to(response, env)
+    end
+
+    it "instruments the javascript file" do
+      subject.any_instance.should_receive(:instrument).with(@output).and_return("_instrumented_")
+      subject.add_to(response, env)
+    end
+
+    it "replaces the response array with the appropriate information" do
+      response = [666, {"Content-Type" => "application/javascript"}, asset]
+      expected = [666, {"Content-Type" => "application/javascript", "Content-Length" => "59"}, asset]
+
+      expect(subject.add_to(response, env)).to eq(expected)
     end
 
   end
@@ -32,7 +55,7 @@ describe Teaspoon::Instrumentation do
   describe ".add?" do
 
     before do
-      subject.stub(:executable).and_return("/path/to/istanbul")
+      Teaspoon::Instrumentation.stub(:executable).and_return("/path/to/istanbul")
     end
 
     it "returns true when everything is good" do
@@ -64,42 +87,19 @@ describe Teaspoon::Instrumentation do
 
   end
 
-  describe ".add_to" do
+  describe "integration" do
 
-    let(:asset) { double(source: source, pathname: 'path/to/instrument.js') }
-    let(:source) { "function add(a, b) { return a + b } // ☃ " }
+    let(:asset) { Rails.application.assets.find_asset('instrumented1.coffee') }
 
     before do
-      Teaspoon::Instrumentation.stub(:add?).and_return(true)
-      asset.should_receive(:clone).and_return(asset)
-
-      File.stub(:open)
-      subject.any_instance.stub(:instrument).and_return(source + " // instrumented")
-
-      path = nil
-      Dir.mktmpdir { |p| path = p }
-      Dir.stub(:mktmpdir).and_yield(path)
-      @output = File.join(path, "instrument.js")
-    end
-
-    it "writes the file to a tmp path" do
-      file = double('file')
-      File.should_receive(:open).with(@output, "w").and_yield(file)
-      file.should_receive(:write).with("function add(a, b) { return a + b } // ☃ ")
-      subject.add_to(response, env)
+      pending("needs istanbul to be installed") unless Teaspoon::Instrumentation.executable
     end
 
-    it "instruments the javascript file" do
-      subject.any_instance.should_receive(:instrument).with(@output).and_return("_instrumented_")
-      subject.add_to(response, env)
-    end
-
-    it "replaces the response array with the appropriate information" do
-      response = [666, {"Content-Type" => "application/javascript"}, asset]
-      expected = [666, {"Content-Type" => "application/javascript", "Content-Length" => "59"}, asset]
-
-      subject.add_to(response, env)
-      expect(response).to eq(expected)
+    it "instruments a file" do
+      status, headers, asset = subject.add_to(response, {"QUERY_STRING" => "instrument=true"})
+      expect(status).to eq(200)
+      expect(headers).to include("Content-Type" => "application/javascript")
+      expect(asset.source).to match(/var __cov_.+ = \(Function\('return this'\)\)\(\);/)
     end
 
   end

data/spec/teaspoon/result_spec.rb

@@ -54,4 +54,41 @@ describe Teaspoon::Result do
 
   end
 
+  describe "#failing?" do
+
+    it "returns a boolean based on status" do
+      subject.status = "foo"
+      expect(subject.failing?).to be_true
+      subject.status = "bar"
+      expect(subject.failing?).to be_true
+      subject.status = "passed"
+      expect(subject.failing?).to be_false
+      subject.status = "pending"
+      expect(subject.failing?).to be_false
+    end
+
+  end
+
+  describe "#passing?" do
+
+    it "returns a boolean based on status" do
+      subject.status = "passed"
+      expect(subject.passing?).to be_true
+      subject.status = "foo"
+      expect(subject.passing?).to be_false
+    end
+
+  end
+
+  describe "#pending?" do
+
+    it "returns a boolean based on status" do
+      subject.status = "pending"
+      expect(subject.pending?).to be_true
+      subject.status = "foo"
+      expect(subject.pending?).to be_false
+    end
+
+  end
+
 end

data/spec/teaspoon/runner_spec.rb

@@ -1,102 +1,113 @@
 require "spec_helper"
 require "teaspoon/runner"
 require "teaspoon/exceptions"
+require "teaspoon/coverage"
 
 describe Teaspoon::Runner do
 
   before do
-    @log = ""
-    STDOUT.stub(:print) { |s| @log << s }
+    Teaspoon.configuration.stub(:formatters).and_return([])
   end
 
-  describe "constructor" do
+  describe "#initialize" do
+
+    it "sets @suite_name and @failure_count" do
+      subject = Teaspoon::Runner.new(:foo)
+      expect(subject.instance_variable_get(:@suite_name)).to eq(:foo)
+      expect(subject.failure_count).to eq(0)
+    end
 
     it "instantiates formatters based on configuration" do
-      Teaspoon.configuration.should_receive(:formatters).and_return(["dot", "xml"])
+      Teaspoon.configuration.stub(:formatters).and_return(["dot", "xml"])
       Teaspoon::Formatters::XmlFormatter = Class.new do
-        def initialize(suite_name = :default) end
+        def initialize(_suite_name = :default, _output_file = nil) end
       end
-      expect(subject.formatters[0]).to be_a(Teaspoon::Formatters::DotFormatter)
-      expect(subject.formatters[1]).to be_a(Teaspoon::Formatters::XmlFormatter)
-    end
-
-  end
-
-  describe "#suppress_logs?" do
-
-    it "returns true if the configuration is true" do
-      Teaspoon.configuration.should_receive(:suppress_log).and_return(true)
-      expect(subject.suppress_logs?).to be(true)
+      expect(subject.instance_variable_get(:@formatters)[0]).to be_a(Teaspoon::Formatters::DotFormatter)
+      expect(subject.instance_variable_get(:@formatters)[1]).to be_a(Teaspoon::Formatters::XmlFormatter)
     end
 
-    it "asks each formatter if it needs to suppress logs" do
-      Teaspoon.configuration.should_receive(:suppress_log).and_return(false)
-      subject.formatters = [double(suppress_logs?: true)]
-      expect(subject.suppress_logs?).to be(true)
-    end
-
-    it "memoizes" do
-      Teaspoon.configuration.should_not_receive(:suppress_log)
-      subject.instance_variable_set(:@suppress_logs, true)
-      expect(subject.suppress_logs?).to be(true)
+    it "raises a Teaspoon::UnknownFormatter exception when a formatter isn't found" do
+      Teaspoon.configuration.stub(:formatters).and_return(["bar"])
+      expect { Teaspoon::Runner.new(:foo) }.to raise_error Teaspoon::UnknownFormatter, "Unknown formatter: \"bar\""
     end
 
   end
 
   describe "#process" do
 
+    let(:formatter) { double }
+    let(:coverage) { double(generate_reports: nil, check_thresholds: nil) }
+
     before do
-      subject.instance_variable_set(:@suppress_logs, false)
+      subject.instance_variable_set(:@formatters, [formatter])
     end
 
-    it "just outputs logs that it doesn't understand" do
-      subject.should_receive(:log).with("_line_")
-      subject.should_receive(:output_from).and_return(false)
-      subject.process("_line_")
+    it "notifies formatters when it understands the log" do
+      formatter.should_receive(:foo)
+      formatter.should_not_receive(:bar)
+      subject.process('{"_teaspoon":true,"type":"foo"}')
+      subject.process('{"_teaspoon":false,"type":"bar"}')
     end
 
-    it "doesn't output logs when suppressed" do
-      subject.should_receive(:suppress_logs?).and_return(true)
-      subject.should_not_receive(:log).with("_line_")
-      subject.should_receive(:output_from).and_return(false)
+    it "notifies formatters of console output when it doesn't understand the log" do
+      formatter.should_receive(:console).with("_line_")
+      subject.should_receive(:result_from_line).and_return(false)
       subject.process("_line_")
     end
 
-    it "handles lines and notifies formatters when it should" do
-      formatter = double('formatter')
-      subject.formatters = [ formatter ]
-      formatter.should_receive(:spec)
-      formatter.should_receive(:error)
-      formatter.should_receive(:results)
-      formatter.should_receive(:exception)
-      formatter.should_not_receive(:log)
-      subject.process('{"_teaspoon": true, "type": "spec"}')
-      subject.process('{"_teaspoon": true, "type": "error"}')
-      subject.process('{"_teaspoon": true, "type": "results"}')
-      subject.process('{"_teaspoon": true, "type": "exception"}')
-    end
-
     it "handles bad json" do
-      subject.should_receive(:log).with("{bad: true}")
+      formatter.should_receive(:console).with("{bad: true}")
       subject.process("{bad: true}")
     end
 
     it "handles json when it's not intended for it" do
-      subject.should_receive(:log).with('{"good": true}')
+      formatter.should_receive(:console).with('{"good": true}')
       subject.process('{"good": true}')
     end
 
-    it 'keeps a count of errors' do
-      subject.formatters = []
-      subject.process('{"_teaspoon": true, "type": "spec"}')
-      subject.process('{"_teaspoon": true, "type": "spec", "status": "passed"}')
-      subject.process('{"_teaspoon": true, "type": "spec", "status": "pending"}')
-      subject.process('{"_teaspoon": true, "type": "error"}')
-      subject.process('{"_teaspoon": true, "type": "exception"}')
-      subject.process('{"_teaspoon": true, "type": "results"}')
+    it "keeps a count of errors" do
+      subject.process('{"_teaspoon":true,"type":"spec"}')
+      subject.process('{"_teaspoon":true,"type":"spec", "status": "passed"}')
+      subject.process('{"_teaspoon":true,"type":"spec", "status": "pending"}')
+      subject.process('{"_teaspoon":true,"type":"error"}')
+      subject.process('{"_teaspoon":true,"type":"results"}')
       expect(subject.failure_count).to be(1)
     end
 
+    describe "with an exception" do
+
+      it "notifies itself, and raises Teaspoon::RunnerException" do
+        subject.should_receive(:on_exception).and_call_original
+        expect { subject.process('{"_teaspoon":true,"type":"exception","message":"_message_"}') }.to raise_error Teaspoon::RunnerException, "_message_"
+      end
+
+    end
+
+    describe "with a result" do
+
+      before do
+        Teaspoon::Coverage.stub(:new).and_return(coverage)
+      end
+
+      it "notifies itself" do
+        subject.should_receive(:on_result)
+        subject.process('{"_teaspoon":true,"type":"result"}')
+      end
+
+      it "resolves coverage" do
+        Teaspoon.configuration.should_receive(:use_coverage).twice.and_return("_coverage_config_")
+        Teaspoon::Coverage.should_receive(:new).with(:default, "_coverage_config_", "_coverage_").and_return(coverage)
+        coverage.should_receive(:generate_reports).and_yield("_generated_reports_")
+        coverage.should_receive(:check_thresholds).and_yield("_threshold_failures_")
+        subject.should_receive(:notify_formatters).once.with("coverage", "_generated_reports_")
+        subject.should_receive(:notify_formatters).once.with("threshold_failure", "_threshold_failures_")
+        subject.should_receive(:notify_formatters).exactly(2).times.and_call_original
+        subject.process('{"_teaspoon":true,"type":"result","coverage":"_coverage_"}')
+        expect(subject.failure_count).to eq(1)
+      end
+
+    end
+
   end
 
 end