service_skeleton 0.0.0.49.g47046b9 → 2.0.0

data/ultravisor/spec/ultravisor/child/cast_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../../spec_helper"
+
+require_relative "../../../lib/ultravisor/child"
+require_relative "../../../lib/ultravisor/error"
+
+class CastCallTest
+  def run
+  end
+
+  def poke_processor
+    process_castcall
+  end
+end
+
+describe Ultravisor::Child do
+  let(:child) { Ultravisor::Child.new(**args) }
+  let(:instance) { child.__send__(:new_instance) }
+
+  describe "#cast" do
+    context "without enable_castcall" do
+      let(:args) do
+        {
+          id: :cast_child,
+          klass: CastCallTest,
+          method: :run,
+        }
+      end
+
+      it "does not accept calls to #cast" do
+        expect { child.cast }.to raise_error(NoMethodError)
+      end
+    end
+
+    context "with enable_castcall" do
+      let(:args) do
+        {
+          id: :cast_child,
+          klass: CastCallTest,
+          method: :run,
+          enable_castcall: true,
+        }
+      end
+
+      before(:each) do
+        # Got to have an instance otherwise all hell breaks loose
+        child.instance_variable_set(:@instance, instance)
+
+        # So we can check if and when it's been called
+        allow(instance).to receive(:to_s).and_call_original
+      end
+
+      it "accepts calls to #cast" do
+        expect { child.cast }.to_not raise_error
+      end
+
+      it "does not accept cast calls to methods that do not exist on the worker object" do
+        expect { child.cast.flibbetygibbets }.to raise_error(NoMethodError)
+      end
+
+      it "does not accept cast calls to private methods on the worker object" do
+        expect { child.cast.eval }.to raise_error(NoMethodError)
+      end
+
+      it "accepts calls to methods that exist on the worker object" do
+        expect { child.cast.to_s }.to_not raise_error
+      end
+
+      it "calls the instance method only when process_castcall is called" do
+        child.cast.to_s
+        expect(instance).to_not have_received(:to_s)
+        instance.poke_processor
+        expect(instance).to have_received(:to_s)
+      end
+
+      it "processes all the queued method calls" do
+        child.cast.to_s
+        child.cast.to_s
+        child.cast.to_s
+        child.cast.to_s
+        child.cast.to_s
+        expect(instance).to_not have_received(:to_s)
+        instance.poke_processor
+        expect(instance).to have_received(:to_s).exactly(5).times
+      end
+
+      let(:cc_fd) { instance.__send__(:castcall_fd) }
+      it "marks the castcall_fd as readable only after cast is called" do
+        expect(IO.select([cc_fd], nil, nil, 0)).to eq(nil)
+
+        child.cast.to_s
+
+        expect(IO.select([cc_fd], nil, nil, 0)).to eq([[cc_fd], [], []])
+      end
+
+      it "does not have a readable castcall_fd after process_castcall" do
+        child.cast.to_s
+        expect(IO.select([cc_fd], nil, nil, 0)).to eq([[cc_fd], [], []])
+        instance.poke_processor
+        expect(IO.select([cc_fd], nil, nil, 0)).to eq(nil)
+      end
+
+      it "does not explode if the instance is dying" do
+        instance.instance_variable_get(:@ultravisor_child_castcall_queue).close
+
+        expect { child.cast.to_s }.to_not raise_error
+      end
+    end
+  end
+end

data/ultravisor/spec/ultravisor/child/id_spec.rb

@@ -0,0 +1,21 @@
+# 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 } } }
+
+  describe "#id" do
+    context "with minimal arguments" do
+      let(:args) { { id: :bob, klass: mock_class, method: :run } }
+
+      it "returns the child's ID" do
+        expect(child.id).to eq(:bob)
+      end
+    end
+  end
+end

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

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

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

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

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