Tests: style.

1 files changed, 648 insertions, 342 deletions

diff --git a/test/test_routing.py b/test/test_routing.py
index 07097fc8..b5c42576 100644
--- a/test/test_routing.py
+++ b/test/test_routing.py
@@ -1,458 +1,764 @@
 import unittest
 import unit
 
-class TestUnitRouting(unit.TestUnitApplicationProto):
 
+class TestUnitRouting(unit.TestUnitApplicationProto):
     def setUpClass():
         unit.TestUnit().check_modules('python')
 
     def setUp(self):
         super().setUp()
 
-        self.conf({
-            "listeners": {
-                "*:7080": {
-                    "pass": "routes"
-                }
-            },
-            "routes": [{
-                "match": { "method": "GET" },
-                "action": { "pass": "applications/empty" }
-            }],
-            "applications": {
-                "empty": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/empty',
-                    "working_directory": self.current_dir + '/python/empty',
-                    "module": "wsgi"
+        self.conf(
+            {
+                "listeners": {"*:7080": {"pass": "routes"}},
+                "routes": [
+                    {
+                        "match": {"method": "GET"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                "applications": {
+                    "empty": {
+                        "type": "python",
+                        "processes": {"spare": 0},
+                        "path": self.current_dir + '/python/empty',
+                        "working_directory": self.current_dir
+                        + '/python/empty',
+                        "module": "wsgi",
+                    },
+                    "mirror": {
+                        "type": "python",
+                        "processes": {"spare": 0},
+                        "path": self.current_dir + '/python/mirror',
+                        "working_directory": self.current_dir
+                        + '/python/mirror',
+                        "module": "wsgi",
+                    },
                 },
-                "mirror": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/mirror',
-                    "working_directory": self.current_dir + '/python/mirror',
-                    "module": "wsgi"
-                }
             }
-        })
+        )
 
     def test_routes_match_method_positive(self):
         self.assertEqual(self.get()['status'], 200, 'method positive GET')
         self.assertEqual(self.post()['status'], 404, 'method positive POST')
 
     def test_routes_match_method_positive_many(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": ["GET", "POST"] },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method positive many configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": ["GET", "POST"]},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method positive many configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'method positive many GET')
-        self.assertEqual(self.post()['status'], 200,
-            'method positive many POST')
-        self.assertEqual(self.delete()['status'], 404,
-            'method positive many DELETE')
+        self.assertEqual(
+            self.post()['status'], 200, 'method positive many POST'
+        )
+        self.assertEqual(
+            self.delete()['status'], 404, 'method positive many DELETE'
+        )
 
     def test_routes_match_method_negative(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "!GET" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method negative configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "!GET"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method negative configure',
+        )
 
         self.assertEqual(self.get()['status'], 404, 'method negative GET')
         self.assertEqual(self.post()['status'], 200, 'method negative POST')
 
     def test_routes_match_method_negative_many(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": ["!GET", "!POST"] },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method negative many configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": ["!GET", "!POST"]},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method negative many configure',
+        )
 
         self.assertEqual(self.get()['status'], 404, 'method negative many GET')
-        self.assertEqual(self.post()['status'], 404,
-            'method negative many POST')
-        self.assertEqual(self.delete()['status'], 200,
-            'method negative many DELETE')
+        self.assertEqual(
+            self.post()['status'], 404, 'method negative many POST'
+        )
+        self.assertEqual(
+            self.delete()['status'], 200, 'method negative many DELETE'
+        )
 
     def test_routes_match_method_wildcard_left(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "*ET" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method wildcard left configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "*ET"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method wildcard left configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'method wildcard left GET')
-        self.assertEqual(self.post()['status'], 404,
-            'method wildcard left POST')
+        self.assertEqual(
+            self.post()['status'], 404, 'method wildcard left POST'
+        )
 
     def test_routes_match_method_wildcard_right(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "GE*" },
-            "action": { "pass": "applications/empty"}
-        }], 'routes'), 'method wildcard right configure')
-
-        self.assertEqual(self.get()['status'], 200,
-            'method wildcard right GET')
-        self.assertEqual(self.post()['status'], 404,
-            'method wildcard right POST')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "GE*"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method wildcard right configure',
+        )
+
+        self.assertEqual(
+            self.get()['status'], 200, 'method wildcard right GET'
+        )
+        self.assertEqual(
+            self.post()['status'], 404, 'method wildcard right POST'
+        )
 
     def test_routes_match_method_wildcard_left_right(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "*GET*" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method wildcard left right configure')
-
-        self.assertEqual(self.get()['status'], 200,
-            'method wildcard right GET')
-        self.assertEqual(self.post()['status'], 404,
-            'method wildcard right POST')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "*GET*"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method wildcard left right configure',
+        )
+
+        self.assertEqual(
+            self.get()['status'], 200, 'method wildcard right GET'
+        )
+        self.assertEqual(
+            self.post()['status'], 404, 'method wildcard right POST'
+        )
 
     def test_routes_match_method_wildcard(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "*" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method wildcard configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "*"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method wildcard configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'method wildcard')
 
     def test_routes_match_method_case_insensitive(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "get" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'method case insensitive configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "get"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'method case insensitive configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'method case insensitive')
 
     def test_routes_absent(self):
-        self.conf({
-            "listeners": {
-                "*:7081": {
-                    "pass": "applications/empty"
-                }
-            },
-            "applications": {
-                "empty": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/empty',
-                    "working_directory": self.current_dir + '/python/empty',
-                    "module": "wsgi"
-                }
+        self.conf(
+            {
+                "listeners": {"*:7081": {"pass": "applications/empty"}},
+                "applications": {
+                    "empty": {
+                        "type": "python",
+                        "processes": {"spare": 0},
+                        "path": self.current_dir + '/python/empty',
+                        "working_directory": self.current_dir
+                        + '/python/empty',
+                        "module": "wsgi",
+                    }
+                },
             }
-        })
+        )
 
         self.assertEqual(self.get(port=7081)['status'], 200, 'routes absent')
 
     def test_routes_pass_invalid(self):
-        self.assertIn('error', self.conf({ "pass": "routes/blah" },
-            'listeners/*:7080'), 'routes invalid')
+        self.assertIn(
+            'error',
+            self.conf({"pass": "routes/blah"}, 'listeners/*:7080'),
+            'routes invalid',
+        )
 
     def test_route_empty(self):
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "*:7080": {
-                    "pass": "routes/main"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"*:7080": {"pass": "routes/main"}},
+                    "routes": {"main": []},
+                    "applications": {
+                        "empty": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": self.current_dir + '/python/empty',
+                            "working_directory": self.current_dir
+                            + '/python/empty',
+                            "module": "wsgi",
+                        },
+                        "mirror": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": self.current_dir + '/python/mirror',
+                            "working_directory": self.current_dir
+                            + '/python/mirror',
+                            "module": "wsgi",
+                        },
+                    },
                 }
-            },
-            "routes": {"main": []},
-            "applications": {
-                "empty": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/empty',
-                    "working_directory": self.current_dir + '/python/empty',
-                    "module": "wsgi"
-                },
-                "mirror": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/mirror',
-                    "working_directory": self.current_dir + '/python/mirror',
-                    "module": "wsgi"
-                }
-            }
-        }), 'route empty configure')
+            ),
+            'route empty configure',
+        )
 
         self.assertEqual(self.get()['status'], 404, 'route empty')
 
     def test_routes_route_empty(self):
-        self.assertIn('success', self.conf({}, 'listeners'),
-            'routes empty listeners configure')
+        self.assertIn(
+            'success',
+            self.conf({}, 'listeners'),
+            'routes empty listeners configure',
+        )
 
-        self.assertIn('success', self.conf({}, 'routes'),
-            'routes empty configure')
+        self.assertIn(
+            'success', self.conf({}, 'routes'), 'routes empty configure'
+        )
 
     def test_routes_route_match_absent(self):
-        self.assertIn('success', self.conf([{
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'route match absent configure')
+        self.assertIn(
+            'success',
+            self.conf([{"action": {"pass": "applications/empty"}}], 'routes'),
+            'route match absent configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'route match absent')
 
     def test_routes_route_action_absent(self):
         self.skip_alerts.append(r'failed to apply new conf')
 
-        self.assertIn('error', self.conf([{
-            "match": { "method": "GET" }
-        }], 'routes'), 'route pass absent configure')
+        self.assertIn(
+            'error',
+            self.conf([{"match": {"method": "GET"}}], 'routes'),
+            'route pass absent configure',
+        )
 
     def test_routes_route_pass_absent(self):
         self.skip_alerts.append(r'failed to apply new conf')
 
-        self.assertIn('error', self.conf([{
-            "match": { "method": "GET" },
-            "action": {}
-        }], 'routes'), 'route pass absent configure')
+        self.assertIn(
+            'error',
+            self.conf([{"match": {"method": "GET"}, "action": {}}], 'routes'),
+            'route pass absent configure',
+        )
 
     def test_routes_rules_two(self):
-        self.assertIn('success', self.conf([{
-            "match": { "method": "GET" },
-            "action": { "pass": "applications/empty" }
-        },
-        {
-            "match": { "method": "POST" },
-            "action": { "pass": "applications/mirror" }
-        }], 'routes'), 'rules two configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"method": "GET"},
+                        "action": {"pass": "applications/empty"},
+                    },
+                    {
+                        "match": {"method": "POST"},
+                        "action": {"pass": "applications/mirror"},
+                    },
+                ],
+                'routes',
+            ),
+            'rules two configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'rules two match first')
-        self.assertEqual(self.post(headers={
-            'Host': 'localhost',
-            'Content-Type': 'text/html',
-            'Connection': 'close'
-        }, body='X')['status'], 200, 'rules two match second')
+        self.assertEqual(
+            self.post(
+                headers={
+                    'Host': 'localhost',
+                    'Content-Type': 'text/html',
+                    'Connection': 'close',
+                },
+                body='X',
+            )['status'],
+            200,
+            'rules two match second',
+        )
 
     def test_routes_two(self):
-        self.assertIn('success', self.conf({
-            "listeners": {
-                "*:7080": {
-                    "pass": "routes/first"
-                }
-            },
-            "routes": {
-                "first": [{
-                    "match": { "method": "GET" },
-                    "action": { "pass": "routes/second" }
-                }],
-                "second": [{
-                    "match": { "host": "localhost" },
-                    "action": { "pass": "applications/empty" }
-                }],
-            },
-            "applications": {
-                "empty": {
-                    "type": "python",
-                    "processes": { "spare": 0 },
-                    "path": self.current_dir + '/python/empty',
-                    "working_directory": self.current_dir + '/python/empty',
-                    "module": "wsgi"
+        self.assertIn(
+            'success',
+            self.conf(
+                {
+                    "listeners": {"*:7080": {"pass": "routes/first"}},
+                    "routes": {
+                        "first": [
+                            {
+                                "match": {"method": "GET"},
+                                "action": {"pass": "routes/second"},
+                            }
+                        ],
+                        "second": [
+                            {
+                                "match": {"host": "localhost"},
+                                "action": {"pass": "applications/empty"},
+                            }
+                        ],
+                    },
+                    "applications": {
+                        "empty": {
+                            "type": "python",
+                            "processes": {"spare": 0},
+                            "path": self.current_dir + '/python/empty',
+                            "working_directory": self.current_dir
+                            + '/python/empty',
+                            "module": "wsgi",
+                        }
+                    },
                 }
-            }
-        }), 'routes two configure')
+            ),
+            'routes two configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'routes two')
 
     def test_routes_match_host_positive(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": "localhost" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host positive configure')
-
-        self.assertEqual(self.get()['status'], 200,
-            'match host positive localhost')
-
-        self.assertEqual(self.get(headers={'Connection': 'close'})['status'],
-            404, 'match host positive empty')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'localhost.',
-            'Connection': 'close'
-        })['status'], 200, 'match host positive trailing dot')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'www.localhost',
-            'Connection': 'close'
-        })['status'], 404, 'match host positive www.localhost')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'localhost1',
-            'Connection': 'close'
-        })['status'], 404, 'match host positive localhost1')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com',
-            'Connection': 'close'
-        })['status'], 404, 'match host positive example.com')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": "localhost"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host positive configure',
+        )
+
+        self.assertEqual(
+            self.get()['status'], 200, 'match host positive localhost'
+        )
+
+        self.assertEqual(
+            self.get(headers={'Connection': 'close'})['status'],
+            404,
+            'match host positive empty',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'localhost.', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host positive trailing dot',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'www.localhost', 'Connection': 'close'})[
+                'status'
+            ],
+            404,
+            'match host positive www.localhost',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'localhost1', 'Connection': 'close'})[
+                'status'
+            ],
+            404,
+            'match host positive localhost1',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'example.com', 'Connection': 'close'})[
+                'status'
+            ],
+            404,
+            'match host positive example.com',
+        )
 
     def test_routes_match_host_ipv4(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": "127.0.0.1" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host ipv4 configure')
-
-        self.assertEqual(self.get(headers={
-            'Host': '127.0.0.1',
-            'Connection': 'close'
-        })['status'], 200, 'match host ipv4')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": "127.0.0.1"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host ipv4 configure',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': '127.0.0.1', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host ipv4',
+        )
 
     def test_routes_match_host_ipv6(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": "[::1]" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host ipv6 configure')
-
-        self.assertEqual(self.get(headers={
-            'Host': '[::1]',
-            'Connection': 'close'
-        })['status'], 200, 'match host ipv6')
-
-        self.assertEqual(self.get(headers={
-            'Host': '[::1]:7080',
-            'Connection': 'close'
-        })['status'], 200, 'match host ipv6 port')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": "[::1]"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host ipv6 configure',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': '[::1]', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host ipv6',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': '[::1]:7080', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host ipv6 port',
+        )
 
     def test_routes_match_host_positive_many(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": ["localhost", "example.com"] },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host positive many configure')
-
-        self.assertEqual(self.get()['status'], 200,
-            'match host positive many localhost')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com',
-            'Connection': 'close'
-        })['status'], 200, 'match host positive many example.com')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": ["localhost", "example.com"]},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host positive many configure',
+        )
+
+        self.assertEqual(
+            self.get()['status'], 200, 'match host positive many localhost'
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'example.com', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host positive many example.com',
+        )
 
     def test_routes_match_host_positive_and_negative(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": ["*example.com", "!www.example.com"] },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host positive and negative configure')
-
-        self.assertEqual(self.get()['status'], 404,
-            'match host positive and negative localhost')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com',
-            'Connection': 'close'
-        })['status'], 200, 'match host positive and negative example.com')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'www.example.com',
-            'Connection': 'close'
-        })['status'], 404, 'match host positive and negative www.example.com')
-
-        self.assertEqual(self.get(headers={
-            'Host': '!www.example.com',
-            'Connection': 'close'
-        })['status'], 200, 'match host positive and negative !www.example.com')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {
+                            "host": ["*example.com", "!www.example.com"]
+                        },
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host positive and negative configure',
+        )
+
+        self.assertEqual(
+            self.get()['status'],
+            404,
+            'match host positive and negative localhost',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'example.com', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host positive and negative example.com',
+        )
+
+        self.assertEqual(
+            self.get(
+                headers={'Host': 'www.example.com', 'Connection': 'close'}
+            )['status'],
+            404,
+            'match host positive and negative www.example.com',
+        )
+
+        self.assertEqual(
+            self.get(
+                headers={'Host': '!www.example.com', 'Connection': 'close'}
+            )['status'],
+            200,
+            'match host positive and negative !www.example.com',
+        )
 
     def test_routes_match_host_positive_and_negative_wildcard(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": ["*example*", "!www.example*"] },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host positive and negative wildcard configure')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com',
-            'Connection': 'close'
-        })['status'], 200,
-            'match host positive and negative wildcard example.com')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'www.example.com',
-            'Connection': 'close'
-        })['status'], 404,
-            'match host positive and negative wildcard www.example.com')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": ["*example*", "!www.example*"]},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host positive and negative wildcard configure',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'example.com', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'match host positive and negative wildcard example.com',
+        )
+
+        self.assertEqual(
+            self.get(
+                headers={'Host': 'www.example.com', 'Connection': 'close'}
+            )['status'],
+            404,
+            'match host positive and negative wildcard www.example.com',
+        )
 
     def test_routes_match_host_case_insensitive(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": "Example.com" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'host case insensitive configure')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com',
-            'Connection': 'close'
-        })['status'], 200, 'host case insensitive example.com')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'EXAMPLE.COM',
-            'Connection': 'close'
-        })['status'], 200, 'host case insensitive EXAMPLE.COM')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": "Example.com"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'host case insensitive configure',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'example.com', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'host case insensitive example.com',
+        )
+
+        self.assertEqual(
+            self.get(headers={'Host': 'EXAMPLE.COM', 'Connection': 'close'})[
+                'status'
+            ],
+            200,
+            'host case insensitive EXAMPLE.COM',
+        )
 
     def test_routes_match_host_port(self):
-        self.assertIn('success', self.conf([{
-            "match": { "host": "example.com" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match host port configure')
-
-        self.assertEqual(self.get(headers={
-            'Host': 'example.com:7080',
-            'Connection': 'close'
-        })['status'], 200, 'match host port')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"host": "example.com"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match host port configure',
+        )
+
+        self.assertEqual(
+            self.get(
+                headers={'Host': 'example.com:7080', 'Connection': 'close'}
+            )['status'],
+            200,
+            'match host port',
+        )
 
     def test_routes_match_uri_positive(self):
-        self.assertIn('success', self.conf([{
-            "match": { "uri": "/" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match uri positive configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"uri": "/"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match uri positive configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'match uri positive')
-        self.assertEqual(self.get(url='/blah')['status'], 404,
-            'match uri positive blah')
-        self.assertEqual(self.get(url='/#blah')['status'], 200,
-            'match uri positive #blah')
-        self.assertEqual(self.get(url='/?var')['status'], 200,
-            'match uri params')
-        self.assertEqual(self.get(url='//')['status'], 200,
-            'match uri adjacent slashes')
-        self.assertEqual(self.get(url='/blah/../')['status'], 200,
-            'match uri relative path')
-        self.assertEqual(self.get(url='/./')['status'], 200,
-            'match uri relative path')
+        self.assertEqual(
+            self.get(url='/blah')['status'], 404, 'match uri positive blah'
+        )
+        self.assertEqual(
+            self.get(url='/#blah')['status'], 200, 'match uri positive #blah'
+        )
+        self.assertEqual(
+            self.get(url='/?var')['status'], 200, 'match uri params'
+        )
+        self.assertEqual(
+            self.get(url='//')['status'], 200, 'match uri adjacent slashes'
+        )
+        self.assertEqual(
+            self.get(url='/blah/../')['status'], 200, 'match uri relative path'
+        )
+        self.assertEqual(
+            self.get(url='/./')['status'], 200, 'match uri relative path'
+        )
 
     def test_routes_match_uri_case_sensitive(self):
-        self.assertIn('success', self.conf([{
-            "match": { "uri": "/BLAH" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match uri case sensitive configure')
-
-        self.assertEqual(self.get(url='/blah')['status'], 404,
-            'match uri case sensitive blah')
-        self.assertEqual(self.get(url='/BlaH')['status'], 404,
-            'match uri case sensitive BlaH')
-        self.assertEqual(self.get(url='/BLAH')['status'], 200,
-            'match uri case sensitive BLAH')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"uri": "/BLAH"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match uri case sensitive configure',
+        )
+
+        self.assertEqual(
+            self.get(url='/blah')['status'],
+            404,
+            'match uri case sensitive blah',
+        )
+        self.assertEqual(
+            self.get(url='/BlaH')['status'],
+            404,
+            'match uri case sensitive BlaH',
+        )
+        self.assertEqual(
+            self.get(url='/BLAH')['status'],
+            200,
+            'match uri case sensitive BLAH',
+        )
 
     def test_routes_match_uri_normalize(self):
-        self.assertIn('success', self.conf([{
-            "match": { "uri": "/blah" },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'match uri normalize configure')
-
-        self.assertEqual(self.get(url='/%62%6c%61%68')['status'], 200,
-            'match uri normalize')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {"uri": "/blah"},
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'match uri normalize configure',
+        )
+
+        self.assertEqual(
+            self.get(url='/%62%6c%61%68')['status'], 200, 'match uri normalize'
+        )
 
     def test_routes_match_rules(self):
-        self.assertIn('success', self.conf([{
-            "match": {
-                "method": "GET",
-                "host": "localhost",
-                "uri": "/"
-            },
-            "action": { "pass": "applications/empty" }
-        }], 'routes'), 'routes match rules configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [
+                    {
+                        "match": {
+                            "method": "GET",
+                            "host": "localhost",
+                            "uri": "/",
+                        },
+                        "action": {"pass": "applications/empty"},
+                    }
+                ],
+                'routes',
+            ),
+            'routes match rules configure',
+        )
 
         self.assertEqual(self.get()['status'], 200, 'routes match rules')
 
     def test_routes_loop(self):
-        self.assertIn('success', self.conf([{
-            "match": { "uri": "/" },
-            "action": { "pass": "routes" }
-        }], 'routes'), 'routes loop configure')
+        self.assertIn(
+            'success',
+            self.conf(
+                [{"match": {"uri": "/"}, "action": {"pass": "routes"}}],
+                'routes',
+            ),
+            'routes loop configure',
+        )
 
         self.assertEqual(self.get()['status'], 500, 'routes loop')
 
+
 if __name__ == '__main__':
     TestUnitRouting.main()