service_skeleton 1.0.1 → 2.0.1

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

@@ -0,0 +1,124 @@
+# 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

@@ -0,0 +1,216 @@
+# 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 only non-keyword args" do
+      let(:args) { { id: :testy, klass: mock_class, args: ["foo", "bar"], method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo, bar)
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+
+        child.spawn(term_queue).wait
+        expect(mock_class).to have_received(:new).with("foo", "bar")
+      end
+    end
+
+    context "with a worker class that takes non-keyword and optional args" do
+      let(:args) { { id: :testy, klass: mock_class, args: ["foo", "bar", baz: "wombat"], method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo, bar, baz = {})
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+
+        child.spawn(term_queue).wait
+        expect(mock_class).to have_received(:new).with("foo", "bar", { baz: "wombat" })
+      end
+    end
+
+    context "with a worker class that takes mixed args" do
+      let(:args) { { id: :testy, klass: mock_class, args: ["foo", "bar", baz: "wombat"], method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo, bar, baz:)
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+
+        child.spawn(term_queue).wait
+        expect(mock_class).to have_received(:new).with("foo", "bar", baz: "wombat")
+      end
+    end
+
+    context "with a worker class that takes keyword args" do
+      let(:args) { { id: :testy, klass: mock_class, args: [foo: "bar", baz: "wombat"], method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo:, baz:)
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+
+        child.spawn(term_queue).wait
+        expect(mock_class).to have_received(:new).with(foo: "bar", baz: "wombat")
+      end
+    end
+
+    context "with a worker class that takes optional args" do
+      let(:args) { { id: :testy, klass: mock_class, args: [foo: "bar", baz: "wombat", fib: "wib", woop: "woob"], method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo:, baz:, fib: "none", woop: nil)
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+        child.spawn(term_queue).wait
+
+        expect(mock_class).to have_received(:new).with(foo: "bar", baz: "wombat", fib: "wib", woop: "woob")
+      end
+    end
+
+    context "with a worker class that takes keyword args in form of a hash" do
+      let(:args) { { id: :testy, klass: mock_class, args: { foo: "bar", baz: "wombat" }, method: :run } }
+      let(:mock_class) do
+        Class.new do
+          def initialize(foo:, baz:)
+          end
+
+          def run
+          end
+        end
+      end
+
+      it "creates the class instance with args" do
+        allow(mock_class).to receive(:new).and_call_original
+        child.spawn(term_queue).wait
+
+        expect(mock_class).to have_received(:new).with(foo: "bar", baz: "wombat")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

data/ultravisor/spec/ultravisor/new_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require_relative "../spec_helper"
+
+require_relative "../../lib/ultravisor"
+
+describe Ultravisor do
+  describe ".new" do
+    context "without arguments" do
+      it "does not explode" do
+        expect { Ultravisor.new }.to_not raise_error
+      end
+
+      it "gives us an Ultravisor instance" do
+        expect(Ultravisor.new).to be_a(Ultravisor)
+      end
+    end
+
+    context "with empty children" do
+      it "does not explode" do
+        expect { Ultravisor.new children: [] }.to_not raise_error
+      end
+    end
+
+    context "with children that isn't an array" do
+      it "raises an error" do
+        [{}, "ohai!", nil, 42].each do |v|
+          expect { Ultravisor.new children: v }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context "with valid children" do
+      let(:ultravisor) { Ultravisor.new(children: [{ id: :testy, klass: Object, method: :to_s }]) }
+
+      it "registers the child by its ID" do
+        expect(ultravisor[:testy]).to be_a(Ultravisor::Child)
+      end
+    end
+
+    context "with two children with the same ID" do
+      it "explodes" do
+        expect do
+          Ultravisor.new(
+            children: [
+              { id: :testy, klass: Object, method: :to_s },
+              { id: :testy, klass: Class, method: :to_s },
+            ]
+          )
+        end.to raise_error(Ultravisor::DuplicateChildError)
+      end
+    end
+
+    context "with a valid strategy" do
+      it "does not explode" do
+        expect { Ultravisor.new strategy: :all_for_one }.to_not raise_error
+      end
+    end
+
+    [
+      { strategy: :bob },
+      { strategy: "all_for_one" },
+      { strategy: ["games"] },
+    ].each do |s|
+      context "with invalid strategy #{s.inspect}" do
+        it "explodes" do
+          expect { Ultravisor.new **s }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end