gorgon 0.0.1

data/spec/failures_printer_spec.rb

@@ -0,0 +1,66 @@
+require 'gorgon/failures_printer'
+
+describe FailuresPrinter do
+  let(:job_state) { stub("Job State", :add_observer => nil,
+                         :is_job_complete? => true, :is_job_cancelled? => false,
+                         :each_failed_test => nil,
+                         :each_running_file => nil)}
+  let(:fd) {stub("File descriptor", :write => nil)}
+
+  subject do
+    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
+    end
+  end
+
+  describe "#update" do
+    before do
+      @printer = 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)
+        @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::OUTPUT_FILE, 'w+').and_yield fd
+        fd.should_receive(:write).with(Yajl::Encoder.encode(["file1.rb", "file2.rb"]))
+        @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)
+      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::OUTPUT_FILE, 'w+').and_yield fd
+        fd.should_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"]))
+        @printer.update({})
+      end
+    end
+  end
+end

data/spec/host_state_spec.rb

@@ -0,0 +1,65 @@
+require 'gorgon/host_state'
+
+describe 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
+  end
+
+  describe "#total_workers_running" do
+    it "returns 0 if there are no worker running files" do
+      @host_state.total_running_workers.should == 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
+    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
+    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
+    end
+  end
+
+  describe "#each_running_file" do
+    before do
+      @host_state.file_started "worker1", "path/to/file1.rb"
+      @host_state.file_started "worker2", "path/to/file2.rb"
+    end
+
+    context "when no #file_finished has been called" do
+      it "yields each currently running file" do
+        files = []
+        @host_state.each_running_file do |file|
+          files << file
+        end
+        files.should == ["path/to/file1.rb", "path/to/file2.rb"]
+      end
+    end
+
+    context "when #file_finished has been called for one of the workers" do
+      it "yields each currently running file" do
+        @host_state.file_finished "worker2", "path/to/file2.rb"
+
+        files = []
+        @host_state.each_running_file do |file|
+          files << file
+        end
+        files.should == ["path/to/file1.rb"]
+      end
+    end
+  end
+end

data/spec/job_definition_spec.rb

@@ -0,0 +1,20 @@
+require 'gorgon/job_definition'
+require 'yajl'
+
+describe JobDefinition do
+  before(:all) do
+    @json_parser = Yajl::Parser.new(:symbolize_keys => true)
+  end
+
+  describe "#to_json" do
+    it "should serialize itself to json" do
+      expected_hash = {:file_queue_name => "string 1", :reply_exchange_name => "string 2",
+        :source_tree_path => "string 3", :sync_exclude => "string 4", :callbacks => {}}
+
+      jd = JobDefinition.new(expected_hash)
+
+      @json_parser.parse(jd.to_json).should == expected_hash
+    end
+  end
+end
+

data/spec/job_state_spec.rb

@@ -0,0 +1,231 @@
+require 'gorgon/job_state'
+
+describe JobState do
+  let(:payload) {
+    {:hostname => "host-name", :worker_id => "worker1", :filename => "path/file.rb",
+      :type => "pass", :failures => []}
+  }
+
+  let (:host_state){ stub("Host State", :file_started => nil, :file_finished => nil)}
+
+  subject { 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 }
+  it { should respond_to(:file_finished).with(1).argument }
+  it { should respond_to :cancel }
+  it { should respond_to :each_failed_test }
+  it { should respond_to :each_running_file }
+  it { should respond_to :total_running_hosts }
+  it { should respond_to :total_running_workers }
+  it { should respond_to :is_job_complete? }
+  it { should respond_to :is_job_cancelled? }
+
+  before do
+    @job_state = JobState.new 5
+  end
+
+  describe "#initialize" do
+    it "sets total files for job" do
+      @job_state.total_files.should be 5
+    end
+
+    it "sets remaining_files_count" do
+      @job_state.remaining_files_count.should be 5
+    end
+
+    it "sets failed_files_count to 0" do
+      @job_state.failed_files_count.should be 0
+    end
+
+    it "set state to starting" do
+      @job_state.state.should be :starting
+    end
+  end
+
+  describe "#finished_files_count" do
+    it "returns total_files - remaining_files_count" do
+      @job_state.finished_files_count.should be 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
+    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
+      @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
+      @job_state.file_started(payload)
+      HostState.should_not_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")
+      @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
+      @job_state.file_started({})
+    end
+  end
+
+  describe "#file_finished" do
+    before do
+      HostState.stub!(:new).and_return host_state
+      @job_state.file_started payload
+    end
+
+    it "decreases remaining_files_count" do
+      lambda do
+        @job_state.file_finished payload
+      end.should(change(@job_state, :remaining_files_count).by(-1))
+
+      @job_state.total_files.should be 5
+    end
+
+    it "doesn't change failed_files_count if type test result is pass" do
+      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
+
+    it "increments failed_files_count if type is failed" do
+      lambda do
+        @job_state.file_finished payload.merge({:type => "fail", :failures => ["Failure messages"]})
+      end.should change(@job_state, :failed_files_count).by(1)
+    end
+
+    it "notify observers" do
+      @job_state.should_receive :notify_observers
+      @job_state.should_receive :changed
+      @job_state.file_finished payload
+    end
+
+    it "raises if job already complete" do
+      finish_job
+      lambda do
+        @job_state.file_finished payload
+      end.should raise_error
+    end
+
+    it "raises if job was cancelled" do
+      @job_state.cancel
+      lambda do
+        @job_state.file_finished payload
+      end.should raise_error
+    end
+
+    it "tells to the proper HostState object that a file finished in that host" do
+      HostState.stub!(: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")
+      @job_state.file_finished({:hostname => "hostname",
+                                 :worker_id => "worker_id",
+                                 :filename => "file_name"})
+    end
+  end
+
+  describe "#is_job_complete?" do
+    it "returns false if remaining_files_count != 0" do
+      @job_state.is_job_complete?.should be_false
+    end
+
+    it "returns true if remaining_files_count == 0" do
+      finish_job
+      @job_state.is_job_complete?.should be_true
+    end
+  end
+
+  describe "#cancel and is_job_cancelled?" do
+    it "cancels job" do
+      @job_state.is_job_cancelled?.should be_false
+      @job_state.cancel
+      @job_state.is_job_cancelled?.should be_true
+    end
+
+    it "notify observers when cancelling" do
+      @job_state.should_receive :changed
+      @job_state.should_receive :notify_observers
+      @job_state.cancel
+    end
+  end
+
+  describe "#each_failed_test" do
+    before do
+      @job_state.file_started payload
+    end
+
+    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"]
+      end
+    end
+  end
+
+  describe "#each_running_file" do
+    before do
+      @job_state.file_started payload
+      @job_state.file_started payload.merge({ :hostname => "host2",
+                                              :filename => "path/file2.rb",
+                                              :worker_id => "worker2"})
+    end
+
+    it "returns each running file" do
+      hosts_files = {}
+      @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"
+    end
+  end
+
+  describe "#total_running_hosts" do
+    it "returns total number of hosts that has workers running files" do
+      @job_state.file_started payload
+      @job_state.file_started payload.merge({:worker_id => "worker2"})
+      @job_state.file_started payload.merge({ :hostname => "host2",
+                                              :filename => "path/file2.rb",
+                                              :worker_id => "worker1"})
+      @job_state.total_running_hosts.should == 2
+    end
+  end
+
+  describe "#total_running_workers" do
+    it "returns total number of workers running accross all hosts" do
+      @job_state.file_started payload
+      @job_state.file_started payload.merge({:worker_id => "worker2"})
+      @job_state.file_started payload.merge({ :hostname => "host2",
+                                              :filename => "path/file2.rb",
+                                              :worker_id => "worker1"})
+      @job_state.total_running_workers.should == 3
+    end
+  end
+
+  private
+
+  def finish_job
+    5.times do
+      @job_state.file_started payload
+      @job_state.file_finished payload
+    end
+  end
+end

data/spec/listener_spec.rb

@@ -0,0 +1,194 @@
+require 'gorgon/listener'
+
+describe Listener do
+  let(:connection_information) { double }
+  let(:queue) { stub("Bunny Queue", :bind => nil) }
+  let(:exchange) { stub("Bunny Exchange") }
+  let(:bunny) { stub("Bunny", :start => nil, :queue => queue, :exchange => exchange) }
+
+  before do
+    Bunny.stub(:new).and_return(bunny)
+    Listener.any_instance.stub(:configuration => {})
+    Listener.any_instance.stub(:connection_information => connection_information)
+    @stub_logger = stub :info => true, :datetime_format= => ""
+    Logger.stub(:new).and_return(@stub_logger)
+  end
+
+  describe "initialization" do
+
+    before do
+      Listener.any_instance.stub(:connect => nil, :initialize_personal_job_queue => nil)
+    end
+
+    it "connects" do
+      Listener.any_instance.should_receive(:connect)
+      Listener.new
+    end
+
+    it "initializes the personal job queue" do
+      Listener.any_instance.should_receive(:initialize_personal_job_queue)
+      Listener.new
+    end
+  end
+
+  describe "logging to a file" do
+    context "passing a log file path in the configuration" do
+      before do
+        Listener.any_instance.stub(:configuration).and_return({:log_file => 'listener.log'})
+      end
+
+      it "should use 'log_file' from the configuration as the log file" do
+        Logger.should_receive(:new).with('listener.log')
+        Listener.new
+      end
+
+      it "should log to 'log_file'" do
+        @stub_logger.should_receive(:info).with("Listener initialized")
+
+        Listener.new
+      end
+    end
+
+    context "passing a literal '-'' as the path in the configuration" do
+      before do
+        Listener.any_instance.stub(:configuration).and_return({:log_file => "-"})
+      end
+
+      it "logs to stdout" do
+        Logger.should_receive(:new).with($stdout)
+        Listener.new
+      end
+    end
+
+    context "without specifying a log file path" do
+      it "should not log" do
+        Logger.should_not_receive(:new)
+        @stub_logger.should_not_receive(:info)
+
+        Listener.new
+      end
+    end
+  end
+
+  context "initialized" do
+    let(:listener) { Listener.new }
+
+    describe "#connect" do
+      it "connects" do
+        Bunny.should_receive(:new).with(connection_information).and_return(bunny)
+        bunny.should_receive(:start)
+
+        listener.connect
+      end
+    end
+
+    describe "#initialize_personal_job_queue" do
+      it "creates the job queue" do
+        bunny.should_receive(:queue).with("", :exclusive => true)
+        listener.initialize_personal_job_queue
+      end
+
+      it "binds the exchange to the queue" do
+        bunny.should_receive(:exchange).with("gorgon.jobs", :type => :fanout).and_return(exchange)
+        queue.should_receive(:bind).with(exchange)
+        listener.initialize_personal_job_queue
+      end
+    end
+
+    describe "#poll" do
+
+      let(:empty_queue) { {:payload => :queue_empty} }
+      let(:job_payload) { {:payload => "Job"} }
+      before do
+        listener.stub(:run_job)
+      end
+
+      context "empty queue" do
+        before do
+          queue.stub(:pop => empty_queue)
+        end
+
+        it "checks the job queue" do
+          queue.should_receive(:pop).and_return(empty_queue)
+          listener.poll
+        end
+
+        it "returns false" do
+          listener.poll.should be_false
+        end
+      end
+
+      context "job pending on queue" do
+        before do
+          queue.stub(:pop => job_payload)
+        end
+
+        it "starts a new job when there is a job payload" do
+          queue.should_receive(:pop).and_return(job_payload)
+          listener.should_receive(:run_job).with(job_payload[:payload])
+          listener.poll
+        end
+
+        it "returns true" do
+          listener.poll.should be_true
+        end
+      end
+    end
+
+    describe "#run_job" do
+      let(:payload) {{
+          :source_tree_path => "path/to/source",
+          :sync_exclude => ["log"], :callbacks => {:a_callback => "path/to/callback"}
+        }}
+
+      let(:syncer) { stub("SourceTreeSyncer", :sync => nil, :exclude= => nil,
+                          :remove_temp_dir => nil, :sys_command => "rsync ...")}
+
+      let(:io) { stub("IO object", :write => nil, :close => nil)}
+      let(:process_status) { stub("Process Status", :exitstatus => 0)}
+      let(:callback_handler) { stub("Callback Handler", :after_sync => nil) }
+
+      before do
+        @listener = Listener.new
+        @json_payload = Yajl::Encoder.encode(payload)
+        stub_classes
+      end
+
+      it "copy source tree" do
+        SourceTreeSyncer.should_receive(:new).once.with("path/to/source").and_return syncer
+        syncer.should_receive(:exclude=).with(["log"])
+        syncer.should_receive(:sync)
+        @listener.run_job(@json_payload)
+      end
+
+      it "remove temp source directory when complete" do
+        syncer.should_receive(:remove_temp_dir)
+        @listener.run_job(@json_payload)
+      end
+
+      it "creates a CallbackHandler object using callbacks passed in payload" do
+        CallbackHandler.should_receive(:new).once.with({:a_callback => "path/to/callback"}).and_return(callback_handler)
+        @listener.run_job(@json_payload)
+      end
+
+      it "calls after_sync callback" do
+        callback_handler.should_receive(:after_sync).once
+        @listener.run_job(@json_payload)
+      end
+
+      it "uses Bundler#with_clean_env so the workers load new gems that could have been installed in after_sync" do
+        Bundler.should_receive(:with_clean_env).and_yield
+        @listener.run_job(@json_payload)
+      end
+    end
+
+    private
+
+    def stub_classes
+      SourceTreeSyncer.stub!(:new).and_return syncer
+      CallbackHandler.stub!(:new).and_return callback_handler
+      Open4.stub!(:popen4).and_return([1, io])
+      Process.stub!(:waitpid2).and_return([0, process_status])
+    end
+  end
+end