gorgon 0.11.0 → 0.11.1

data/spec/dummy/spec/keeping_rspec_config_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe "Keeping rspec configuration" do
+  it "keeps rspec configuration" do
+    expect(RSpec.configuration.custom_setting).to eq(:set)
+  end
+end

data/spec/dummy/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'rspec'
+
+RSpec.shared_examples "a shared example" do
+  it "passes" do
+    expect(true).to eq(true)
+  end
+end
+
+RSpec.configure do |config|
+  config.add_setting :custom_setting
+  config.custom_setting = :set
+end

data/spec/dummy/spec/successful_spec.rb

@@ -0,0 +1,9 @@
+describe "Successful spec" do
+  it "passes" do
+    expect(true).to eq(true)
+  end
+
+  it "passes again" do
+    expect(false).to eq(false)
+  end
+end

data/spec/dummy/spec/using_shared_example_spec.rb

@@ -0,0 +1,3 @@
+RSpec.describe "Using shared example spec" do
+  it_behaves_like "a shared example"
+end

data/spec/dummy/test/.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+
+module Stuff
+class Haha < Test::Unit::TestCase
+  def test_blahblah
+    assert true
+  end
+
+  def test_going_to_blow_up
+    sleep 1
+    raise "oh mah gawd"
+  end
+end
+end
+

data/spec/dummy/test/minitest/mini1_test.rb

@@ -0,0 +1,11 @@
+require 'minitest/unit'
+
+class GorgonMini1Test < MiniTest::Unit::TestCase
+  def test_pass
+    assert true
+  end
+
+  def test_that_will_be_skipped
+    skip "test this later"
+  end
+end

data/spec/dummy/test/minitest/mini2_test.rb

@@ -0,0 +1,25 @@
+require 'minitest/unit'
+
+class GorgonMini2Test < MiniTest::Unit::TestCase
+  def test_pass
+    assert true
+  end
+
+  def test_fails
+    assert false
+  end
+end
+
+class OtherCaseTest < MiniTest::Unit::TestCase
+  def test_pass
+    assert true
+  end
+
+  def test_fails
+    assert false
+  end
+
+  def test_that_will_be_skipped
+    skip "test this later"
+  end
+end

data/spec/dummy/test/unit/1_syntax_error_test.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+
+module Stuff
+  class Haha1 < Test::Unit::TestCase
+    def test_no_end
+      assert true
+  end
+end
+

data/spec/dummy/test/unit/exception_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+module Stuff
+  class Haha1 < Test::Unit::TestCase
+    def test_blahblah
+      assert true
+    end
+
+    def test_going_to_blow_up
+      raise "oh mah gawd"
+    end
+  end
+end
+

data/spec/dummy/test/unit/failing_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+
+module Stuff
+class Over9000 < Test::Unit::TestCase
+  def test_blahblah
+    assert true
+  end
+
+  def test_will_fail
+    assert false
+  end
+
+  def test_2_will_fail
+    assert false
+  end
+end
+end

data/spec/dummy/test/unit/successful_test.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+
+module Stuff
+class SuccessfulTest < Test::Unit::TestCase
+  def assert_true
+    assert true
+  end
+end
+end

data/spec/dummy/test_gorgon.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAtXfCXWX3qlOLErhwX9OVEFK2nYFnbNVulBZE5vPWbDwBUyTS
+zuNAOtN7cmF/5GFnWJm2UHr+BMc5yKWQwoXak6I44z9apxREr/TXAVBER6NyO/Zq
+dj2p0HxZy9FZHCcPV2wwGSE3O5U8mcphmWS9xYhjVhoopN5vjobgXm6ie7IYVJvY
+vtZOCxCBKmDxETDl9HYphySwsNhc4fvPaYmDP8jk2SGN7Z3g2kD8FOme8rUUdYNQ
+fni2l7Aq4oRNUnl48v6aMGKqW89RAd+Lg/mjPVcIsm/67XH5E0FgOvVAPTYqne06
+bBpZckHru42xUPNlkHthiL9PbpBuYVYNKQ9gWwIDAQABAoIBAQCG0RdcbjHmn7SV
+zuLlvnpjKyAyuf3NlG9Xo4fDEWq+9IGDdLsNKzX/vjhbTOZIFLlD0Mbq2cU4ZY6f
+a6m1at5tijq7UckWke9JzhuiBTEFDAAFXlfPypYLpybLTpfmW3qBV4YQVWYEZSYl
+l36VCIwYYfBy+nIxsnOsrrWoUodyXyhetYGUrbn6dspgC5K7dPhDDEtK2YQEWVrH
+d8XFyl3/RTB55BPo/PUlqYfeRCdOWMtqOzW/nVvNgRVVNubr+TP8Y9nhs2XovsHD
+IGmjItrMl1pbTC7O2mHAd5gGkFlq3jEr8EXK87KN/BKDUBCVDMaZYwUliFgnpQbT
+Ik/7RG45AoGBAN4lRvdkZlB4ADKM2ocGjBIDDszf/7NDD6Y+/iJSlo/LPCDoxGjf
+ZhCHzvqeZl7SbWr2XUhn6vVGZS4WJYb3ys/QNLKtK/XI5JYtoTFOysQY3RYttyYG
+twuSI7M+lgVXvpAPoX2/dlSd7whalRDWZSLPUXrBdX6YvrmRYpOfvdklAoGBANEf
+fYLyiQZmwx4F5i1EC6WYR7PakUABLPrr5L35lUiHhO1gLgu+bOgseDEBbjdOV/ES
+YZO0zeTC8ou+An+nBT9S1fxIkOfxRAbSUXn5DTYOztNEfpA/zB9/NJug+P21oMMW
+h6rixz/G5ayvOz6ZCJzvwBWPXPdu6U5uLjBNRtt/AoGAJ42xnhkFUqybNGT5//K9
+e/OJbhcwOyXkonAy5b+YyU+hjCaF2jp0vNrBksQjbBzBmLr3Dw5ZuoRnPZZ55hc2
+yFvFFk9ZNXEoqkjDm7jwx4u5ydon8yBc9TV3H9Iz+g2Og64UzgQKOLTKO82NHytd
+ZJ5PXrEVj43436ewSqK1tfUCgYEAtd6RJWUQzkRoxJ+UwyE+j9GT6lLXp7ZeDAtD
+cASzU9SoQlk3Mnd196VVEimQVQEJclruCatgtObmUan6OlJjOeMsvq/NdipZYyVe
+PpneZ3kRXqNe/sy9FVdnxUGFygA/w+rAKln3tvufm0L6X0JwPywy/Y0k6PvIY7Fm
+8hMC4LkCgYAO82O4xrdo7Cjh1S4itM5nDuiQS4/tYcnxIHirHh6roolBoz2oIu5M
+PoMZZbAAvP0mbPESndwL2f/JL8aU9EgTT9qZYtAa802yMLsFIASUWdmpA5pdnjcr
+bKQ+SBYgH+c4L+kdLr0qk79FpU/SyahIlrEcTMOfKzj+PHVn64b5XQ==
+-----END RSA PRIVATE KEY-----

data/spec/end_to_end_spec.rb

@@ -0,0 +1,142 @@
+require "open4"
+require "socket"
+require File.expand_path("../support/end_to_end_helpers", __FILE__)
+
+describe "EndToEnd" do
+  include Gorgon::EndToEndHelpers
+
+  HOSTNAME = "listener"
+
+  before(:all) do
+    Dir.chdir(File.join(__dir__, "dummy")) do
+      pid, stdin, stdout, stderr = Open4::popen4("bundle exec gorgon")
+      @outputs = stdout.read.split("*" * 80)
+    end
+  end
+
+  context "number of output hunks" do
+    it "is same as errors raised plus meta information" do
+      expect(@outputs.count).to eq(7), "expected 7 output hunks, got:\n#{@outputs.inspect}"
+    end
+  end
+
+  context "meta suite run information" do
+    it "has version and legend information" do
+        expected_meta = <<-META
+Welcome to Gorgon #{Gorgon::VERSION}
+before job starts was called
+Loading environment and workers...\r                                  \rLegend:
+F - failure files count
+H - number of hosts that have run files
+W - number of workers running files
+
+
+Progress: ||
+
+        META
+        expect(@outputs[0]).to eq(expected_meta)
+    end
+  end
+
+  context "last hunk" do
+    it "has information for running after_job_finishes callback" do
+      expect(@outputs.last).to match(Gorgon::EndToEndHelpers::AFTER_RUNNING_REGEX)
+    end
+  end
+
+  context "exception test" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /Stuff::Haha1/)
+      expected_output = <<-EXPECTED
+
+File 'test/unit/exception_test.rb' failed/crashed at '#{HOSTNAME}:1'
+Error:
+test_going_to_blow_up(Stuff::Haha1):
+RuntimeError: oh mah gawd
+    test/unit/exception_test.rb:10:in `test_going_to_blow_up'
+
+      EXPECTED
+
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+
+  context "exception spec" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /exception_spec/)
+      expected_output = <<-EXPECTED
+
+File 'spec/exception_spec.rb' failed/crashed at '#{HOSTNAME}:1'
+Test name: Exception spec raises: line 2
+RuntimeError
+Message: 
+	BOOOOM from spec!
+
+
+      EXPECTED
+
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+
+  context "syntax error test" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /1_syntax_error_test/, strip_backtrace: true)
+      expected_output = <<-EXPECTED
+
+File 'test/unit/1_syntax_error_test.rb' failed/crashed at '#{HOSTNAME}:1'
+Exception: test/unit/1_syntax_error_test.rb:9: syntax error, unexpected end-of-input, expecting keyword_end
+
+      EXPECTED
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+
+  context "syntax error spec" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /1_syntax_error_spec/, strip_backtrace: true)
+      expected_output = <<-EXPECTED
+
+File 'spec/1_syntax_error_spec.rb' failed/crashed at '#{HOSTNAME}:1'
+Exception: undefined local variable or method `ruby' for main:Object
+
+      EXPECTED
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+
+  context "failing test" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /failing_test\.rb/)
+      expected_output = <<-EXPECTED
+
+File 'test/unit/failing_test.rb' failed/crashed at '#{HOSTNAME}:1'
+Failure:
+test_2_will_fail(Stuff::Over9000) [test/unit/failing_test.rb:14]:
+<false> is not true.
+Failure:
+test_will_fail(Stuff::Over9000) [test/unit/failing_test.rb:10]:
+<false> is not true.
+
+      EXPECTED
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+
+  context "failing spec" do
+    it "has proper error output" do
+      actual_output = extract_hunk(@outputs, /failing_spec\.rb/)
+      expected_output = <<-EXPECTED
+
+File 'spec/failing_spec.rb' failed/crashed at '#{HOSTNAME}:1'
+Test name: Failing spec fails: line 6
+RSpec::Expectations::ExpectationNotMetError
+Message: 
+	failed
+
+
+      EXPECTED
+      expect(actual_output).to eq(expected_output)
+    end
+  end
+end

data/spec/failures_printer_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/failures_printer'
 
-describe FailuresPrinter do
+describe Gorgon::FailuresPrinter do
   let(:job_state) { double("Job State", :add_observer => nil,
                          :is_job_complete? => true, :is_job_cancelled? => false,
                          :each_failed_test => nil,
@@ -8,63 +8,63 @@ describe FailuresPrinter do
   let(:fd) {double("File descriptor", :write => nil)}
 
   subject do
-    FailuresPrinter.new({}, job_state)
+    Gorgon::FailuresPrinter.new({}, job_state)
   end
 
   it { should respond_to :update }
 
   describe "#initialize" do
     it "add its self to observers of job_state" do
-      job_state.should_receive(:add_observer)
-      FailuresPrinter.new({}, job_state)
+      expect(job_state).to receive(:add_observer)
+      Gorgon::FailuresPrinter.new({}, job_state)
     end
   end
 
   describe "#update" do
     before do
-      @printer = FailuresPrinter.new({}, job_state)
+      @printer = Gorgon::FailuresPrinter.new({}, job_state)
     end
 
     context "job is not completed nor cancelled" do
       it "doesn't output anything" do
-        job_state.stub(:is_job_complete? => false)
-        File.should_not_receive(:open)
+        allow(job_state).to receive(:is_job_complete?).and_return(false)
+        expect(File).not_to receive(:open)
         @printer.update({})
       end
     end
 
     context "job is completed" do
       it "outputs failed tests return by job_state#each_failed_test" do
-        job_state.stub(:each_failed_test).and_yield({:filename => "file1.rb"}).and_yield({:filename => "file2.rb"})
-        File.should_receive(:open).with(FailuresPrinter::DEFAULT_OUTPUT_FILE, 'w+').and_yield fd
-        fd.should_receive(:write).with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
+        allow(job_state).to receive(:each_failed_test).and_yield({:filename => "file1.rb"}).and_yield({:filename => "file2.rb"})
+        expect(File).to receive(:open).with(Gorgon::FailuresPrinter::DEFAULT_OUTPUT_FILE, 'w+').and_yield fd
+        expect(fd).to receive(:write).with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
         @printer.update({})
       end
 
       it "outputs failed tests to 'failed_files' in configuration" do
-        printer = FailuresPrinter.new({failed_files: 'a-file-somewhere.json'}, job_state)
-        File.should_receive(:open).with('a-file-somewhere.json', 'w+')
+        printer = Gorgon::FailuresPrinter.new({failed_files: 'a-file-somewhere.json'}, job_state)
+        expect(File).to receive(:open).with('a-file-somewhere.json', 'w+')
         printer.update({})
       end
     end
 
     context "job is cancelled" do
       before do
-        job_state.stub(:is_job_complete?).and_return(false)
-        job_state.stub(:is_job_cancelled?).and_return(true)
+        allow(job_state).to receive(:is_job_complete?).and_return(false)
+        allow(job_state).to receive(:is_job_cancelled?).and_return(true)
       end
 
       it "outputs failed tests return by job_state#each_failed_test" do
-        job_state.stub(:each_failed_test).and_yield({:filename => "file1.rb"}).and_yield({:filename => "file2.rb"})
-        File.should_receive(:open).with(FailuresPrinter::DEFAULT_OUTPUT_FILE, 'w+').and_yield fd
-        fd.should_receive(:write).once.with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
+        allow(job_state).to receive(:each_failed_test).and_yield({:filename => "file1.rb"}).and_yield({:filename => "file2.rb"})
+        expect(File).to receive(:open).with(Gorgon::FailuresPrinter::DEFAULT_OUTPUT_FILE, 'w+').and_yield fd
+        expect(fd).to receive(:write).once.with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
         @printer.update({})
       end
 
       it "outputs still-running files returns by job_state#each_running_file" do
-        job_state.stub(:each_running_file).and_yield("host1", "file1.rb").and_yield("host2", "file2.rb")
-        File.stub(:open).and_yield fd
-        fd.should_receive(:write).once.with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
+        allow(job_state).to receive(:each_running_file).and_yield("host1", "file1.rb").and_yield("host2", "file2.rb")
+        allow(File).to receive(:open).and_yield fd
+        expect(fd).to receive(:write).once.with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
         @printer.update({})
       end
     end

data/spec/gem_command_handler_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/gem_command_handler'
 
-describe GemCommandHandler do
+describe Gorgon::GemCommandHandler do
   let(:exchange) { double("GorgonBunny Exchange", :publish => nil) }
   let(:bunny) { double("GorgonBunny", :exchange => exchange, :stop => nil) }
 
@@ -15,70 +15,70 @@ describe GemCommandHandler do
 
   describe "#handle" do
     before do
-      @handler = GemCommandHandler.new bunny
+      @handler = Gorgon::GemCommandHandler.new bunny
       @running_response = {:type => :running_command, :hostname => Socket.gethostname}
       stub_methods
     end
 
     it "publishes 'running_command' message" do
-      bunny.should_receive(:exchange).with("name", anything).and_return(exchange)
-      Yajl::Encoder.should_receive(:encode).with(@running_response).and_return :json_msg
-      exchange.should_receive(:publish).with(:json_msg)
+      expect(bunny).to receive(:exchange).with("name", anything).and_return(exchange)
+      expect(Yajl::Encoder).to receive(:encode).with(@running_response).and_return :json_msg
+      expect(exchange).to receive(:publish).with(:json_msg)
       @handler.handle payload, {}
     end
 
     it "runs 'gem <command> gorgon' using popen4" do
-      Open4.should_receive(:popen4).with("gem cmd gorgon").and_return([1, stdin, stdout, stderr])
+      expect(Open4).to receive(:popen4).with("gem cmd gorgon").and_return([1, stdin, stdout, stderr])
       @handler.handle payload, {}
     end
 
     it "uses binary gem from configuration if this was specified" do
-      Open4.should_receive(:popen4).with("path/to/gem cmd gorgon").and_return([1, stdin, stdout, stderr])
+      expect(Open4).to receive(:popen4).with("path/to/gem cmd gorgon").and_return([1, stdin, stdout, stderr])
       @handler.handle payload, {:bin_gem_path => "path/to/gem"}
     end
 
     it "waits for the command to finish" do
-      Open4.should_receive(:popen4).ordered
-      Process.should_receive(:waitpid2).with(1).ordered.and_return([nil, status])
+      expect(Open4).to receive(:popen4).ordered
+      expect(Process).to receive(:waitpid2).with(1).ordered.and_return([nil, status])
       @handler.handle payload, {}
     end
 
     it "closes stding and reads stdout and stderr from process" do
-      stdin.should_receive(:close)
-      stdout.should_receive(:read)
-      stderr.should_receive(:read)
+      expect(stdin).to receive(:close)
+      expect(stdout).to receive(:read)
+      expect(stderr).to receive(:read)
       @handler.handle payload, {}
     end
 
     it "sends 'command_completed' message when exitstatus is 0" do
       response = {:type => :command_completed, :hostname => Socket.gethostname,
         :command => "gem cmd gorgon", :stdout => "output", :stderr => "errors" }
-      Yajl::Encoder.should_receive(:encode).once.ordered.with(@running_response)
-      Yajl::Encoder.should_receive(:encode).once.ordered.with(response).and_return :json_msg
-      exchange.should_receive(:publish).with(:json_msg)
+      expect(Yajl::Encoder).to receive(:encode).once.ordered.with(@running_response)
+      expect(Yajl::Encoder).to receive(:encode).once.ordered.with(response).and_return :json_msg
+      expect(exchange).to receive(:publish).with(:json_msg)
       @handler.handle payload, {}
     end
 
     it "stops bunny and exit if exitstatus is 0" do
-      bunny.should_receive(:stop).once.ordered
-      @handler.should_receive(:exit).once.ordered
+      expect(bunny).to receive(:stop).once.ordered
+      expect(@handler).to receive(:exit).once.ordered
       @handler.handle payload, {}
     end
 
     it "sends 'command_failed' message when exitstatus is not 0" do
-      status.should_receive(:exitstatus).and_return(99)
+      expect(status).to receive(:exitstatus).and_return(99)
       response = {:type => :command_failed, :hostname => Socket.gethostname,
         :command => "gem cmd gorgon", :stdout => "output", :stderr => "errors" }
-      Yajl::Encoder.should_receive(:encode).with(response).and_return :json_msg
-      exchange.should_receive(:publish).with(:json_msg)
+      expect(Yajl::Encoder).to receive(:encode).with(response).and_return :json_msg
+      expect(exchange).to receive(:publish).with(:json_msg)
       @handler.handle payload, {}
     end
   end
 
   def stub_methods
-    Open4.stub(:popen4).and_return([1, stdin, stdout, stderr])
-    Process.stub(:waitpid2).and_return([nil, status])
-    Yajl::Encoder.stub(:encode).and_return :json_msg
-    @handler.stub(:exit)
+    allow(Open4).to receive(:popen4).and_return([1, stdin, stdout, stderr])
+    allow(Process).to receive(:waitpid2).and_return([nil, status])
+    allow(Yajl::Encoder).to receive(:encode).and_return :json_msg
+    allow(@handler).to receive(:exit)
   end
 end