Tests: Ruby module.

test/ruby/at_exit/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    at_exit do
+      env['rack.errors'].puts('At exit called.')
+    end
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/body_array/config.ru

@@ -0,0 +1,5 @@
+app = Proc.new do |env|
+    ['200', {'Content-Length' => '10'}, ['0123', '4567', '89']]
+end
+
+run app

test/ruby/body_each_error/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    io = IO.new(0, 'r')
+    ['200', {'Content-Length' => '0'}, io]
+end
+
+run app

test/ruby/body_empty/config.ru

@@ -0,0 +1,5 @@
+app = Proc.new do |env|
+    ['200', {}, []]
+end
+
+run app

test/ruby/body_file/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    file = File.open('file', 'r')
+    ['200', {'Content-Length' => '5'}, file]
+end
+
+run app

test/ruby/body_file/file

@@ -0,0 +1 @@
+body

test/ruby/empty/config.ru

@@ -0,0 +1,9 @@
+app = Proc.new do |env|
+    body = env['rack.input'].gets
+    #body += env['rack.input'].gets
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/errors_puts/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    env['rack.errors'].puts('Error in application')
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/errors_puts_int/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    env['rack.errors'].puts(1234567890)
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/errors_write/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    env['rack.errors'].write('Error in application')
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/errors_write_int/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    env['rack.errors'].write(1234567890)
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/errors_write_to_s_custom/config.ru

@@ -0,0 +1,15 @@
+app = Proc.new do |env|
+
+    class Custom
+        def to_s()
+            nil
+        end
+    end
+
+    e = Custom.new()
+
+    env['rack.errors'].write(e)
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/header_custom/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    ['200', {
+        'Content-Length' => '0',
+        'Custom-Header' => env['rack.input'].read
+    }, []]
+end
+
+run app

test/ruby/header_rack/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    ['200', {
+        'Content-Length' => '0',
+        'rack.header' => 'hello'
+    }, ['']]
+end
+
+run app

test/ruby/header_status/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    ['200', {
+        'Content-Length' => '0',
+        'Status' => '200'
+    }, []]
+end
+
+run app

test/ruby/input_each/config.ru

@@ -0,0 +1,11 @@
+app = Proc.new do |env|
+    body = ''
+    env['rack.input'].each do |value|
+        body += value
+    end
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_gets/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    body = env['rack.input'].gets
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_gets_all/config.ru

@@ -0,0 +1,14 @@
+app = Proc.new do |env|
+    body = ''
+    buf = ''
+    loop do
+        buf = env['rack.input'].gets
+        break if buf == nil
+        body += buf
+    end
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_read_buffer/config.ru

@@ -0,0 +1,9 @@
+app = Proc.new do |env|
+    body = ''
+    env['rack.input'].read(nil, body)
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_read_buffer_not_empty/config.ru

@@ -0,0 +1,9 @@
+app = Proc.new do |env|
+    body = 'blah'
+    env['rack.input'].read(nil, body)
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_read_empty/config.ru

@@ -0,0 +1,6 @@
+app = Proc.new do |env|
+    body = env['rack.input'].read
+    ['200', {'Content-Length' => body.length.to_s}, [body]]
+end
+
+run app

test/ruby/input_read_parts/config.ru

@@ -0,0 +1,10 @@
+app = Proc.new do |env|
+    body = env['rack.input'].read(4)
+    body += env['rack.input'].read(4)
+    body += env['rack.input'].read(1)
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/input_rewind/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    env['rack.input'].read
+    env['rack.input'].rewind
+    body = env['rack.input'].read
+    ['200', {'Content-Length' => body.length.to_s}, [body]]
+end
+
+run app

test/ruby/mirror/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    body = env['rack.input'].read
+    ['200', {
+        'Content-Length' => body.length.to_s
+    }, [body]]
+end
+
+run app

test/ruby/query_string/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    ['200', {
+        'Content-Length' => '0',
+        'Query-String' => env['QUERY_STRING']
+    }, ['']]
+end
+
+run app

test/ruby/server_port/config.ru

@@ -0,0 +1,8 @@
+app = Proc.new do |env|
+    ['200', {
+        'Content-Length' => '0',
+        'Server-Port' => env['SERVER_PORT']
+    }, ['']]
+end
+
+run app

test/ruby/status_int/config.ru

@@ -0,0 +1,5 @@
+app = Proc.new do |env|
+    [200, {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/syntax_error/config.ru

@@ -0,0 +1,5 @@
+app = Proc.new |env|
+    ['200', {'Content-Length' => '0'}, ['']]
+end
+
+run app

test/ruby/variables/config.ru

@@ -0,0 +1,24 @@
+app = Proc.new do |env|
+    body = env['rack.input'].read
+    version = env['rack.version'].join('')
+
+    ['200', {
+        'Content-Type' => env['CONTENT_TYPE'],
+        'Content-Length' => body.length.to_s,
+        'Request-Method' => env['REQUEST_METHOD'],
+        'Request-Uri' => env['REQUEST_URI'],
+        'Http-Host' => env['HTTP_HOST'],
+        'Server-Protocol' => env['SERVER_PROTOCOL'],
+        'Custom-Header' => env['HTTP_CUSTOM_HEADER'],
+        'Rack-Version' => version,
+        'Rack-Url-Scheme' => env['rack.url_scheme'],
+        'Rack-Multithread' => env['rack.multithread'].to_s,
+        'Rack-Multiprocess' => env['rack.multiprocess'].to_s,
+        'Rack-Run-Once' => env['rack.run_once'].to_s,
+        'Rack-Hijack-Q' => env['rack.hijack?'].to_s,
+        'Rack-Hijack' => env['rack.hijack'].to_s,
+        'Rack-Hijack-IO' => env['rack.hijack_io'].to_s
+    }, [body]]
+end
+
+run app

test/test_perl_application.py

@@ -1,5 +1,3 @@
-import re
-import time
 import unittest
 import unit
 
@@ -23,9 +21,8 @@ class TestUnitPerlApplication(unit.TestUnitApplicationPerl):
         headers = resp['headers']
         self.assertRegex(headers.pop('Server'), r'Unit/[\d\.]+',
             'server header')
-        self.assertLess(abs(time.mktime(time.gmtime()) -
+        self.assertLess(abs(self.date_to_sec_epoch(headers.pop('Date')) -
-            time.mktime(time.strptime(headers.pop('Date'),
+            self.sec_epoch()), 5, 'date header')
-            '%a, %d %b %Y %H:%M:%S GMT'))), 5, 'date header')
         self.assertDictEqual(headers, {
             'Content-Length': str(len(body)),
             'Content-Type': 'text/html',
@@ -88,10 +85,11 @@ class TestUnitPerlApplication(unit.TestUnitApplicationPerl):
 
         self.assertEqual(self.get()['body'], '1', 'errors result')
 
-        with open(self.testdir + '/unit.log', 'r') as f:
+        self.stop()
-            m = re.search('Error in application', f.read())
 
-        self.assertIsNotNone(m, 'errors log')
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+Error in application'),
+            'errors print')
 
     def test_perl_application_header_equal_names(self):
         self.load('header_equal_names')

test/test_python_application.py

@@ -1,4 +1,3 @@
-import time
 import unittest
 import unit
 
@@ -22,9 +21,8 @@ class TestUnitPythonApplication(unit.TestUnitApplicationPython):
         headers = resp['headers']
         self.assertRegex(headers.pop('Server'), r'Unit/[\d\.]+',
             'server header')
-        self.assertLess(abs(time.mktime(time.gmtime()) -
+        self.assertLess(abs(self.date_to_sec_epoch(headers.pop('Date')) -
-            time.mktime(time.strptime(headers.pop('Date'),
+            self.sec_epoch()), 5, 'date header')
-            '%a, %d %b %Y %H:%M:%S GMT'))), 5, 'date header')
         self.assertDictEqual(headers, {
             'Content-Length': str(len(body)),
             'Content-Type': 'text/html',

test/test_ruby_application.py

@@ -0,0 +1,281 @@
+import unittest
+import unit
+
+class TestUnitRubyApplication(unit.TestUnitApplicationRuby):
+
+    def setUpClass():
+        unit.TestUnit().check_modules('ruby')
+
+    def test_ruby_application(self):
+        self.load('variables')
+
+        body = 'Test body string.'
+
+        resp = self.post(headers={
+            'Host': 'localhost',
+            'Content-Type': 'text/html',
+            'Custom-Header': 'blah'
+        }, body=body)
+
+        self.assertEqual(resp['status'], 200, 'status')
+        headers = resp['headers']
+        self.assertRegex(headers.pop('Server'), r'Unit/[\d\.]+',
+            'server header')
+        self.assertLess(abs(self.date_to_sec_epoch(headers.pop('Date')) -
+            self.sec_epoch()), 5, 'date header')
+        self.assertDictEqual(headers, {
+            'Content-Length': str(len(body)),
+            'Content-Type': 'text/html',
+            'Request-Method': 'POST',
+            'Request-Uri': '/',
+            'Http-Host': 'localhost',
+            'Server-Protocol': 'HTTP/1.1',
+            'Custom-Header': 'blah',
+            'Rack-Version': '13',
+            'Rack-Url-Scheme': 'http',
+            'Rack-Multithread': 'false',
+            'Rack-Multiprocess': 'true',
+            'Rack-Run-Once': 'false',
+            'Rack-Hijack-Q': 'false',
+            'Rack-Hijack': '',
+            'Rack-Hijack-IO': ''
+        }, 'headers')
+        self.assertEqual(resp['body'], body, 'body')
+
+    def test_ruby_application_query_string(self):
+        self.load('query_string')
+
+        resp = self.get(url='/?var1=val1&var2=val2')
+
+        self.assertEqual(resp['headers']['Query-String'], 'var1=val1&var2=val2',
+            'Query-String header')
+
+    @unittest.expectedFailure
+    def test_ruby_application_server_port(self):
+        self.load('server_port')
+
+        self.assertEqual(self.get()['headers']['Server-Port'], '7080',
+            'Server-Port header')
+
+    def test_ruby_application_status_int(self):
+        self.load('status_int')
+
+        self.assertEqual(self.get()['status'], 200, 'status int')
+
+    def test_ruby_application_input_read_empty(self):
+        self.load('input_read_empty')
+
+        self.assertEqual(self.get()['body'], '', 'read empty')
+
+    def test_ruby_application_input_read_parts(self):
+        self.load('input_read_parts')
+
+        self.assertEqual(self.post(body='0123456789')['body'], '012345678',
+            'input read parts')
+
+    def test_ruby_application_input_read_buffer(self):
+        self.load('input_read_buffer')
+
+        self.assertEqual(self.post(body='0123456789')['body'], '0123456789',
+            'input read buffer')
+
+    def test_ruby_application_input_read_buffer_not_empty(self):
+        self.load('input_read_buffer_not_empty')
+
+        self.assertEqual(self.post(body='0123456789')['body'], '0123456789',
+            'input read buffer not empty')
+
+    def test_ruby_application_input_gets(self):
+        self.load('input_gets')
+
+        body = '0123456789'
+
+        self.assertEqual(self.post(body=body)['body'], body, 'input gets')
+
+    def test_ruby_application_input_gets_2(self):
+        self.load('input_gets')
+
+        self.assertEqual(self.post(body='01234\n56789\n')['body'], '01234\n',
+            'input gets 2')
+
+    def test_ruby_application_input_gets_all(self):
+        self.load('input_gets_all')
+
+        body = '\n01234\n56789\n\n'
+
+        self.assertEqual(self.post(body=body)['body'], body, 'input gets all')
+
+    def test_ruby_application_input_each(self):
+        self.load('input_each')
+
+        body = '\n01234\n56789\n\n'
+
+        self.assertEqual(self.post(body=body)['body'], body, 'input each')
+
+    @unittest.expectedFailure
+    def test_ruby_application_input_rewind(self):
+        self.load('input_rewind')
+
+        body = '0123456789'
+
+        self.assertEqual(self.post(body=body)['body'], body, 'input rewind')
+
+    @unittest.expectedFailure
+    def test_ruby_application_syntax_error(self):
+        self.skip_alerts.extend([
+            r'Failed to parse rack script',
+            r'syntax error',
+            r'new_from_string',
+            r'parse_file'
+        ])
+        self.load('syntax_error')
+
+        self.assertEqual(self.get()['status'], 500, 'syntax error')
+
+    def test_ruby_application_errors_puts(self):
+        self.load('errors_puts')
+
+        self.get()
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+Error in application'),
+            'errors puts')
+
+    def test_ruby_application_errors_puts_int(self):
+        self.load('errors_puts_int')
+
+        self.get()
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+1234567890'),
+            'errors puts int')
+
+    def test_ruby_application_errors_write(self):
+        self.load('errors_write')
+
+        self.get()
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+Error in application'),
+            'errors write')
+
+    def test_ruby_application_errors_write_to_s_custom(self):
+        self.load('errors_write_to_s_custom')
+
+        self.assertEqual(self.get()['status'], 200,
+            'errors write to_s custom')
+
+    def test_ruby_application_errors_write_int(self):
+        self.load('errors_write_int')
+
+        self.get()
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+1234567890'),
+            'errors write int')
+
+    def test_ruby_application_at_exit(self):
+        self.skip_alerts.append(r'sendmsg.+failed')
+        self.load('at_exit')
+
+        self.get()
+
+        self.conf({
+            "listeners": {},
+            "applications": {}
+        })
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+At exit called\.'), 'at exit')
+
+    def test_ruby_application_header_custom(self):
+        self.load('header_custom')
+
+        resp = self.post(body="\ntc=one,two\ntc=three,four,\n\n")
+
+        self.assertEqual(resp['headers']['Custom-Header'],
+            ['', 'tc=one,two', 'tc=three,four,', '', ''], 'header custom')
+
+    @unittest.expectedFailure
+    def test_ruby_application_header_custom_non_printable(self):
+        self.load('header_custom')
+
+        self.assertEqual(self.post(body='\b')['status'], 500,
+            'header custom non printable')
+
+    def test_ruby_application_header_status(self):
+        self.load('header_status')
+
+        self.assertEqual(self.get()['status'], 200, 'header status')
+
+    @unittest.expectedFailure
+    def test_ruby_application_header_rack(self):
+        self.load('header_rack')
+
+        self.assertEqual(self.get()['status'], 500, 'header rack')
+
+    def test_ruby_application_body_empty(self):
+        self.load('body_empty')
+
+        self.assertEqual(self.get()['body'], '0\r\n\r\n', 'body empty')
+
+    def test_ruby_application_body_array(self):
+        self.load('body_array')
+
+        self.assertEqual(self.get()['body'], '0123456789', 'body array')
+
+    def test_ruby_application_body_large(self):
+        self.load('mirror')
+
+        body = '0123456789' * 1000
+
+        self.assertEqual(self.post(body=body)['body'], body, 'body large')
+
+    @unittest.expectedFailure
+    def test_ruby_application_body_each_error(self):
+        self.load('body_each_error')
+
+        self.assertEqual(self.get()['status'], 500, 'body each error status')
+
+        self.stop()
+
+        self.assertIsNotNone(
+            self.search_in_log(r'\[error\].+Failed to run ruby script'),
+            'body each error')
+
+    def test_ruby_application_body_file(self):
+        self.load('body_file')
+
+        self.assertEqual(self.get()['body'], 'body\n', 'body file')
+
+    def test_ruby_keepalive_body(self):
+        self.load('mirror')
+
+        (resp, sock) = self.post(headers={
+            'Connection': 'keep-alive',
+            'Content-Type': 'text/html',
+            'Host': 'localhost'
+        }, start=True, body='0123456789' * 500)
+
+        self.assertEqual(resp['body'], '0123456789' * 500, 'keep-alive 1')
+
+        resp = self.post(headers={
+            'Connection': 'close',
+            'Content-Type': 'text/html',
+            'Host': 'localhost'
+        }, sock=sock, body='0123456789')
+
+        self.assertEqual(resp['body'], '0123456789', 'keep-alive 2')
+
+if __name__ == '__main__':
+    unittest.main()

test/unit.py

@@ -16,12 +16,13 @@ class TestUnit(unittest.TestCase):
 
     pardir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
     architecture = platform.architecture()[0]
+    maxDiff = None
 
     def setUp(self):
         self._run()
 
     def tearDown(self):
-        self._stop()
+        self.stop()
 
         with open(self.testdir + '/unit.log', 'r', encoding='utf-8',
             errors='ignore') as f:
@@ -44,7 +45,7 @@ class TestUnit(unittest.TestCase):
                     break
 
         if m is None:
-            self._stop()
+            self.stop()
             exit("Unit is writing log too long")
 
         self._check_alerts(log)
@@ -56,12 +57,16 @@ class TestUnit(unittest.TestCase):
                 missed_module = module
                 break
 
-        self._stop()
+        self.stop()
         shutil.rmtree(self.testdir)
 
         if missed_module:
             raise unittest.SkipTest('Unit has no ' + missed_module + ' module')
 
+    def stop(self):
+        if self._started:
+            self._stop()
+
     def _run(self):
         self.testdir = tempfile.mkdtemp(prefix='unit-test-')
 
@@ -85,6 +90,8 @@ class TestUnit(unittest.TestCase):
             self.testdir + '/unit.log', self.testdir + '/control.unit.sock'):
             exit("Could not start unit")
 
+        self._started = True
+
         self.skip_alerts = [r'read signalfd\(4\) failed']
         self.skip_sanitizer = False
 
@@ -105,6 +112,8 @@ class TestUnit(unittest.TestCase):
         if os.path.exists(self.testdir + '/unit.pid'):
             exit("Could not terminate unit")
 
+        self._started = False
+
         self._p.join(timeout=1)
         self._terminate_process(self._p)
 
@@ -322,6 +331,16 @@ class TestUnitApplicationProto(TestUnitControl):
 
     current_dir = os.path.dirname(os.path.abspath(__file__))
 
+    def sec_epoch(self):
+        return time.mktime(time.gmtime())
+
+    def date_to_sec_epoch(self, date):
+        return time.mktime(time.strptime(date, '%a, %d %b %Y %H:%M:%S GMT'))
+
+    def search_in_log(self, pattern):
+        with open(self.testdir + '/unit.log', 'r') as f:
+            return re.search(pattern, f.read())
+
 class TestUnitApplicationPython(TestUnitApplicationProto):
     def load(self, script, name=None):
         if name is None:
@@ -343,6 +362,24 @@ class TestUnitApplicationPython(TestUnitApplicationProto):
             }
         })
 
+class TestUnitApplicationRuby(TestUnitApplicationProto):
+    def load(self, script, name='config.ru'):
+        self.conf({
+            "listeners": {
+                "*:7080": {
+                    "application": script
+                }
+            },
+            "applications": {
+                script: {
+                    "type": "ruby",
+                    "processes": { "spare": 0 },
+                    "working_directory": self.current_dir + '/ruby/' + script,
+                    "script": self.current_dir + '/ruby/' + script + '/' + name
+                }
+            }
+        })
+
 class TestUnitApplicationPerl(TestUnitApplicationProto):
     def load(self, script, name='psgi.pl'):
         self.conf({