service_skeleton 0.0.0.1.ENOTAG → 0.0.0.2.g46c1e0e

data/ultravisor/spec/ultravisor/new_spec.rb

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

data/ultravisor/spec/ultravisor/remove_child_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-require_relative "../spec_helper"
-
-require_relative "../../lib/ultravisor"
-
-describe Ultravisor do
-  let(:args) { {} }
-  let(:ultravisor) { Ultravisor.new(**args) }
-  let(:mock_child) { instance_double(Ultravisor::Child) }
-
-  describe "#remove_child" do
-    before(:each) do
-      ultravisor.instance_variable_set(:@children, [[:lamb, mock_child]])
-    end
-
-    context "when the ultravisor isn't running" do
-      it "removes the child from the list of children" do
-        ultravisor.remove_child(:lamb)
-
-        expect(ultravisor[:lamb]).to be(nil)
-      end
-
-      it "doesn't explode if asked to remove a child that doesn't exist" do
-        expect { ultravisor.remove_child(:no_such_child) }.to_not raise_error
-      end
-    end
-
-    context "while the ultravisor is running" do
-      let(:mock_thread) { instance_double(Thread) }
-
-      before(:each) do
-        allow(mock_child).to receive(:shutdown)
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-      end
-
-      it "shuts down the child" do
-        expect(mock_child).to receive(:shutdown)
-
-        ultravisor.remove_child(:lamb)
-      end
-
-      it "removes the child from the list of children" do
-        ultravisor.remove_child(:lamb)
-
-        expect(ultravisor[:lamb]).to be(nil)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/run_spec.rb

@@ -1,334 +0,0 @@
-# frozen_string_literal: true
-require_relative "../spec_helper"
-
-require_relative "../../lib/ultravisor"
-
-describe Ultravisor do
-  uses_logger
-
-  describe "#run" do
-    let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-    let(:args) { { children: [{ id: :testy, klass: mock_class, method: :run }] } }
-    let(:ultravisor) { Ultravisor.new(**args) }
-    let(:mock_thread) { instance_double(Thread) }
-
-    before(:each) do
-      allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop).and_return(:shutdown)
-    end
-
-    context "with no children" do
-      let(:args) { {} }
-
-      it "doesn't start anything" do
-        expect(Thread).to_not receive(:new)
-
-        expect { ultravisor.run }.to_not raise_error
-      end
-    end
-
-    context "when already running" do
-      before(:each) do
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-      end
-
-      it "raises an exception" do
-        expect { ultravisor.run }.to raise_error(Ultravisor::AlreadyRunningError)
-      end
-    end
-
-    context "when the event handler gets an unknown event" do
-      before(:each) do
-        allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop).and_return("wassamatta", :shutdown)
-        allow(logger).to receive(:error)
-      end
-
-      it "logs an error" do
-        expect(logger).to receive(:error).with(match(/^Ultravisor#.*process_events/))
-
-        ultravisor.run
-      end
-    end
-
-    context "with a single child" do
-      let(:child) { Ultravisor::Child.new(id: :testy, klass: Object, method: :to_s) }
-
-      before(:each) do
-        allow(child).to receive(:spawn)
-        ultravisor.instance_variable_set(:@children, [[child.id, child]])
-      end
-
-      it "spawns a child worker" do
-        expect(child).to receive(:spawn)
-
-        ultravisor.run
-      end
-
-      it "shuts down the child on termination" do
-        expect(ultravisor.instance_variable_get(:@children).first.last).to receive(:shutdown)
-
-        ultravisor.run
-      end
-
-      context "that terminates" do
-        before(:each) do
-          allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop).and_return(child, :shutdown)
-          allow(ultravisor).to receive(:sleep)
-        end
-
-        context "within the limits of its restart policy" do
-          it "spawns the child again" do
-            expect(child).to receive(:spawn).exactly(:twice)
-
-            ultravisor.run
-          end
-
-          it "sleeps between restart" do
-            expect(ultravisor).to receive(:sleep).with(1)
-
-            ultravisor.run
-          end
-        end
-
-        context "too often for its restart policy" do
-          before(:each) do
-            allow(child).to receive(:restart?).and_raise(Ultravisor::BlownRestartPolicyError)
-            allow(logger).to receive(:error)
-          end
-
-          it "terminates the ultravisor" do
-            expect(ultravisor.instance_variable_get(:@queue)).to receive(:<<).with(:shutdown)
-
-            ultravisor.run
-          end
-
-          it "logs an error" do
-            expect(logger).to receive(:error)
-
-            ultravisor.run
-          end
-        end
-
-        context "with a restart_policy delay range" do
-          let(:child) { Ultravisor::Child.new(id: :testy, klass: mock_class, method: :run, restart_policy: { delay: 7..12 }) }
-
-          it "sleeps for a period within the range" do
-            expect(ultravisor).to receive(:sleep).with(be_between(7, 12))
-
-            ultravisor.run
-          end
-        end
-
-        context "while we're in the process of shutting down" do
-          before(:each) do
-            allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop) do
-              if ultravisor.instance_variable_get(:@running_thread)
-                ultravisor.instance_variable_set(:@running_thread, nil)
-                child
-              else
-                :shutdown
-              end
-            end
-          end
-
-          it "doesn't respawn the child" do
-            expect(child).to receive(:spawn).exactly(:once)
-
-            ultravisor.run
-          end
-        end
-
-        context "with restart: :never" do
-          let(:child) { Ultravisor::Child.new(id: :once, klass: mock_class, restart: :never, method: :run) }
-
-          it "doesn't respawn the child" do
-            expect(child).to receive(:spawn).exactly(:once)
-
-            ultravisor.run
-          end
-        end
-
-        context "with restart: :on_failure" do
-          let(:child) { Ultravisor::Child.new(id: :once, klass: mock_class, restart: :on_failure, method: :run) }
-
-          it "doesn't respawn the child" do
-            expect(child).to receive(:spawn).exactly(:once)
-
-            ultravisor.run
-          end
-        end
-
-        context "with an error" do
-          before(:each) do
-            allow(logger).to receive(:error)
-            ex = Errno::ENOENT.new("I stiiiiiiiill haven't found, what I'm lookin' for")
-            ex.set_backtrace(caller)
-            allow(child).to receive(:termination_exception).and_return(ex)
-          end
-
-          it "logs the error" do
-            expect(logger).to receive(:error).with(match(/:testy/))
-
-            ultravisor.run
-          end
-
-          it "respawns the child" do
-            expect(child).to receive(:spawn).exactly(:twice)
-
-            ultravisor.run
-          end
-
-          context "with restart: :on_failure" do
-            let(:child) { Ultravisor::Child.new(id: :once, klass: mock_class, restart: :on_failure, method: :run) }
-
-            it "respawns the child" do
-              expect(child).to receive(:spawn).exactly(:twice)
-
-              ultravisor.run
-            end
-          end
-        end
-      end
-    end
-
-    context "with two children" do
-      let(:args) do
-        {
-          children: [
-            {
-              id: :one,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :two,
-              klass: Object,
-              method: :to_s,
-            }
-          ]
-        }
-      end
-
-      it "starts the children in order of their definition" do
-        expect(ultravisor[:one]).to receive(:spawn).ordered
-        expect(ultravisor[:two]).to receive(:spawn).ordered
-
-        ultravisor.run
-      end
-
-      it "shuts the children down in the opposite order" do
-        expect(ultravisor[:two]).to receive(:shutdown).ordered
-        expect(ultravisor[:one]).to receive(:shutdown).ordered
-
-        ultravisor.run
-      end
-    end
-
-    context "with an all_for_one strategy" do
-      let(:args) do
-        {
-          strategy: :all_for_one,
-          children: [
-            {
-              id: :one,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :two,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :three,
-              klass: Object,
-              method: :to_s,
-            },
-          ]
-        }
-      end
-
-      let(:child1) { Ultravisor::Child.new(id: :one, klass: Object, method: :to_s) }
-      let(:child2) { Ultravisor::Child.new(id: :two, klass: Object, method: :to_s) }
-      let(:child3) { Ultravisor::Child.new(id: :three, klass: Object, method: :to_s) }
-
-      before(:each) do
-        ultravisor.instance_variable_set(:@children, [[:one, child1], [:two, child2], [:three, child3]])
-        allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop).and_return(child2, :shutdown)
-        allow(ultravisor).to receive(:sleep)
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-      end
-
-      it "shuts down all the other children in reverse order" do
-        expect(child3).to receive(:shutdown).ordered
-        expect(child1).to receive(:shutdown).ordered
-
-        ultravisor.__send__(:process_events)
-      end
-
-      it "starts up all children in order" do
-        expect(child1).to receive(:spawn).ordered
-        expect(child2).to receive(:spawn).ordered
-        expect(child3).to receive(:spawn).ordered
-
-        ultravisor.__send__(:process_events)
-      end
-    end
-
-    context "with a rest_for_one strategy" do
-      let(:args) do
-        {
-          strategy: :rest_for_one,
-          children: [
-            {
-              id: :one,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :two,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :three,
-              klass: Object,
-              method: :to_s,
-            },
-            {
-              id: :four,
-              klass: Object,
-              method: :to_s,
-            },
-          ]
-        }
-      end
-
-      let(:child1) { Ultravisor::Child.new(id: :one, klass: Object, method: :to_s) }
-      let(:child2) { Ultravisor::Child.new(id: :two, klass: Object, method: :to_s) }
-      let(:child3) { Ultravisor::Child.new(id: :three, klass: Object, method: :to_s) }
-      let(:child4) { Ultravisor::Child.new(id: :four, klass: Object, method: :to_s) }
-
-      before(:each) do
-        ultravisor.instance_variable_set(:@children, [[:one, child1], [:two, child2], [:three, child3], [:four, child4]])
-        allow(ultravisor.instance_variable_get(:@queue)).to receive(:pop).and_return(child2, :shutdown)
-        allow(ultravisor).to receive(:sleep)
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-      end
-
-      it "shuts down only the children after the failed one, in reverse order" do
-        expect(child4).to receive(:shutdown).ordered
-        expect(child3).to receive(:shutdown).ordered
-
-        ultravisor.__send__(:process_events)
-      end
-
-      it "starts up all the relevant children in order" do
-        expect(child2).to receive(:spawn).ordered
-        expect(child3).to receive(:spawn).ordered
-        expect(child4).to receive(:spawn).ordered
-
-        ultravisor.__send__(:process_events)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/shutdown_spec.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require_relative "../spec_helper"
-
-require_relative "../../lib/ultravisor"
-
-describe Ultravisor do
-  let(:args) { {} }
-  let(:ultravisor) { Ultravisor.new(**args) }
-  let(:mock_thread) { instance_double(Thread) }
-
-  describe "#shutdown" do
-    it "takes the @op_m lock" do
-      expect(ultravisor.instance_variable_get(:@op_m)).to receive(:synchronize).and_call_original
-
-      ultravisor.shutdown
-    end
-
-    context "when the ultravisor isn't running" do
-      it "returns itself" do
-        expect(ultravisor.shutdown).to eq(ultravisor)
-      end
-    end
-
-    context "when the ultravisor is running" do
-      before(:each) do
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-        allow(ultravisor.instance_variable_get(:@op_cv))
-          .to receive(:wait) do
-          ultravisor.instance_variable_set(:@running_thread, nil)
-        end
-      end
-
-      it "signals the ultravisor to shutdown" do
-        expect(ultravisor.instance_variable_get(:@queue)).to receive(:<<).with(:shutdown)
-
-        ultravisor.shutdown
-      end
-
-      it "waits until the CV is signalled" do
-        expect(ultravisor.instance_variable_get(:@op_cv)).to receive(:wait) do |m|
-          expect(m).to eq(ultravisor.instance_variable_get(:@op_m))
-            ultravisor.instance_variable_set(:@running_thread, nil)
-            nil
-        end
-
-        ultravisor.shutdown
-      end
-
-      context "when asked to not wait" do
-        it "doesn't wait on the CV" do
-          expect(ultravisor.instance_variable_get(:@op_cv)).to_not receive(:wait)
-
-          ultravisor.shutdown(wait: false)
-        end
-      end
-
-      it "returns itself" do
-        expect(ultravisor.shutdown).to eq(ultravisor)
-      end
-
-      context "when forced" do
-        before(:each) do
-          allow(mock_thread).to receive(:kill)
-        end
-
-        it "kills the thread" do
-          expect(mock_thread).to receive(:kill)
-
-          ultravisor.shutdown(force: true)
-        end
-
-        it "tells everyone waiting for the shutdown that the deed is done" do
-          expect(ultravisor.instance_variable_get(:@op_cv)).to receive(:broadcast)
-
-          ultravisor.shutdown(force: true)
-        end
-
-        it "unsets the running thread" do
-          ultravisor.shutdown(force: true)
-
-          expect(ultravisor.instance_variable_get(:@running_thread)).to be(nil)
-        end
-
-        it "doesn't wait on the CV" do
-          expect(ultravisor.instance_variable_get(:@op_cv)).to_not receive(:wait)
-
-          ultravisor.shutdown(force: true)
-        end
-
-        context "with children" do
-          let(:child) { Ultravisor::Child.new(id: :one, klass: Object, method: :to_s) }
-
-          before(:each) do
-            ultravisor.instance_variable_set(:@children, [[:child, child]])
-          end
-
-          it "forcibly shuts down the children" do
-            expect(child).to receive(:shutdown).with(force: true)
-
-            ultravisor.shutdown(force: true)
-          end
-        end
-      end
-    end
-  end
-end