Tests: get rid of classes in test files.

Class usage came from the unittest framework and it was always redundant
after migration to the pytest.  This commit removes classes from files
containing tests to make them more readable and understandable.

1 files changed, 234 insertions, 222 deletions

diff --git a/test/test_access_log.py b/test/test_access_log.py
index 184a5fdf..bccea56f 100644
--- a/test/test_access_log.py
+++ b/test/test_access_log.py
@@ -1,61 +1,63 @@
 import time
 
 import pytest
-from unit.applications.lang.python import TestApplicationPython
+from unit.applications.lang.python import ApplicationPython
 from unit.option import option
 
 prerequisites = {'modules': {'python': 'any'}}
 
+client = ApplicationPython()
 
-class TestAccessLog(TestApplicationPython):
-    def load(self, script):
-        super().load(script)
-
-        assert 'success' in self.conf(
-            f'"{option.temp_dir}/access.log"', 'access_log'
-        ), 'access_log configure'
-
-    def set_format(self, format):
-        assert 'success' in self.conf(
-            {
-                'path': f'{option.temp_dir}/access.log',
-                'format': format,
-            },
-            'access_log',
-        ), 'access_log format'
-
-    def test_access_log_keepalive(self, wait_for_record):
-        self.load('mirror')
-
-        assert self.get()['status'] == 200, 'init'
-
-        (_, sock) = self.post(
-            headers={
-                'Host': 'localhost',
-                'Connection': 'keep-alive',
-            },
-            start=True,
-            body='01234',
-            read_timeout=1,
-        )
 
-        assert (
-            wait_for_record(r'"POST / HTTP/1.1" 200 5', 'access.log')
-            is not None
-        ), 'keepalive 1'
+def load(script):
+    client.load(script)
+
+    assert 'success' in client.conf(
+        f'"{option.temp_dir}/access.log"', 'access_log'
+    ), 'access_log configure'
+
+
+def set_format(format):
+    assert 'success' in client.conf(
+        {
+            'path': f'{option.temp_dir}/access.log',
+            'format': format,
+        },
+        'access_log',
+    ), 'access_log format'
+
+
+def test_access_log_keepalive(wait_for_record):
+    load('mirror')
+
+    assert client.get()['status'] == 200, 'init'
 
-        _ = self.post(sock=sock, body='0123456789')
+    (_, sock) = client.post(
+        headers={
+            'Host': 'localhost',
+            'Connection': 'keep-alive',
+        },
+        start=True,
+        body='01234',
+        read_timeout=1,
+    )
 
-        assert (
-            wait_for_record(r'"POST / HTTP/1.1" 200 10', 'access.log')
-            is not None
-        ), 'keepalive 2'
+    assert (
+        wait_for_record(r'"POST / HTTP/1.1" 200 5', 'access.log') is not None
+    ), 'keepalive 1'
 
-    def test_access_log_pipeline(self, wait_for_record):
-        self.load('empty')
+    _ = client.post(sock=sock, body='0123456789')
 
-        self.http(
-            b"""GET / HTTP/1.1
+    assert (
+        wait_for_record(r'"POST / HTTP/1.1" 200 10', 'access.log') is not None
+    ), 'keepalive 2'
+
+
+def test_access_log_pipeline(wait_for_record):
+    load('empty')
+
+    client.http(
+        b"""GET / HTTP/1.1
 Host: localhost
 Referer: Referer-1
 
@@ -69,244 +71,254 @@ Referer: Referer-3
 Connection: close
 
 """,
-            raw_resp=True,
-            raw=True,
+        raw_resp=True,
+        raw=True,
+    )
+
+    assert (
+        wait_for_record(r'"GET / HTTP/1.1" 200 0 "Referer-1" "-"', 'access.log')
+        is not None
+    ), 'pipeline 1'
+    assert (
+        wait_for_record(r'"GET / HTTP/1.1" 200 0 "Referer-2" "-"', 'access.log')
+        is not None
+    ), 'pipeline 2'
+    assert (
+        wait_for_record(r'"GET / HTTP/1.1" 200 0 "Referer-3" "-"', 'access.log')
+        is not None
+    ), 'pipeline 3'
+
+
+def test_access_log_ipv6(wait_for_record):
+    load('empty')
+
+    assert 'success' in client.conf(
+        {"[::1]:7080": {"pass": "applications/empty"}}, 'listeners'
+    )
+
+    client.get(sock_type='ipv6')
+
+    assert (
+        wait_for_record(
+            r'::1 - - \[.+\] "GET / HTTP/1.1" 200 0 "-" "-"', 'access.log'
         )
+        is not None
+    ), 'ipv6'
 
-        assert (
-            wait_for_record(
-                r'"GET / HTTP/1.1" 200 0 "Referer-1" "-"', 'access.log'
-            )
-            is not None
-        ), 'pipeline 1'
-        assert (
-            wait_for_record(
-                r'"GET / HTTP/1.1" 200 0 "Referer-2" "-"', 'access.log'
-            )
-            is not None
-        ), 'pipeline 2'
-        assert (
-            wait_for_record(
-                r'"GET / HTTP/1.1" 200 0 "Referer-3" "-"', 'access.log'
-            )
-            is not None
-        ), 'pipeline 3'
-
-    def test_access_log_ipv6(self, wait_for_record):
-        self.load('empty')
-
-        assert 'success' in self.conf(
-            {"[::1]:7080": {"pass": "applications/empty"}}, 'listeners'
-        )
 
-        self.get(sock_type='ipv6')
+def test_access_log_unix(temp_dir, wait_for_record):
+    load('empty')
 
-        assert (
-            wait_for_record(
-                r'::1 - - \[.+\] "GET / HTTP/1.1" 200 0 "-" "-"', 'access.log'
-            )
-            is not None
-        ), 'ipv6'
+    addr = f'{temp_dir}/sock'
 
-    def test_access_log_unix(self, temp_dir, wait_for_record):
-        self.load('empty')
+    assert 'success' in client.conf(
+        {f'unix:{addr}': {"pass": "applications/empty"}}, 'listeners'
+    )
 
-        addr = f'{temp_dir}/sock'
+    client.get(sock_type='unix', addr=addr)
 
-        assert 'success' in self.conf(
-            {f'unix:{addr}': {"pass": "applications/empty"}}, 'listeners'
+    assert (
+        wait_for_record(
+            r'unix: - - \[.+\] "GET / HTTP/1.1" 200 0 "-" "-"', 'access.log'
         )
+        is not None
+    ), 'unix'
 
-        self.get(sock_type='unix', addr=addr)
 
-        assert (
-            wait_for_record(
-                r'unix: - - \[.+\] "GET / HTTP/1.1" 200 0 "-" "-"', 'access.log'
-            )
-            is not None
-        ), 'unix'
+def test_access_log_referer(wait_for_record):
+    load('empty')
 
-    def test_access_log_referer(self, wait_for_record):
-        self.load('empty')
+    client.get(
+        headers={
+            'Host': 'localhost',
+            'Referer': 'referer-value',
+            'Connection': 'close',
+        }
+    )
 
-        self.get(
-            headers={
-                'Host': 'localhost',
-                'Referer': 'referer-value',
-                'Connection': 'close',
-            }
+    assert (
+        wait_for_record(
+            r'"GET / HTTP/1.1" 200 0 "referer-value" "-"', 'access.log'
         )
+        is not None
+    ), 'referer'
+
+
+def test_access_log_user_agent(wait_for_record):
+    load('empty')
 
-        assert (
-            wait_for_record(
-                r'"GET / HTTP/1.1" 200 0 "referer-value" "-"', 'access.log'
-            )
-            is not None
-        ), 'referer'
-
-    def test_access_log_user_agent(self, wait_for_record):
-        self.load('empty')
-
-        self.get(
-            headers={
-                'Host': 'localhost',
-                'User-Agent': 'user-agent-value',
-                'Connection': 'close',
-            }
+    client.get(
+        headers={
+            'Host': 'localhost',
+            'User-Agent': 'user-agent-value',
+            'Connection': 'close',
+        }
+    )
+
+    assert (
+        wait_for_record(
+            r'"GET / HTTP/1.1" 200 0 "-" "user-agent-value"', 'access.log'
         )
+        is not None
+    ), 'user agent'
+
+
+def test_access_log_http10(wait_for_record):
+    load('empty')
+
+    client.get(http_10=True)
+
+    assert (
+        wait_for_record(r'"GET / HTTP/1.0" 200 0 "-" "-"', 'access.log')
+        is not None
+    ), 'http 1.0'
+
+
+def test_access_log_partial(wait_for_record):
+    load('empty')
 
-        assert (
-            wait_for_record(
-                r'"GET / HTTP/1.1" 200 0 "-" "user-agent-value"', 'access.log'
-            )
-            is not None
-        ), 'user agent'
+    assert client.post()['status'] == 200, 'init'
 
-    def test_access_log_http10(self, wait_for_record):
-        self.load('empty')
+    _ = client.http(b"""GE""", raw=True, read_timeout=1)
 
-        self.get(http_10=True)
+    time.sleep(1)
 
-        assert (
-            wait_for_record(r'"GET / HTTP/1.0" 200 0 "-" "-"', 'access.log')
-            is not None
-        ), 'http 1.0'
+    assert (
+        wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
+    ), 'partial'
 
-    def test_access_log_partial(self, wait_for_record):
-        self.load('empty')
 
-        assert self.post()['status'] == 200, 'init'
+def test_access_log_partial_2(wait_for_record):
+    load('empty')
 
-        _ = self.http(b"""GE""", raw=True, read_timeout=1)
+    assert client.post()['status'] == 200, 'init'
 
-        time.sleep(1)
+    client.http(b"""GET /\n""", raw=True)
 
-        assert (
-            wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
-        ), 'partial'
+    assert (
+        wait_for_record(r'"-" 400 \d+ "-" "-"', 'access.log') is not None
+    ), 'partial 2'
 
-    def test_access_log_partial_2(self, wait_for_record):
-        self.load('empty')
 
-        assert self.post()['status'] == 200, 'init'
+def test_access_log_partial_3(wait_for_record):
+    load('empty')
 
-        self.http(b"""GET /\n""", raw=True)
+    assert client.post()['status'] == 200, 'init'
 
-        assert (
-            wait_for_record(r'"-" 400 \d+ "-" "-"', 'access.log') is not None
-        ), 'partial 2'
+    _ = client.http(b"""GET / HTTP/1.1""", raw=True, read_timeout=1)
 
-    def test_access_log_partial_3(self, wait_for_record):
-        self.load('empty')
+    time.sleep(1)
 
-        assert self.post()['status'] == 200, 'init'
+    assert (
+        wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
+    ), 'partial 3'
 
-        _ = self.http(b"""GET / HTTP/1.1""", raw=True, read_timeout=1)
 
-        time.sleep(1)
+def test_access_log_partial_4(wait_for_record):
+    load('empty')
 
-        assert (
-            wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
-        ), 'partial 3'
+    assert client.post()['status'] == 200, 'init'
 
-    def test_access_log_partial_4(self, wait_for_record):
-        self.load('empty')
+    _ = client.http(b"""GET / HTTP/1.1\n""", raw=True, read_timeout=1)
 
-        assert self.post()['status'] == 200, 'init'
+    time.sleep(1)
 
-        _ = self.http(b"""GET / HTTP/1.1\n""", raw=True, read_timeout=1)
+    assert (
+        wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
+    ), 'partial 4'
 
-        time.sleep(1)
 
-        assert (
-            wait_for_record(r'"-" 400 0 "-" "-"', 'access.log') is not None
-        ), 'partial 4'
+@pytest.mark.skip('not yet')
+def test_access_log_partial_5(wait_for_record):
+    load('empty')
 
-    @pytest.mark.skip('not yet')
-    def test_access_log_partial_5(self, wait_for_record):
-        self.load('empty')
+    assert client.post()['status'] == 200, 'init'
 
-        assert self.post()['status'] == 200, 'init'
+    client.get(headers={'Connection': 'close'})
+
+    assert (
+        wait_for_record(r'"GET / HTTP/1.1" 400 \d+ "-" "-"', 'access.log')
+        is not None
+    ), 'partial 5'
+
+
+def test_access_log_get_parameters(wait_for_record):
+    load('empty')
+
+    client.get(url='/?blah&var=val')
+
+    assert (
+        wait_for_record(
+            r'"GET /\?blah&var=val HTTP/1.1" 200 0 "-" "-"', 'access.log'
+        )
+        is not None
+    ), 'get parameters'
 
-        self.get(headers={'Connection': 'close'})
 
-        assert (
-            wait_for_record(r'"GET / HTTP/1.1" 400 \d+ "-" "-"', 'access.log')
-            is not None
-        ), 'partial 5'
+def test_access_log_delete(search_in_file):
+    load('empty')
 
-    def test_access_log_get_parameters(self, wait_for_record):
-        self.load('empty')
+    assert 'success' in client.conf_delete('access_log')
 
-        self.get(url='/?blah&var=val')
+    client.get(url='/delete')
 
-        assert (
-            wait_for_record(
-                r'"GET /\?blah&var=val HTTP/1.1" 200 0 "-" "-"', 'access.log'
-            )
-            is not None
-        ), 'get parameters'
+    assert search_in_file(r'/delete', 'access.log') is None, 'delete'
 
-    def test_access_log_delete(self, search_in_file):
-        self.load('empty')
 
-        assert 'success' in self.conf_delete('access_log')
+def test_access_log_change(temp_dir, wait_for_record):
+    load('empty')
 
-        self.get(url='/delete')
+    client.get()
 
-        assert search_in_file(r'/delete', 'access.log') is None, 'delete'
+    assert 'success' in client.conf(f'"{temp_dir}/new.log"', 'access_log')
 
-    def test_access_log_change(self, temp_dir, wait_for_record):
-        self.load('empty')
+    client.get()
 
-        self.get()
+    assert (
+        wait_for_record(r'"GET / HTTP/1.1" 200 0 "-" "-"', 'new.log')
+        is not None
+    ), 'change'
 
-        assert 'success' in self.conf(f'"{temp_dir}/new.log"', 'access_log')
 
-        self.get()
+def test_access_log_format(wait_for_record):
+    load('empty')
 
-        assert (
-            wait_for_record(r'"GET / HTTP/1.1" 200 0 "-" "-"', 'new.log')
-            is not None
-        ), 'change'
+    def check_format(format, expect, url='/'):
+        set_format(format)
 
-    def test_access_log_format(self, wait_for_record):
-        self.load('empty')
+        assert client.get(url=url)['status'] == 200
+        assert wait_for_record(expect, 'access.log') is not None, 'found'
 
-        def check_format(format, expect, url='/'):
-            self.set_format(format)
+    format = 'BLAH\t0123456789'
+    check_format(format, format)
+    check_format('$uri $status $uri $status', '/ 200 / 200')
 
-            assert self.get(url=url)['status'] == 200
-            assert wait_for_record(expect, 'access.log') is not None, 'found'
 
-        format = 'BLAH\t0123456789'
-        check_format(format, format)
-        check_format('$uri $status $uri $status', '/ 200 / 200')
+def test_access_log_variables(wait_for_record):
+    load('mirror')
 
-    def test_access_log_variables(self, wait_for_record):
-        self.load('mirror')
+    # $body_bytes_sent
 
-        # $body_bytes_sent
+    set_format('$uri $body_bytes_sent')
+    body = '0123456789' * 50
+    client.post(url='/bbs', body=body, read_timeout=1)
+    assert (
+        wait_for_record(fr'^\/bbs {len(body)}$', 'access.log') is not None
+    ), '$body_bytes_sent'
 
-        self.set_format('$uri $body_bytes_sent')
-        body = '0123456789' * 50
-        self.post(url='/bbs', body=body, read_timeout=1)
-        assert (
-            wait_for_record(fr'^\/bbs {len(body)}$', 'access.log') is not None
-        ), '$body_bytes_sent'
 
-    def test_access_log_incorrect(self, temp_dir, skip_alert):
-        skip_alert(r'failed to apply new conf')
+def test_access_log_incorrect(temp_dir, skip_alert):
+    skip_alert(r'failed to apply new conf')
 
-        assert 'error' in self.conf(
-            f'{temp_dir}/blah/access.log',
-            'access_log/path',
-        ), 'access_log path incorrect'
+    assert 'error' in client.conf(
+        f'{temp_dir}/blah/access.log',
+        'access_log/path',
+    ), 'access_log path incorrect'
 
-        assert 'error' in self.conf(
-            {
-                'path': f'{temp_dir}/access.log',
-                'format': '$remote_add',
-            },
-            'access_log',
-        ), 'access_log format incorrect'
+    assert 'error' in client.conf(
+        {
+            'path': f'{temp_dir}/access.log',
+            'format': '$remote_add',
+        },
+        'access_log',
+    ), 'access_log format incorrect'