Improve controller test robustness.

Author: ioquatix

fixtures/async/container/controllers.rb

@@ -12,5 +12,39 @@ def self.path_for(controller)
 				File.join(ROOT, "#{controller}.rb")
 			end
 		end
+		
+		AController = Sus::Shared("a controller") do |controller|
+			let(:controller_path) {Async::Container::Controllers.path_for(controller)}
+			
+			let(:pipe) {IO.pipe}
+			let(:input) {pipe.first}
+			let(:output) {pipe.last}
+		
+			let(:server) {Async::Container::Notify::Server.open}
+			let(:notify_socket) {server.path}
+		
+			let(:process_id) {@process_id}
+		
+			before do
+				environment = ENV.to_h.merge({"NOTIFY_SOCKET" => notify_socket})
+				@notify = server.bind
+				
+				@process_id = Process.spawn(environment, "bundle", "exec", controller_path, out: output)
+				output.close
+			end
+		
+			after do
+				if @process_id
+					Process.kill(:TERM, @process_id)
+					Process.wait(@process_id)
+				end
+				
+				@notify&.close
+			end
+			
+			def wait_until_ready
+				@notify.wait_until_ready
+			end
+		end
 	end
 end

fixtures/async/container/controllers/graceful.rb

@@ -12,6 +12,7 @@ class Graceful < Async::Container::Controller
 	def setup(container)
 		container.run(name: "graceful", count: 1, restart: true) do |instance|
 			instance.ready!
+			
 			$stdout.puts "Ready..."
 
 			sleep

lib/async/container/notify/server.rb

@@ -129,6 +129,14 @@ def receive
 							end
 						end
 					end
+					
+					def wait_until_ready
+						while message = receive
+							if message[:ready] == true
+								return
+							end
+						end
+					end
 				end
 			end
 		end

test/async/container/controller.rb

@@ -5,6 +5,7 @@
 
 require "async/container/controller"
 require "async/container/controllers"
+require "async/container/notify/server"
 
 describe Async::Container::Controller do
 	let(:controller) {subject.new}
@@ -98,97 +99,41 @@ def controller.setup(container)
 	end
 
 	with "graceful controller" do
-		let(:controller_path) {Async::Container::Controllers.path_for("graceful")}
-		
-		let(:pipe) {IO.pipe}
-		let(:input) {pipe.first}
-		let(:output) {pipe.last}
-		
-		let(:pid) {@pid}
-		
-		def before
-			@pid = Process.spawn("bundle", "exec", controller_path, out: output)
-			output.close
-			
-			super
-		end
-		
-		def after(error = nil)
-			Process.kill(:TERM, @pid)
-			Process.wait(@pid)
-			
-			super
-		end
+		include_context Async::Container::AController, "graceful"
 
 		it "has graceful shutdown" do
 			expect(input.gets).to be == "Ready...\n"
 
-			Process.kill(:INT, @pid)
+			wait_until_ready
+			
+			Process.kill(:INT, process_id)
 
 			expect(input.gets).to be == "Exiting...\n"
 		end
 	end
 
 	with "bad controller" do
-		let(:controller_path) {Async::Container::Controllers.path_for("bad")}
-		
-		let(:pipe) {IO.pipe}
-		let(:input) {pipe.first}
-		let(:output) {pipe.last}
-		
-		let(:pid) {@pid}
-		
-		def before
-			@pid = Process.spawn("bundle", "exec", controller_path, out: output)
-			output.close
-			
-			super
-		end
-		
-		def after(error = nil)
-			Process.kill(:TERM, @pid)
-			Process.wait(@pid)
-			
-			super
-		end
+		include_context Async::Container::AController, "bad"
 
 		it "fails to start" do
 			expect(input.gets).to be == "Ready...\n"
 
-			Process.kill(:INT, @pid)
+			Process.kill(:INT, process_id)
 
 			# It was killed:
 			expect(input.gets).to be_nil
 		end
 	end
 
 	with "signals" do
-		let(:controller_path) {Async::Container::Controllers.path_for("dots")}
-		
-		let(:pipe) {IO.pipe}
-		let(:input) {pipe.first}
-		let(:output) {pipe.last}
-		
-		let(:pid) {@pid}
-		
-		def before
-			@pid = Process.spawn("bundle", "exec", controller_path, out: output)
-			output.close
-			
-			super
-		end
-		
-		def after(error = nil)
-			Process.kill(:TERM, @pid)
-			Process.wait(@pid)
-			
-			super
-		end
+		include_context Async::Container::AController, "dots"
 
 		it "restarts children when receiving SIGHUP" do
 			expect(input.read(1)).to be == "."
 
-			Process.kill(:HUP, pid)
+			wait_until_ready
+			
+			Process.kill(:HUP, process_id)
 
 			# The ordering between the old child writing "I" and the new child writing "." is timing-dependent (blue-green restart starts the new container before stopping the old one). Accept either order.
 			expect(input.read(2)).to (be == "I.").or(be == ".I")
@@ -197,15 +142,19 @@ def after(error = nil)
 		it "exits gracefully when receiving SIGINT" do
 			expect(input.read(1)).to be == "."
 
-			Process.kill(:INT, pid)
+			wait_until_ready
+			
+			Process.kill(:INT, process_id)
 
 			expect(input.read).to be == "I"
 		end
 
 		it "exits gracefully when receiving SIGTERM" do
 			expect(input.read(1)).to be == "."
 
-			Process.kill(:TERM, pid)
+			wait_until_ready
+			
+			Process.kill(:TERM, process_id)
 
 			# SIGTERM now behaves like SIGINT (graceful)
 			expect(input.read).to be == "I"