Tests: using LF line ending for test files.

6 files changed, 869 insertions, 869 deletions

diff --git a/test/test_configuration.py b/test/test_configuration.py
index 8a3612a8..f10a5e8b 100644
--- a/test/test_configuration.py
+++ b/test/test_configuration.py
@@ -1,146 +1,146 @@
-import unittest

-import unit

-

-class TestUnitConfiguration(unit.TestUnitControl):

-

-    def setUpClass():

-        unit.TestUnit().check_modules('python')

-

-    def test_json(self):

-        self.assertIn('error', self.put('/', '00'), 'leading zero')

-

-    def test_json_applications(self):

-        self.assertIn('error', self.put('/applications', '"{}"'),

-            'applications string')

-        self.assertIn('error', self.put('/applications', '{'),

-            'applications miss brace')

-

-        self.assertTry('assertIn', 'negative workers', 'error',

-            self.put('/applications', """

-            {

-                "app": {

-                    "type": "python",

-                    "workers": -1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """))

-

-        self.assertTry('assertIn', 'application type only', 'error',

-            self.put('/applications', """

-            {

-                "app": {

-                    "type": "python"

-                }

-            }

-            """))

-

-        self.assertIn('error', self.put('/applications', """

-            {

-                app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'applications miss quote')

-

-        self.assertIn('error', self.put('/applications', """

-            {

-                "app" {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'applications miss colon')

-

-        self.assertIn('error', self.put('/applications', """

-            {

-                "app": {

-                    "type": "python"

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'applications miss comma')

-

-        self.assertIn('success', self.put('/applications', b'{ \n\r\t}'),

-            'skip space')

-

-        self.assertIn('success', self.put('/applications', """

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "../app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'relative path')

-

-        self.assertIn('success', self.put('/applications', b"""

-            {

-                "ap\u0070": {

-                    "type": "\u0070ython",

-                    "workers": 1,

-                    "path": "\u002Fapp",

-                    "module": "wsgi"

-                }

-            }

-            """), 'unicode')

-

-        self.assertIn('success', self.put('/applications', """

-            {

-                "приложение": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'unicode 2')

-

-        self.assertIn('error', self.put('/applications', b"""

-            {

-                "app": {

-                    "type": "python",

-                    "workers": \u0031,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """), 'unicode number')

-

-    def test_json_listeners(self):

-        self.assertTry('assertIn', 'listener empty', 'error',

-            self.put('/listeners', '{"*:7080":{}}'))

-        self.assertIn('error', self.put('/listeners',

-            '{"*:7080":{"application":"app"}}'), 'listeners no app')

-

-        self.put('/applications', """

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """)

-

-        self.assertIn('success', self.put('/listeners',

-            '{"*:7080":{"application":"app"}}'), 'listeners wildcard')

-        self.assertIn('success', self.put('/listeners',

-            '{"127.0.0.1:7081":{"application":"app"}}'), 'listeners explicit')

-        self.assertIn('success', self.put('/listeners',

-            '{"[::1]:7082":{"application":"app"}}'), 'listeners explicit ipv6')

-        self.assertIn('error', self.put('/listeners',

-            '{"127.0.0.1":{"application":"app"}}'), 'listeners no port')

-

-if __name__ == '__main__':

-    unittest.main()

+import unittest
+import unit
+
+class TestUnitConfiguration(unit.TestUnitControl):
+
+    def setUpClass():
+        unit.TestUnit().check_modules('python')
+
+    def test_json(self):
+        self.assertIn('error', self.put('/', '00'), 'leading zero')
+
+    def test_json_applications(self):
+        self.assertIn('error', self.put('/applications', '"{}"'),
+            'applications string')
+        self.assertIn('error', self.put('/applications', '{'),
+            'applications miss brace')
+
+        self.assertTry('assertIn', 'negative workers', 'error',
+            self.put('/applications', """
+            {
+                "app": {
+                    "type": "python",
+                    "workers": -1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """))
+
+        self.assertTry('assertIn', 'application type only', 'error',
+            self.put('/applications', """
+            {
+                "app": {
+                    "type": "python"
+                }
+            }
+            """))
+
+        self.assertIn('error', self.put('/applications', """
+            {
+                app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'applications miss quote')
+
+        self.assertIn('error', self.put('/applications', """
+            {
+                "app" {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'applications miss colon')
+
+        self.assertIn('error', self.put('/applications', """
+            {
+                "app": {
+                    "type": "python"
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'applications miss comma')
+
+        self.assertIn('success', self.put('/applications', b'{ \n\r\t}'),
+            'skip space')
+
+        self.assertIn('success', self.put('/applications', """
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "../app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'relative path')
+
+        self.assertIn('success', self.put('/applications', b"""
+            {
+                "ap\u0070": {
+                    "type": "\u0070ython",
+                    "workers": 1,
+                    "path": "\u002Fapp",
+                    "module": "wsgi"
+                }
+            }
+            """), 'unicode')
+
+        self.assertIn('success', self.put('/applications', """
+            {
+                "приложение": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'unicode 2')
+
+        self.assertIn('error', self.put('/applications', b"""
+            {
+                "app": {
+                    "type": "python",
+                    "workers": \u0031,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """), 'unicode number')
+
+    def test_json_listeners(self):
+        self.assertTry('assertIn', 'listener empty', 'error',
+            self.put('/listeners', '{"*:7080":{}}'))
+        self.assertIn('error', self.put('/listeners',
+            '{"*:7080":{"application":"app"}}'), 'listeners no app')
+
+        self.put('/applications', """
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """)
+
+        self.assertIn('success', self.put('/listeners',
+            '{"*:7080":{"application":"app"}}'), 'listeners wildcard')
+        self.assertIn('success', self.put('/listeners',
+            '{"127.0.0.1:7081":{"application":"app"}}'), 'listeners explicit')
+        self.assertIn('success', self.put('/listeners',
+            '{"[::1]:7082":{"application":"app"}}'), 'listeners explicit ipv6')
+        self.assertIn('error', self.put('/listeners',
+            '{"127.0.0.1":{"application":"app"}}'), 'listeners no port')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_php_basic.py b/test/test_php_basic.py
index fa1484a3..d37f92f5 100644
--- a/test/test_php_basic.py
+++ b/test/test_php_basic.py
@@ -1,166 +1,166 @@
-import unittest

-import unit

-

-class TestUnitBasic(unit.TestUnitControl):

-

-    def setUpClass():

-        unit.TestUnit().check_modules('php')

-

-    def test_php_get(self):

-        resp = self.get()

-        self.assertEqual(resp, {'listeners': {}, 'applications': {}}, 'empty')

-        self.assertEqual(self.get('/listeners'), {}, 'empty listeners prefix')

-        self.assertEqual(self.get('/applications'), {},

-            'empty applications prefix')

-

-        self.put('/applications', """

-            {

-                "app": {

-                    "type": "php",

-                    "workers": 1,

-                    "root": "/app",

-                    "index": "index.php"

-                }

-            }

-            """)

-

-        resp = self.get()

-

-        self.assertEqual(resp['listeners'], {}, 'php empty listeners')

-        self.assertEqual(resp['applications'],

-            {

-                "app": {

-                    "type": "php",

-                    "workers": 1,

-                    "root": "/app",

-                    "index": "index.php"

-                }

-             },

-             'php applications')

-

-        self.assertEqual(self.get('/applications'),

-            {

-                "app": {

-                    "type": "php",

-                    "workers": 1,

-                    "root": "/app",

-                    "index": "index.php"

-                }

-            },

-            'php applications prefix')

-

-        self.assertEqual(self.get('/applications/app'),

-            {

-                "type": "php",

-                "workers": 1,

-                "root": "/app",

-                "index": "index.php"

-            },

-            'php applications prefix 2')

-

-        self.assertEqual(self.get('/applications/app/type'), 'php',

-            'php applications type')

-        self.assertEqual(self.get('/applications/app/workers'), 1,

-            'php applications workers')

-

-        self.put('/listeners', '{"*:7080":{"application":"app"}}')

-

-        self.assertEqual(self.get()['listeners'],

-            {"*:7080":{"application":"app"}}, 'php listeners')

-        self.assertEqual(self.get('/listeners'),

-            {"*:7080":{"application":"app"}}, 'php listeners prefix')

-        self.assertEqual(self.get('/listeners/*:7080'),

-            {"application":"app"}, 'php listeners prefix 2')

-        self.assertEqual(self.get('/listeners/*:7080/application'), 'app',

-            'php listeners application')

-

-    def test_php_put(self):

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "php",

-                        "workers": 1,

-                        "root": "/app",

-                        "index": "index.php"

-                    }

-                }

-            }

-            """)

-

-        resp = self.get()

-

-        self.assertEqual(resp['listeners'], {"*:7080":{"application":"app"}},

-            'put listeners')

-

-        self.assertEqual(resp['applications'],

-            {

-                "app": {

-                    "type": "php",

-                    "workers": 1,

-                    "root": "/app",

-                    "index": "index.php"

-                }

-            },

-            'put applications')

-

-        self.put('/listeners', '{"*:7081":{"application":"app"}}')

-        self.assertEqual(self.get('/listeners'),

-            {"*:7081": {"application":"app"}}, 'put listeners prefix')

-

-        self.put('/listeners/*:7082', '{"application":"app"}')

-

-        self.assertEqual(self.get('/listeners'),

-            {

-                "*:7081": {

-                    "application": "app"

-                },

-                "*:7082": {

-                    "application": "app"

-                }

-            },

-            'put listeners prefix 3')

-

-        self.put('/applications/app/workers', '30')

-        self.assertEqual(self.get('/applications/app/workers'), 30,

-            'put applications workers')

-

-        self.put('/applications/app/root', '"/www"')

-        self.assertEqual(self.get('/applications/app/root'), '/www',

-            'put applications root')

-

-    def test_php_delete(self):

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "php",

-                        "workers": 1,

-                        "root": "/app",

-                        "index": "index.php"

-                    }

-                }

-            }

-            """)

-

-        self.assertIn('error', self.delete('/applications/app'),

-            'delete app before listener')

-        self.assertIn('success', self.delete('/listeners/*:7080'),

-            'delete listener')

-        self.assertIn('success', self.delete('/applications/app'),

-            'delete app after listener')

-        self.assertIn('error', self.delete('/applications/app'),

-            'delete app again')

-

-if __name__ == '__main__':

-    unittest.main()

+import unittest
+import unit
+
+class TestUnitBasic(unit.TestUnitControl):
+
+    def setUpClass():
+        unit.TestUnit().check_modules('php')
+
+    def test_php_get(self):
+        resp = self.get()
+        self.assertEqual(resp, {'listeners': {}, 'applications': {}}, 'empty')
+        self.assertEqual(self.get('/listeners'), {}, 'empty listeners prefix')
+        self.assertEqual(self.get('/applications'), {},
+            'empty applications prefix')
+
+        self.put('/applications', """
+            {
+                "app": {
+                    "type": "php",
+                    "workers": 1,
+                    "root": "/app",
+                    "index": "index.php"
+                }
+            }
+            """)
+
+        resp = self.get()
+
+        self.assertEqual(resp['listeners'], {}, 'php empty listeners')
+        self.assertEqual(resp['applications'],
+            {
+                "app": {
+                    "type": "php",
+                    "workers": 1,
+                    "root": "/app",
+                    "index": "index.php"
+                }
+             },
+             'php applications')
+
+        self.assertEqual(self.get('/applications'),
+            {
+                "app": {
+                    "type": "php",
+                    "workers": 1,
+                    "root": "/app",
+                    "index": "index.php"
+                }
+            },
+            'php applications prefix')
+
+        self.assertEqual(self.get('/applications/app'),
+            {
+                "type": "php",
+                "workers": 1,
+                "root": "/app",
+                "index": "index.php"
+            },
+            'php applications prefix 2')
+
+        self.assertEqual(self.get('/applications/app/type'), 'php',
+            'php applications type')
+        self.assertEqual(self.get('/applications/app/workers'), 1,
+            'php applications workers')
+
+        self.put('/listeners', '{"*:7080":{"application":"app"}}')
+
+        self.assertEqual(self.get()['listeners'],
+            {"*:7080":{"application":"app"}}, 'php listeners')
+        self.assertEqual(self.get('/listeners'),
+            {"*:7080":{"application":"app"}}, 'php listeners prefix')
+        self.assertEqual(self.get('/listeners/*:7080'),
+            {"application":"app"}, 'php listeners prefix 2')
+        self.assertEqual(self.get('/listeners/*:7080/application'), 'app',
+            'php listeners application')
+
+    def test_php_put(self):
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "php",
+                        "workers": 1,
+                        "root": "/app",
+                        "index": "index.php"
+                    }
+                }
+            }
+            """)
+
+        resp = self.get()
+
+        self.assertEqual(resp['listeners'], {"*:7080":{"application":"app"}},
+            'put listeners')
+
+        self.assertEqual(resp['applications'],
+            {
+                "app": {
+                    "type": "php",
+                    "workers": 1,
+                    "root": "/app",
+                    "index": "index.php"
+                }
+            },
+            'put applications')
+
+        self.put('/listeners', '{"*:7081":{"application":"app"}}')
+        self.assertEqual(self.get('/listeners'),
+            {"*:7081": {"application":"app"}}, 'put listeners prefix')
+
+        self.put('/listeners/*:7082', '{"application":"app"}')
+
+        self.assertEqual(self.get('/listeners'),
+            {
+                "*:7081": {
+                    "application": "app"
+                },
+                "*:7082": {
+                    "application": "app"
+                }
+            },
+            'put listeners prefix 3')
+
+        self.put('/applications/app/workers', '30')
+        self.assertEqual(self.get('/applications/app/workers'), 30,
+            'put applications workers')
+
+        self.put('/applications/app/root', '"/www"')
+        self.assertEqual(self.get('/applications/app/root'), '/www',
+            'put applications root')
+
+    def test_php_delete(self):
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "php",
+                        "workers": 1,
+                        "root": "/app",
+                        "index": "index.php"
+                    }
+                }
+            }
+            """)
+
+        self.assertIn('error', self.delete('/applications/app'),
+            'delete app before listener')
+        self.assertIn('success', self.delete('/listeners/*:7080'),
+            'delete listener')
+        self.assertIn('success', self.delete('/applications/app'),
+            'delete app after listener')
+        self.assertIn('error', self.delete('/applications/app'),
+            'delete app again')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_python_application.py b/test/test_python_application.py
index 5066624a..7014036b 100644
--- a/test/test_python_application.py
+++ b/test/test_python_application.py
@@ -1,90 +1,90 @@
-import unittest

-import unit

-

-class TestUnitApplication(unit.TestUnitControl):

-

-    def setUpClass():

-        u = unit.TestUnit()

-

-        u.check_modules('python')

-        u.check_version('0.4')

-

-    def test_python_application(self):

-        code, name = """

-

-def application(environ, start_response):

-

-    content_length = int(environ.get('CONTENT_LENGTH', 0))

-    body = bytes(environ['wsgi.input'].read(content_length))

-

-    start_response('200 OK', [

-        ('Content-Type', environ.get('CONTENT_TYPE')),

-        ('Content-Length', str(len(body))),

-        ('Request-Method', environ.get('REQUEST_METHOD')),

-        ('Request-Uri', environ.get('REQUEST_URI')),

-        ('Path-Info', environ.get('PATH_INFO')),

-        ('Http-Host', environ.get('HTTP_HOST')),

-        ('Remote-Addr', environ.get('REMOTE_ADDR')),

-        ('Server-Name', environ.get('SERVER_NAME')),

-        ('Server-Port', environ.get('SERVER_PORT')),

-        ('Server-Protocol', environ.get('SERVER_PROTOCOL')),

-        ('Custom-Header', environ.get('HTTP_CUSTOM_HEADER'))

-    ])

-    return [body]

-

-""", 'py_app'

-

-        self.python_application(name, code)

-

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "python",

-                        "workers": 1,

-                        "path": "%s",

-                        "module": "wsgi"

-                    }

-                }

-            }

-            """ % (self.testdir + '/' + name))

-

-        body = 'Test body string.'

-

-        r = unit.TestUnitHTTP.post(headers={

-            'Host': 'localhost',

-            'Content-Type': 'text/html',

-            'Custom-Header': 'blah'

-        }, data=body)

-

-        self.assertEqual(r.status_code, 200, 'status')

-        self.assertEqual(r.headers['Content-Length'], str(len(body)),

-            'header content length')

-        self.assertEqual(r.headers['Content-Type'], 'text/html',

-            'header content type')

-        self.assertEqual(r.headers['Request-Method'], 'POST',

-            'header request method')

-        self.assertEqual(r.headers['Request-Uri'], '/', 'header request uri')

-        self.assertEqual(r.headers['Path-Info'], '/', 'header path info')

-        self.assertEqual(r.headers['Http-Host'], 'localhost',

-            'header http host')

-        self.assertEqual(r.headers['Remote-Addr'], '127.0.0.1',

-            'header remote addr')

-

-        self.assertTry('assertEqual', 'header server port',

-            r.headers['Server-Port'], '7080')

-

-        self.assertEqual(r.headers['Server-Protocol'], 'HTTP/1.1',

-            'header server protocol')

-        self.assertEqual(r.headers['Custom-Header'], 'blah',

-            'header custom header')

-        self.assertEqual(r.content, str.encode(body), 'body')

-

-

-if __name__ == '__main__':

-    unittest.main()

+import unittest
+import unit
+
+class TestUnitApplication(unit.TestUnitControl):
+
+    def setUpClass():
+        u = unit.TestUnit()
+
+        u.check_modules('python')
+        u.check_version('0.4')
+
+    def test_python_application(self):
+        code, name = """
+
+def application(environ, start_response):
+
+    content_length = int(environ.get('CONTENT_LENGTH', 0))
+    body = bytes(environ['wsgi.input'].read(content_length))
+
+    start_response('200 OK', [
+        ('Content-Type', environ.get('CONTENT_TYPE')),
+        ('Content-Length', str(len(body))),
+        ('Request-Method', environ.get('REQUEST_METHOD')),
+        ('Request-Uri', environ.get('REQUEST_URI')),
+        ('Path-Info', environ.get('PATH_INFO')),
+        ('Http-Host', environ.get('HTTP_HOST')),
+        ('Remote-Addr', environ.get('REMOTE_ADDR')),
+        ('Server-Name', environ.get('SERVER_NAME')),
+        ('Server-Port', environ.get('SERVER_PORT')),
+        ('Server-Protocol', environ.get('SERVER_PROTOCOL')),
+        ('Custom-Header', environ.get('HTTP_CUSTOM_HEADER'))
+    ])
+    return [body]
+
+""", 'py_app'
+
+        self.python_application(name, code)
+
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "python",
+                        "workers": 1,
+                        "path": "%s",
+                        "module": "wsgi"
+                    }
+                }
+            }
+            """ % (self.testdir + '/' + name))
+
+        body = 'Test body string.'
+
+        r = unit.TestUnitHTTP.post(headers={
+            'Host': 'localhost',
+            'Content-Type': 'text/html',
+            'Custom-Header': 'blah'
+        }, data=body)
+
+        self.assertEqual(r.status_code, 200, 'status')
+        self.assertEqual(r.headers['Content-Length'], str(len(body)),
+            'header content length')
+        self.assertEqual(r.headers['Content-Type'], 'text/html',
+            'header content type')
+        self.assertEqual(r.headers['Request-Method'], 'POST',
+            'header request method')
+        self.assertEqual(r.headers['Request-Uri'], '/', 'header request uri')
+        self.assertEqual(r.headers['Path-Info'], '/', 'header path info')
+        self.assertEqual(r.headers['Http-Host'], 'localhost',
+            'header http host')
+        self.assertEqual(r.headers['Remote-Addr'], '127.0.0.1',
+            'header remote addr')
+
+        self.assertTry('assertEqual', 'header server port',
+            r.headers['Server-Port'], '7080')
+
+        self.assertEqual(r.headers['Server-Protocol'], 'HTTP/1.1',
+            'header server protocol')
+        self.assertEqual(r.headers['Custom-Header'], 'blah',
+            'header custom header')
+        self.assertEqual(r.content, str.encode(body), 'body')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_python_atexit.py b/test/test_python_atexit.py
index 28b6f67b..be45d113 100644
--- a/test/test_python_atexit.py
+++ b/test/test_python_atexit.py
@@ -1,65 +1,65 @@
-import os

-import time

-import unittest

-import unit

-

-class TestUnitApplication(unit.TestUnitControl):

-

-    def setUpClass():

-        u = unit.TestUnit()

-

-        u.check_modules('python')

-        u.check_version('0.3')

-

-    def test_python_application(self):

-        code, name = """

-import atexit

-

-def create_file():

-    open('%s', 'w')

-

-atexit.register(create_file)

-

-def application(env, start_response):

-    start_response('200 OK', [('Content-Type','text/html')])

-    return [b'body']

-

-""" % (self.testdir + '/atexit'), 'py_app'

-

-        self.python_application(name, code)

-

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "python",

-                        "workers": 1,

-                        "path": "%s",

-                        "module": "wsgi"

-                    }

-                }

-            }

-            """ % (self.testdir + '/' + name))

-

-        unit.TestUnitHTTP.get()

-

-        self.put('/', """

-            {

-                "listeners": {},

-                "applications": {}

-            }

-            """)

-

-        time.sleep(0.2)

-

-        self.assertEqual(os.path.exists(self.testdir + '/atexit'), True,

-            'python atexit')

-

-

-if __name__ == '__main__':

-    unittest.main()

+import os
+import time
+import unittest
+import unit
+
+class TestUnitApplication(unit.TestUnitControl):
+
+    def setUpClass():
+        u = unit.TestUnit()
+
+        u.check_modules('python')
+        u.check_version('0.3')
+
+    def test_python_application(self):
+        code, name = """
+import atexit
+
+def create_file():
+    open('%s', 'w')
+
+atexit.register(create_file)
+
+def application(env, start_response):
+    start_response('200 OK', [('Content-Type','text/html')])
+    return [b'body']
+
+""" % (self.testdir + '/atexit'), 'py_app'
+
+        self.python_application(name, code)
+
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "python",
+                        "workers": 1,
+                        "path": "%s",
+                        "module": "wsgi"
+                    }
+                }
+            }
+            """ % (self.testdir + '/' + name))
+
+        unit.TestUnitHTTP.get()
+
+        self.put('/', """
+            {
+                "listeners": {},
+                "applications": {}
+            }
+            """)
+
+        time.sleep(0.2)
+
+        self.assertEqual(os.path.exists(self.testdir + '/atexit'), True,
+            'python atexit')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_python_basic.py b/test/test_python_basic.py
index a68f1bad..00460712 100644
--- a/test/test_python_basic.py
+++ b/test/test_python_basic.py
@@ -1,166 +1,166 @@
-import unittest

-import unit

-

-class TestUnitBasic(unit.TestUnitControl):

-

-    def setUpClass():

-        unit.TestUnit().check_modules('python')

-

-    def test_python_get(self):

-        resp = self.get()

-        self.assertEqual(resp, {'listeners': {}, 'applications': {}}, 'empty')

-        self.assertEqual(self.get('/listeners'), {}, 'empty listeners prefix')

-        self.assertEqual(self.get('/applications'), {},

-            'empty applications prefix')

-

-        self.put('/applications', """

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            }

-            """)

-

-        resp = self.get()

-

-        self.assertEqual(resp['listeners'], {}, 'python empty listeners')

-        self.assertEqual(resp['applications'],

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-             },

-             'python applications')

-

-        self.assertEqual(self.get('/applications'),

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module":"wsgi"

-                }

-            },

-            'python applications prefix')

-

-        self.assertEqual(self.get('/applications/app'),

-            {

-                "type": "python",

-                "workers": 1,

-                "path": "/app",

-                "module": "wsgi"

-            },

-            'python applications prefix 2')

-

-        self.assertEqual(self.get('/applications/app/type'), 'python',

-            'python applications type')

-        self.assertEqual(self.get('/applications/app/workers'), 1,

-            'python applications workers')

-

-        self.put('/listeners', '{"*:7080":{"application":"app"}}')

-

-        self.assertEqual(self.get()['listeners'],

-            {"*:7080":{"application":"app"}}, 'python listeners')

-        self.assertEqual(self.get('/listeners'),

-            {"*:7080":{"application":"app"}}, 'python listeners prefix')

-        self.assertEqual(self.get('/listeners/*:7080'),

-            {"application":"app"}, 'python listeners prefix 2')

-        self.assertEqual(self.get('/listeners/*:7080/application'), 'app',

-            'python listeners application')

-

-    def test_python_put(self):

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "python",

-                        "workers": 1,

-                        "path": "/app",

-                        "module": "wsgi"

-                    }

-                }

-            }

-            """)

-

-        resp = self.get()

-

-        self.assertEqual(resp['listeners'], {"*:7080":{"application":"app"}},

-            'put listeners')

-

-        self.assertEqual(resp['applications'],

-            {

-                "app": {

-                    "type": "python",

-                    "workers": 1,

-                    "path": "/app",

-                    "module": "wsgi"

-                }

-            },

-            'put applications')

-

-        self.put('/listeners', '{"*:7081":{"application":"app"}}')

-        self.assertEqual(self.get('/listeners'),

-            {"*:7081": {"application":"app"}}, 'put listeners prefix')

-

-        self.put('/listeners/*:7082', '{"application":"app"}')

-

-        self.assertEqual(self.get('/listeners'),

-            {

-                "*:7081": {

-                    "application": "app"

-                },

-                "*:7082": {

-                    "application": "app"

-                }

-            },

-            'put listeners prefix 3')

-

-        self.put('/applications/app/workers', '30')

-        self.assertEqual(self.get('/applications/app/workers'), 30,

-            'put applications workers')

-

-        self.put('/applications/app/path', '"/www"')

-        self.assertEqual(self.get('/applications/app/path'), '/www',

-            'put applications path')

-

-    def test_python_delete(self):

-        self.put('/', """

-            {

-                "listeners": {

-                    "*:7080": {

-                        "application": "app"

-                    }

-                },

-                "applications": {

-                    "app": {

-                        "type": "python",

-                        "workers": 1,

-                        "path": "/app",

-                        "module": "wsgi"

-                    }

-                }

-            }

-            """)

-

-        self.assertIn('error', self.delete('/applications/app'),

-            'delete app before listener')

-        self.assertIn('success', self.delete('/listeners/*:7080'),

-            'delete listener')

-        self.assertIn('success', self.delete('/applications/app'),

-            'delete app after listener')

-        self.assertIn('error', self.delete('/applications/app'),

-            'delete app again')

-

-if __name__ == '__main__':

-    unittest.main()

+import unittest
+import unit
+
+class TestUnitBasic(unit.TestUnitControl):
+
+    def setUpClass():
+        unit.TestUnit().check_modules('python')
+
+    def test_python_get(self):
+        resp = self.get()
+        self.assertEqual(resp, {'listeners': {}, 'applications': {}}, 'empty')
+        self.assertEqual(self.get('/listeners'), {}, 'empty listeners prefix')
+        self.assertEqual(self.get('/applications'), {},
+            'empty applications prefix')
+
+        self.put('/applications', """
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            }
+            """)
+
+        resp = self.get()
+
+        self.assertEqual(resp['listeners'], {}, 'python empty listeners')
+        self.assertEqual(resp['applications'],
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+             },
+             'python applications')
+
+        self.assertEqual(self.get('/applications'),
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module":"wsgi"
+                }
+            },
+            'python applications prefix')
+
+        self.assertEqual(self.get('/applications/app'),
+            {
+                "type": "python",
+                "workers": 1,
+                "path": "/app",
+                "module": "wsgi"
+            },
+            'python applications prefix 2')
+
+        self.assertEqual(self.get('/applications/app/type'), 'python',
+            'python applications type')
+        self.assertEqual(self.get('/applications/app/workers'), 1,
+            'python applications workers')
+
+        self.put('/listeners', '{"*:7080":{"application":"app"}}')
+
+        self.assertEqual(self.get()['listeners'],
+            {"*:7080":{"application":"app"}}, 'python listeners')
+        self.assertEqual(self.get('/listeners'),
+            {"*:7080":{"application":"app"}}, 'python listeners prefix')
+        self.assertEqual(self.get('/listeners/*:7080'),
+            {"application":"app"}, 'python listeners prefix 2')
+        self.assertEqual(self.get('/listeners/*:7080/application'), 'app',
+            'python listeners application')
+
+    def test_python_put(self):
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "python",
+                        "workers": 1,
+                        "path": "/app",
+                        "module": "wsgi"
+                    }
+                }
+            }
+            """)
+
+        resp = self.get()
+
+        self.assertEqual(resp['listeners'], {"*:7080":{"application":"app"}},
+            'put listeners')
+
+        self.assertEqual(resp['applications'],
+            {
+                "app": {
+                    "type": "python",
+                    "workers": 1,
+                    "path": "/app",
+                    "module": "wsgi"
+                }
+            },
+            'put applications')
+
+        self.put('/listeners', '{"*:7081":{"application":"app"}}')
+        self.assertEqual(self.get('/listeners'),
+            {"*:7081": {"application":"app"}}, 'put listeners prefix')
+
+        self.put('/listeners/*:7082', '{"application":"app"}')
+
+        self.assertEqual(self.get('/listeners'),
+            {
+                "*:7081": {
+                    "application": "app"
+                },
+                "*:7082": {
+                    "application": "app"
+                }
+            },
+            'put listeners prefix 3')
+
+        self.put('/applications/app/workers', '30')
+        self.assertEqual(self.get('/applications/app/workers'), 30,
+            'put applications workers')
+
+        self.put('/applications/app/path', '"/www"')
+        self.assertEqual(self.get('/applications/app/path'), '/www',
+            'put applications path')
+
+    def test_python_delete(self):
+        self.put('/', """
+            {
+                "listeners": {
+                    "*:7080": {
+                        "application": "app"
+                    }
+                },
+                "applications": {
+                    "app": {
+                        "type": "python",
+                        "workers": 1,
+                        "path": "/app",
+                        "module": "wsgi"
+                    }
+                }
+            }
+            """)
+
+        self.assertIn('error', self.delete('/applications/app'),
+            'delete app before listener')
+        self.assertIn('success', self.delete('/listeners/*:7080'),
+            'delete listener')
+        self.assertIn('success', self.delete('/applications/app'),
+            'delete app after listener')
+        self.assertIn('error', self.delete('/applications/app'),
+            'delete app again')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/unit.py b/test/unit.py
index 86ff308d..87fbd029 100644
--- a/test/unit.py
+++ b/test/unit.py
@@ -1,236 +1,236 @@
-import os

-import re

-import sys

-import json

-import time

-import shutil

-import socket

-import tempfile

-import unittest

-from requests import Request, Session

-from subprocess import call

-from multiprocessing import Process

-

-class TestUnit(unittest.TestCase):

-

-    pardir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))

-

-    def setUp(self):

-        self._run()

-

-    def tearDown(self):

-        self._stop()

-

-        if '--log' in sys.argv:

-            with open(self.testdir + '/unit.log', 'r') as f:

-                print(f.read())

-

-        if '--leave' not in sys.argv:

-            shutil.rmtree(self.testdir)

-

-    def assertTry(self, assert_method, description, *args):

-        try: getattr(self, assert_method)(*args, msg=description)

-        except AssertionError: print('not yet: ' + description)

-

-    def check_modules(self, *modules):

-        self._run()

-

-        for i in range(50):

-            with open(self.testdir + '/unit.log', 'r') as f:

-                log = f.read()

-                m = re.search('controller started', log, re.M | re.S)

-

-                if m is None:

-                    time.sleep(0.1)

-                else:

-                    break

-

-        if m is None:

-            exit("Unit is writing log too long")

-

-        missed_module = ''

-        for module in modules:

-            m = re.search('module: ' + module, log, re.M | re.S)

-            if m is None:

-                missed_module = module

-                break

-

-        self._stop()

-        shutil.rmtree(self.testdir)

-

-        if missed_module:

-            raise unittest.SkipTest('Unit has no ' + missed_module + ' module')

-

-    def check_version(self, version):

-        with open(self.pardir + '/src/nxt_main.h' , 'r') as f:

-            m = re.search('NXT_VERSION\s+"(\d+\.\d+)"', f.read(), re.M | re.S)

-

-            current = m.group(1).split('.')

-            need = version.split('.')

-

-            for i in range(len(need)):

-                if need[i] > current[i]:

-                    raise unittest.SkipTest('Unit too old')

-

-    def _run(self):

-        self.testdir = tempfile.mkdtemp(prefix='unit-test-')

-

-        os.mkdir(self.testdir + '/state')

-

-        print()

-

-        def _run_unit():

-            call([self.pardir + '/build/unitd',

-                '--no-daemon',

-                '--modules', self.pardir + '/build',

-                '--state', self.testdir + '/state',

-                '--pid', self.testdir + '/unit.pid',

-                '--log', self.testdir + '/unit.log',

-                '--control', 'unix:' + self.testdir + '/control.unit.sock'])

-

-        self._p = Process(target=_run_unit)

-        self._p.start()

-

-        if not self._waitforfiles(self.testdir + '/unit.pid',

-            self.testdir + '/unit.log', self.testdir + '/control.unit.sock'):

-            exit("Could not start unit")

-

-    def python_application(self, name, code):

-        os.mkdir(self.testdir + '/' + name)

-

-        with open(self.testdir + '/' + name + '/wsgi.py', 'w') as f:

-            f.write(code)

-

-    def _stop(self):

-        with open(self.testdir + '/unit.pid', 'r') as f:

-            pid = f.read().rstrip()

-

-        call(['kill', pid])

-

-        for i in range(50):

-            if not os.path.exists(self.testdir + '/unit.pid'):

-                break

-            time.sleep(0.1)

-

-        if os.path.exists(self.testdir + '/unit.pid'):

-            exit("Could not terminate unit")

-

-        self._p.join(timeout=1)

-        self._terminate_process(self._p)

-

-    def _terminate_process(self, process):

-        if process.is_alive():

-            process.terminate()

-            process.join(timeout=5)

-

-            if process.is_alive():

-                exit("Could not terminate process " + process.pid)

-

-        if process.exitcode:

-            exit("Child process terminated with code " + str(process.exitcode))

-

-    def _waitforfiles(self, *files):

-        for i in range(50):

-            wait = False

-            ret = 0

-

-            for f in files:

-                if not os.path.exists(f):

-                   wait = True

-                   break

-

-            if wait:

-                time.sleep(0.1)

-

-            else:

-                ret = 1

-                break

-

-        return ret

-

-class TestUnitControl(TestUnit):

-

-    # TODO socket reuse

-    # TODO http client

-

-    def http(self, req):

-        with self._control_sock() as sock:

-            sock.sendall(req)

-

-            if '--verbose' in sys.argv:

-                print('>>>', req, sep='\n')

-

-            resp = self._recvall(sock)

-

-            if '--verbose' in sys.argv:

-                print('<<<', resp, sep='\n')

-

-        return resp

-

-    def get(self, path='/'):

-        resp = self.http(('GET ' + path

-            + ' HTTP/1.1\r\nHost: localhost\r\n\r\n').encode())

-

-        return self._body_json(resp)

-

-    def delete(self, path='/'):

-        resp = self.http(('DELETE ' + path

-            + ' HTTP/1.1\r\nHost: localhost\r\n\r\n').encode())

-

-        return self._body_json(resp)

-

-    def put(self, path='/', data=''):

-        if isinstance(data, str):

-            data = data.encode()

-

-        resp = self.http(('PUT ' + path + ' HTTP/1.1\nHost: localhost\n'

-            + 'Content-Length: ' + str(len(data))

-            + '\r\n\r\n').encode() + data)

-

-        return self._body_json(resp)

-

-    def _control_sock(self):

-        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

-        sock.connect(self.testdir + '/control.unit.sock')

-        return sock

-

-    def _recvall(self, sock, buff_size=4096):

-        data = ''

-        while True:

-            part = sock.recv(buff_size).decode()

-            data += part

-            if len(part) < buff_size:

-                break

-

-        return data

-

-    def _body_json(self, resp):

-        m = re.search('.*?\x0d\x0a?\x0d\x0a?(.*)', resp, re.M | re.S)

-        return json.loads(m.group(1))

-

-class TestUnitHTTP():

-

-    @classmethod

-    def http(self, method, **kwargs):

-        host = '127.0.0.1:7080' if 'host' not in kwargs else kwargs['host']

-        uri = '/' if 'uri' not in kwargs else kwargs['uri']

-        sess = Session() if 'sess' not in kwargs else kwargs['sess']

-        data = None if 'data' not in kwargs else kwargs['data']

-        headers = None if 'headers' not in kwargs else kwargs['headers']

-

-        req = Request(method, 'http://' + host + uri, data=data,

-            headers=headers)

-

-        r = sess.send(req.prepare())

-

-        if 'keep' not in kwargs:

-            sess.close()

-            return r

-

-        return (r, sess)

-

-    def get(**kwargs):

-        return TestUnitHTTP.http('GET', **kwargs)

-

-    def post(**kwargs):

-        return TestUnitHTTP.http('POST', **kwargs)

+import os
+import re
+import sys
+import json
+import time
+import shutil
+import socket
+import tempfile
+import unittest
+from requests import Request, Session
+from subprocess import call
+from multiprocessing import Process
+
+class TestUnit(unittest.TestCase):
+
+    pardir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
+
+    def setUp(self):
+        self._run()
+
+    def tearDown(self):
+        self._stop()
+
+        if '--log' in sys.argv:
+            with open(self.testdir + '/unit.log', 'r') as f:
+                print(f.read())
+
+        if '--leave' not in sys.argv:
+            shutil.rmtree(self.testdir)
+
+    def assertTry(self, assert_method, description, *args):
+        try: getattr(self, assert_method)(*args, msg=description)
+        except AssertionError: print('not yet: ' + description)
+
+    def check_modules(self, *modules):
+        self._run()
+
+        for i in range(50):
+            with open(self.testdir + '/unit.log', 'r') as f:
+                log = f.read()
+                m = re.search('controller started', log, re.M | re.S)
+
+                if m is None:
+                    time.sleep(0.1)
+                else:
+                    break
+
+        if m is None:
+            exit("Unit is writing log too long")
+
+        missed_module = ''
+        for module in modules:
+            m = re.search('module: ' + module, log, re.M | re.S)
+            if m is None:
+                missed_module = module
+                break
+
+        self._stop()
+        shutil.rmtree(self.testdir)
+
+        if missed_module:
+            raise unittest.SkipTest('Unit has no ' + missed_module + ' module')
+
+    def check_version(self, version):
+        with open(self.pardir + '/src/nxt_main.h' , 'r') as f:
+            m = re.search('NXT_VERSION\s+"(\d+\.\d+)"', f.read(), re.M | re.S)
+
+            current = m.group(1).split('.')
+            need = version.split('.')
+
+            for i in range(len(need)):
+                if need[i] > current[i]:
+                    raise unittest.SkipTest('Unit too old')
+
+    def _run(self):
+        self.testdir = tempfile.mkdtemp(prefix='unit-test-')
+
+        os.mkdir(self.testdir + '/state')
+
+        print()
+
+        def _run_unit():
+            call([self.pardir + '/build/unitd',
+                '--no-daemon',
+                '--modules', self.pardir + '/build',
+                '--state', self.testdir + '/state',
+                '--pid', self.testdir + '/unit.pid',
+                '--log', self.testdir + '/unit.log',
+                '--control', 'unix:' + self.testdir + '/control.unit.sock'])
+
+        self._p = Process(target=_run_unit)
+        self._p.start()
+
+        if not self._waitforfiles(self.testdir + '/unit.pid',
+            self.testdir + '/unit.log', self.testdir + '/control.unit.sock'):
+            exit("Could not start unit")
+
+    def python_application(self, name, code):
+        os.mkdir(self.testdir + '/' + name)
+
+        with open(self.testdir + '/' + name + '/wsgi.py', 'w') as f:
+            f.write(code)
+
+    def _stop(self):
+        with open(self.testdir + '/unit.pid', 'r') as f:
+            pid = f.read().rstrip()
+
+        call(['kill', pid])
+
+        for i in range(50):
+            if not os.path.exists(self.testdir + '/unit.pid'):
+                break
+            time.sleep(0.1)
+
+        if os.path.exists(self.testdir + '/unit.pid'):
+            exit("Could not terminate unit")
+
+        self._p.join(timeout=1)
+        self._terminate_process(self._p)
+
+    def _terminate_process(self, process):
+        if process.is_alive():
+            process.terminate()
+            process.join(timeout=5)
+
+            if process.is_alive():
+                exit("Could not terminate process " + process.pid)
+
+        if process.exitcode:
+            exit("Child process terminated with code " + str(process.exitcode))
+
+    def _waitforfiles(self, *files):
+        for i in range(50):
+            wait = False
+            ret = 0
+
+            for f in files:
+                if not os.path.exists(f):
+                   wait = True
+                   break
+
+            if wait:
+                time.sleep(0.1)
+
+            else:
+                ret = 1
+                break
+
+        return ret
+
+class TestUnitControl(TestUnit):
+
+    # TODO socket reuse
+    # TODO http client
+
+    def http(self, req):
+        with self._control_sock() as sock:
+            sock.sendall(req)
+
+            if '--verbose' in sys.argv:
+                print('>>>', req, sep='\n')
+
+            resp = self._recvall(sock)
+
+            if '--verbose' in sys.argv:
+                print('<<<', resp, sep='\n')
+
+        return resp
+
+    def get(self, path='/'):
+        resp = self.http(('GET ' + path
+            + ' HTTP/1.1\r\nHost: localhost\r\n\r\n').encode())
+
+        return self._body_json(resp)
+
+    def delete(self, path='/'):
+        resp = self.http(('DELETE ' + path
+            + ' HTTP/1.1\r\nHost: localhost\r\n\r\n').encode())
+
+        return self._body_json(resp)
+
+    def put(self, path='/', data=''):
+        if isinstance(data, str):
+            data = data.encode()
+
+        resp = self.http(('PUT ' + path + ' HTTP/1.1\nHost: localhost\n'
+            + 'Content-Length: ' + str(len(data))
+            + '\r\n\r\n').encode() + data)
+
+        return self._body_json(resp)
+
+    def _control_sock(self):
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect(self.testdir + '/control.unit.sock')
+        return sock
+
+    def _recvall(self, sock, buff_size=4096):
+        data = ''
+        while True:
+            part = sock.recv(buff_size).decode()
+            data += part
+            if len(part) < buff_size:
+                break
+
+        return data
+
+    def _body_json(self, resp):
+        m = re.search('.*?\x0d\x0a?\x0d\x0a?(.*)', resp, re.M | re.S)
+        return json.loads(m.group(1))
+
+class TestUnitHTTP():
+
+    @classmethod
+    def http(self, method, **kwargs):
+        host = '127.0.0.1:7080' if 'host' not in kwargs else kwargs['host']
+        uri = '/' if 'uri' not in kwargs else kwargs['uri']
+        sess = Session() if 'sess' not in kwargs else kwargs['sess']
+        data = None if 'data' not in kwargs else kwargs['data']
+        headers = None if 'headers' not in kwargs else kwargs['headers']
+
+        req = Request(method, 'http://' + host + uri, data=data,
+            headers=headers)
+
+        r = sess.send(req.prepare())
+
+        if 'keep' not in kwargs:
+            sess.close()
+            return r
+
+        return (r, sess)
+
+    def get(**kwargs):
+        return TestUnitHTTP.http('GET', **kwargs)
+
+    def post(**kwargs):
+        return TestUnitHTTP.http('POST', **kwargs)