Fix PEP8 empty line errors

2 files changed, 26 insertions, 3 deletions

diff --git a/tests/parseutils/test_ctes.py b/tests/parseutils/test_ctes.py
index 9566cf65..4d2d050f 100644
--- a/tests/parseutils/test_ctes.py
+++ b/tests/parseutils/test_ctes.py
@@ -117,5 +117,3 @@ def test_multiple_cte_extraction():
     assert tuple(ctes) == (
         ('x', ('abc', 'def'), start1, stop1),
         ('y', ('ghi', 'jkl'), start2, stop2))
-
-
diff --git a/tests/parseutils/test_parseutils.py b/tests/parseutils/test_parseutils.py
index 6c2994f8..4ffc7ee3 100644
--- a/tests/parseutils/test_parseutils.py
+++ b/tests/parseutils/test_parseutils.py
@@ -2,10 +2,12 @@ import pytest
 from pgcli.packages.parseutils.tables import extract_tables
 from pgcli.packages.parseutils.utils import find_prev_keyword, is_open_quote
 
+
 def test_empty_string():
     tables = extract_tables('')
     assert tables == ()
 
+
 def test_simple_select_single_table():
     tables = extract_tables('select * from abc')
     assert tables == ((None, 'abc', None, False),)
@@ -33,62 +35,75 @@ def test_simple_select_single_table_double_quoted():
     tables = extract_tables('select * from "Abc"')
     assert tables == ((None, 'Abc', None, False),)
 
+
 def test_simple_select_multiple_tables():
     tables = extract_tables('select * from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_simple_select_multiple_tables_double_quoted():
     tables = extract_tables('select * from "Abc", "Def"')
     assert set(tables) == set([(None, 'Abc', None, False),
                                (None, 'Def', None, False)])
 
+
 def test_simple_select_single_table_deouble_quoted_aliased():
     tables = extract_tables('select * from "Abc" a')
     assert tables == ((None, 'Abc', 'a', False),)
 
+
 def test_simple_select_multiple_tables_deouble_quoted_aliased():
     tables = extract_tables('select * from "Abc" a, "Def" d')
     assert set(tables) == set([(None, 'Abc', 'a', False),
                                (None, 'Def', 'd', False)])
 
+
 def test_simple_select_multiple_tables_schema_qualified():
     tables = extract_tables('select * from abc.def, ghi.jkl')
     assert set(tables) == set([('abc', 'def', None, False),
                                ('ghi', 'jkl', None, False)])
 
+
 def test_simple_select_with_cols_single_table():
     tables = extract_tables('select a,b from abc')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_simple_select_with_cols_single_table_schema_qualified():
     tables = extract_tables('select a,b from abc.def')
     assert tables == (('abc', 'def', None, False),)
 
+
 def test_simple_select_with_cols_multiple_tables():
     tables = extract_tables('select a,b from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_simple_select_with_cols_multiple_qualified_tables():
     tables = extract_tables('select a,b from abc.def, def.ghi')
     assert set(tables) == set([('abc', 'def', None, False),
                                ('def', 'ghi', None, False)])
 
+
 def test_select_with_hanging_comma_single_table():
     tables = extract_tables('select a, from abc')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_select_with_hanging_comma_multiple_tables():
     tables = extract_tables('select a, from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_select_with_hanging_period_multiple_tables():
     tables = extract_tables('SELECT t1. FROM tabl1 t1, tabl2 t2')
     assert set(tables) == set([(None, 'tabl1', 't1', False),
                                (None, 'tabl2', 't2', False)])
 
+
 def test_simple_insert_single_table():
     tables = extract_tables('insert into abc (id, name) values (1, "def")')
 
@@ -98,19 +113,23 @@ def test_simple_insert_single_table():
 
     assert tables == ((None, 'abc', 'abc', False),)
 
+
 @pytest.mark.xfail
 def test_simple_insert_single_table_schema_qualified():
     tables = extract_tables('insert into abc.def (id, name) values (1, "def")')
     assert tables == (('abc', 'def', None, False),)
 
+
 def test_simple_update_table_no_schema():
     tables = extract_tables('update abc set id = 1')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_simple_update_table_with_schema():
     tables = extract_tables('update abc.def set id = 1')
     assert tables == (('abc', 'def', None, False),)
 
+
 @pytest.mark.parametrize('join_type', ['', 'INNER', 'LEFT', 'RIGHT OUTER'])
 def test_join_table(join_type):
     sql = 'SELECT * FROM abc a {0} JOIN def d ON a.id = d.num'.format(join_type)
@@ -118,6 +137,7 @@ def test_join_table(join_type):
     assert set(tables) == set([(None, 'abc', 'a', False),
                                (None, 'def', 'd', False)])
 
+
 def test_join_table_schema_qualified():
     tables = extract_tables('SELECT * FROM abc.def x JOIN ghi.jkl y ON x.id = y.num')
     assert set(tables) == set([('abc', 'def', 'x', False),
@@ -156,21 +176,25 @@ def test_subselect_tables():
     tables = extract_tables(sql)
     assert tables == ((None, 'abc', None, False),)
 
+
 @pytest.mark.parametrize('text', ['SELECT * FROM foo.', 'SELECT 123 AS foo'])
 def test_extract_no_tables(text):
     tables = extract_tables(text)
     assert tables == tuple()
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo({0})'.format(arg_list))
     assert tables == ((None, 'foo', None, True),)
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_schema_qualified_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo.bar({0})'.format(arg_list))
     assert tables == (('foo', 'bar', None, True),)
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_aliased_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo({0}) bar'.format(arg_list))
@@ -182,6 +206,7 @@ def test_simple_table_and_function():
     assert set(tables) == set([(None, 'foo', None, False),
                                (None, 'bar', None, True)])
 
+
 def test_complex_table_and_function():
     tables = extract_tables('''SELECT * FROM foo.bar baz
                                JOIN bar.qux(x, y, z) quux''')
@@ -189,12 +214,12 @@ def test_complex_table_and_function():
                                ('bar', 'qux', 'quux', True)])
 
 
-
 def test_find_prev_keyword_using():
     q = 'select * from tbl1 inner join tbl2 using (col1, '
     kw, q2 = find_prev_keyword(q)
     assert kw.value == '(' and q2 == 'select * from tbl1 inner join tbl2 using ('
 
+
 @pytest.mark.parametrize('sql', [
     'select * from foo where bar',
     'select * from foo where bar = 1 and baz or ',