teabag 0.3.5 → 0.3.6

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

@@ -32,3 +32,25 @@ describe "Teabag.Runner", ->
       spyOn(String.prototype, "substring").andReturn("grep=foo&bar=baz")
       runner = new Teabag.Runner()
       expect(runner.params).toEqual(grep: "foo", bar: "baz")
+
+
+  describe "#getReporter", ->
+
+    it "returns the correct reporter when using PhantomJS", ->
+      runner = new Teabag.Runner()
+      runner.params = {}
+      spyOn(String.prototype, 'match').andReturn(20)
+      expect(runner.getReporter()).toBe(Teabag.Reporters.Console)
+
+    it "returns the correct reporter when using the browser", ->
+      runner = new Teabag.Runner()
+      runner.params = {}
+      spyOn(String.prototype, 'match').andReturn(0)
+      expect(runner.getReporter()).toBe(Teabag.Reporters.HTML)
+
+    it "allows setting the param", ->
+      runner = new Teabag.Runner()
+      runner.params = {reporter: "Console"}
+      expect(runner.getReporter()).toBe(Teabag.Reporters.Console)
+      runner.params = {reporter: "HTML"}
+      expect(runner.getReporter()).toBe(Teabag.Reporters.HTML)

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

@@ -17,7 +17,7 @@ describe "Teabag", ->
       expect(keys).toContain("console")
 
 
-  describe "@execute", ->
+  describe ".execute", ->
 
     beforeEach ->
       Teabag.defer = false

data/spec/javascripts/teabag/jasmine/models_jspec.coffee

@@ -0,0 +1,101 @@
+describe "Jasmine Teabag.Spec", ->
+
+  beforeEach ->
+    @mockSuite =
+      getFullName: -> "_full jasmine name_"
+    @mockSpecResultsItems = [
+      {message: "_jasmine_message1_", trace: {stack: "_jasmine_stack_trace1_"}, passed: -> false}
+      {message: "_jasmine_message2_", trace: {stack: "_jasmine_stack_trace2_"}, passed: -> false}
+    ]
+    @mockSpecResults =
+      skipped: false
+      passed: -> true
+      getItems: => @mockSpecResultsItems
+    @mockSpec =
+      description: "_jasmine_description_"
+      viewId: 42
+      pending: false
+      suite: @mockSuite
+      getFullName: -> "_full jasmine description_"
+      results: => @mockSpecResults
+
+  describe "constructor", ->
+
+    it "has the expected properties", ->
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.fullDescription).toBe("_full jasmine description_")
+      expect(spec.description).toBe("_jasmine_description_")
+      expect(spec.link).toBe("?grep=_full%20jasmine%20description_")
+      expect(spec.parent).toBe(@mockSuite)
+      expect(spec.suiteName).toBe("_full jasmine name_")
+      expect(spec.viewId).toBe(42)
+      expect(spec.pending).toBe(false)
+
+
+  describe "#errors", ->
+
+    it "returns the expected object", ->
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.errors()).toEqual([{message: "_jasmine_message1_", stack: "_jasmine_stack_trace1_"}, {message: "_jasmine_message2_", stack: "_jasmine_stack_trace2_"}])
+      spyOn(@mockSpecResultsItems[0], "passed").andReturn(true)
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.errors()).toEqual([{message: "_jasmine_message2_", stack: "_jasmine_stack_trace2_"}])
+
+
+  describe "#getParents", ->
+
+    it "gets the parent suites", ->
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.getParents()[0].fullDescription).toEqual("_full jasmine name_")
+
+
+  describe "#result", ->
+
+    describe "passing", ->
+
+      it "returns the expected object", ->
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).toEqual({status: "passed", skipped: false})
+
+    describe "skipped", ->
+
+      it "returns the expected object", ->
+        @mockSpecResults.skipped = true
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).toEqual({status: "passed", skipped: true})
+
+    describe "pending", ->
+
+      it "returns the expected object", ->
+        @mockSpec.pending = true
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).toEqual({status: "pending", skipped: false})
+
+    describe "failing", ->
+
+      it "returns the expected object", ->
+        spyOn(@mockSpecResults, "passed").andReturn(false)
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).toEqual({status: "failed", skipped: false})
+
+
+
+describe "Jasmine Teabag.Suite", ->
+
+  beforeEach ->
+    @mockParentSuite = {}
+    @mockSuite =
+      description: "_jasmine_description_"
+      parentSuite: @mockParentSuite
+      viewId: 42
+      getFullName: -> "_full jasmine description_"
+
+  describe "constructor", ->
+
+    it "has the expected properties", ->
+      suite = new Teabag.Suite(@mockSuite)
+      expect(suite.fullDescription).toBe("_full jasmine description_")
+      expect(suite.description).toBe("_jasmine_description_")
+      expect(suite.link).toBe("?grep=_full%20jasmine%20description_")
+      expect(suite.parent).toBe(@mockParentSuite)
+      expect(suite.viewId).toBe(42)

data/spec/javascripts/teabag/jasmine/runner_jspec.coffee

@@ -20,7 +20,7 @@ describe "Jasmine Teabag.Runner", ->
     beforeEach ->
       @runner.params = {grep: "foo"}
       @instance = {setFilter: ->}
-      if navigator.userAgent.match(/PhantomJS/)
+      if window.navigator.userAgent.match(/PhantomJS/)
         @reporterSpy = spyOn(Teabag.Reporters, "Console").andReturn(@instance)
       else
         @reporterSpy = spyOn(Teabag.Reporters, "HTML").andReturn(@instance)

data/spec/javascripts/teabag/mocha/models_mspec.coffee

@@ -0,0 +1,95 @@
+describe "Mocha Teabag.Spec", ->
+
+  beforeEach ->
+    @mockSuite =
+      fullTitle: -> "_full mocha name_"
+      parent:
+        root: true
+    @mockSpec =
+      title: "_mocha_description_"
+      parent: @mockSuite
+      viewId: 420
+      pending: false
+      state: "passed"
+      err: {message: "_mocha_message_", stack: "_mocha_stack_trace_"}
+      fullTitle: -> "_full mocha description_"
+
+  describe "constructor", ->
+
+      it "has the expected properties", ->
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.fullDescription).to.be("_full mocha description_")
+        expect(spec.description).to.be("_mocha_description_")
+        expect(spec.link).to.be("?grep=_full%20mocha%20description_")
+        expect(spec.parent).to.be(@mockSuite)
+        expect(spec.suiteName).to.be("_full mocha name_")
+        expect(spec.viewId).to.be(420)
+        expect(spec.pending).to.be(false)
+
+
+  describe "#errors", ->
+
+    it "returns the expected object", ->
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.errors()).to.eql([{message: "_mocha_message_", stack: "_mocha_stack_trace_"}])
+
+
+  describe "#getParents", ->
+
+    it "gets the parent suites", ->
+      spec = new Teabag.Spec(@mockSpec)
+      expect(spec.getParents()[0].fullDescription).to.be("_full mocha name_")
+
+
+  describe "#result", ->
+
+    describe "passing", ->
+
+      it "returns the expected object", ->
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).to.eql({status: "passed", skipped: false})
+
+    describe "skipped", ->
+
+      it "returns the expected object", ->
+        @mockSpec.state = "skipped"
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).to.eql({status: "passed", skipped: true})
+
+    describe "pending", ->
+
+      it "returns the expected object", ->
+        @mockSpec.pending = true
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).to.eql({status: "pending", skipped: false})
+
+    describe "failing", ->
+
+      it "returns the expected object", ->
+        @mockSpec.state = "failed"
+        spec = new Teabag.Spec(@mockSpec)
+        expect(spec.result()).to.eql({status: "failed", skipped: false})
+
+
+
+describe "Mocha Teabag.Suite", ->
+
+  beforeEach ->
+    @mockParentSuite = {root: false}
+    @mockSuite =
+      fullTitle: -> "_full mocha description_"
+      title: "_mocha_description_"
+      viewId: 420
+      parent: @mockParentSuite
+
+  describe "constructor", ->
+
+    describe "with mocha type suite", ->
+
+      it "has the expected properties", ->
+        suite = new Teabag.Suite(@mockSuite)
+        expect(suite.fullDescription).to.be("_full mocha description_")
+        expect(suite.description).to.be("_mocha_description_")
+        expect(suite.link).to.be("?grep=_full%20mocha%20description_")
+        expect(suite.parent).to.be(@mockParentSuite)
+        expect(suite.viewId).to.be(420)

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

@@ -2,10 +2,14 @@ describe "Mocha Teabag.Reporters.Console", ->
 
   beforeEach ->
     @runner = {on: @onSpy = sinon.spy()}
+    @reportRunnerStartingSpy = Teabag.Reporters.Console.prototype.reportRunnerStarting = sinon.spy()
     @reporter = new Teabag.Reporters.Console(@runner)
 
   describe "constructor", ->
 
+    it "calls reporterRunnerStarting", ->
+      assert.calledOnce(@reportRunnerStartingSpy, "foo")
+
     it "registers for 'fail', 'test end', and 'end'", ->
       assert.calledWith(@onSpy, "fail", @reporter.reportSpecResults)
       assert.calledWith(@onSpy, "test end", @reporter.reportSpecResults)

data/spec/javascripts/teabag/mocha/runner_mspec.coffee

@@ -14,10 +14,10 @@ describe "Mocha Teabag.Runner", ->
   describe "#setup", ->
 
     it "adds the reporter to the env", ->
-      spy = mocha.setup = sinon.spy()
-      @runner.params = {grep: "foo"}
-      @runner.setup()
-      if navigator.userAgent.match(/PhantomJS/)
-        assert.calledOnce(spy, reporter: Teabag.Reporters.Console)
-      else
-        assert.calledOnce(spy, reporter: Teabag.Reporters.HTML)
+#      spy = mocha.setup = sinon.spy()
+#      @runner.params = {grep: "foo"}
+#      @runner.setup()
+#      if window.navigator.userAgent.match(/PhantomJS/)
+#        assert.calledOnce(spy, reporter: Teabag.Reporters.Console)
+#      else
+#        assert.calledOnce(spy, reporter: Teabag.Reporters.HTML)

data/spec/javascripts/teabag/phantomjs/runner_spec.coffee

@@ -1,5 +1,5 @@
 #= require_self
-#= require phantomjs/runner
+#= require drivers/phantomjs/runner
 
 # stub out phantomjs
 window.phantom = {exit: ->}
@@ -121,26 +121,26 @@ describe "PhantomJS Runner", ->
       expect(Object.keys(object)).toEqual(["onError", "onConsoleMessage", "onLoadFinished"])
 
 
-  describe "page callback methods", ->
+  describe "callback method", ->
 
     beforeEach ->
       @callbacks = @runner.pageCallbacks()
 
-    describe "onError", ->
+    describe "#onError", ->
 
       it "logs the json of a message and trace", ->
         @callbacks.onError("_message_", ["trace1", "trace2"])
         expect(@logSpy).toHaveBeenCalledWith('{"_teabag":true,"type":"error","message":"_message_","trace":["trace1","trace2"]}')
 
 
-    describe "onConsoleMessage", ->
+    describe "#onConsoleMessage", ->
 
       it "logs the message", ->
         @callbacks.onConsoleMessage("_message_")
         expect(@logSpy).toHaveBeenCalledWith("_message_")
 
 
-    describe "onLoadFinish", ->
+    describe "#onLoadFinish", ->
 
       beforeEach ->
         @runner.initPage()

data/spec/teabag/configuration_spec.rb

@@ -21,7 +21,7 @@ describe Teabag do
     after do
       Teabag.configuration.suppress_log = false
       Teabag.configuration.fail_fast = true
-      Teabag.configuration.formatters = 'progress'
+      Teabag.configuration.formatters = "dot"
     end
 
     it "allows overriding of fail_fast and suppress_log from the env" do
@@ -57,7 +57,7 @@ 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('progress')
+    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)

data/spec/teabag/console_spec.rb

@@ -47,23 +47,11 @@ describe Teabag::Console do
 
   describe "#run_specs" do
 
-    before do
-      Phantomjs.stub(:run)
-    end
-
-    it "instantiates the formatter" do
-      formatter = mock(failure_count: nil)
-      Teabag::Runner.should_receive(:new).and_return(formatter)
-      subject.run_specs(:default)
-    end
-
-    it "phantomjs.run and logs the results of each line using the formatter" do
-      args = [Teabag::Engine.root.join("lib/teabag/phantomjs/runner.coffee").to_s, "http://url.com/teabag/default"]
-      Teabag::Runner.any_instance.should_receive(:process).with("_line_")
-      @block = nil
-      Phantomjs.should_receive(:run).with(*args) { |&b| @block = b }
-      subject.run_specs(:default)
-      @block.call("_line_")
+    it "calls run_specs on the driver" do
+      driver = mock(run_specs: nil)
+      subject.should_receive(:driver).and_return(driver)
+      driver.should_receive(:run_specs).with(:suite_name, "http://url.com/teabag/suite_name")
+      subject.run_specs(:suite_name)
     end
 
   end

data/spec/teabag/drivers/phantomjs_driver_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "teabag/drivers/phantomjs_driver"
+
+describe Teabag::Drivers::PhantomjsDriver do
+
+  describe "#run_specs" do
+
+    before do
+      Phantomjs.stub(:run)
+    end
+
+    it "instantiates the formatter" do
+      runner = mock(failure_count: nil)
+      Teabag::Runner.should_receive(:new).and_return(runner)
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "calls phantomjs.run and logs the results of each line using the formatter" do
+      args = [Teabag::Engine.root.join("lib/teabag/drivers/phantomjs/runner.coffee").to_s, "_url_"]
+      Teabag::Runner.any_instance.should_receive(:process).with("_line_")
+      @block = nil
+      Phantomjs.should_receive(:run).with(*args) { |&b| @block = b }
+      subject.run_specs(:default, "_url_")
+      @block.call("_line_")
+    end
+
+  end
+
+end

data/spec/teabag/drivers/selenium_driver_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "teabag/drivers/selenium_driver"
+
+describe Teabag::Drivers::SeleniumDriver do
+
+  describe "#run_specs" do
+
+    before do
+      @navigate = mock(to: nil)
+      @driver = mock(quit: nil, navigate: @navigate, execute_script: nil)
+      Selenium::WebDriver.stub(:for).and_return(@driver)
+      @wait = mock(until: nil)
+      Selenium::WebDriver::Wait.stub(:new).and_return(@wait)
+    end
+
+    it "instantiates the formatter" do
+      runner = mock(failure_count: nil)
+      Teabag::Runner.should_receive(:new).and_return(runner)
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "returns the number of failures from the runner" do
+      runner = mock(failure_count: 42)
+      Teabag::Runner.should_receive(:new).and_return(runner)
+      expect(subject.run_specs(:default, "_url_")).to be(42)
+    end
+
+    it "loads firefox for the webdriver" do
+      Selenium::WebDriver.should_receive(:for).with(:firefox)
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "navigates to the correct url" do
+      @navigate.should_receive(:to).with("_url_?reporter=Console")
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "ensures quit is called on the driver" do
+      @driver.should_receive(:quit)
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "waits for the specs to complete, setting the interval, timeout and message" do
+      Selenium::WebDriver::Wait.should_receive(:new).with(timeout: 180, interval: 0.01, message: "Timed out")
+      subject.run_specs(:default, "_url_")
+    end
+
+    it "waits until it's done (checking Teabag.finished) and processes each line" do
+      @block = nil
+      @wait.should_receive(:until) { |&b| @block = b }
+      @driver.should_receive(:execute_script).with("return window.Teabag && window.Teabag.finished").and_return(true)
+      @driver.should_receive(:execute_script).with("return Teabag.getMessages()").and_return(["_line_"])
+      Teabag::Runner.any_instance.should_receive(:process).with("_line_\n")
+      subject.run_specs(:default, "_url_")
+      @block.call
+    end
+
+  end
+
+end