gorgon 0.11.0 → 0.11.1

data/spec/gem_service_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/gem_service'
 
-describe GemService do
+describe Gorgon::GemService do
   let(:configuration){ {:connection => {:host => "host"}, :originator_log_file => "file.log"}}
   let(:protocol) { double("OriginatorProtocol", :connect => nil,
                         :receive_payloads => nil, :disconnect => nil,
@@ -8,46 +8,46 @@ describe GemService do
   let(:logger){ double("Originator Logger", :log => nil, :log_message => nil)}
 
   before do
-    $stdout.stub(:write)
-    GemService.any_instance.stub(:load_configuration_from_file).and_return configuration
-    EM.stub(:run).and_yield
-    EM.stub(:add_periodic_timer).and_yield
-    OriginatorLogger.stub(:new).and_return logger
-    OriginatorProtocol.stub(:new).and_return(protocol)
-    @service = GemService.new
+    allow($stdout).to receive(:write)
+    allow_any_instance_of(Gorgon::GemService).to receive(:load_configuration_from_file).and_return configuration
+    allow(EM).to receive(:run).and_yield
+    allow(EM).to receive(:add_periodic_timer).and_yield
+    allow(Gorgon::OriginatorLogger).to receive(:new).and_return logger
+    allow(Gorgon::OriginatorProtocol).to receive(:new).and_return(protocol)
+    @service = Gorgon::GemService.new
     @command = "install"
   end
 
   describe "#run" do
     it "runs EventMachine loop and connect using configuration[:connection]" do
-      EM.should_receive(:run)
-      protocol.should_receive(:connect).once.ordered.with({:host => "host"}, anything)
+      expect(EM).to receive(:run)
+      expect(protocol).to receive(:connect).once.ordered.with({:host => "host"}, anything)
       @service.run @command
     end
 
     it "calls Protocol#send_message_to_listeners with version number" do
-      protocol.should_receive(:send_message_to_listeners).with(:gem_command, :gem_command => @command)
+      expect(protocol).to receive(:send_message_to_listeners).with(:gem_command, :gem_command => @command)
       @service.run @command
     end
 
     it "adds a periodic timer that checks if there is any listener running command" do
-      EM.should_receive(:add_periodic_timer).with(GemService::TIMEOUT)
+      expect(EM).to receive(:add_periodic_timer).with(Gorgon::GemService::TIMEOUT)
       @service.run @command
     end
 
     context "when it receives an running_command message" do
       before do
         payload = {:type => "running_command", :hostname => "host"}
-        protocol.stub(:receive_payloads).and_yield Yajl::Encoder.encode(payload)
+        allow(protocol).to receive(:receive_payloads).and_yield Yajl::Encoder.encode(payload)
       end
 
       it "writes to console" do
-        $stdout.should_receive(:write).with(/host/)
+        expect($stdout).to receive(:write).with(/host/)
         @service.run @command
       end
 
       it "won't diconnect as long as there is a host running_command" do
-        protocol.should_not_receive(:disconnect)
+        expect(protocol).not_to receive(:disconnect)
         @service.run @command
       end
     end
@@ -56,17 +56,17 @@ describe GemService do
       before do
         running_command_payload = {:type => "running_command", :hostname => "host"}
         complete_payload = {:type => "command_completed", :hostname => "host"}
-        protocol.stub(:receive_payloads).and_yield(Yajl::Encoder.encode(running_command_payload))
+        allow(protocol).to receive(:receive_payloads).and_yield(Yajl::Encoder.encode(running_command_payload))
           .and_yield(Yajl::Encoder.encode(complete_payload))
       end
 
       it "writes to console" do
-        $stdout.should_receive(:write).at_least(:twice).with(/host/)
+        expect($stdout).to receive(:write).at_least(:twice).with(/host/)
         @service.run @command
       end
 
       it "disconnect since there is no host running command anymore" do
-        protocol.should_receive(:disconnect)
+        expect(protocol).to receive(:disconnect)
         @service.run @command
       end
     end

data/spec/gorgon_rspec_formatter_spec.rb

@@ -22,53 +22,53 @@ describe RSpec::Core::Formatters::GorgonRspecFormatter do
   end
 
   it "returns an array of hashes when there are failures" do
-    @formatter.stub(:examples).and_return([example, fail_example])
+    allow(@formatter).to receive(:examples).and_return([example, fail_example])
 
     expected_result = [{:test_name => "Full_Description: line 2", :description => "description",
                          :full_description => "Full_Description", :status => "failed",
                          :file_path => "path/to/file", :line_number => 2}]
-    output.should_receive(:write).with(expected_result.to_json)
+    expect(output).to receive(:write).with(expected_result.to_json)
     @formatter.stop
     @formatter.close
   end
 
   it "returns an empty array when all examples pass" do
-    @formatter.stub(:examples).and_return([example, example])
+    allow(@formatter).to receive(:examples).and_return([example, example])
 
-    output.should_receive(:write).with("[]")
+    expect(output).to receive(:write).with("[]")
     @formatter.stop
     @formatter.close
   end
 
   it "returns an empty array when all examples are pending" do
-    example.stub(:execution_result).and_return(:status => "pending")
-    @formatter.stub(:examples).and_return([example, example])
+    allow(example).to receive(:execution_result).and_return(:status => "pending")
+    allow(@formatter).to receive(:examples).and_return([example, example])
 
-    output.should_receive(:write).with("[]")
+    expect(output).to receive(:write).with("[]")
     @formatter.stop
     @formatter.close
   end
 
   it "returns exception details if there is an exception" do
-    fail_example.stub(:exception).and_return(exception)
-    @formatter.stub(:examples).and_return([fail_example])
+    allow(fail_example).to receive(:exception).and_return(exception)
+    allow(@formatter).to receive(:examples).and_return([fail_example])
     expected_result = [{:test_name => "Full_Description: line 2", :description => "description",
                          :full_description => "Full_Description", :status => "failed",
                          :file_path => "path/to/file", :line_number => 2, :class => Object.name,
                          :message => "some msg", :location => "backtrace"}]
-    output.should_receive(:write).with(expected_result.to_json)
+    expect(output).to receive(:write).with(expected_result.to_json)
     @formatter.stop
     @formatter.close
   end
 
   it "uses RSpec 3 API when available" do
-    fail_example.execution_result.should_receive(:status).and_return(:failed)
+    expect(fail_example.execution_result).to receive(:status).and_return(:failed)
     notification = double(examples: [fail_example])
 
     expected_result = [{:test_name => "Full_Description: line 2", :description => "description",
         :full_description => "Full_Description", :status => "failed",
         :file_path => "path/to/file", :line_number => 2}]
-    output.should_receive(:write).with(expected_result.to_json)
+    expect(output).to receive(:write).with(expected_result.to_json)
     @formatter.stop(notification)
     @formatter.close
   end

data/spec/host_state_spec.rb

@@ -1,36 +1,36 @@
 require 'gorgon/host_state'
 
-describe HostState do
+describe Gorgon::HostState do
   it { should respond_to(:file_started).with(2).arguments }
   it { should respond_to(:file_finished).with(2).arguments }
   it { should respond_to(:each_running_file).with(0).argument }
   it { should respond_to(:total_running_workers).with(0).argument }
 
   before do
-    @host_state = HostState.new
+    @host_state = Gorgon::HostState.new
   end
 
   describe "#total_workers_running" do
     it "returns 0 if there are no worker running files" do
-      @host_state.total_running_workers.should == 0
+      expect(@host_state.total_running_workers).to eq(0)
     end
 
     it "returns 1 if #file_started was called, but #file_finished has not been called with such a worker id" do
       @host_state.file_started "worker1", "path/to/file.rb"
-      @host_state.total_running_workers.should == 1
+      expect(@host_state.total_running_workers).to eq(1)
     end
 
     it "returns 0 if #file_started and #file_finished were called for the same worker_id" do
       @host_state.file_started "worker1", "path/to/file.rb"
       @host_state.file_finished "worker1", "path/to/file.rb"
-      @host_state.total_running_workers.should == 0
+      expect(@host_state.total_running_workers).to eq(0)
     end
 
     it "returns 1 if #file_started and #file_finished were called for different worker id (worker1)" do
       @host_state.file_started "worker1", "path/to/file.rb"
       @host_state.file_started "worker2", "path/to/file2.rb"
       @host_state.file_finished "worker2", "path/to/file2.rb"
-      @host_state.total_running_workers.should == 1
+      expect(@host_state.total_running_workers).to eq(1)
     end
   end
 
@@ -46,7 +46,7 @@ describe HostState do
         @host_state.each_running_file do |file|
           files << file
         end
-        files.should == ["path/to/file1.rb", "path/to/file2.rb"]
+        expect(files).to eq(["path/to/file1.rb", "path/to/file2.rb"])
       end
     end
 
@@ -58,7 +58,7 @@ describe HostState do
         @host_state.each_running_file do |file|
           files << file
         end
-        files.should == ["path/to/file1.rb"]
+        expect(files).to eq(["path/to/file1.rb"])
       end
     end
   end

data/spec/job_definition_spec.rb

@@ -1,7 +1,7 @@
 require 'gorgon/job_definition'
 require 'yajl'
 
-describe JobDefinition do
+describe Gorgon::JobDefinition do
   before(:all) do
     @json_parser = Yajl::Parser.new(:symbolize_keys => true)
   end
@@ -16,9 +16,9 @@ describe JobDefinition do
         :callbacks => {}
       }
 
-      jd = JobDefinition.new(expected_hash)
+      jd = Gorgon::JobDefinition.new(expected_hash)
 
-      @json_parser.parse(jd.to_json).should == expected_hash
+      expect(@json_parser.parse(jd.to_json)).to eq(expected_hash)
     end
   end
 end

data/spec/job_state_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/job_state'
 
-describe JobState do
+describe Gorgon::JobState do
   let(:payload) {
     {:hostname => "host-name", :worker_id => "worker1", :filename => "path/file.rb",
       :type => "pass", :failures => []}
@@ -8,7 +8,7 @@ describe JobState do
 
   let (:host_state){ double("Host State", :file_started => nil, :file_finished => nil)}
 
-  subject { JobState.new 5 }
+  subject { Gorgon::JobState.new 5 }
   it { should respond_to :failed_files_count }
   it { should respond_to :finished_files_count }
   it { should respond_to(:file_started).with(1).argument }
@@ -23,112 +23,112 @@ describe JobState do
   it { should respond_to :is_job_cancelled? }
 
   before do
-    @job_state = JobState.new 5
+    @job_state = Gorgon::JobState.new 5
   end
 
   describe "#initialize" do
     it "sets total files for job" do
-      @job_state.total_files.should be 5
+      expect(@job_state.total_files).to eq(5)
     end
 
     it "sets remaining_files_count" do
-      @job_state.remaining_files_count.should be 5
+      expect(@job_state.remaining_files_count).to eq(5)
     end
 
     it "sets failed_files_count to 0" do
-      @job_state.failed_files_count.should be 0
+      expect(@job_state.failed_files_count).to eq(0)
     end
 
     it "set state to starting" do
-      @job_state.state.should be :starting
+      expect(@job_state.state).to eq(:starting)
     end
   end
 
   describe "#finished_files_count" do
     it "returns total_files - remaining_files_count" do
-      @job_state.finished_files_count.should be 0
+      expect(@job_state.finished_files_count).to eq(0)
     end
   end
 
   describe "#file_started" do
     it "change state to running after first start_file_message is received" do
       @job_state.file_started({})
-      @job_state.state.should be :running
+      expect(@job_state.state).to eq(:running)
     end
 
     it "creates a new HostState object if this is the first file started by 'hostname'" do
-      HostState.should_receive(:new).and_return host_state
+      expect(Gorgon::HostState).to receive(:new).and_return host_state
       @job_state.file_started(payload)
     end
 
     it "doesn't create a new HostState object if this is not the first file started by 'hostname'" do
-      HostState.stub(:new).and_return host_state
+      allow(Gorgon::HostState).to receive(:new).and_return host_state
       @job_state.file_started(payload)
-      HostState.should_not_receive(:new)
+      expect(Gorgon::HostState).not_to receive(:new)
       @job_state.file_started(payload)
     end
 
     it "calls #file_started on HostState object representing 'hostname'" do
-      HostState.stub(:new).and_return host_state
-      host_state.should_receive(:file_started).with("worker_id", "file_name")
+      allow(Gorgon::HostState).to receive(:new).and_return host_state
+      expect(host_state).to receive(:file_started).with("worker_id", "file_name")
       @job_state.file_started({:hostname => "hostname",
                                 :worker_id => "worker_id",
                                 :filename => "file_name"})
     end
 
     it "notify observers" do
-      @job_state.should_receive :notify_observers
-      @job_state.should_receive :changed
+      expect(@job_state).to receive :notify_observers
+      expect(@job_state).to receive :changed
       @job_state.file_started({})
     end
   end
 
   describe "#file_finished" do
     before do
-      HostState.stub(:new).and_return host_state
+      allow(Gorgon::HostState).to receive(:new).and_return host_state
       @job_state.file_started payload
     end
 
     it "decreases remaining_files_count" do
-      lambda do
+      expect(lambda do
         @job_state.file_finished payload
-      end.should(change(@job_state, :remaining_files_count).by(-1))
+      end).to change{@job_state.remaining_files_count}.by(-1)
 
-      @job_state.total_files.should be 5
+      expect(@job_state.total_files).to eq(5)
     end
 
     it "doesn't change failed_files_count if type test result is pass" do
-      lambda do
+      expect(lambda do
         @job_state.file_finished payload
-      end.should_not change(@job_state, :failed_files_count)
-      @job_state.failed_files_count.should be 0
+      end).not_to change{@job_state.failed_files_count}
+      expect(@job_state.failed_files_count).to eq(0)
     end
 
     it "increments failed_files_count if type is failed" do
-      lambda do
+      expect(lambda do
         @job_state.file_finished payload.merge({:type => "fail", :failures => ["Failure messages"]})
-      end.should change(@job_state, :failed_files_count).by(1)
+      end).to change{@job_state.failed_files_count}.by(1)
     end
 
     it "notify observers" do
-      @job_state.should_receive :notify_observers
-      @job_state.should_receive :changed
+      expect(@job_state).to receive :notify_observers
+      expect(@job_state).to receive :changed
       @job_state.file_finished payload
     end
 
     it "raises if job already complete" do
       finish_job
-      lambda do
+      expect(lambda do
         @job_state.file_finished payload
-      end.should raise_error
+      end).to raise_error(RuntimeError)
     end
 
     it "tells to the proper HostState object that a file finished in that host" do
-      HostState.stub(:new).and_return host_state
+      allow(Gorgon::HostState).to receive(:new).and_return host_state
       @job_state.file_started({:hostname => "hostname",
                                 :worker_id => "worker_id",
                                 :filename => "file_name"})
-      host_state.should_receive(:file_finished).with("worker_id", "file_name")
+      expect(host_state).to receive(:file_finished).with("worker_id", "file_name")
       @job_state.file_finished({:hostname => "hostname",
                                  :worker_id => "worker_id",
                                  :filename => "file_name"})
@@ -141,37 +141,37 @@ describe JobState do
 
     it "adds crashed host to JobState#crashed_hosted" do
       @job_state.gorgon_crash_message(crash_msg)
-      @job_state.crashed_hosts.should == ["host"]
+      expect(@job_state.crashed_hosts).to eq(["host"])
     end
 
     it "notify observers" do
-      @job_state.should_receive :notify_observers
-      @job_state.should_receive :changed
+      expect(@job_state).to receive :notify_observers
+      expect(@job_state).to receive :changed
       @job_state.gorgon_crash_message crash_msg
     end
   end
 
   describe "#is_job_complete?" do
     it "returns false if remaining_files_count != 0" do
-      @job_state.is_job_complete?.should be_false
+      expect(@job_state.is_job_complete?).to be_falsey
     end
 
     it "returns true if remaining_files_count == 0" do
       finish_job
-      @job_state.is_job_complete?.should be_true
+      expect(@job_state.is_job_complete?).to be_truthy
     end
   end
 
   describe "#cancel and is_job_cancelled?" do
     it "cancels job" do
-      @job_state.is_job_cancelled?.should be_false
+      expect(@job_state.is_job_cancelled?).to be_falsey
       @job_state.cancel
-      @job_state.is_job_cancelled?.should be_true
+      expect(@job_state.is_job_cancelled?).to be_truthy
     end
 
     it "notify observers when cancelling" do
-      @job_state.should_receive :changed
-      @job_state.should_receive :notify_observers
+      expect(@job_state).to receive :changed
+      expect(@job_state).to receive :notify_observers
       @job_state.cancel
     end
   end
@@ -184,7 +184,7 @@ describe JobState do
     it "returns failed tests info" do
       @job_state.file_finished payload.merge({:type => "fail", :failures => ["Failure messages"]})
       @job_state.each_failed_test do |test|
-        test[:failures].should == ["Failure messages"]
+        expect(test[:failures]).to eq(["Failure messages"])
       end
     end
   end
@@ -202,9 +202,9 @@ describe JobState do
       @job_state.each_running_file do |hostname, filename|
         hosts_files[hostname] = filename
       end
-      hosts_files.size.should == 2
-      hosts_files["host-name"].should == "path/file.rb"
-      hosts_files["host2"].should == "path/file2.rb"
+     expect(hosts_files.size).to eq(2)
+     expect(hosts_files["host-name"]).to eq("path/file.rb")
+     expect(hosts_files["host2"]).to eq("path/file2.rb")
     end
   end
 
@@ -215,7 +215,7 @@ describe JobState do
       @job_state.file_started payload.merge({ :hostname => "host2",
                                               :filename => "path/file2.rb",
                                               :worker_id => "worker1"})
-      @job_state.total_running_hosts.should == 2
+      expect(@job_state.total_running_hosts).to eq(2)
     end
   end
 
@@ -226,7 +226,7 @@ describe JobState do
       @job_state.file_started payload.merge({ :hostname => "host2",
                                               :filename => "path/file2.rb",
                                               :worker_id => "worker1"})
-      @job_state.total_running_workers.should == 3
+      expect(@job_state.total_running_workers).to eq(3)
     end
   end