service_skeleton 0.0.0.1.ENOTAG → 0.0.0.2.g46c1e0e

data/ultravisor/spec/ultravisor/child/new_spec.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end; def sigterm; end } } }
-
-  describe ".new" do
-    context "with minimal arguments" do
-      let(:args) { { id: :bob, klass: mock_class, method: :run } }
-
-      it "does not explode" do
-        expect { Ultravisor::Child.new(**args) }.to_not raise_error
-      end
-
-      it "does not instantiate an instance of klass" do
-        expect(mock_class).to_not receive(:new)
-
-        Ultravisor::Child.new(**args)
-      end
-    end
-
-    context "with defined args" do
-      let(:args) { { id: :bob, klass: mock_class, args: [foo: "bar"], method: :run } }
-
-      it "explodes" do
-        expect { Ultravisor::Child.new(**args) }.to raise_error(Ultravisor::InvalidKAMError)
-      end
-    end
-
-    context "with a class that takes args" do
-      let(:mock_class) { Class.new.tap { |k| k.class_eval { def initialize(*x); end } } }
-      let(:args) { { id: :testy, klass: mock_class, args: [1, 2, 3], method: :to_s } }
-
-      it "doesn't explode" do
-        expect { Ultravisor::Child.new(**args) }.to_not raise_error
-      end
-    end
-
-    context "with a non-existent method" do
-      let(:args) { { id: :testy, klass: mock_class, method: :gogogo } }
-
-      it "explodes" do
-        expect { Ultravisor::Child.new(**args) }.to raise_error(Ultravisor::InvalidKAMError)
-      end
-    end
-
-    context "with a method that takes args" do
-      let(:args) { { id: :testy, klass: mock_class, method: :public_send } }
-
-      it "explodes" do
-        expect { Ultravisor::Child.new(**args) }.to raise_error(Ultravisor::InvalidKAMError)
-      end
-    end
-
-    context "with a valid restart value" do
-      it "is fine" do
-        %i{always on_failure never}.each do |v|
-          expect { Ultravisor::Child.new(id: :x, klass: Object, method: :to_s, restart: v) }.to_not raise_error
-        end
-      end
-    end
-
-    context "with an invalid restart value" do
-      it "explodes" do
-        [:sometimes, "always", 42, { max: 4 }].each do |v|
-          expect { Ultravisor::Child.new(id: :x, klass: Object, method: :to_s, restart: v) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    context "with a valid restart_policy" do
-      it "is happy" do
-        expect do
-          Ultravisor::Child.new(id: :rp, klass: Object, method: :to_s, restart_policy: { period: 5, max: 2, delay: 1 })
-        end.to_not raise_error
-      end
-    end
-
-    [
-      { when: :never },
-      { period: -1 },
-      { period: "never" },
-      { period: :sometimes },
-      { period: (0..10) },
-      { max: -1 },
-      { max: "powers" },
-      { max: (1..5) },
-      { delay: -1 },
-      { delay: "buses" },
-      { delay: (-1..3) },
-      { delay: (3..1) },
-      "whenever you're ready",
-    ].each do |p|
-      it "explodes with invalid restart_policy #{p.inspect}" do
-        expect do
-          Ultravisor::Child.new(id: :boom, klass: Object, method: :to_s, restart_policy: p)
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context "with a valid shutdown spec" do
-      it "is happy" do
-        expect do
-          Ultravisor::Child.new(id: :rp, klass: mock_class, method: :to_s, shutdown: { method: :sigterm, timeout: 2 })
-        end.to_not raise_error
-      end
-    end
-
-    [
-      { method: "man" },
-      { method: :send },
-      { method: :nonexistent_method },
-      { timeout: -4 },
-      { timeout: (3..5) },
-      { timeout: "MC Hammer" },
-      { woogiewoogie: "boo!" },
-      "freddie!",
-    ].each do |s|
-      it "explodes with invalid shutdown spec #{s.inspect}" do
-        expect do
-          Ultravisor::Child.new(id: :boom, klass: Object, method: :to_s, shutdown: s)
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context "with castcall enabled" do
-      it "is happy" do
-        expect do
-          Ultravisor::Child.new(id: :castcall, klass: Object, method: :to_s, enable_castcall: true)
-        end.to_not raise_error
-      end
-    end
-
-    [
-      :bob,
-      42,
-      "unsafe",
-      { safe: :un },
-    ].each do |a|
-      it "explodes with invalid access spec #{a.inspect}" do
-        expect do
-          Ultravisor::Child.new(id: :boom, klass: Object, method: :to_s, access: a)
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/restart_delay_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-
-describe Ultravisor::Child do
-  let(:base_args) { { id: :bob, klass: mock_class, method: :run } }
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-
-  describe "#restart_delay" do
-    context "by default" do
-      let(:args) { base_args }
-
-      it "returns the default delay" do
-        expect(child.restart_delay).to eq(1)
-      end
-    end
-
-    context "with a specified numeric delay" do
-      let(:args) { base_args.merge(restart_policy: { delay: 3.14159 }) }
-
-      it "returns the specified delay" do
-        expect(child.restart_delay).to be_within(0.00001).of(3.14159)
-      end
-    end
-
-    context "with a delay range" do
-      let(:args) { base_args.merge(restart_policy: { delay: 2..5 }) }
-
-      it "returns a delay in the given range" do
-        delays = 10.times.map { child.restart_delay }
-
-        expect(delays.all? { |d| (2..5).include?(d) }).to be(true)
-        expect(delays.uniq.length).to eq(10)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/restart_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:base_args) { { id: :bob, klass: Object, method: :to_s } }
-  let(:child) { Ultravisor::Child.new(**args) }
-
-  describe "#restart?" do
-    context "when restart: :always" do
-      # Yes, this is the default, but I do like to be explicit
-      let(:args) { base_args.merge(restart: :always) }
-
-      it "is true always" do
-        expect(child.restart?).to be(true)
-      end
-    end
-
-    context "when restart: :never" do
-      let(:args) { base_args.merge(restart: :never) }
-
-      it "is false always" do
-        expect(child.restart?).to be(false)
-      end
-    end
-
-    context "when restart: :on_failure" do
-      let(:args) { base_args.merge(restart: :on_failure) }
-
-      it "is true if the child terminated with an exception" do
-        expect(child).to receive(:termination_exception).and_return(Exception.new("boom"))
-
-        expect(child.restart?).to be(true)
-      end
-
-      it "is false if the child didn't terminate with an exception" do
-        expect(child).to receive(:termination_exception).and_return(nil)
-
-        expect(child.restart?).to be(false)
-      end
-    end
-
-    context "with a restart history that isn't blown" do
-      let(:args) { base_args.merge(restart: :always, restart_policy: { period: 10, max: 3 }) }
-
-      before(:each) do
-        child.instance_variable_set(:@runtime_history, [4.99, 4.99, 4.99])
-      end
-
-      it "still returns true" do
-        expect(child.restart?).to be(true)
-      end
-    end
-
-    context "with a restart history that is blown" do
-      let(:args) { base_args.merge(restart: :always, restart_policy: { period: 10, max: 2 }) }
-
-      before(:each) do
-        child.instance_variable_set(:@runtime_history, [4.99, 4.99, 4.99])
-      end
-
-      it "explodes" do
-        expect { child.restart? }.to raise_error(Ultravisor::BlownRestartPolicyError)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/run_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-  let(:mock_instance) { double(mock_class) } # rubocop:disable RSpec/VerifiedDoubles
-  let(:term_queue) { instance_double(Queue) }
-
-  describe "#run" do
-    before(:each) do
-      allow(term_queue).to receive(:<<)
-    end
-
-    context "with minimal arguments" do
-      let(:args) { { id: :bob, klass: mock_class, method: :run } }
-
-      before(:each) do
-        allow(mock_class).to receive(:new).and_return(mock_instance)
-        allow(mock_instance).to receive(:run)
-      end
-
-      it "instantiates the class" do
-        expect(mock_class).to receive(:new).with(no_args)
-
-        child.spawn(term_queue).wait
-      end
-
-      it "calls the run method on the class instance" do
-        expect(mock_instance).to receive(:run).with(no_args)
-
-        child.spawn(term_queue).wait
-      end
-
-      it "registers the thread it is running in" do
-        expect(mock_instance).to receive(:run) do
-          expect(child.instance_variable_get(:@thread)).to eq(Thread.current)
-        end
-
-        child.spawn(term_queue).wait
-      end
-
-      it "notes the start time" do
-        expect(mock_instance).to receive(:run) do
-          # Can only check @start_time while the child is running, as the
-          # variable gets nil'd after the run completes
-          expect(child.instance_variable_get(:@start_time).to_f).to be_within(0.01).of(Time.now.to_f)
-        end
-
-        child.spawn(term_queue).wait
-      end
-
-      it "notes the termination value" do
-        expect(mock_instance).to receive(:run).with(no_args).and_return(42)
-
-        child.spawn(term_queue)
-
-        expect(child.termination_value).to eq(42)
-      end
-
-      it "tells the ultravisor it terminated" do
-        expect(term_queue).to receive(:<<).with(child)
-
-        child.spawn(term_queue).wait
-      end
-
-      context "when the worker object's run method raises an exception" do
-        before(:each) do
-          allow(mock_instance).to receive(:run).and_raise(RuntimeError.new("FWACKOOM"))
-        end
-
-        it "makes a note of the exception" do
-          child.spawn(term_queue)
-
-          expect(child.termination_exception).to be_a(RuntimeError)
-        end
-      end
-    end
-
-    context "with a worker class that takes args" do
-      let(:args) { { id: :testy, klass: mock_class, args: ["foo", "bar", baz: "wombat"], method: :run } }
-      let(:mock_class) { Class.new.tap { |k| k.class_eval { def initialize(*x); end; def run; end } } }
-
-      it "creates the class instance with args" do
-        expect(mock_class).to receive(:new).with("foo", "bar", baz: "wombat").and_call_original
-
-        child.spawn(term_queue).wait
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/shutdown_spec.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  uses_logger
-
-  let(:base_args) { { id: :bob, klass: mock_class, method: :run } }
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end; def sigterm; end } } }
-  let(:mock_instance) { instance_double(mock_class) }
-  let(:term_queue) { instance_double(Queue) }
-
-  describe "#shutdown" do
-    let(:args) { base_args }
-
-    context "when the child isn't running" do
-      it "returns immediately" do
-        child.shutdown
-      end
-    end
-
-    context "when the child is running" do
-      before(:each) do
-        orig_thread_new = Thread.method(:new)
-        allow(Thread).to receive(:new) do |&b|
-          orig_thread_new.call(&b).tap do |th|
-            @thread = th
-            allow(th).to receive(:kill).and_call_original
-            allow(th).to receive(:join).and_call_original
-          end
-        end
-
-        allow(mock_class).to receive(:new).and_return(mock_instance)
-        allow(mock_instance).to receive(:run)
-
-        allow(term_queue).to receive(:<<)
-      end
-
-      it "kills the thread" do
-        child.spawn(term_queue).shutdown
-
-        expect(@thread).to have_received(:kill)
-      end
-
-      it "waits for the thread to be done" do
-        child.spawn(term_queue).shutdown
-
-        expect(@thread).to have_received(:join).with(1)
-      end
-
-      it "doesn't put anything on the queue" do
-        expect(term_queue).to_not receive(:<<)
-
-        child.spawn(term_queue).shutdown
-      end
-
-      context "when there's a shutdown spec" do
-        let(:args) { base_args.merge(shutdown: { method: :sigterm, timeout: 0.05 }) }
-
-        before(:each) do
-          allow(mock_instance).to receive(:sigterm)
-        end
-
-        it "calls the specified shutdown method" do
-          expect(mock_instance).to receive(:sigterm)
-
-          child.spawn(term_queue).shutdown
-        end
-
-        it "waits for up to the timeout period" do
-          child.spawn(term_queue).shutdown
-
-          expect(@thread).to have_received(:join).with(0.05)
-        end
-
-        context "the worker doesn't finish quickly enough" do
-          before(:each) do
-            allow(mock_instance).to receive(:run) { sleep 15 }
-          end
-
-          it "kills the thread" do
-            child.spawn(term_queue).shutdown
-
-            expect(@thread).to have_received(:kill)
-          end
-        end
-      end
-
-      context "when the thread infinihangs" do
-        # No need for a big timeout, we know it's not going to succeed
-        let(:args) { base_args.merge(shutdown: { timeout: 0.000001 }) }
-        let(:m) { Mutex.new }
-        let(:cv) { ConditionVariable.new }
-
-        before(:each) do
-          allow(mock_instance).to receive(:run) do
-            Thread.handle_interrupt(Numeric => :never) do
-              m.synchronize do
-                @state = 1
-                cv.signal
-                cv.wait(m) until @state == 2
-              end
-            end
-          end
-
-          allow(logger).to receive(:error)
-        end
-
-        it "logs an error" do
-          expect(logger).to receive(:error)
-
-          child.spawn(term_queue)
-          m.synchronize { cv.wait(m) until @state == 1 }
-          child.shutdown
-          m.synchronize { @state = 2; cv.signal }
-        end
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/spawn_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-  let(:mock_instance) { double(mock_class) }  # rubocop:disable RSpec/VerifiedDoubles
-  let(:term_queue) { instance_double(Queue) }
-
-  describe "#spawn" do
-    before(:each) do
-      allow(term_queue).to receive(:<<)
-    end
-
-    context "with minimal arguments" do
-      let(:args) { { id: :bob, klass: mock_class, method: :run } }
-
-      before(:each) do
-        allow(mock_class).to receive(:new).and_return(mock_instance)
-        allow(mock_instance).to receive(:run)
-      end
-
-      it "instantiates the class" do
-        expect(mock_class).to receive(:new).with(no_args)
-
-        child.spawn(term_queue).wait
-      end
-
-      it "calls the run method on the class instance" do
-        expect(mock_instance).to receive(:run).with(no_args)
-
-        child.spawn(term_queue).wait
-      end
-
-      it "registers the thread it is running in" do
-        expect(mock_instance).to receive(:run) do
-          expect(child.instance_variable_get(:@thread)).to eq(Thread.current)
-        end
-
-        child.spawn(term_queue).wait
-      end
-
-      it "notes the start time" do
-        expect(mock_instance).to receive(:run) do
-          # Can only check @start_time while the child is running, as the
-          # variable gets nil'd after the run completes
-          expect(child.instance_variable_get(:@start_time).to_f).to be_within(0.01).of(Time.now.to_f)
-        end
-
-        child.spawn(term_queue).wait
-      end
-
-      it "notes the termination value" do
-        expect(mock_instance).to receive(:run).with(no_args).and_return(42)
-
-        child.spawn(term_queue)
-
-        expect(child.termination_value).to eq(42)
-      end
-
-      it "tells the ultravisor it terminated" do
-        expect(term_queue).to receive(:<<).with(child)
-
-        child.spawn(term_queue).wait
-      end
-
-      it "creates a new thread" do
-        expect(Thread).to receive(:new)
-
-        child.spawn(term_queue).wait
-      end
-
-      context "when the worker object's run method raises an exception" do
-        before(:each) do
-          allow(mock_instance).to receive(:run).and_raise(RuntimeError.new("FWACKOOM"))
-        end
-
-        it "makes a note of the exception" do
-          child.spawn(term_queue)
-
-          expect(child.termination_exception).to be_a(RuntimeError)
-        end
-
-        it "tells the ultravisor it terminated" do
-          expect(term_queue).to receive(:<<).with(child)
-
-          child.spawn(term_queue).wait
-        end
-      end
-    end
-
-    context "with a worker class that takes args" do
-      let(:args) { { id: :testy, klass: mock_class, args: ["foo", "bar", baz: "wombat"], method: :run } }
-      let(:mock_class) { Class.new.tap { |k| k.class_eval { def initialize(*x); end; def run; end } } }
-
-      it "creates the class instance with args" do
-        expect(mock_class).to receive(:new).with("foo", "bar", baz: "wombat").and_call_original
-
-        child.spawn(term_queue).wait
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/unsafe_instance_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:args) { { id: :bob, klass: Object, method: :to_s } }
-  let(:child) { Ultravisor::Child.new(**args) }
-
-  describe "#unsafe_instance" do
-    context "by default" do
-      it "explodes" do
-        expect { child.unsafe_instance }.to raise_error(Ultravisor::ThreadSafetyError)
-      end
-    end
-
-    context "with access: :unsafe" do
-      let(:args) { { id: :bob, klass: Object, method: :to_s, access: :unsafe } }
-
-      context "when there's no instance object" do
-        it "waits for the instance object to appear" do
-          expect(child.instance_variable_get(:@spawn_cv)).to receive(:wait) do
-            child.instance_variable_set(:@instance, "gogogo")
-          end
-
-          child.unsafe_instance
-        end
-      end
-
-      context "when there's an instance object" do
-        before(:each) do
-          child.instance_variable_set(:@instance, "bob")
-        end
-
-        it "returns the instance object" do
-          expect(child.unsafe_instance).to eq("bob")
-        end
-      end
-    end
-
-    context "when the child is running" do
-      it "only exits once the child has finished" do
-        child.instance_variable_set(:@thread, Thread.new {})
-
-        expect(child.instance_variable_get(:@spawn_cv)).to receive(:wait).with(child.instance_variable_get(:@spawn_m)) do
-          child.instance_variable_set(:@thread, nil)
-        end
-
-        child.wait
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/wait_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:args) { { id: :bob, klass: mock_class, method: :run } }
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-
-  describe "#wait" do
-    context "when the child isn't running" do
-      it "just returns straight away" do
-        child.wait
-      end
-    end
-
-    context "when the child is running" do
-      it "only exits once the child has finished" do
-        child.instance_variable_set(:@thread, Thread.new {})
-
-        expect(child.instance_variable_get(:@spawn_cv)).to receive(:wait).with(child.instance_variable_get(:@spawn_m)) do
-          child.instance_variable_set(:@thread, nil)
-        end
-
-        child.wait
-      end
-    end
-  end
-end