teabag 0.5.5 → 0.6.0

data/spec/features/instrumentation_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+feature "instrumenting javascript" do
+
+  before do
+    pending("needs istanbul to be installed") unless Teabag::Instrumentation.which('istanbul')
+  end
+
+  scenario "requesting with instrument=true adds istanbul instrumentation" do
+    visit "/assets/instrumented1.js?instrument=true"
+    expect(html).to include("if (typeof __coverage__ === 'undefined') { __coverage__ = {}; }")
+  end
+
+  scenario "requesting without instrument=true doesn't do anything" do
+    visit "/assets/instrumented2.js?instrument=false"
+    expect(html).to_not include("if (typeof __coverage__ === 'undefined') { __coverage__ = {}; }")
+  end
+
+end

data/spec/javascripts/teabag/base/reporters/console_spec.coffee

@@ -141,11 +141,13 @@ describe "Teabag.Reporters.Console", ->
 
     it "logs the results", ->
       spy = spyOn(@reporter, "log")
+      window.__coverage__ ||= {}
       @reporter.reportRunnerResults()
       Teabag.finished = false
       args = spy.mostRecentCall.args[0]
       expect(args["type"]).toEqual("result")
       expect(args["elapsed"]).toBeDefined()
+      expect(args["coverage"]).toBe(window.__coverage__)
 
     it "tells Teabag that we're finished", ->
       @reporter.reportRunnerResults()

data/spec/javascripts/teabag/base/teabag_spec.coffee

@@ -15,7 +15,6 @@ describe "Teabag", ->
       # caching
       expect(keys).toContain("Date")
       expect(keys).toContain("location")
-      expect(keys).toContain("console")
 
 
   describe ".execute", ->

data/spec/javascripts/teabag/mocha/reporters/html_mspec.coffee

@@ -29,7 +29,7 @@ describe "Mocha Teabag.Reporters.HTML", ->
   describe "#envInfo", ->
 
     it "returns the version", ->
-      expect(@reporter.envInfo()).to.be("mocha 1.7.4")
+      expect(@reporter.envInfo()).to.be("mocha 1.8.1")
 
 
 describe "Mocha Teabag.Reporters.HTML.SpecView", ->

data/spec/spec_helper.rb

@@ -15,5 +15,3 @@ RSpec.configure do |config|
   config.infer_base_class_for_anonymous_controllers = false
   config.order = "random"
 end
-
-Teabag.configuration.suites = {}

data/spec/teabag/configuration_spec.rb

@@ -19,23 +19,19 @@ describe Teabag do
   describe ".override_from_env" do
 
     after do
-      Teabag.configuration.suppress_log = false
-      Teabag.configuration.fail_fast = true
-      Teabag.configuration.formatters = "dot"
+      ENV["SUPPRESS_LOG"] = nil
+      ENV["FAIL_FAST"] = nil
+      ENV["FORMATTERS"] = nil
     end
 
     it "allows overriding of fail_fast and suppress_log from the env" do
-      Teabag.setup { |c| config = c }
       ENV["SUPPRESS_LOG"] = "true"
       ENV["FAIL_FAST"] = "false"
       ENV["FORMATTERS"] = "something"
+      Teabag.configuration.should_receive(:suppress_log=).with(true)
+      Teabag.configuration.should_receive(:fail_fast=).with(false)
+      Teabag.configuration.should_receive(:formatters=).with("something")
       Teabag.send(:override_from_env)
-      expect(Teabag.configuration.suppress_log).to eq(true)
-      expect(Teabag.configuration.fail_fast).to eq(false)
-      expect(Teabag.configuration.formatters).to eq('something')
-      ENV["SUPPRESS_LOG"] = nil
-      ENV["FAIL_FAST"] = nil
-      ENV["FORMATTERS"] = nil
     end
 
   end
@@ -49,7 +45,7 @@ describe Teabag::Configuration do
 
   after do
     Teabag::Configuration.mount_at = "/teabag"
-    Teabag::Configuration.suites = {}
+    Teabag::Configuration.suites.delete("test_suite")
   end
 
   it "has the default configuration" do
@@ -57,11 +53,13 @@ describe Teabag::Configuration do
     expect(subject.asset_paths).to include("spec/javascripts")
     expect(subject.asset_paths).to include("spec/javascripts/stylesheets")
     expect(subject.fixture_path).to eq("spec/javascripts/fixtures")
-    expect(subject.formatters).to eq('dot')
+    expect(subject.formatters).to eq(['dot'])
     expect(subject.server_timeout).to eq(20)
     expect(subject.fail_fast).to eq(true)
     expect(subject.suppress_log).to eq(false)
-    expect(subject.suites).to eq({})
+    expect(subject.suites).to be_a(Hash)
+    expect(subject.coverage).to eq(false)
+    expect(subject.coverage_reports).to eq(["text-summary"])
   end
 
   it "allows setting various configuration options" do
@@ -81,9 +79,9 @@ describe Teabag::Configuration::Suite do
 
   it "has the default configuration" do
     subject = Teabag::Configuration::Suite.new
-    expect(subject.matcher).to eq("{spec/javascripts,app/assets}/**/*_spec.{js,js.coffee,coffee}")
+    expect(subject.matcher).to eq("{spec/javascripts,spec/dummy/app/assets/javascripts/specs}/**/*_spec.{js,js.coffee,coffee}")
     expect(subject.helper).to eq("spec_helper")
-    expect(subject.javascripts).to eq(["teabag-jasmine"])
+    expect(subject.javascripts).to eq(["teabag/jasmine"])
     expect(subject.stylesheets).to eq(["teabag"])
   end
 

data/spec/teabag/coverage_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "teabag/coverage"
+
+describe Teabag::Coverage do
+
+  subject { Teabag::Coverage.new({"foo" => "bar"}) }
+
+  describe "#reports" do
+
+    before do
+      Teabag.configuration.should_receive(:coverage_reports).and_return(["text", "text-summary", "html"])
+      subject.stub(:generate_report) { |i, f| "_#{f}_report_" }
+      File.stub(:write)
+
+      path = nil
+      Dir.mktmpdir { |p| path = p }
+      Dir.stub(:mktmpdir).and_yield(path)
+      @output = File.join(path, "coverage.json")
+    end
+
+    it "writes the data to a file" do
+      File.should_receive(:write).with(@output, '{"foo":"bar"}')
+      subject.reports
+    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")
+      expect(subject.reports).to eq("\n_text_report_\n\n_text-summary_report_\n")
+    end
+
+  end
+
+end

data/spec/teabag/environment_spec.rb

@@ -69,18 +69,9 @@ describe Teabag::Environment do
 
   describe ".configure_from_options" do
 
-    before do
-      @stored_configuration = Teabag.configuration.color
-    end
-
-    after do
-      Teabag.configuration.color = @stored_configuration
-    end
-
     it "allows overriding configuration directives from options" do
-      Teabag.configuration.color = true
+      Teabag.configuration.should_receive(:color=).with(false)
       Teabag::Environment.configure_from_options(color: false)
-      expect(Teabag.configuration.color).to be(false)
     end
 
   end

data/spec/teabag/formatters/base_formatter_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "teabag/formatters/base_formatter"
+require "teabag/result"
+
+describe Teabag::Formatters::BaseFormatter do
+
+  before do
+    @log = ""
+    STDOUT.stub(:print) { |s| @log << s }
+  end
+
+  describe "#result" do
+
+    it "calls log_coverage" do
+      subject.should_receive(:log_coverage).with("_coverage_")
+      subject.result("coverage" => "_coverage_")
+    end
+
+  end
+
+  describe "#log_coverage" do
+
+    it "logs the coverage information" do
+      mock = mock(reports: nil)
+      Teabag::Coverage.should_receive(:new).with("_data_").and_return(mock)
+      mock.should_receive(:reports).and_return("_reports_")
+      STDOUT.should_receive(:print).with("_reports_")
+      subject.send(:log_coverage, "_data_")
+    end
+
+    it "doesn't log if there's no data" do
+      Teabag::Coverage.should_not_receive(:new)
+      subject.send(:log_coverage, {})
+    end
+
+    it "doesn't log when suppressing logs" do
+      Teabag.configuration.should_receive(:suppress_log).and_return(true)
+      Teabag::Coverage.should_not_receive(:new)
+      subject.send(:log_coverage, "_data_")
+    end
+
+  end
+
+end

data/spec/teabag/formatters/dot_formatter_spec.rb

@@ -64,21 +64,17 @@ describe Teabag::Formatters::DotFormatter do
 
       it "logs the details and raises an exception" do
         subject.failures << Teabag::Result.build_from_json("label" => "some spec", "suite" => "full description", "message" => "some message", "link" => "full description")
-        expect {
+        expect{
           subject.result("elapsed" => 0.31337)
         }.to raise_error(Teabag::Failure)
-        expect(@log).to eq("\n\nFailures:\n\n  1) full description some spec\n\e[31m     Failure/Error: some message\n\e[0m\nFinished in 0.31337 seconds\n\e[31m666 examples, 1 failure\n\e[0m\nFailed examples:\n\e[31m\nteabag -s default --filter=\"full description\"\e[0m\n\n")
+        expect(@log).to eq("\n\nFailures:\n\n  1) full description some spec\n\e[31m     Failure/Error: some message\n\n\e[0mFinished in 0.31337 seconds\n\e[31m666 examples, 1 failure\n\e[0m\nFailed examples:\n\n\e[31mteabag -s default --filter=\"full description\"\n\e[0m\n")
         expect(subject.failures.length).to be(1)
       end
 
       describe "when fail_fast is false" do
 
-        after do
-          Teabag.configuration.fail_fast = true
-        end
-
         it "doesn't raise the exception" do
-          Teabag.configuration.fail_fast = false
+          Teabag.configuration.should_receive(:fail_fast).and_return(false)
           subject.failures << Teabag::Result.build_from_json("message" => "some message")
           subject.result("elapsed" => 0.31337)
           expect(subject.failures.length).to be(1)
@@ -93,7 +89,7 @@ describe Teabag::Formatters::DotFormatter do
       it "logs the details" do
         subject.pendings << Teabag::Result.build_from_json("label" => "some spec", "suite" => "full description")
         subject.result("elapsed" => 0.31337)
-        expect(@log).to eq("\n\nPending:\e[33m\n  full description some spec\n\e[0m\e[36m    # Not yet implemented\n\e[0m\nFinished in 0.31337 seconds\n\e[33m666 examples, 0 failures, 1 pending\n\e[0m")
+        expect(@log).to eq("\n\nPending:\n\e[33m  full description some spec\n\e[0m\e[36m    # Not yet implemented\n\n\e[0mFinished in 0.31337 seconds\n\e[33m666 examples, 0 failures, 1 pending\n\e[0m")
       end
 
     end
@@ -103,7 +99,7 @@ describe Teabag::Formatters::DotFormatter do
   describe "#exception" do
 
     it "raises" do
-      expect { subject.exception }.to raise_error(Teabag::RunnerException)
+      expect{ subject.exception }.to raise_error(Teabag::RunnerException)
     end
 
   end

data/spec/teabag/instrumentation_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+require "rack/test"
+
+describe Teabag::Instrumentation do
+
+  subject { Teabag::Instrumentation }
+
+  let(:asset) { mock(source: nil) }
+  let(:response) { [200, {"Content-Type" => "application/javascript"}, asset] }
+  let(:env) { {"QUERY_STRING" => "instrument=true"} }
+
+  before do
+    Teabag::Instrumentation.stub(:which).and_return("/path/to/istanbul")
+    Teabag::Instrumentation.instance_variable_set(:@executable, nil)
+  end
+
+  after do
+    Teabag::Instrumentation.instance_variable_set(:@executable, nil)
+  end
+
+  describe ".executable" do
+
+    it "returns the executable" do
+      expect(subject.executable).to eq("/path/to/istanbul")
+      expect(subject.instance_variable_get(:@executable)).to eq("/path/to/istanbul")
+    end
+
+  end
+
+  describe ".add?" do
+
+    before do
+      subject.stub(:executable).and_return("/path/to/istanbul")
+    end
+
+    it "returns true when everything is good" do
+      expect(subject.add?(response, {"QUERY_STRING" => "instrument=true"})).to be(true)
+      expect(subject.add?(response, {"QUERY_STRING" => "instrument=1"})).to be(true)
+    end
+
+    it "doesn't if the query param isn't set (or isn't something we care about)" do
+      expect(subject.add?(response, {})).to_not be(true)
+      expect(subject.add?(response, {"QUERY_STRING" => "instrument=foo"})).to_not be(true)
+    end
+
+    it "doesn't if response isn't 200" do
+      expect(subject.add?([404, {"Content-Type" => "application/javascript"}, asset], env)).to_not be(true)
+    end
+
+    it "doesn't when the content type isn't application/javascript" do
+      expect(subject.add?([200, {"Content-Type" => "foo/bar"}, asset], env)).to_not be(true)
+    end
+
+    it "doesn't if there's no executable" do
+      subject.should_receive(:executable).and_return(false)
+      expect(subject.add?(response, env)).to_not be(true)
+    end
+
+    it "doesn't if there's no asset" do
+      expect(subject.add?([404, {"Content-Type" => "application/javascript"}, []], env)).to_not be(true)
+    end
+
+  end
+
+  describe ".add_to" do
+
+    let(:asset) { mock(source: "function add(a, b) { return a + b }", pathname: 'path/to/instrument.js') }
+
+    before do
+      Teabag::Instrumentation.stub(:add?).and_return(true)
+
+      File.stub(:write)
+      subject.any_instance.stub(:instrument).and_return("_foo_")
+
+      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.should_receive(:write).with(@output, "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" => "5"}, asset]
+
+      subject.add_to(response, env)
+      expect(response).to eq(expected)
+    end
+
+  end
+
+end

data/spec/teabag/result_spec.rb

@@ -3,33 +3,34 @@ require "teabag/result"
 
 describe Teabag::Result do
 
+  subject { Teabag::Result.build_from_json(json) }
   let(:suite_name) { 'My Suite' }
-  let(:json) do
-    { "type"              => "spec",
-      "suite"             => "_suite_name_",
-      "label"             => "_spec_name_",
-      "status"            => "failed",
-      "skipped"           => false,
-      "link"              => "?grep=_spec_description_",
-      "message"           => "_message_",
-      "trace"             => "_trace_" }
-  end
-  let(:result) { Teabag::Result.build_from_json(json) }
+  let(:json) {{
+    "type"     => "spec",
+    "suite"    => "_suite_name_",
+    "label"    => "_spec_name_",
+    "status"   => "failed",
+    "skipped"  => false,
+    "link"     => "?grep=_spec_description_",
+    "message"  => "_message_",
+    "trace"    => "_trace_",
+    "coverage" => "_coverage_",
+  }}
 
   describe ".build_from_json" do
 
     describe "with a results object" do
 
-      let(:json) do
-        { "elapsed"  => 0.01,
-          "failures" => 10,
-          "pending"  => 1,
-          "total"    => 25 }
-      end
+      let(:json) {{
+        "elapsed"  => 0.01,
+        "failures" => 10,
+        "pending"  => 1,
+        "total"    => 25
+      }}
 
       it "assigns from the JSON hash" do
-        expect(result.elapsed).to eq(0.01)
-        expect(result.total).to eq(25)
+        expect(subject.elapsed).to eq(0.01)
+        expect(subject.total).to eq(25)
       end
 
     end
@@ -37,15 +38,16 @@ describe Teabag::Result do
     describe "with a spec" do
 
       it "assigns from the JSON hash" do
-        expect(result.type).to eq('spec')
-        expect(result.suite).to eq('_suite_name_')
-        expect(result.label).to eq('_spec_name_')
-        expect(result.description).to eq('_suite_name_ _spec_name_')
-        expect(result.status).to eq('failed')
-        expect(result.skipped).to be_false
-        expect(result.link).to eq('?grep=_spec_description_')
-        expect(result.message).to eq('_message_')
-        expect(result.trace).to eq('_trace_')
+        expect(subject.type).to eq('spec')
+        expect(subject.suite).to eq('_suite_name_')
+        expect(subject.label).to eq('_spec_name_')
+        expect(subject.description).to eq('_suite_name_ _spec_name_')
+        expect(subject.status).to eq('failed')
+        expect(subject.skipped).to be_false
+        expect(subject.link).to eq('?grep=_spec_description_')
+        expect(subject.message).to eq('_message_')
+        expect(subject.trace).to eq('_trace_')
+        expect(subject.coverage).to eq('_coverage_')
       end
 
     end