Tests: style.

1 files changed, 235 insertions, 165 deletions

diff --git a/test/test_configuration.py b/test/test_configuration.py
index 20c5fc8b..4848f741 100644
--- a/test/test_configuration.py
+++ b/test/test_configuration.py
@@ -1,8 +1,8 @@
 import unittest
 import unit
 
-class TestUnitConfiguration(unit.TestUnitControl):
 
+class TestUnitConfiguration(unit.TestUnitControl):
     def setUpClass():
         unit.TestUnit().check_modules('python')
 
@@ -13,7 +13,10 @@ class TestUnitConfiguration(unit.TestUnitControl):
         self.assertIn('error', self.conf('00'), 'leading zero')
 
     def test_json_unicode(self):
-        self.assertIn('success', self.conf(b"""
+        self.assertIn(
+            'success',
+            self.conf(
+                b"""
             {
                 "ap\u0070": {
                     "type": "\u0070ython",
@@ -22,32 +25,51 @@ class TestUnitConfiguration(unit.TestUnitControl):
                     "module": "wsgi"
                 }
             }
-            """, 'applications'), 'unicode')
-
-        self.assertDictEqual(self.conf_get('applications'), {
-            "app": {
-                "type": "python",
-                "processes": { "spare": 0 },
-                "path": "/app",
-                "module": "wsgi"
-            }
-        }, 'unicode get')
+            """,
+                'applications',
+            ),
+            'unicode',
+        )
+
+        self.assertDictEqual(
+            self.conf_get('applications'),
+            {
+                "app": {
+                    "type": "python",
+                    "processes": {"spare": 0},
+                    "path": "/app",
+                    "module": "wsgi",
+                }
+            },
+            'unicode get',
+        )
 
     def test_json_unicode_2(self):
-        self.assertIn('success', self.conf({
-            "приложение": {
-                "type": "python",
-                "processes": { "spare": 0 },
-                "path": "/app",
-                "module": "wsgi"
-            }
-        }, 'applications'), 'unicode 2')
-
-        self.assertIn('приложение', self.conf_get('applications'),
-            'unicode 2 get')
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "приложение": {
+                        "type": "python",
+                        "processes": {"spare": 0},
+                        "path": "/app",
+                        "module": "wsgi",
+                    }
+                },
+                'applications',
+            ),
+            'unicode 2',
+        )
+
+        self.assertIn(
+            'приложение', self.conf_get('applications'), 'unicode 2 get'
+        )
 
     def test_json_unicode_number(self):
-        self.assertIn('error', self.conf(b"""
+        self.assertIn(
+            'error',
+            self.conf(
+                b"""
             {
                 "app": {
                     "type": "python",
@@ -56,7 +78,11 @@ class TestUnitConfiguration(unit.TestUnitControl):
                     "module": "wsgi"
                 }
             }
-            """, 'applications'), 'unicode number')
+            """,
+                'applications',
+            ),
+            'unicode number',
+        )
 
     def test_applications_open_brace(self):
         self.assertIn('error', self.conf('{', 'applications'), 'open brace')
@@ -65,20 +91,25 @@ class TestUnitConfiguration(unit.TestUnitControl):
         self.assertIn('error', self.conf('"{}"', 'applications'), 'string')
 
     def test_applications_type_only(self):
-        self.skip_alerts.extend([
-            r'python module is empty',
-            r'failed to apply new conf',
-            r'process \d+ exited on signal'
-        ])
-
-        self.assertIn('error', self.conf({
-            "app": {
-                "type": "python"
-            }
-        }, 'applications'), 'type only')
+        self.skip_alerts.extend(
+            [
+                r'python module is empty',
+                r'failed to apply new conf',
+                r'process \d+ exited on signal',
+            ]
+        )
+
+        self.assertIn(
+            'error',
+            self.conf({"app": {"type": "python"}}, 'applications'),
+            'type only',
+        )
 
     def test_applications_miss_quote(self):
-        self.assertIn('error', self.conf("""
+        self.assertIn(
+            'error',
+            self.conf(
+                """
             {
                 app": {
                     "type": "python",
@@ -87,10 +118,17 @@ class TestUnitConfiguration(unit.TestUnitControl):
                     "module": "wsgi"
                 }
             }
-            """, 'applications'), 'miss quote')
+            """,
+                'applications',
+            ),
+            'miss quote',
+        )
 
     def test_applications_miss_colon(self):
-        self.assertIn('error', self.conf("""
+        self.assertIn(
+            'error',
+            self.conf(
+                """
             {
                 "app" {
                     "type": "python",
@@ -99,10 +137,17 @@ class TestUnitConfiguration(unit.TestUnitControl):
                     "module": "wsgi"
                 }
             }
-            """, 'applications'), 'miss colon')
+            """,
+                'applications',
+            ),
+            'miss colon',
+        )
 
     def test_applications_miss_comma(self):
-        self.assertIn('error', self.conf("""
+        self.assertIn(
+            'error',
+            self.conf(
+                """
             {
                 "app": {
                     "type": "python"
@@ -111,181 +156,206 @@ class TestUnitConfiguration(unit.TestUnitControl):
                     "module": "wsgi"
                 }
             }
-            """, 'applications'), 'miss comma')
+            """,
+                'applications',
+            ),
+            'miss comma',
+        )
 
     def test_applications_skip_spaces(self):
-        self.assertIn('success', self.conf(b'{ \n\r\t}', 'applications'),
-            'skip spaces')
+        self.assertIn(
+            'success', self.conf(b'{ \n\r\t}', 'applications'), 'skip spaces'
+        )
 
     def test_applications_relative_path(self):
-        self.assertIn('success', self.conf({
-            "app": {
-                "type": "python",
-                "processes": { "spare": 0 },
-                "path": "../app",
-                "module": "wsgi"
-            }
-        }, 'applications'), 'relative path')
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "app": {
+                        "type": "python",
+                        "processes": {"spare": 0},
+                        "path": "../app",
+                        "module": "wsgi",
+                    }
+                },
+                'applications',
+            ),
+            'relative path',
+        )
 
     @unittest.expectedFailure
     def test_listeners_empty(self):
         self.skip_sanitizer = True
-        self.skip_alerts.extend([
-            r'failed to apply previous configuration',
-            r'process \d+ exited on signal'
-        ])
+        self.skip_alerts.extend(
+            [
+                r'failed to apply previous configuration',
+                r'process \d+ exited on signal',
+            ]
+        )
 
-        self.assertIn('error', self.conf({"*:7080":{}}, 'listeners'),
-            'listener empty')
+        self.assertIn(
+            'error', self.conf({"*:7080": {}}, 'listeners'), 'listener empty'
+        )
 
     def test_listeners_no_app(self):
-        self.assertIn('error', self.conf({"*:7080":{"application":"app"}},
-            'listeners'), 'listeners no app')
+        self.assertIn(
+            'error',
+            self.conf({"*:7080": {"application": "app"}}, 'listeners'),
+            'listeners no app',
+        )
 
     def test_listeners_wildcard(self):
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "*:7080": {
-                    "application":"app"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"*:7080": {"application": "app"}},
+                    "applications": {
+                        "app": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": "/app",
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            },
-            "applications": {
-                "app": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": "/app",
-                    "module": "wsgi"
-                }
-            }
-        }), 'listeners wildcard')
+            ),
+            'listeners wildcard',
+        )
 
     def test_listeners_explicit(self):
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "127.0.0.1:7080": {
-                    "application":"app"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"127.0.0.1:7080": {"application": "app"}},
+                    "applications": {
+                        "app": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": "/app",
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            },
-            "applications": {
-                "app": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": "/app",
-                    "module": "wsgi"
-                }
-            }
-        }), 'explicit')
+            ),
+            'explicit',
+        )
 
     def test_listeners_explicit_ipv6(self):
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "[::1]:7080": {
-                    "application":"app"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"[::1]:7080": {"application": "app"}},
+                    "applications": {
+                        "app": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": "/app",
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            },
-            "applications": {
-                "app": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": "/app",
-                    "module": "wsgi"
-                }
-            }
-        }), 'explicit ipv6')
+            ),
+            'explicit ipv6',
+        )
 
     def test_listeners_no_port(self):
-        self.skip_alerts.extend([
-            r'invalid listener "127\.0\.0\.1"',
-            r'failed to apply new conf',
-            r'process \d+ exited on signal'
-        ])
-
-        self.assertIn('error', self.conf({
-            "listeners": {
-                "127.0.0.1": {
-                    "application":"app"
+        self.skip_alerts.extend(
+            [
+                r'invalid listener "127\.0\.0\.1"',
+                r'failed to apply new conf',
+                r'process \d+ exited on signal',
+            ]
+        )
+
+        self.assertIn(
+            'error',
+            self.conf(
+                {
+                    "listeners": {"127.0.0.1": {"application": "app"}},
+                    "applications": {
+                        "app": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": "/app",
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            },
-            "applications": {
-                "app": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": "/app",
-                    "module": "wsgi"
-                }
-            }
-        }), 'no port')
+            ),
+            'no port',
+        )
 
     def test_json_application_name_large(self):
         name = "X" * 1024 * 1024
 
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "*:7080": {
-                    "application": name
-                }
-            },
-            "applications": {
-                name: {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": "/app",
-                    "module": "wsgi"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"*:7080": {"application": name}},
+                    "applications": {
+                        name: {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": "/app",
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            }
-        }))
+            ),
+        )
 
     @unittest.expectedFailure
     def test_json_application_many(self):
-        self.skip_alerts.extend([
-            r'eventfd.+failed',
-            r'epoll.+failed',
-            r'failed to apply'
-        ])
+        self.skip_alerts.extend(
+            [r'eventfd.+failed', r'epoll.+failed', r'failed to apply']
+        )
         apps = 999
 
         conf = {
-            "applications":
-                {"app-" + str(a): {
+            "applications": {
+                "app-"
+                + str(a): {
                     "type": "python",
-                    "processes": { "spare": 0 },
+                    "processes": {"spare": 0},
                     "path": "/app",
-                    "module": "wsgi"
-                } for a in range(apps)
+                    "module": "wsgi",
+                }
+                for a in range(apps)
             },
             "listeners": {
-                "*:" + str(7000 + a): {
-                    "application": "app-" + str(a)
-                } for a in range(apps)
-            }
+                "*:" + str(7000 + a): {"application": "app-" + str(a)}
+                for a in range(apps)
+            },
         }
 
         self.assertIn('success', self.conf(conf))
 
     def test_json_application_many2(self):
-        self.skip_alerts.extend([
-            r'eventfd.+failed',
-            r'epoll.+failed',
-            r'failed to apply'
-        ])
+        self.skip_alerts.extend(
+            [r'eventfd.+failed', r'epoll.+failed', r'failed to apply']
+        )
 
         conf = {
-            "applications":
-                {"app-" + str(a): {
+            "applications": {
+                "app-"
+                + str(a): {
                     "type": "python",
-                    "processes": { "spare": 0 },
+                    "processes": {"spare": 0},
                     "path": "/app",
-                    "module": "wsgi"
-                } for a in range(999)
-            },
-            "listeners": {
-                "*:7001": {
-                    "application": "app-1"
+                    "module": "wsgi",
                 }
-            }
+                for a in range(999)
+            },
+            "listeners": {"*:7001": {"application": "app-1"}},
         }
 
         self.assertIn('success', self.conf(conf))
 
+
 if __name__ == '__main__':
     TestUnitConfiguration.main()