jasmine-selenium-sauce 1.0.0

data/spec/jasmine-selenium-sauce/jasmine_results_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'jasmine_results'
+require 'sample_results'
+
+describe Jasmine::Sauce::CI::JasmineResults do
+
+  let(:under_test) { Jasmine::Sauce::CI::JasmineResults.new(suites, suite_results) }
+
+  describe "#suites" do
+    subject { under_test.suites }
+
+    context "when no suites" do
+      let(:suites) { {} }
+      let(:suite_results) { {} }
+      it { should be_empty }
+    end
+
+    context "when suites" do
+      include_context "suites sample"
+      let(:suite_results) { {} }
+      it { should eq(suites) }
+    end
+  end
+
+  describe "#for_spec_id" do
+    let(:spec_id) { "1" }
+    let(:suites) { {} }
+    subject { under_test.for_spec_id(spec_id) }
+
+    context "when unknown spec id" do
+      let(:suite_results) { {} }
+      it { should be_nil }
+    end
+
+    context "when valid spec id" do
+      include_context "suite result sample"
+      it { should eq(suite_results["1"]) }
+    end
+  end
+end

data/spec/jasmine-selenium-sauce/sauce_config_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'sauce_config'
+
+describe Jasmine::Sauce::CI::SauceConfig do
+
+  after do
+    ENV.delete('SAUCELABS_URL')
+    ENV.delete('JASMINE_URL')
+    ENV.delete('SAUCE_BROWSER')
+  end
+
+  describe "#validate" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.validate }
+
+    context "when valid" do
+      before do
+        ENV['SAUCELABS_URL'] = 'sauce'
+        ENV['JASMINE_URL'] = 'jasmine'
+        ENV['SAUCE_BROWSER'] = 'browser'
+      end
+      specify { expect { subject }.not_to raise_error  }
+    end
+
+    context "when saucelabs url is not set" do
+      before do
+        ENV['JASMINE_URL'] = 'jasmine'
+        ENV['SAUCE_BROWSER'] = 'browser'
+      end
+      specify { expect { subject }.to raise_error(ArgumentError)  }
+    end
+
+    context "when jasmine url is not set" do
+      before do
+        ENV['SAUCELABS_URL'] = 'sauce'
+        ENV['SAUCE_BROWSER'] = 'browser'
+      end
+      specify { expect { subject }.to raise_error(ArgumentError)  }
+    end
+
+    context "when browser is not set" do
+      before do
+        ENV['SAUCELABS_URL'] = 'sauce'
+        ENV['JASMINE_URL'] = 'jasmine'
+      end
+      specify { expect { subject }.to raise_error(ArgumentError)  }
+    end
+  end
+  
+  shared_examples_for "overridable configuration setting" do |env_setting, default|
+    context "when not specified" do
+      it { should eq(default) }
+    end
+
+    context "when specified" do
+      let(:value) { "random value" }
+      before { ENV[env_setting] = value }
+      after { ENV.delete(env_setting) }
+      it { should eq(value) }
+    end
+  end
+
+  describe "#saucelabs_server_url" do
+    let(:url) { "http://user:password@ondemand.saucelabs.com:80/wd/hub" }
+    before { ENV['SAUCELABS_URL'] = url }
+    after { ENV.delete('SAUCELABS_URL') }
+    its(:saucelabs_server_url) { should eq(url)}
+  end
+
+  describe "#jasmine_server_url" do
+    let(:url) { "http://my.host.com/jasmine" }
+    before { ENV['JASMINE_URL'] = url }
+    after { ENV.delete('JASMINE_URL') }
+    its(:jasmine_server_url) { should eq(url)}
+  end
+
+  describe "#sauce_browser" do
+    let(:browser) { "Chrome" }
+    before { ENV['SAUCE_BROWSER'] = browser }
+    after { ENV.delete('SAUCE_BROWSER') }
+    its(:browser) { should eq(browser)}
+  end
+
+  describe "#sauce_platform" do
+    context "when not specified" do
+      its(:platform) { should eq(:VISTA) }
+    end
+
+    context "when specified" do
+      let(:platform) { "WIN_7" }
+      before { ENV['SAUCE_PLATFORM'] = platform }
+      after { ENV.delete('SAUCE_PLATFORM') }
+      its(:platform) { should eq(platform.to_sym) }
+    end
+  end
+
+  describe "#browser_version" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.browser_version }
+    it_behaves_like "overridable configuration setting", 'SAUCE_BROWSER_VERSION', nil
+  end
+
+  describe "#record_screenshots" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.record_screenshots }
+    it_behaves_like "overridable configuration setting", 'SAUCE_SCREENSHOTS', false
+  end
+
+  describe "#record_video" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.record_video }
+    it_behaves_like "overridable configuration setting", 'SAUCE_VIDEO', false
+  end
+
+  describe "#idle_timeout" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.idle_timeout }
+    it_behaves_like "overridable configuration setting", 'SAUCE_IDLE_TIMEOUT', 90
+  end
+
+  describe "#max_duration" do
+    subject { Jasmine::Sauce::CI::SauceConfig.new.max_duration }
+    it_behaves_like "overridable configuration setting", 'SAUCE_MAX_DURATION', 180
+  end
+end

data/spec/jasmine-selenium-sauce/selenium_runner_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'selenium_runner'
+require 'jasmine_results'
+require 'sample_results'
+
+describe Jasmine::Sauce::CI::SeleniumRunner do
+
+  let(:driver) { double("Driver") }
+  let(:url) { "jasmine.url" }
+  let(:under_test) { Jasmine::Sauce::CI::SeleniumRunner.new(driver) }
+
+  describe "#run" do
+    subject { under_test.run(url) }
+
+    let(:load_timeout) { 0.01 }
+    before do
+      driver.should_receive(:connect).with(url)
+      under_test.should_receive(:load_jasmine_timeout).and_return(load_timeout)
+    end
+
+    context "when loading jasmine times out" do
+      before do
+        driver.should_receive(:evaluate_js).and_return(false, false)
+      end
+      specify { expect {subject}.to raise_error("Timed out after #{load_timeout}s waiting for Jasmine to load") }
+    end
+
+    context "when jasmine execution times out" do
+      let(:load_result) { true }
+      let(:suites) { {} }
+      let(:jasmine_finished_result) { false }
+      before do
+        under_test.should_receive(:jasmine_execution_timeout).and_return(load_timeout)
+        driver.should_receive(:evaluate_js).and_return(load_result, suites, jasmine_finished_result, jasmine_finished_result)
+      end
+      specify { expect {subject}.to raise_error("Timed out after #{load_timeout}s waiting for Jasmine to finish") }
+    end
+
+    context "when there are no suites" do
+      let(:load_result) { true }
+      let(:suites) { {} }
+      let(:jasmine_finished_result) { true }
+      let(:suite_results) { {} }
+
+      before do
+        under_test.should_receive(:jasmine_execution_timeout).and_return(load_timeout)
+        driver.should_receive(:evaluate_js).and_return(load_result, suites, jasmine_finished_result)
+        driver.should_receive(:disconnect)
+      end
+
+      it("should return no suites") { subject.suites.should be_empty }
+      it("should return no suite results") { subject.for_spec_id('0').should be_nil }
+    end
+
+    shared_context "selenium runner is successful" do
+      include_context "suites sample"
+      include_context "suite result sample"
+
+      let(:load_result) { true }
+      let(:jasmine_finished_result) { true }
+
+      before do
+        under_test.should_receive(:jasmine_execution_timeout).and_return(load_timeout)
+        driver.should_receive(:disconnect)
+      end
+
+      it("should return suites") { subject.suites.should eq(suites) }
+      it("should return suite results") { subject.for_spec_id('0').should eq(suite_results['0']) }
+    end
+
+    context "when there are suites" do
+      include_context "selenium runner is successful"
+
+      before {
+        driver.should_receive(:evaluate_js).and_return(load_result, suites, jasmine_finished_result, suite_results)
+      }
+    end
+
+    context "when suites exceed batch size" do
+      let(:batch_size) { 1 }
+      let(:under_test) { Jasmine::Sauce::CI::SeleniumRunner.new(driver, batch_size) }
+      include_context "selenium runner is successful"
+
+      before {
+        driver.should_receive(:evaluate_js).and_return(load_result, suites, jasmine_finished_result,
+                                                       suite_results.select {|k,_| k == '0'},
+                                                       suite_results.select {|k,_| k == '1'},
+                                                       suite_results.select {|k,_| k == '2'})
+      }
+    end
+  end
+
+end

data/spec/jasmine-selenium-sauce/selenium_saucelabs_driver_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'sauce_config'
+require 'selenium_saucelabs_driver'
+require 'sample_results'
+
+describe Jasmine::Sauce::CI::SeleniumSauceLabsDriver do
+
+  let(:under_test) { Jasmine::Sauce::CI::SeleniumSauceLabsDriver.new(config) }
+  let(:config) { Jasmine::Sauce::CI::SauceConfig.new }
+  let(:driver) { double("SeleniumWebDriver") }
+
+  shared_context "create driver is stubbed" do
+    before do
+      Jasmine::Sauce::CI::SeleniumSauceLabsDriver.any_instance.should_receive(:create_driver).with(config).and_return(driver)
+    end
+  end
+
+  describe "#create_driver" do
+    let(:selenium_client) { double("Selenium::WebDriver::Remote::Http::Default") }
+    let(:timeout) { "client timeout" }
+    let(:sauce_url) { "http://sauce.url" }
+    let(:capabilities) { "desired capabilities" }
+    subject { under_test }
+    before do
+      config.should_receive(:selenium_client_timeout).and_return(timeout)
+      config.should_receive(:saucelabs_server_url).and_return(sauce_url)
+      Selenium::WebDriver::Remote::Http::Default.should_receive(:new).and_return(selenium_client)
+      selenium_client.should_receive(:timeout=).with(timeout)
+      Jasmine::Sauce::CI::SeleniumSauceLabsDriver.any_instance.should_receive(:generate_capabilities).and_return(capabilities)
+      Selenium::WebDriver.should_receive(:for) do | browser, options |
+        browser.should eq(:remote)
+        options[:http_client].should eq(selenium_client)
+        options[:url].should eq(sauce_url)
+        options[:desired_capabilities].should eq(capabilities)
+      end
+    end
+
+    it("should interact with webdriver correctly") { subject }
+  end
+
+  describe "#connect" do
+    include_context "create driver is stubbed"
+    let(:url) { "http://jasmine.server.url/jasmine" }
+    let(:navigator) { double("SeleniumNavigator") }
+    subject { under_test.connect(url) }
+    before do
+      driver.should_receive(:navigate).and_return(navigator)
+      navigator.should_receive(:to).with(url)
+    end
+
+    specify { expect { subject }.not_to raise_error }
+  end
+
+  describe "#disconnect" do
+    include_context "create driver is stubbed"
+    subject { under_test.disconnect }
+    before do
+      driver.should_receive(:quit)
+    end
+
+    specify { expect { subject }.not_to raise_error }
+  end
+
+  describe "#evaluate_js" do
+    include_context "create driver is stubbed"
+    let(:script) { "the javascript" }
+    subject { under_test.evaluate_js(script) }
+    before do
+      driver.should_receive(:execute_script).and_return(script_result)
+    end
+
+    context "when simple result" do
+      let(:script_result) { "true" }
+      it { should be_true }
+    end
+
+    context "when json result" do
+      include_context "suites sample"
+      let(:script_result) { suites.to_json }
+      it { should eq(JSON.parse(script_result)) }
+    end
+  end
+
+  describe "#generate_capabilities" do
+    include_context "create driver is stubbed"
+    subject { under_test.generate_capabilities(config) }
+    before do
+      config.should_receive(:platform).and_return("platform")
+      config.should_receive(:browser).and_return("browser")
+      config.should_receive(:browser_version).and_return("version")
+      config.should_receive(:record_screenshots).and_return("screens")
+      config.should_receive(:record_video).and_return("video")
+      config.should_receive(:idle_timeout).and_return("idle")
+      config.should_receive(:max_duration).and_return("duration")
+    end
+
+    it { subject['platform'].should eq "platform" }
+    it { subject['browserName'].should eq "browser" }
+    it { subject['browser-version'].should eq "version" }
+    it { subject['record-screenshots'].should eq "screens" }
+    it { subject['record-video'].should eq "video" }
+    it { subject['idle-timeout'].should eq "idle" }
+    it { subject['max-duration'].should eq "duration" }
+  end
+
+end

data/spec/jasmine-selenium-sauce_spec.rb

@@ -0,0 +1,54 @@
+require_relative 'spec_helper'
+require_relative 'vcr_helper'
+require 'jasmine-selenium-sauce'
+require 'sauce_config'
+require 'reporter_fake'
+
+describe Jasmine::Sauce::CI::Main do
+
+  describe "#run" do
+
+    let(:config) { Jasmine::Sauce::CI::SauceConfig.new }
+    let(:reporter) { ReporterFake.new }
+    subject { Jasmine::Sauce::CI::Main.run(config, reporter) }
+
+    after do
+      ENV.delete('SAUCELABS_URL')
+      ENV.delete('JASMINE_URL')
+      ENV.delete('SAUCE_BROWSER')
+    end
+
+    context "when there are no failures" do
+      use_vcr_cassette 'jasmine_success', record: :none
+      before do
+        ENV['SAUCELABS_URL'] = 'http://username:password@ondemand.saucelabs.com:80/wd/hub'
+        ENV['JASMINE_URL'] = 'http://jasmine.server.com/jasmine'
+        ENV['SAUCE_BROWSER'] = 'chrome'
+      end
+
+      describe "passing tests" do
+        it { subject[:passed].should eq([0,1,2]) }
+      end
+      describe "failing tests" do
+        it { subject[:failed].should be_empty }
+      end
+    end
+
+    context "when there are failures" do
+      use_vcr_cassette 'jasmine_failures', record: :none
+      before do
+        ENV['SAUCELABS_URL'] = 'http://username:password@ondemand.saucelabs.com:80/wd/hub'
+        ENV['JASMINE_URL'] = 'http://jasmine.server.com/jasmine'
+        ENV['SAUCE_BROWSER'] = 'chrome'
+      end
+
+      describe "passing tests" do
+        it { subject[:passed].should eq([0,2]) }
+      end
+      describe "failing tests" do
+        it { subject[:failed].should eq([1]) }
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib', 'jasmine-selenium-sauce'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'fixtures'))
+

data/spec/support/reporter_fake.rb

@@ -0,0 +1,31 @@
+
+class ReporterFake
+
+  def report(jasmine_results)
+    results = { passed: [], failed: []}
+    jasmine_results.suites.each do |suite|
+      child_results = process_children(suite["children"], jasmine_results)
+      results[:passed].concat(child_results[:passed]) if child_results[:passed]
+      results[:failed].concat(child_results[:failed]) if child_results[:failed]
+    end
+    results
+  end
+
+  def process_children(children, jasmine_results)
+    results = { passed: [], failed: []}
+    children.each do |node|
+      type = node["type"]
+      if type == "suite"
+        child_results = process_children(node["children"], jasmine_results)
+        results[:passed].concat(child_results[:passed]) if child_results[:passed]
+        results[:failed].concat(child_results[:failed]) if child_results[:failed]
+      elsif type == "spec"
+        spec_result = jasmine_results.for_spec_id(node["id"].to_s)
+        results[:passed] << node["id"] if spec_result["result"] == "passed"
+        results[:failed] << node["id"] if spec_result["result"] == "failed"
+      end
+    end
+    results
+  end
+
+end