Keep runner from stalling when circular objects are present

Author: sheelc

lib/jasmine/runners/selenium.rb

@@ -52,14 +52,32 @@ def get_results
         spec_results = []
 
         loop do
-          slice = driver.execute_script("return jsApiReporter.specResults(#{index}, #{result_batch_size})")
-          spec_results << Jasmine::Result.map_raw_results(slice)
+          slice = results_without_circular_references(index)
+          spec_results << slice
           index += result_batch_size
           break if slice.size < result_batch_size
         end
         spec_results.flatten
       end
 
+      def results_without_circular_references(starting_index)
+        slice = driver.execute_script(<<-JS)
+          var specResults = jsApiReporter.specResults(#{starting_index}, #{result_batch_size})
+          for (var i = 0; i < specResults.length; i++) {
+            var expectations = specResults[i].failedExpectations;
+            if (specResults[i].passedExpectations) {
+              expectations = expectations.concat(specResults[i].passedExpectations);
+            }
+            for (var j = 0; j < expectations.length; j++) {
+              var expectation = expectations[j];
+              try { JSON.stringify(expectation.expected); } catch (e) { expectation.expected = '<circular expected>'; }
+              try { JSON.stringify(expectation.actual); } catch (e) { expectation.actual = '<circular actual>'; }
+            }
+          }
+          return specResults;
+        JS
+        Jasmine::Result.map_raw_results(slice)
+      end
     end
   end
 end

spec/fixtures/contains_circular_references_spec.js

@@ -0,0 +1,7 @@
+it("handles circular references", function() {
+  var objA = {};
+  var objB = {back_reference: objA};
+  objA.back_reference = objB;
+
+  expect(objA).not.toBe(objA);
+});

spec/jasmine_selenium_runner/configure_jasmine_spec.rb

@@ -10,7 +10,7 @@
     let(:config) { { 'selenium_server' => 'http://example.com/selenium/stuff' }}
 
     it "make a webdriver pointing to the custom server" do
-      Selenium::WebDriver.should_receive(:for).with(:remote, hash_including(url: 'http://example.com/selenium/stuff'))
+      expect(Selenium::WebDriver).to receive(:for).with(:remote, hash_including(url: 'http://example.com/selenium/stuff'))
       configurer.make_runner
     end
   end
@@ -20,8 +20,8 @@
 
     it "should create a firebug profile and pass that to WebDriver" do
       profile = double(:profile, enable_firebug: nil)
-      Selenium::WebDriver::Firefox::Profile.stub(:new).and_return(profile)
-      Selenium::WebDriver.should_receive(:for).with('firefox-firebug'.to_sym, {profile: profile})
+      allow(Selenium::WebDriver::Firefox::Profile).to receive(:new).and_return(profile)
+      expect(Selenium::WebDriver).to receive(:for).with('firefox-firebug'.to_sym, {profile: profile})
       configurer.make_runner
     end
   end
@@ -32,17 +32,17 @@ class FakeConfig
     end
 
     def configure
-      Dir.stub(:pwd).and_return(working_dir)
-      Jasmine.stub(:configure).and_yield(fake_config)
+      allow(Dir).to receive(:pwd).and_return(working_dir)
+      allow(Jasmine).to receive(:configure).and_yield(fake_config)
       JasmineSeleniumRunner::ConfigureJasmine.install_selenium_runner
     end
 
     def stub_config_file(config_obj)
       config_path = File.join(working_dir, 'spec', 'javascripts', 'support', 'jasmine_selenium_runner.yml')
-      File.stub(:exist?).and_call_original
-      File.stub(:exist?).with(config_path).and_return(true)
-      File.stub(:read).and_call_original
-      File.stub(:read).with(config_path).and_return(YAML.dump(config_obj))
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(config_path).and_return(true)
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(config_path).and_return(YAML.dump(config_obj))
     end
 
     let(:working_dir) { 'hi' }
@@ -64,8 +64,8 @@ def make_runner
     end
 
     it "should use the custom class" do
-      Selenium::WebDriver.should_not_receive(:for)
-      Foo::Bar.any_instance.should_receive(:make_runner)
+      expect(Selenium::WebDriver).not_to receive(:for)
+      expect_any_instance_of(Foo::Bar).to receive(:make_runner)
       fake_config.runner.call(nil, nil)
     end
   end

spec/selenium_runner_integration_spec.rb

@@ -21,7 +21,27 @@
         `bundle exec jasmine examples`
         FileUtils.cp(File.join(project_root, 'spec', 'fixtures', 'is_in_firefox_spec.js'), File.join(dir, 'spec', 'javascripts'))
         ci_output = `bundle exec rake -E "require 'jasmine_selenium_runner'" --trace jasmine:ci`
-        ci_output.should =~ /[1-9][0-9]* specs, 0 failures/
+        expect(ci_output).to match(/[1-9][0-9]* specs, 0 failures/)
+      end
+    end
+  end
+
+  it "allows rake jasmine:ci to retrieve results even though Selenium can't transmit back circular JS objects" do
+    in_temp_dir do |dir, project_root|
+      File.open(File.join(dir, 'Gemfile'), 'w') do |file|
+        file.write <<-GEMFILE
+source 'https://rubygems.org'
+gem 'jasmine_selenium_runner', :path => '#{project_root}'
+gem 'jasmine', :git => 'https://github.com/pivotal/jasmine-gem.git'
+GEMFILE
+      end
+      Bundler.with_clean_env do
+        `bundle`
+        `bundle exec jasmine init`
+        `bundle exec jasmine examples`
+        FileUtils.cp(File.join(project_root, 'spec', 'fixtures', 'contains_circular_references_spec.js'), File.join(dir, 'spec', 'javascripts'))
+        ci_output = `bundle exec rake -E "require 'jasmine_selenium_runner'" --trace jasmine:ci`
+        expect(ci_output).to match(/[1-9][0-9]* specs, 1 failure/)
       end
     end
   end
@@ -68,13 +88,13 @@
         before = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
           http.request(job_list_request)
         end
-        JSON.parse(before.body).should == []
+        expect(JSON.parse(before.body)).to be_empty
         ci_output = %x{bundle exec rake -E "require 'jasmine_selenium_runner'" --trace jasmine:ci}
-        ci_output.should =~ (/[1-9][0-9]* specs, 0 failures/)
+        expect(ci_output).to match(/[1-9][0-9]* specs, 0 failures/)
         after = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
           http.request(job_list_request)
         end
-        JSON.parse(after.body).should_not be_empty
+        expect(JSON.parse(after.body)).not_to be_empty
       end
     end
   end
@@ -107,7 +127,7 @@ def bundle_install
         `bundle exec rails g jasmine:examples`
         FileUtils.cp(File.join(project_root, 'spec', 'fixtures', 'is_in_firefox_spec.js'), File.join(dir, 'rails-test', 'spec', 'javascripts'))
         output = `bundle exec rake jasmine:ci`
-        output.should =~ /[1-9]\d* specs, 0 failures/
+        expect(output).to match(/[1-9]\d* specs, 0 failures/)
       end
     end
   end