mini-pure-gem 0.0.1

data/unicorn-6.1.0/t/t0011-active-unix-socket.sh

@@ -0,0 +1,79 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 11 "existing UNIX domain socket check"
+
+read_pid_unix () {
+	x=$(printf 'GET / HTTP/1.0\r\n\r\n' | \
+	    socat - UNIX:$unix_socket | \
+	    tail -1)
+	test -n "$x"
+	y="$(expr "$x" : '\([0-9][0-9]*\)')"
+	test x"$x" = x"$y"
+	test -n "$y"
+	echo "$y"
+}
+
+t_begin "setup and start" && {
+	rtmpfiles unix_socket unix_config
+	rm -f $unix_socket
+	unicorn_setup
+	grep -v ^listen < $unicorn_config > $unix_config
+	echo "listen '$unix_socket'" >> $unix_config
+	unicorn -D -c $unix_config pid.ru
+	unicorn_wait_start
+	orig_master_pid=$unicorn_pid
+}
+
+t_begin "get pid of worker" && {
+	worker_pid=$(read_pid_unix)
+	t_info "worker_pid=$worker_pid"
+}
+
+t_begin "fails to start with existing pid file" && {
+	rm -f $ok
+	unicorn -D -c $unix_config pid.ru || echo ok > $ok
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "worker pid unchanged" && {
+	test x"$(read_pid_unix)" = x$worker_pid
+	> $r_err
+}
+
+t_begin "fails to start with listening UNIX domain socket bound" && {
+	rm $ok $pid
+	unicorn -D -c $unix_config pid.ru || echo ok > $ok
+	test x"$(cat $ok)" = xok
+	> $r_err
+}
+
+t_begin "worker pid unchanged (again)" && {
+	test x"$(read_pid_unix)" = x$worker_pid
+}
+
+t_begin "nuking the existing Unicorn succeeds" && {
+	kill -9 $unicorn_pid
+	while kill -0 $unicorn_pid
+	do
+		sleep 1
+	done
+	check_stderr
+}
+
+t_begin "succeeds in starting with leftover UNIX domain socket bound" && {
+	test -S $unix_socket
+	unicorn -D -c $unix_config pid.ru
+	unicorn_wait_start
+}
+
+t_begin "worker pid changed" && {
+	test x"$(read_pid_unix)" != x$worker_pid
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "no errors" && check_stderr
+
+t_done

data/unicorn-6.1.0/t/t0012-reload-empty-config.sh

@@ -0,0 +1,86 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "reloading unset config resets defaults"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_orig before_reload after_reload
+	cat $unicorn_config > $unicorn_config_orig
+	cat >> $unicorn_config <<EOF
+logger Logger.new(STDOUT)
+preload_app true
+timeout 0x7fffffff
+worker_processes 2
+after_fork { |s,w| }
+\$dump_cfg = lambda { |fp,srv|
+  defaults = Unicorn::Configurator::DEFAULTS
+  defaults.keys.map { |x| x.to_s }.sort.each do |key|
+    next if key =~ %r{\Astd(?:err|out)_path\z}
+    key = key.to_sym
+    def_value = defaults[key]
+    srv_value = srv.respond_to?(key) ? srv.__send__(key)
+                                     : srv.instance_variable_get("@#{key}")
+    fp << "#{key}|#{srv_value}|#{def_value}\\n"
+  end
+}
+before_fork { |s,w|
+  File.open("$before_reload", "a") { |fp| \$dump_cfg.call(fp, s) }
+}
+before_exec { |s| }
+EOF
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	curl -sSf http://$listen/ > $tmp
+}
+
+t_begin "replace config file with original(-ish)" && {
+	grep -v ^pid < $unicorn_config_orig > $unicorn_config
+	cat >> $unicorn_config <<EOF
+before_fork { |s,w|
+  File.open("$after_reload", "a") { |fp| \$dump_cfg.call(fp, s) }
+}
+EOF
+}
+
+t_begin "reload signal succeeds" && {
+	kill -HUP $unicorn_pid
+	while ! egrep '(done|error) reloading' $r_err >/dev/null
+	do
+		sleep 1
+	done
+	while ! grep reaped < $r_err >/dev/null
+	do
+		sleep 1
+	done
+	grep 'done reloading' $r_err >/dev/null
+}
+
+t_begin "ensure worker is started" && {
+	curl -sSf http://$listen/ > $tmp
+}
+
+t_begin "pid file no longer exists" && {
+	if test -f $pid
+	then
+		die "pid=$pid should not exist"
+	fi
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_begin "ensure reloading restored settings" && {
+	awk < $after_reload -F'|' '
+$1 != "before_fork" && $2 != $3 { print $0; exit(1) }
+'
+}
+
+t_done

data/unicorn-6.1.0/t/t0013-rewindable-input-false.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "rewindable_input toggled to false"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	echo rewindable_input false >> $unicorn_config
+	unicorn -D -c $unicorn_config t0013.ru
+	unicorn_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	test xOK = x$(curl -T t0013.ru -H Expect: -vsSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/unicorn-6.1.0/t/t0013.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::StreamInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/unicorn-6.1.0/t/t0014-rewindable-input-true.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "rewindable_input toggled to true"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	echo rewindable_input true >> $unicorn_config
+	unicorn -D -c $unicorn_config t0014.ru
+	unicorn_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	test xOK = x$(curl -T t0014.ru -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/unicorn-6.1.0/t/t0014.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::TeeInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/unicorn-6.1.0/t/t0015-configurator-internals.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "configurator internals tests (from FAQ)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	cat >> $unicorn_config <<EOF
+HttpRequest::DEFAULTS["rack.url_scheme"] = "https"
+Configurator::DEFAULTS[:logger].formatter = Logger::Formatter.new
+EOF
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "single request" && {
+	curl -sSfv http://$listen/ | grep '"rack.url_scheme"=>"https"'
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "no errors" && check_stderr
+
+t_done

data/unicorn-6.1.0/t/t0018-write-on-close.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "write-on-close tests for funky response-bodies"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -D -c $unicorn_config write-on-close.ru
+	unicorn_wait_start
+}
+
+t_begin "write-on-close response body succeeds" && {
+	test xGoodbye = x"$(curl -sSf http://$listen/)"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/unicorn-6.1.0/t/t0019-max_header_len.sh

@@ -0,0 +1,49 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 5 "max_header_len setting (only intended for Rainbows!)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	req='GET / HTTP/1.0\r\n\r\n'
+	len=$(printf "$req" | count_bytes)
+	echo Unicorn::HttpParser.max_header_len = $len >> $unicorn_config
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "minimal request succeeds" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf "$req"
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+	test xok = x$(cat $ok)
+
+	fgrep "HTTP/1.1 200 OK" $tmp
+}
+
+t_begin "big request fails" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'GET /xxxxxx HTTP/1.0\r\n\r\n'
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+	test xok = x$(cat $ok)
+	fgrep "HTTP/1.1 413" $tmp
+}
+
+dbgcat tmp
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/unicorn-6.1.0/t/t0020-at_exit-handler.sh

@@ -0,0 +1,49 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 5 "at_exit/END handlers work as expected"
+
+t_begin "setup and startup" && {
+	unicorn_setup
+	cat >> $unicorn_config <<EOF
+at_exit { \$stdout.syswrite("#{Process.pid} BOTH\\n") }
+END { \$stdout.syswrite("#{Process.pid} END BOTH\\n") }
+after_fork do |_,_|
+  at_exit { \$stdout.syswrite("#{Process.pid} WORKER ONLY\\n") }
+  END { \$stdout.syswrite("#{Process.pid} END WORKER ONLY\\n") }
+end
+EOF
+
+	unicorn -D pid.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read worker PID" && {
+	worker_pid=$(curl -sSf http://$listen/)
+	t_info "worker_pid=$worker_pid"
+}
+
+t_begin "issue graceful shutdown (SIGQUIT) and wait for termination" && {
+	kill -QUIT $unicorn_pid
+
+	while kill -0 $unicorn_pid >/dev/null 2>&1
+	do
+		sleep 1
+	done
+}
+
+t_begin "check stderr" && check_stderr
+
+dbgcat r_err
+dbgcat r_out
+
+t_begin "all at_exit handlers ran" && {
+	grep "$worker_pid BOTH" $r_out
+	grep "$unicorn_pid BOTH" $r_out
+	grep "$worker_pid END BOTH" $r_out
+	grep "$unicorn_pid END BOTH" $r_out
+	grep "$worker_pid WORKER ONLY" $r_out
+	grep "$worker_pid END WORKER ONLY" $r_out
+}
+
+t_done

data/unicorn-6.1.0/t/t0021-process_detach.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 5 "Process.detach on forked background process works"
+
+t_begin "setup and startup" && {
+	t_fifos process_detach
+	unicorn_setup
+	TEST_FIFO=$process_detach \
+	  unicorn -E none -D detach.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read detached PID with HTTP/1.0" && {
+	detached_pid=$(curl -0 -sSf http://$listen/)
+	t_info "detached_pid=$detached_pid"
+}
+
+t_begin "read background FIFO" && {
+	test xHIHI = x"$(cat $process_detach)"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/unicorn-6.1.0/t/t0022-listener_names-preload_app.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+. ./test-lib.sh
+
+# Raindrops::Middleware depends on Unicorn.listener_names,
+# ensure we don't break Raindrops::Middleware when preload_app is true
+
+t_plan 4 "Unicorn.listener_names available with preload_app=true"
+
+t_begin "setup and startup" && {
+	unicorn_setup
+	echo preload_app true >> $unicorn_config
+	unicorn -E none -D listener_names.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read listener names includes listener" && {
+	resp=$(curl -sSf http://$listen/)
+	ok=false
+	t_info "resp=$resp"
+	case $resp in
+	*\"$listen\"*) ok=true ;;
+	esac
+	$ok
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/unicorn-6.1.0/t/t0100-rack-input-tests.sh

@@ -0,0 +1,124 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+
+t_plan 10 "rack.input read tests"
+
+t_begin "setup and startup" && {
+	rtmpfiles curl_out curl_err
+	unicorn_setup
+	unicorn -E none -D rack-input-tests.ru -c $unicorn_config
+	blob_sha1=$(rsha1 < random_blob)
+	blob_size=$(count_bytes < random_blob)
+	t_info "blob_sha1=$blob_sha1"
+	unicorn_wait_start
+}
+
+t_begin "corked identity request" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'PUT / HTTP/1.0\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $blob_size
+		cat random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "corked chunked request" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		content-md5-put < random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "corked identity request (input#size first)" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'PUT /size_first HTTP/1.0\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $blob_size
+		cat random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "corked identity request (input#rewind first)" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'PUT /rewind_first HTTP/1.0\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $blob_size
+		cat random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "corked chunked request (input#size first)" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'PUT /size_first HTTP/1.1\r\n'
+		printf 'Host: example.com\r\n'
+		printf 'Transfer-Encoding: chunked\r\n'
+		printf 'Trailer: Content-MD5\r\n'
+		printf '\r\n'
+		content-md5-put --no-headers < random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "corked chunked request (input#rewind first)" && {
+	rm -f $tmp
+	(
+		cat $fifo > $tmp &
+		printf 'PUT /rewind_first HTTP/1.1\r\n'
+		printf 'Host: example.com\r\n'
+		printf 'Transfer-Encoding: chunked\r\n'
+		printf 'Trailer: Content-MD5\r\n'
+		printf '\r\n'
+		content-md5-put --no-headers < random_blob
+		wait
+		echo ok > $ok
+	) | ( sleep 1 && socat - TCP4:$listen > $fifo )
+	test 1 -eq $(grep $blob_sha1 $tmp |count_lines)
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "regular request" && {
+	curl -sSf -T random_blob http://$listen/ > $curl_out 2> $curl_err
+        test x$blob_sha1 = x$(cat $curl_out)
+        test ! -s $curl_err
+}
+
+t_begin "chunked request" && {
+	curl -sSf -T- < random_blob http://$listen/ > $curl_out 2> $curl_err
+        test x$blob_sha1 = x$(cat $curl_out)
+        test ! -s $curl_err
+}
+
+dbgcat r_err
+
+t_begin "shutdown" && {
+	kill $unicorn_pid
+}
+
+t_done

data/unicorn-6.1.0/t/t0116-client_body_buffer_size.sh

@@ -0,0 +1,80 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 12 "client_body_buffer_size settings"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_tmp one_meg
+	dd if=/dev/zero bs=1M count=1 of=$one_meg
+	cat >> $unicorn_config <<EOF
+after_fork do |server, worker|
+  File.open("$fifo", "wb") { |fp| fp.syswrite "START" }
+end
+EOF
+	cat $unicorn_config > $unicorn_config_tmp
+	echo client_body_buffer_size 0 >> $unicorn_config
+	unicorn -D -c $unicorn_config t0116.ru
+	unicorn_wait_start
+	fs_class=Unicorn::TmpIO
+	mem_class=StringIO
+
+	test x"$(cat $fifo)" = xSTART
+}
+
+t_begin "class for a zero-byte file should be StringIO" && {
+	> $tmp
+	test xStringIO = x"$(curl -T $tmp -sSf http://$listen/input_class)"
+}
+
+t_begin "class for a 1 byte file should be filesystem-backed" && {
+	echo > $tmp
+	test x$fs_class = x"$(curl -T $tmp -sSf http://$listen/tmp_class)"
+}
+
+t_begin "reload with default client_body_buffer_size" && {
+	mv $unicorn_config_tmp $unicorn_config
+	kill -HUP $unicorn_pid
+	test x"$(cat $fifo)" = xSTART
+}
+
+t_begin "class for a 1 byte file should be memory-backed" && {
+	echo > $tmp
+	test x$mem_class = x"$(curl -T $tmp -sSf http://$listen/tmp_class)"
+}
+
+t_begin "class for a random blob file should be filesystem-backed" && {
+	resp="$(curl -T random_blob -sSf http://$listen/tmp_class)"
+	test x$fs_class = x"$resp"
+}
+
+t_begin "one megabyte file should be filesystem-backed" && {
+	resp="$(curl -T $one_meg -sSf http://$listen/tmp_class)"
+	test x$fs_class = x"$resp"
+}
+
+t_begin "reload with a big client_body_buffer_size" && {
+	echo "client_body_buffer_size(1024 * 1024)" >> $unicorn_config
+	kill -HUP $unicorn_pid
+	test x"$(cat $fifo)" = xSTART
+}
+
+t_begin "one megabyte file should be memory-backed" && {
+	resp="$(curl -T $one_meg -sSf http://$listen/tmp_class)"
+	test x$mem_class = x"$resp"
+}
+
+t_begin "one megabyte + 1 byte file should be filesystem-backed" && {
+	echo >> $one_meg
+	resp="$(curl -T $one_meg -sSf http://$listen/tmp_class)"
+	test x$fs_class = x"$resp"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/unicorn-6.1.0/t/t0116.ru

@@ -0,0 +1,16 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  input = env['rack.input']
+  case env["PATH_INFO"]
+  when "/tmp_class"
+    body = input.instance_variable_get(:@tmp).class.name
+  when "/input_class"
+    body = input.class.name
+  else
+    return [ 500, {}, [] ]
+  end
+  [ 200, {}, [ body ] ]
+end
+run app

data/unicorn-6.1.0/t/t0300-no-default-middleware.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 3 "test the -N / --no-default-middleware option"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -N -D -c $unicorn_config fails-rack-lint.ru
+	unicorn_wait_start
+}
+
+t_begin "check exit status with Rack::Lint not present" && {
+	test 42 -eq "$(curl -sf -o/dev/null -w'%{http_code}' http://$listen/)"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+	check_stderr
+}
+
+t_done