cukeforker 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d03e238b71431b30c8f05c48e123ea3e85c5a63
-  data.tar.gz: 04eae12de5cb6df297f997bcd51b3ccd574cce6f
+  metadata.gz: f0a71153dc8250ce79cb7ed2b93ed9bc153f1adb
+  data.tar.gz: a509ebde9c5946ddd5bc51e0175a9afedbadf632
 SHA512:
-  metadata.gz: f580a26bd8a34850e9b81ba28cc3b20efbe3d37e3108f35784187ea77698418d8550ffefdf55bba0cae80bf999b862bc1e733718db9572d803eaa4768ee46233
-  data.tar.gz: d18e7ae8b58348e2edb0447567ca99712014daa536973a3234054765b202af3e6d481b10c6117d9b44902f8c1142f41a1051f1d8ff5e558f79ccbae2a94070f4
+  metadata.gz: da6c6dca2c50581ba380f3be11031561e72c8c7eaf424e6ad15c2c91b2a80cf4c6ae2abdc93ae5a2432afc4dd24ccb316b2a9adc136f228c3c3a0cb4541d75c6
+  data.tar.gz: 3f0381d1203723e7962a0c9aa4f5e7895a8978acc3be1ed5cac55f0d0f0f97989fb7c6bf7fd296d033c58611b619d044845db08f066841ce3c57e0df6d4770c0

data/lib/cukeforker/runner.rb

@@ -6,7 +6,7 @@ module CukeForker
   # where 'features' is an Array of file:line
   # and 'opts' is a Hash of options:
   #
-  #   :max        => Fixnum            number of workers (default: 2)
+  #   :max        => Fixnum            number of workers (default: 2, pass 0 for unlimited)
   #   :vnc        => true/false,Class  children are launched with DISPLAY set from a VNC server pool,
   #                                    where the size of the pool is equal to :max. If passed a Class instance,
   #                                    this will be passed as the second argument to VncTools::ServerPool.

data/lib/cukeforker/version.rb

@@ -1,3 +1,3 @@
 module CukeForker
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/lib/cukeforker/worker_queue.rb

@@ -5,6 +5,10 @@ module CukeForker
     def initialize(max)
       @max = max
 
+      if @max < 0
+        raise ArgumentError, "max workers cannot be negative, got #{@max.inspect}"
+      end
+
       @pending = []
       @running = []
       @finished = []
@@ -59,7 +63,7 @@ module CukeForker
     end
 
     def full?
-      size == @max
+      @max != 0 && size == @max
     end
 
     def empty?

data/spec/cukeforker/formatters/scenario_line_logger_spec.rb

@@ -6,8 +6,8 @@ module CukeForker::Formatters
     it "returns scenario names and line numbers for a scenario" do
       logger = ScenarioLineLogger.new
 
-      feature = mock("Cucumber::Ast::Feature")
-      feature_element = mock("Cucumber::Ast::Scenario")
+      feature = double("Cucumber::Ast::Feature")
+      feature_element = double("Cucumber::Ast::Scenario")
 
       feature.should_receive(:file).twice.and_return('features/test1.feature')
       feature_element.should_receive(:source_tags).twice.and_return('')
@@ -26,9 +26,9 @@ module CukeForker::Formatters
     it "returns scenario names and line numbers for a scenario outline" do
       logger = ScenarioLineLogger.new
 
-      feature = mock("Cucumber::Ast::Feature")
-      location = mock("Cucumber::Ast::Location", :line => 4)
-      feature_element = Cucumber::Ast::ScenarioOutline.new(*Array.new(11) {|a| stub(a, :each => true) })
+      feature = double("Cucumber::Ast::Feature")
+      location = double("Cucumber::Ast::Location", :line => 4)
+      feature_element = Cucumber::Ast::ScenarioOutline.new(*Array.new(11) {|a| double(a, :each => true) })
       feature_element.stub(:location => location)
 
       feature.should_receive(:file).and_return('features/test1.feature')

data/spec/cukeforker/logging_listener_spec.rb

@@ -8,10 +8,10 @@ module CukeForker
     it "logs all events" do
       Time.stub(:now => Time.now)
 
-      mock_worker  = mock(Worker,     :id => "1", :feature => "foo/bar", :failed? => false)
-      mock_worker2 = mock(Worker,     :id => "15", :feature => "foo/baz", :failed? => true)
+      mock_worker  = double(Worker,     :id => "1", :feature => "foo/bar", :failed? => false)
+      mock_worker2 = double(Worker,     :id => "15", :feature => "foo/baz", :failed? => true)
 
-      mock_display = mock(VncTools::Server)
+      mock_display = double(VncTools::Server)
       mock_display.stub(:display).and_return(nil, ":5", ":15")
 
       listener.on_run_starting

data/spec/cukeforker/recording_vnc_listener_spec.rb

@@ -2,10 +2,10 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 module CukeForker
   describe RecordingVncListener do
-    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(:server)       { double(VncTools::Server, :display => ":2")}
+    let(:vnc_listener) { double(VncListener).as_null_object  }
+    let(:worker)       { double(Worker, :data => OpenStruct.new(:vnc => server), :out => ".", :basename => "foo", :failed? => true) }
+    let(:recorder)     { double(VncTools::Recorder, :start => nil, :stop => nil, :output => "foo.mp4")   }
     let(:listener)     { RecordingVncListener.new vnc_listener }
 
     it "forwards messages to the wrapped listener do" do

data/spec/cukeforker/runner_spec.rb

@@ -10,12 +10,12 @@ module CukeForker
         max       = 4
         format    = :json
         out       = "/tmp"
-        listeners = [mock(AbstractListener, :update => nil)]
+        listeners = [double(AbstractListener, :update => nil)]
         log       = false
         features  = %w[a b]
 
-        mock_queue = mock(WorkerQueue)
-        mock_workers = Array.new(2) { |n| mock("Worker-#{n}") }
+        mock_queue = double(WorkerQueue)
+        mock_workers = Array.new(2) { |n| double("Worker-#{n}") }
 
         Process.stub(:pid => 1234)
 
@@ -37,9 +37,9 @@ module CukeForker
       end
 
       it "sets up the VNC pool if :vnc => true" do
-        mock_pool = mock(VncTools::ServerPool, :add_observer => nil)
+        mock_pool = double(VncTools::ServerPool, :add_observer => nil)
         VncTools::ServerPool.should_receive(:new).with(2).and_return mock_pool
-        VncListener.should_receive(:new).with(mock_pool).and_return mock(:update => nil)
+        VncListener.should_receive(:new).with(mock_pool).and_return double(:update => nil)
 
         Runner.create([], :max => 2, :vnc => true)
       end
@@ -47,37 +47,37 @@ module CukeForker
       it "sets up the VNC pool with a custom server class" do
         server_class = Class.new
 
-        mock_pool = mock(VncTools::ServerPool, :add_observer => nil)
+        mock_pool = double(VncTools::ServerPool, :add_observer => nil)
         VncTools::ServerPool.should_receive(:new).with(2, server_class).and_return mock_pool
-        VncListener.should_receive(:new).with(mock_pool).and_return mock(:update => nil)
+        VncListener.should_receive(:new).with(mock_pool).and_return double(:update => nil)
 
         Runner.create([], :max => 2, :vnc => server_class)
       end
 
       it "sets up VNC recording if :record => true" do
-        mock_pool = mock(VncTools::ServerPool, :add_observer => nil)
+        mock_pool = double(VncTools::ServerPool, :add_observer => nil)
         VncTools::ServerPool.should_receive(:new).with(2).and_return mock_pool
 
-        mock_vnc_listener = mock(:update => nil)
+        mock_vnc_listener = double(: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))
+        RecordingVncListener.should_receive(:new).with(mock_vnc_listener).and_return(double(:update => nil))
 
         Runner.create([], :max => 2, :vnc => true, :record => true)
       end
 
       it "sets up VNC recording if :record => Hash" do
-        mock_pool = mock(VncTools::ServerPool, :add_observer => nil)
+        mock_pool = double(VncTools::ServerPool, :add_observer => nil)
         VncTools::ServerPool.should_receive(:new).with(2).and_return mock_pool
 
-        mock_vnc_listener = mock(:update => nil)
+        mock_vnc_listener = double(:update => nil)
         VncListener.should_receive(:new).with(mock_pool).and_return(mock_vnc_listener)
-        RecordingVncListener.should_receive(:new).with(mock_vnc_listener, :codec => "flv").and_return(mock(:update => nil))
+        RecordingVncListener.should_receive(:new).with(mock_vnc_listener, :codec => "flv").and_return(double(:update => nil))
 
         Runner.create([], :max => 2, :vnc => true, :record => {:codec => "flv"})
       end
 
       it "creates and runs a new runner" do
-        r = mock(Runner)
+        r = double(Runner)
         Runner.should_receive(:create).with(%w[a b], {}).and_return(r)
         r.should_receive(:run)
 
@@ -86,8 +86,8 @@ module CukeForker
     end
 
     context "running" do
-      let(:listener) { mock(AbstractListener, :update => nil) }
-      let(:queue)    { mock(Queue, :has_failures? => false) }
+      let(:listener) { double(AbstractListener, :update => nil) }
+      let(:queue)    { double(Queue, :has_failures? => false) }
       let(:runner)   { Runner.new(queue) }
 
       it "processes the queue" do

data/spec/cukeforker/scenarios_spec.rb

@@ -28,10 +28,10 @@ module CukeForker
             | 1       |
         ")
 
-      Cucumber::FeatureFile.stub!(:new).with("features/test1.feature").and_return(feature_1)
-      Cucumber::FeatureFile.stub!(:new).with("features/test2.feature").and_return(feature_2)
+      Cucumber::FeatureFile.stub(:new).with("features/test1.feature").and_return(feature_1)
+      Cucumber::FeatureFile.stub(:new).with("features/test2.feature").and_return(feature_2)
 
-      Scenarios.stub!(:feature_files).and_return(['features/test1.feature', 'features/test2.feature'])
+      Scenarios.stub(:feature_files).and_return(['features/test1.feature', 'features/test2.feature'])
 
       all_scenarios = Scenarios.all
 
@@ -54,9 +54,9 @@ module CukeForker
           Scenario: test scenario 2
             Given nothing else happens")
 
-      Cucumber::FeatureFile.stub!(:new).with("features/test1.feature").and_return(feature_1)
+      Cucumber::FeatureFile.stub(:new).with("features/test1.feature").and_return(feature_1)
 
-      Scenarios.stub!(:feature_files).and_return(['features/test1.feature'])
+      Scenarios.stub(:feature_files).and_return(['features/test1.feature'])
 
       all_scenarios = Scenarios.by_args(%W[-t @find_me])
 

data/spec/cukeforker/vnc_listener_spec.rb

@@ -2,9 +2,9 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 module CukeForker
   describe VncListener do
-    let(:server)    { mock(VncTools::Server, :display => ":15")    }
-    let(:pool)      { mock(VncTools::ServerPool)                   }
-    let(:worker)    { mock(Worker, :data => OpenStruct.new) }
+    let(:server)    { double(VncTools::Server, :display => ":15")    }
+    let(:pool)      { double(VncTools::ServerPool)                   }
+    let(:worker)    { double(Worker, :data => OpenStruct.new) }
     let(:listener)  { VncListener.new pool                  }
 
     it "fetches a display from the pool and assings it to the worker" do

data/spec/cukeforker/worker_queue_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 module CukeForker
   describe WorkerQueue do
-    let(:workers) { Array.new(5) { |n| mock("Worker-#{n}") } }
+    let(:workers) { Array.new(5) { |n| double("Worker-#{n}") } }
     let(:queue) { WorkerQueue.new(3) }
 
     it "adds an item to the queue" do
@@ -28,6 +28,20 @@ module CukeForker
       queue.should be_backed_up
     end
 
+    it "is unlimited if max workers = 0" do
+      unlimited_queue = WorkerQueue.new(0)
+
+      workers.each { |w| queue.add double.as_null_object }
+
+      unlimited_queue.fill
+      unlimited_queue.should_not be_full
+      unlimited_queue.should_not be_backed_up
+    end
+
+    it "raises if max workers is negative" do
+      expect { WorkerQueue.new(-1) }.to raise_error(ArgumentError)
+    end
+
     it "removes finished workers from the queue" do
       workers.each do |w|
         w.should_receive(:start)
@@ -36,9 +50,9 @@ module CukeForker
 
       queue.fill
 
-      workers[0].stub!(:finished? => true)
-      workers[1].stub!(:finished? => true)
-      workers[2].stub!(:finished? => false)
+      workers[0].stub(:finished? => true)
+      workers[1].stub(:finished? => true)
+      workers[2].stub(:finished? => false)
 
       queue.poll
 

data/spec/cukeforker/worker_spec.rb

@@ -68,7 +68,7 @@ module CukeForker
     end
 
     it "fires an event after forking" do
-      mock_listener = mock(AbstractListener)
+      mock_listener = double(AbstractListener)
       mock_listener.should_receive(:update).with(:on_worker_forked, worker)
 
       worker.add_observer mock_listener
@@ -88,12 +88,12 @@ module CukeForker
     end
 
     it "considers itself failed if the exit code was 1" do
-      worker.stub :status => mock(:exitstatus => 1)
+      worker.stub :status => double(:exitstatus => 1)
       worker.should be_failed
     end
 
     it "considers itself failed  if the exit code was 0" do
-      worker.stub :status => mock(:exitstatus => 0)
+      worker.stub :status => double(:exitstatus => 0)
       worker.should_not be_failed
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cukeforker
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Jari Bakken
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber