rspec-background-process 0.1.0

data/spec/features/exec_and_loading_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../spec_helper'
+
+feature 'support for starting new process via fort to exec or fork followed by Ruby load', with: :background_process do
+	context 'default value is used' do
+		scenario 'replace forked ruby interpreter with given executable via exec' do
+			process = background_process('spec/support/test_process')
+
+			process.ready_when_log_includes "ENV['PROCESS_SPAWN_TYPE']"
+			instance = process.start.wait_ready
+
+			expect(instance.log_file.read).to include "ENV['PROCESS_SPAWN_TYPE']: exec"
+		end
+	end
+
+	context 'load is set to true' do
+		scenario 'load ruby code directly into forked interpreter via load' do
+			process = background_process('spec/support/test_process', load: true)
+
+			process.ready_when_log_includes "ENV['PROCESS_SPAWN_TYPE']"
+			instance = process.start.wait_ready
+
+			expect(instance.log_file.read).to include "ENV['PROCESS_SPAWN_TYPE']: load"
+		end
+	end
+end
+

data/spec/features/pool_lru_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+feature 'process pool can keep limited number of processes running between test evicting processes using LRU', subject: :process do
+	scenario 'extra LRU processes (over 4 by default) are stopped between tests' do
+		instances = []
+		instances << subject.with{|p| p.argument '1'}.start
+		instances << subject.with{|p| p.argument '2'}.start
+		instances << subject.with{|p| p.argument '3'}.start
+		instances << subject.with{|p| p.argument '4'}.start
+		instances << subject.with{|p| p.argument '5'}.start
+
+		# keeps all running
+		expect(instances).to all be_running
+
+		# let LRU do the job (executed after each scenario/example)
+		process_pool.cleanup
+
+		# first instance should not be running (LRU)
+		expect(instances.shift).not_to be_running
+		# remaining 4 should be kept running
+		expect(instances).to all be_running
+	end
+end

data/spec/features/ready_test_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../spec_helper'
+
+feature 'background process readiness verification' do
+	context 'with log file based check', subject: :process do
+		scenario 'raise exception when no readiness check was defined for process instance' do
+			expect {
+				subject.start.wait_ready
+			}.to raise_error RuntimeError, 'no readiness check defined'
+		end
+
+		scenario 'starting a background process with readiness check based on log file contents' do
+			process = subject.with do |process|
+				process.ready_when_log_includes 'started'
+			end
+
+			instance = process.instance
+			instance.start
+
+			expect(instance).to be_running
+			expect(instance.log_file.read).not_to include 'started'
+
+			instance.wait_ready
+
+			expect(instance).to be_ready
+			expect(instance.log_file.read).to include 'started'
+		end
+	end
+
+	context 'with URL based check', subject: :http_process do
+		scenario 'starting a background process with readiness check based on HTTP request' do
+			process = subject.with do |process|
+				process.ready_when_url_response_status 'http://localhost:1234/health_check', 'OK'
+			end
+
+			instance = process.instance
+			instance.start
+
+			expect(instance).to be_running
+			expect(instance.log_file.read).not_to include 'got health_check request'
+
+			instance.wait_ready
+
+			expect(instance).to be_ready
+			expect(instance.log_file.read).to include 'got health_check request'
+		end
+	end
+end
+

data/spec/features/refresh_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../spec_helper'
+
+feature 'refreshing pooled processes state', subject: :process do
+	scenario 'by default processes are restarted on refresh' do
+		instance = subject.start
+
+		expect {
+			instance.refresh
+		}.to change {
+			instance.pid
+		}
+	end
+
+	context 'with custom command' do
+		let! :test_marker do
+			Pathname.new('/tmp/processtest1')
+		end
+
+		before do
+			test_marker.exist? and test_marker.unlink
+		end
+
+		scenario 'refresh executes custom command' do
+			instance = subject.with do |process|
+				process.refresh_command "touch #{test_marker}"
+			end.start
+
+			expect(test_marker).not_to exist
+
+			instance.refresh
+
+			expect(test_marker).to exist
+		end
+
+		scenario 'refresh execute command in current working directory of the process' do
+			instance = subject.with do |process|
+				process.refresh_command "pwd > /tmp/pwd"
+			end.start
+
+			instance.refresh
+
+			expect(Pathname.new(Pathname.new('/tmp/pwd').read.strip).realpath.to_s).to eq instance.working_directory.realpath.to_s
+		end
+	end
+end
+

data/spec/features/reuse_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../spec_helper'
+
+feature 'processes with same definition reuse single instance', subject: :process do
+	context 'arguments' do
+		scenario 'defining two instances with same arguments' do
+			instance1 = subject.with{|p| p.argument 'foo'}.instance
+			instance2 = subject.with{|p| p.argument 'foo'}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'defining two instances with different arguments' do
+			instance1 = subject.with{|p| p.argument 'foo'}.instance
+			instance2 = subject.with{|p| p.argument 'bar'}.instance
+
+			expect(instance1).not_to eq(instance2)
+		end
+	end
+
+	context 'working directory' do
+		scenario 'defining two instances with same working directory' do
+			instance1 = subject.with{|p| p.working_directory 'foo'}.instance
+			instance2 = subject.with{|p| p.working_directory 'foo'}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'defining two instances with different working directory' do
+			instance1 = subject.with{|p| p.working_directory 'foo'}.instance
+			instance2 = subject.with{|p| p.working_directory 'bar'}.instance
+
+			expect(instance1).not_to eq(instance2)
+		end
+	end
+
+	context 'extensions' do
+		scenario 'defining two instances with same extensions but different options' do
+			instance1 = subject.with{|p| p.extend RSpecBackgroundProcess::BackgroundProcess::Server, port_count: 3, base_port: 1200}.instance
+			instance2 = subject.with{|p| p.extend RSpecBackgroundProcess::BackgroundProcess::Server, port_count: 1, base_port: 1200}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'defining two instances with different extensions' do
+			instance1 = subject.instance
+			instance2 = subject.with{|p| p.extend RSpecBackgroundProcess::BackgroundProcess::Server, port_count: 1, base_port: 1200}.instance
+
+			expect(instance1).not_to eq(instance2)
+		end
+	end
+
+	context 'options not affecting instance key (reused)' do
+		scenario 'logging settings differ' do
+			instance1 = subject.instance
+			instance2 = subject.with{|p| p.logging_enabled}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'ready test differ' do
+			instance1 = subject.with{|p| p.ready_test{|i| false}}.instance
+			instance2 = subject.with{|p| p.ready_test{|i| true}}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'refresh action differ' do
+			instance1 = subject.with{|p| p.refresh_action{|i| false}}.instance
+			instance2 = subject.with{|p| p.refresh_action{|i| true}}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+
+		scenario 'timeouts differ' do
+			instance1 = subject.with{|p| p.ready_timeout(1); p.kill_timeout(1); p.term_timeout(1)}.instance
+			instance2 = subject.with{|p| p.ready_timeout(2); p.kill_timeout(2); p.term_timeout(2)}.instance
+
+			expect(instance1).to eq(instance2)
+		end
+	end
+end

data/spec/features/server_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+feature 'server process with port allocation', subject: :http_process_ready_variables do
+	scenario 'allocating port for new process instance form pool' do
+		instance = subject.with do |process|
+			process.http_port_allocated_form 1400, 4
+		end.instance
+
+		expect(instance.ports).to contain_exactly 1400, 1401, 1402, 1403
+	end
+
+	scenario 'new ports allocated for new instance' do
+		# use up a port
+		subject.with do |process|
+			process.http_port_allocated_form 1500, 1
+		end.instance
+
+		instance = subject.with do |process|
+			process.argument 'foo'
+			process.http_port_allocated_form 1500, 1
+		end.instance
+
+		expect(instance.ports).to contain_exactly 1501
+	end
+
+	scenario 'using port number with argument value' do
+		instance = subject.with do |process|
+			process.argument '--listen', 'localhost:<allocated port 1>'
+			process.http_port_allocated_form 1600, 1
+		end.instance
+		instance.start.wait_ready
+
+		expect(instance.log_file.read).to include('"localhost:1600"').and include('listening on port: 1600')
+	end
+end

data/spec/features/variables_replacement_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../spec_helper'
+
+feature 'instance variable replacement', subject: :process_ready_variables do
+	# some variables are only available while the instance is about to be started or even after it was forked
+	# to be able to use this variables to set up the process run they need to be replaced in arguments etc.
+
+	context 'argument expansion' do
+		scenario 'with log file' do
+			instance = subject.with do |process|
+				process.argument 'log file:<log file>'
+			end.instance
+			instance.start.wait_ready
+
+			expect(instance.log_file.read).to include "ARGV: [\"log file:#{instance.log_file}\"]"
+		end
+
+		scenario 'with pid file' do
+			instance = subject.with do |process|
+				process.argument 'pid file:<pid file>'
+			end.instance
+			instance.start.wait_ready
+
+			expect(instance.log_file.read).to include "ARGV: [\"pid file:#{instance.pid_file}\"]"
+		end
+
+		scenario 'with working directory' do
+			instance = subject.with do |process|
+				process.argument 'working directory:<working directory>'
+			end.instance
+			instance.start.wait_ready
+
+			expect(instance.log_file.read).to include "ARGV: [\"working directory:#{instance.working_directory}\"]"
+		end
+
+		scenario 'with instance name' do
+			instance = subject.with do |process|
+				process.argument 'name:<name>'
+			end.instance
+			instance.start.wait_ready
+
+			expect(instance.log_file.read).to include "ARGV: [\"name:#{instance.name}\"]"
+		end
+
+		scenario 'with project directory' do
+			instance = subject.with do |process|
+				process.argument 'project directory:<project directory>'
+			end.instance
+			instance.start.wait_ready
+
+			cwd = Dir.pwd
+
+			expect(instance.log_file.read).to include "ARGV: [\"project directory:#{cwd}\"]"
+		end
+
+		context 'server', subject: :http_process_ready_variables do
+			scenario 'with port numbers' do
+				instance = subject.with do |process|
+					process.argument 'port number 1:<allocated port 1>'
+					process.argument 'port number 2:<allocated port 2>'
+					process.http_port_allocated_form 1700, 2
+				end.instance
+				instance.start.wait_ready
+
+				expect(instance.log_file.read).to include("ARGV: [\"port number 1:1700\", \"port number 2:1701\"]")
+			end
+		end
+	end
+end

data/spec/process_definition_spec.rb

@@ -0,0 +1,182 @@
+require_relative 'spec_helper'
+
+describe RSpecBackgroundProcess::ProcessPool::ProcessDefinition, subject: :process do
+	describe '#with' do
+		it 'should execute passed block it in context of cloned process definition' do
+			expect { |b|
+				subject.with(&b)
+			}.to yield_with_args(
+				an_instance_of(RSpecBackgroundProcess::ProcessPool::ProcessDefinition)
+				.and different_than subject
+			)
+		end
+
+		example 'defining process variation' do
+			hello_process = subject.with do |process|
+				process.argument 'hello'
+				process.logging_enabled
+			end
+
+			hello_foo_bar_process = hello_process.with do |process|
+				process.argument 'foo-bar'
+			end
+
+			expect {
+				hello_process.start
+			}.to output(
+				a_string_matching 'starting.*spec/support/test_process hello`'
+			).to_stdout
+
+			expect {
+				hello_foo_bar_process.start
+			}.to output(
+				a_string_matching 'starting.*spec/support/test_process hello foo-bar'
+			).to_stdout
+		end
+	end
+
+	describe '#instance' do
+		it 'should create new process instance' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.and_call_original
+
+			subject.instance
+		end
+
+		it 'should not crate new process when called more than once' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.once
+			.and_call_original
+
+			subject.instance
+			subject.instance
+		end
+	end
+
+	describe '#argument' do
+		it 'should pass given argument to process' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.with(anything, anything, a_collection_containing_exactly('foo bar', 'baz'), anything, anything)
+			.and_call_original
+
+			subject.argument 'foo bar'
+			subject.argument 'baz'
+
+			subject.instance
+		end
+
+		it 'should pass given option argument to process' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.with(anything, anything, a_collection_containing_exactly('--foo', 'bar', '--baz', 'hello world'), anything, anything)
+			.and_call_original
+
+			subject.argument '--foo', 'bar'
+			subject.argument '--baz', 'hello world'
+
+			subject.instance
+		end
+	end
+
+	describe '#extend' do
+		it 'should extend instance with given extension' do
+			TestExtension = Module.new
+			extension = class_spy('TestExtension')
+
+			process = subject.with do |process|
+				process.extend extension
+			end
+
+			# used for key generation
+			expect(extension).to receive(:name).and_return('test')
+
+			# actually used to extend background process
+			expect(extension).to receive(:extended) do |instance|
+				expect(instance).to be_an_instance_of(RSpecBackgroundProcess::LoadedBackgroundProcess)
+			end.once
+
+			process.instance
+		end
+	end
+
+	describe '#read_timeout' do
+		it 'should pass given argument to process' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.with(anything, anything, anything, anything, a_hash_including(ready_timeout: 42))
+			.and_call_original
+
+			subject.ready_timeout 42
+
+			subject.instance
+		end
+	end
+
+	describe '#term_timeout' do
+		it 'should pass given argument to process' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.with(anything, anything, anything, anything, a_hash_including(term_timeout: 42))
+			.and_call_original
+
+			subject.term_timeout 42
+
+			subject.instance
+		end
+	end
+
+	describe '#kill_timeout' do
+		it 'should pass given argument to process' do
+			expect(RSpecBackgroundProcess::BackgroundProcess).to receive(:new)
+			.with(anything, anything, anything, anything, a_hash_including(kill_timeout: 42))
+			.and_call_original
+
+			subject.kill_timeout 42
+
+			subject.instance
+		end
+	end
+
+	describe '#ready_test' do
+		it 'should register a block to be called when process is verified' do
+			expect { |b|
+				subject.ready_test do |*args|
+					b.to_proc.call(*args)
+					# need to return true
+					true
+				end
+
+				#TODO: only test if the block was passed to the instance
+				subject.instance.start.wait_ready
+			}.to yield_control
+		end
+	end
+
+	describe 'logging' do
+		specify 'logging should be disabled by default' do
+			process_pool.logging_enabled? and skip 'logging enabled by default'
+			expect {
+				subject.instance.start
+			}.not_to output.to_stdout
+		end
+
+		describe '#logging_enable' do
+			it 'should make the instance to print out state changes' do
+				subject.logging_enabled
+
+				expect {
+					subject.instance.start
+				}.to output(
+					a_string_including 'process is now running'
+				).to_stdout
+			end
+		end
+
+		describe '#logging_enabled?' do
+			it 'should be true when instance logging is enabled' do
+				process_pool.logging_enabled? and skip 'logging enabled by default'
+
+				expect(subject).not_to be_logging_enabled
+				subject.logging_enabled
+				expect(subject).to be_logging_enabled
+			end
+		end
+	end
+end