passenger-jmazzi 2.2.9

data/test/ruby/application_spec.rb

@@ -0,0 +1,43 @@
+require 'support/config'
+require 'support/test_helper'
+require 'phusion_passenger/application'
+include PhusionPassenger
+
+describe Application do
+	include TestHelper
+	
+	before :each do
+		@stub = setup_rails_stub('foobar')
+	end
+	
+	after :each do
+		teardown_rails_stub
+	end
+	
+	it "correctly detects Rails version numbers specified in environment.rb" do
+		rails_version = Application.detect_framework_version(@stub.app_root)
+		rails_version.should =~ /^2\.0\.(\d+)$/
+	end
+	
+	it "returns :vendor if an application uses a vendored Rails" do
+		@stub.use_vendor_rails('minimal')
+		rails_version = Application.detect_framework_version(@stub.app_root)
+		rails_version.should == :vendor
+	end
+	
+	it "returns nil if an application does not specify its Rails version" do
+		File.write(@stub.environment_rb) do |content|
+			content.sub(/^RAILS_GEM_VERSION = .*$/, '')
+		end
+		rails_version = Application.detect_framework_version(@stub.app_root)
+		rails_version.should be_nil
+	end
+	
+	it "raises VersionNotFound if a nonexistant Rails version is specified" do
+		File.write(@stub.environment_rb) do |content|
+			content.sub(/^RAILS_GEM_VERSION = .*$/, "RAILS_GEM_VERSION = '1.9.1972'")
+		end
+		detector = lambda { Application.detect_framework_version(@stub.app_root) }
+		detector.should raise_error(::PhusionPassenger::VersionNotFound)
+	end
+end

data/test/ruby/message_channel_spec.rb

@@ -0,0 +1,170 @@
+require 'socket'
+require 'support/config'
+require 'phusion_passenger/message_channel'
+include PhusionPassenger
+
+describe MessageChannel do
+	describe "scenarios with a single channel" do
+		before :each do
+			@reader_pipe, @writer_pipe = IO.pipe
+			@reader = MessageChannel.new(@reader_pipe)
+			@writer = MessageChannel.new(@writer_pipe)
+		end
+		
+		after :each do
+			@reader_pipe.close unless @reader_pipe.closed?
+			@writer_pipe.close unless @writer_pipe.closed?
+		end
+		
+		it "can read a single written array message" do
+			@writer.write("hello")
+			@reader.read.should == ["hello"]
+		end
+		
+		it "can handle array messages that contain spaces" do
+			@writer.write("hello world", "! ")
+			@reader.read.should == ["hello world", "! "]
+		end
+		
+		it "can handle array messages that have only a single empty string" do
+			@writer.write("")
+			@reader.read.should == [""]
+		end
+		
+		it "can handle array messages with empty arguments" do
+			@writer.write("hello", "", "world")
+			@reader.read.should == ["hello", "", "world"]
+			
+			@writer.write("")
+			@reader.read.should == [""]
+			
+			@writer.write(nil, "foo")
+			@reader.read.should == ["", "foo"]
+		end
+		
+		it "properly detects end-of-file when reading an array message" do
+			@writer.close
+			@reader.read.should be_nil
+		end
+		
+		it "can read a single written scalar message" do
+			@writer.write_scalar("hello world")
+			@reader.read_scalar.should == "hello world"
+		end
+		
+		it "can handle empty scalar messages" do
+			@writer.write_scalar("")
+			@reader.read_scalar.should == ""
+		end
+		
+		it "properly detects end-of-file when reading a scalar message" do
+			@writer.close
+			@reader.read_scalar.should be_nil
+		end
+		
+		it "raises SecurityError when a received scalar message's size is larger than a specified maximum" do
+			@writer.write_scalar(" " * 100)
+			lambda { @reader.read_scalar(99) }.should raise_error(SecurityError)
+		end
+	end
+	
+	describe "scenarios with 2 channels and 2 concurrent processes" do
+		after :each do
+			@parent_socket.close
+			Process.waitpid(@pid) rescue nil
+		end
+		
+		it "both processes can read and write a single array message" do
+			spawn_process do
+				x = @channel.read
+				@channel.write("#{x}!")
+			end
+			@channel.write("hello")
+			@channel.read.should == ["hello!"]
+		end
+		
+		it "can handle scalar messages with arbitrary binary data" do
+			garbage_files = ["garbage1.dat", "garbage2.dat", "garbage3.dat"]
+			spawn_process do
+				garbage_files.each do |name|
+					data = File.read("stub/#{name}")
+					@channel.write_scalar(data)
+				end
+			end
+			
+			garbage_files.each do |name|
+				data = File.read("stub/#{name}")
+				@channel.read_scalar.should == data
+			end
+		end
+		
+		it "supports IO object (file descriptor) passing" do
+			spawn_process do
+				writer = @channel.recv_io
+				writer.write("it works")
+				writer.close
+			end
+			reader, writer = IO.pipe
+			@channel.send_io(writer)
+			writer.close
+			reader.read.should == "it works"
+			reader.close
+		end
+		
+		it "supports large amounts of data" do
+			iterations = 1000
+			blob = "123" * 1024
+			spawn_process do
+				iterations.times do |i|
+					@channel.write(blob)
+				end
+			end
+			iterations.times do
+				@channel.read.should == [blob]
+			end
+		end
+		
+		it "has stream properties" do
+			garbage = File.read("stub/garbage1.dat")
+			spawn_process do
+				@channel.write("hello", "world")
+				@channel.write_scalar(garbage)
+				@channel.send_io(STDIN)
+				@channel.write_scalar(":-)")
+				
+				a = @channel.read_scalar
+				b = @channel.read
+				b << a
+				@channel.write(*b)
+			end
+			@channel.read.should == ["hello", "world"]
+			@channel.read_scalar.should == garbage
+			@channel.recv_io.close
+			@channel.read_scalar.should == ":-)"
+			
+			@channel.write_scalar("TASTE MY WRATH! ULTIMATE SWORD TECHNIQUE!! DRAGON'S BREATH SL--")
+			@channel.write("Uhm, watch your step.", "WAAHH?!", "Calm down, Motoko!!")
+			@channel.read.should == ["Uhm, watch your step.", "WAAHH?!", "Calm down, Motoko!!",
+				"TASTE MY WRATH! ULTIMATE SWORD TECHNIQUE!! DRAGON'S BREATH SL--"]
+		end
+		
+		def spawn_process
+			@parent_socket, @child_socket = UNIXSocket.pair
+			@pid = fork do
+				@parent_socket.close
+				@channel = MessageChannel.new(@child_socket)
+				begin
+					yield
+				rescue Exception => e
+					print_exception("child", e)
+				ensure
+					@child_socket.close
+					exit!
+				end
+			end
+			@child_socket.close
+			@channel = MessageChannel.new(@parent_socket)
+		end
+	end
+end
+

data/test/ruby/rack/application_spawner_spec.rb

@@ -0,0 +1,99 @@
+require 'support/config'
+require 'support/test_helper'
+require 'phusion_passenger/rack/application_spawner'
+
+describe PhusionPassenger::Rack::ApplicationSpawner do
+	include TestHelper
+	
+	before :each do
+		@stub = setup_stub('rack')
+	end
+	
+	after :each do
+		@stub.destroy
+	end
+	
+	it "can spawn our stub application" do
+		spawn(@stub.app_root).close
+	end
+	
+	it "propagates exceptions in application startup" do
+		File.prepend("#{@stub.app_root}/config.ru", "raise StandardError, 'foo'\n")
+		spawn = lambda { spawn(@stub.app_root, "print_exceptions" => false) }
+		spawn.should raise_error(StandardError)
+	end
+	
+	it "lowers privilege to the owner of config.ru" do
+		system("chown", "-R", CONFIG['normal_user_1'], @stub.app_root)
+		File.prepend("#{@stub.app_root}/config.ru", %q{
+			File.new('touch.txt', 'w').close
+		})
+		spawn(@stub.app_root).close
+		config_ru_owner = File.stat("#{@stub.app_root}/config.ru").uid
+		touch_txt_owner = File.stat("#{@stub.app_root}/touch.txt").uid
+		config_ru_owner.should == touch_txt_owner
+	end if Process.euid == 0
+	
+	it "sets the environment variables passed in the environment_variables option" do
+		File.append("#{@stub.app_root}/config.ru", %q{
+			File.open("env.txt", "w") do |f|
+				ENV.each_pair do |key, value|
+					f.puts("#{key} = #{value}")
+				end
+			end
+		})
+		env_vars_string = "PATH\0/usr/bin:/opt/sw/bin\0FOO\0foo bar!\0"
+		options = { "environment_variables" => [env_vars_string].pack("m") }
+		spawn(@stub.app_root, options).close
+		
+		contents = File.read("#{@stub.app_root}/env.txt")
+		contents.should =~ %r(PATH = /usr/bin:/opt/sw/bin\n)
+		contents.should =~ %r(FOO = foo bar\!\n)
+	end
+	
+	it "calls the starting_worker_process event after config.ru has been loaded" do
+		File.append("#{@stub.app_root}/config.ru", %q{
+			PhusionPassenger.on_event(:starting_worker_process) do
+				File.append("rackresult.txt", "worker_process_started\n")
+			end
+			File.append("rackresult.txt", "end of config.ru\n");
+		})
+		spawn(@stub.app_root).close
+		spawn(@stub.app_root).close
+		
+		# Give some time for the starting_worker_process hook to be executed.
+		sleep 0.2
+		
+		contents = File.read("#{@stub.app_root}/rackresult.txt")
+		contents.should == "end of config.ru\n" +
+			"worker_process_started\n" +
+			"end of config.ru\n" +
+			"worker_process_started\n"
+	end
+	
+	it "calls the stopping_worker_process event" do
+		File.append("#{@stub.app_root}/config.ru", %q{
+			PhusionPassenger.on_event(:stopping_worker_process) do
+				File.append("rackresult.txt", "worker_process_stopped\n")
+			end
+			File.append("rackresult.txt", "end of config.ru\n");
+		})
+		spawn(@stub.app_root).close
+		spawn(@stub.app_root).close
+		
+		# Give some time for the starting_worker_process hook to be executed.
+		sleep 0.2
+		
+		contents = File.read("#{@stub.app_root}/rackresult.txt")
+		contents.should == "end of config.ru\n" +
+			"worker_process_stopped\n" +
+			"end of config.ru\n" +
+			"worker_process_stopped\n"
+	end	
+	
+	def spawn(app_root, extra_options = {})
+		options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options)
+		PhusionPassenger::Rack::ApplicationSpawner.spawn_application(app_root, options)
+	end
+end
+

data/test/ruby/rails/application_spawner_spec.rb

@@ -0,0 +1,159 @@
+require 'support/config'
+require 'support/test_helper'
+require 'phusion_passenger/railz/application_spawner'
+
+require 'ruby/rails/minimal_spawner_spec'
+require 'ruby/spawn_server_spec'
+require 'ruby/rails/spawner_privilege_lowering_spec'
+require 'ruby/rails/spawner_error_handling_spec'
+
+include PhusionPassenger
+include PhusionPassenger::Railz
+
+describe ApplicationSpawner do
+	include TestHelper
+	
+	before :each do
+		@stub = setup_rails_stub('foobar')
+		@spawner = ApplicationSpawner.new(@stub.app_root,
+			"lowest_user" => CONFIG['lowest_user'])
+		@spawner.start
+		@server = @spawner
+	end
+	
+	after :each do
+		@spawner.stop
+		@stub.destroy
+	end
+	
+	it_should_behave_like "a spawn server"
+	
+	def spawn_arbitrary_application
+		@spawner.spawn_application
+	end
+end
+
+describe ApplicationSpawner do
+	include TestHelper
+	
+	describe "smart spawning" do
+		it_should_behave_like "a minimal spawner"
+		it_should_behave_like "handling errors in application initialization"
+		
+		it "calls the starting_worker_process event, with forked=true, after a new worker process has been forked off" do
+			use_rails_stub('foobar') do |stub|
+				File.append(stub.environment_rb, %q{
+					PhusionPassenger.on_event(:starting_worker_process) do |forked|
+						File.append("result.txt", "forked = #{forked}\n")
+					end
+					File.append("result.txt", "end of environment.rb\n");
+				})
+				
+				spawner = ApplicationSpawner.new(stub.app_root,
+					"lowest_user" => CONFIG['lowest_user'])
+				spawner.start
+				begin
+					spawner.spawn_application.close
+					spawner.spawn_application.close
+				ensure
+					spawner.stop
+				end
+				
+				# Give some time for the starting_worker_process hook to be executed.
+				sleep 0.2
+				
+				contents = File.read("#{stub.app_root}/result.txt")
+				contents.should == "end of environment.rb\n" +
+					"forked = true\n" +
+					"forked = true\n"
+			end
+		end
+		
+		def spawn_stub_application(stub, extra_options = {})
+			options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options)
+			@spawner = ApplicationSpawner.new(stub.app_root, options)
+			begin
+				@spawner.start
+				return @spawner.spawn_application
+			ensure
+				@spawner.stop rescue nil
+			end
+		end
+	end
+	
+	describe "conservative spawning" do
+		it_should_behave_like "a minimal spawner"
+		it_should_behave_like "handling errors in application initialization"
+		
+		it "calls the starting_worker_process event, with forked=true, after environment.rb has been loaded" do
+			use_rails_stub('foobar') do |stub|
+				File.append(stub.environment_rb, %q{
+					PhusionPassenger.on_event(:starting_worker_process) do |forked|
+						File.append("result.txt", "forked = #{forked}\n")
+					end
+					File.append("result.txt", "end of environment.rb\n");
+				})
+				spawn_stub_application(stub).close
+				spawn_stub_application(stub).close
+				
+				# Give some time for the starting_worker_process hook to be executed.
+				sleep 0.2
+				
+				contents = File.read("#{stub.app_root}/result.txt")
+				contents.should == "end of environment.rb\n" +
+					"forked = false\n" +
+					"end of environment.rb\n" +
+					"forked = false\n"
+			end
+		end
+		
+		def spawn_stub_application(stub, extra_options = {})
+			options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options)
+			@spawner = ApplicationSpawner.new(stub.app_root, options)
+			return @spawner.spawn_application!
+		end
+	end
+end
+
+Process.euid == ApplicationSpawner::ROOT_UID &&
+describe("ApplicationSpawner privilege lowering support") do
+	include TestHelper
+	
+	describe "regular spawning" do
+		it_should_behave_like "a spawner that supports lowering of privileges"
+	
+		def spawn_stub_application(options = {})
+			options = {
+				"lower_privilege" => true,
+				"lowest_user" => CONFIG['lowest_user']
+			}.merge(options)
+			@spawner = ApplicationSpawner.new(@stub.app_root, options)
+			@spawner.start
+			begin
+				app = @spawner.spawn_application
+				yield app
+			ensure
+				app.close if app
+				@spawner.stop
+			end
+		end
+	end
+	
+	describe "conservative spawning" do
+		it_should_behave_like "a spawner that supports lowering of privileges"
+	
+		def spawn_stub_application(options = {})
+			options = {
+				"lower_privilege" => true,
+				"lowest_user" => CONFIG['lowest_user']
+			}.merge(options)
+			@spawner = ApplicationSpawner.new(@stub.app_root, options)
+			begin
+				app = @spawner.spawn_application!
+				yield app
+			ensure
+				app.close if app
+			end
+		end
+	end
+end