cukeforker 0.1.0 → 0.1.1

data/lib/cukeforker.rb

@@ -7,6 +7,7 @@ require "cucumber/cli/main"
 require "vnctools"
 require "fileutils"
 require "observer"
+require "forwardable"
 require "ostruct"
 
 module CukeForker

data/lib/cukeforker/recording_vnc_listener.rb

@@ -1,30 +1,56 @@
 module CukeForker
-  class RecordingVncListener < VncListener
-    def initialize(pool, opts = {})
-      super(pool)
-      
-      @ext     = opts[:codec] || "mpeg4"
-      @options = opts
+  class RecordingVncListener < AbstractListener
+    extend Forwardable
+
+    def_delegators :@listener, :on_run_starting, :on_worker_finished, :on_worker_forked,
+                              :on_run_interrupted, :on_run_finished, :on_display_fetched,
+                              :on_display_released, :on_display_starting, :on_display_stopping,
+                              :on_eta
+
+
+    def initialize(listener, opts = {})
+      @listener = listener
+      @ext      = opts[:codec] || "mp4"
+      @options  = opts
+
+      @recorders = []
     end
-    
+
     def on_worker_starting(worker)
-      super
-      worker.data.recorder = recorder_for(worker)
+      @listener.on_worker_starting(worker)
+
+      @recorders << worker.data.recorder = recorder_for(worker)
+      worker.data.recorder.start
     end
 
     def on_worker_finished(worker)
-      worker.data.recorder.stop
+      recorder = worker.data.recorder
+      recorder.stop
+
+      unless worker.failed?
+        FileUtils.rm_rf recorder.output
+      end
+
+      @recorders.delete(recorder)
       worker.data.recorder = nil
-      
-      super
+
+      @listener.on_worker_finished(worker)
+    end
+
+    def on_run_interrupted
+      @listener.on_run_interrupted
+
+      @recorders.each do |recorder|
+        recorder.stop rescue nil
+      end
     end
 
     private
-    
+
     def recorder_for(worker)
       display = worker.data.vnc.display
       output  = File.join(worker.out, "#{worker.basename}.#{@ext}")
-      
+
       VncTools::Recorder.new display, output, @options
     end
 

data/lib/cukeforker/runner.rb

@@ -9,6 +9,8 @@ module CukeForker
   #   :max        => Fixnum       number of workers (default: 2)
   #   :vnc        => true/false   children are launched with DISPLAY set from a VNC server pool,
   #                               where the size of the pool is equal to :max
+  #   :record     => true/false   whether to record a video of failed tests (requires ffmpeg)
+  #                               this will be ignored if if :vnc is not true
   #   :notify     => object       (or array of objects) implementing the AbstractListener API
   #   :out        => path         directory to dump output to (default: current working dir)
   #   :log        => true/false   wether or not to log to stdout (default: true)
@@ -47,7 +49,11 @@ module CukeForker
 
       if opts[:vnc]
         vnc_pool = VncTools::ServerPool.new(max)
-        listeners << VncListener.new(vnc_pool)
+        listener = VncListener.new(vnc_pool)
+
+        if opts[:record]
+          listeners << RecordingVncListener.new(listener)
+        end
       end
 
       queue = WorkerQueue.new max

data/lib/cukeforker/version.rb

@@ -1,3 +1,3 @@
 module CukeForker
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/cukeforker/recording_vnc_listener_spec.rb

@@ -2,9 +2,78 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 module CukeForker
   describe RecordingVncListener do
-    let(:recorder)  { mock(VncTools::Recorder) }
-    let(:listener)  { RecordingVncListener.new nil, :codec => "foo" }
+    let(:server)       { mock(VncTools::Server, :display => ":2")}
+    let(:vnc_listener) { mock(VncListener).as_null_object  }
+    let(:worker)       { mock(Worker, :data => OpenStruct.new(:vnc => server), :out => ".", :basename => "foo", :failed? => true) }
+    let(:recorder)     { mock(VncTools::Recorder, :start => nil, :stop => nil, :output => "foo.mp4")   }
+    let(:listener)     { RecordingVncListener.new vnc_listener }
+
+    it "forwards messages to the wrapped listener do" do
+      VncTools::Recorder.should_receive(:new).and_return(recorder)
+
+      # TODO: better way to do this
+
+      vnc_listener.should_receive :on_run_starting
+      vnc_listener.should_receive :on_worker_starting
+      vnc_listener.should_receive :on_worker_finished
+      vnc_listener.should_receive :on_worker_forked
+      vnc_listener.should_receive :on_run_interrupted
+      vnc_listener.should_receive :on_run_finished
+      vnc_listener.should_receive :on_display_fetched
+      vnc_listener.should_receive :on_display_released
+      vnc_listener.should_receive :on_display_starting
+      vnc_listener.should_receive :on_display_stopping
+      vnc_listener.should_receive :on_eta
+
+      listener.on_run_starting
+      listener.on_worker_starting worker
+      listener.on_worker_finished worker
+      listener.on_worker_forked worker
+      listener.on_run_interrupted
+      listener.on_run_finished
+      listener.on_display_fetched
+      listener.on_display_released
+      listener.on_display_starting
+      listener.on_display_stopping
+      listener.on_eta
+    end
+
+    it "starts recording when the worker is started" do
+      VncTools::Recorder.should_receive(:new).with(":2", "./foo.mp4", {}).and_return(recorder)
+      recorder.should_receive(:start)
+
+      listener.on_worker_starting worker
+    end
+
+    it "stops recording when the worker is finished" do
+      worker.data.recorder = recorder
+      recorder.should_receive(:stop)
+
+      listener.on_worker_finished worker
+
+      worker.data.recorder.should be_nil
+    end
+
+    it "deletes the output file if the worker succeeded" do
+      worker.data.recorder = recorder
+      recorder.stub(:stop)
+
+      worker.should_receive(:failed?).and_return(false)
+      recorder.should_receive(:output).and_return("./foo.mp4")
+      FileUtils.should_receive(:rm_rf).with("./foo.mp4")
+
+      listener.on_worker_finished worker
+    end
+
+    it "stops all recorders when the run is interrupted" do
+      VncTools::Recorder.should_receive(:new).with(":2", "./foo.mp4", {}).and_return(recorder)
+      recorder.should_receive(:start)
+
+      listener.on_worker_starting worker
+      recorder.should_receive(:stop)
+
+      listener.on_run_interrupted
+    end
 
-    # TODO: yuck inheritance
   end # RecordingVncListener
 end # CukeForker

data/spec/cukeforker/runner_spec.rb

@@ -44,6 +44,17 @@ module CukeForker
         Runner.create([], :max => 2, :vnc => true)
       end
 
+      it "sets up VNC recording if :record => true" do
+        mock_pool = mock(VncTools::ServerPool, :add_observer => nil)
+        VncTools::ServerPool.should_receive(:new).with(2).and_return mock_pool
+
+        mock_vnc_listener = mock(:update => nil)
+        VncListener.should_receive(:new).with(mock_pool).and_return(mock_vnc_listener)
+        RecordingVncListener.should_receive(:new).with(mock_vnc_listener).and_return(mock(:update => nil))
+
+        Runner.create([], :max => 2, :vnc => true, :record => true)
+      end
+
       it "creates and runs a new runner" do
         r = mock(Runner)
         Runner.should_receive(:create).with(%w[a b], {}).and_return(r)
@@ -78,6 +89,16 @@ module CukeForker
 
         runner.run
       end
+
+      it "fires on_run_interrupted and shuts down if an error occurs" do
+        runner.add_observer listener
+
+        queue.stub(:process).and_raise(StandardError)
+        runner.stub(:stop)
+        listener.should_receive(:update).with(:on_run_interrupted)
+
+        lambda { runner.run }.should raise_error(StandardError)
+      end
     end
 
   end # Runner

metadata

@@ -2,7 +2,7 @@
 name: cukeforker
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Jari Bakken
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-04 00:00:00 +01:00
+date: 2011-02-11 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency