def test_blank_lines_internal_decorator_fix():
rules = [BlankLinesRule()]
src = """
def test():
pass
class Test(object):
def one():
pass
@a_decorator
def wow():
pass
"""
expected = """
def test():
pass
class Test(object):
def one():
pass
@a_decorator
def wow():
pass
"""
actual = linter(src, rules, fix=True)
assert src_equal(actual, expected)
def test_blank_lines_internal_func_fix():
rules = [BlankLinesRule()]
src = """
def test():
pass
class Two(object):
def cool():
pass
def wow():
pass
"""
expected = """
def test():
pass
class Two(object):
def cool():
pass
def wow():
pass
"""
actual = linter(src, rules, fix=True)
assert src_equal(actual, expected)
def test_list_wrong_format_and_comment_force_wrap():
src = """
def wow():
yes = True
x = 1
y = 2
if yes:
var = [ # first comment
x, y, # here is a comment
"yes I think it is", # here is another comment
]
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
expected = """
def wow():
yes = True
x = 1
y = 2
if yes:
var = [
# first comment
x,
y, # here is a comment
"yes I think it is" # here is another comment
]
"""
assert src_equal(actual, expected)
def test_blank_lines_w_comments_fix():
rules = [BlankLinesRule()]
src = """
class Test(object):
pass
# one
# three
# two
class TestTwo(object):
pass
"""
expected = """
class Test(object):
pass
# one
# three
# two
class TestTwo(object):
pass
"""
actual = linter(src, rules, fix=True)
assert src_equal(actual, expected)
def test_no_active_rules():
rules = [ExampleRule({'rule_setting': "off"})]
src = "print('test')"
actual = linter(src, rules)
expected = DEFAULT_LINTER_RESULT
assert actual == expected
def test_lint_fixer():
rules = [AnotherExampleRule()]
src = "test = 1"
actual = linter(src, rules)
expected = "test = 1"
assert src_equal(actual["ast"], expected)
def test_func_wrong_format_force_wrap():
src = """
def test(one, two, three):
pass
def wow():
yes = True
x = 1
y = 2
if yes:
test(
x, y,
"yes I think it is",
)
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
expected = """
def test(one, two, three):
pass
def wow():
yes = True
x = 1
y = 2
if yes:
test(x, y, "yes I think it is")
"""
assert src_equal(actual, expected)
def test_no_src():
rules = [ExampleRule()]
src = ""
actual = linter(src, rules)
expected = DEFAULT_LINTER_RESULT
assert actual == expected
def test_list_force_rewrap():
src = """
def wow():
yes = True
x = 1
y = 2
if yes:
var = [
x, y,
"yes I think it is",
"this is a really long message, does this still work now?"
]
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
expected = """
def wow():
yes = True
x = 1
y = 2
if yes:
var = [
x,
y,
"yes I think it is",
"this is a really long message, does this still work now?"
]
"""
assert src_equal(actual, expected)
def test_blank_lines_missing_newline_windows_fix():
rules = [BlankLinesRule()]
src = "def test():\r\n pass\r\n\r\nclass Two:\r\n pass\r\n"
expected = "def test():\r\n pass\r\n\r\n\r\nclass Two:\r\n pass\r\n"
actual = linter(src, rules, fix=True)
assert src_equal(actual, expected)
def test_comments_separating_funcs_pass():
rules = [BlankLinesRule({'rule_settings': "error"})]
src = """
def remove_farewell(text):
text = ""
return text
# def word_tokenize(text, nlp):
# doc = nlp.tokenizer(text)
# tokens = [word.string.strip() for word in doc]
# return tokens
# def pos_tag(text, nlp):
# doc = nlp(text)
# tags = [(word.string.strip(), word.tag_) for word in doc]
# return(tags)
def word_tokenize(text):
return wrd_tokenize(text)
"""
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_func_nested_should_wrap():
src = """
def test(one, two, three):
pass
def wow():
yes = True
if yes:
test("this is a really long string, does this work?", "I'm not sure if this is long enough", "yes I think it is")
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
expected = """
def test(one, two, three):
pass
def wow():
yes = True
if yes:
test(
"this is a really long string, does this work?",
"I'm not sure if this is long enough",
"yes I think it is"
)
"""
assert src_equal(actual, expected)
def test_class_docstring_present():
rules = [RequireClassDocstrings({'rule_setting': "error"})]
src = 'class Test(object):\n """This is a docstring"""\n pass'
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_module_docstring_mult_newline_present():
rules = [RequireModuleDocstrings({'rule_setting': "error"})]
src = '\n\n\n"""This is a docstring"""\nprint("hi there")'
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_method_docstring_present():
rules = [RequireFuncDocstrings({'rule_setting': "error"})]
src = 'class Test(object):\n'
' def test():\n'
' """Docstring is here!"""'
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_func_should_not_wrap():
src = """
def test(one, two, three):
pass
test("this is small", "I'm sure", "of it")
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
assert src_equal(actual, src)
def test_class_def_with_post_comment():
src = ("# [ API ]\n"
"# pylint: disable=too-many-instance-attributes\n"
"# There are a lot of things that the model need to track and do.\n"
"class PyTorchModel(Model, nn.Module):\n"
' """The Dataset object that handles batching."""\n')
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
assert src_equal(actual, src)
def test_max_length_error():
src = "print('this line is less than 100 characters, but i need to really stretch it. who knows.')"
rules = [MaxLength()]
actual = linter(src, rules)
expected = [{
"filename": "",
"lineno": 1,
"msg": "max line has been exceeded 91 > 80",
"name": "max_length",
}]
assert actual["errors"] == expected
def test_class_def_with_pre_comment():
src = """
# [ API ]
# pylint: disable=too-many-instance-attributes
# There are a lot of things that the model need to track and do.
class PyTorchModel(Model, nn.Module):
pass
"""
rules = [FuncWrap()]
actual = linter(src, rules, fix=True)
assert src_equal(actual, src)
def test_func_docstring_comment_error():
rules = [RequireFuncDocstrings({'rule_setting': "error"})]
src = 'def test():\n # this is a comment\n pass'
expected = [{
"msg": "function definition requires docstring",
"lineno": 1,
"filename": "",
"name": "require_func_docstrings",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_module_docstring_error():
rules = [RequireModuleDocstrings({'rule_setting': "error"})]
src = 'print("hi there")'
expected = [{
"name": "require_module_docstrings",
"filename": "",
"lineno": 1,
"msg": "module requires docstring",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_class_docstring_missing_error():
rules = [RequireClassDocstrings({'rule_setting': "error"})]
src = 'class Test(object):\n pass'
expected = [{
"msg": "class definition requires docstring",
"lineno": 1,
"filename": "",
"name": "require_class_docstrings",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_tuple_unwrap():
src = """test = (
"one",
"really long string",
)
another = "string"
"""
rules = [ListWrap()]
actual = linter(src, rules, fix=True)
expected = """test = ("one", "really long string")
another = "string"
"""
assert src_equal(actual, expected)
def test_module_docstring_comment_error():
rules = [RequireModuleDocstrings({'rule_setting': "error"})]
src = """# this is a comment
print("another one")
"""
expected = [{
"name": "require_module_docstrings",
"filename": "",
"lineno": 1,
"msg": "module requires docstring",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_tuple_wrap():
src = """test = ("one", "really long string", "that should wrap", "but will it actually break it up?")
another = "string"
"""
rules = [ListWrap()]
actual = linter(src, rules, fix=True)
expected = """test = (
"one",
"really long string",
"that should wrap",
"but will it actually break it up?"
)
another = "string"
"""
assert src_equal(actual, expected)
def test_method_docstring_error():
rules = [RequireFuncDocstrings({'rule_setting': "error"})]
src = """
class Test(object):
def test():
pass
"""
expected = [{
"msg": "function definition requires docstring",
"lineno": 3,
"filename": "",
"name": "require_func_docstrings",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_method_decorated_pass():
rules = [BlankLinesRule({'rule_settings': "error"})]
src = """
class Vocab(object):
def __init__(self):
pass
@staticmethod
def boo():
pass
"""
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_nested_indent_pass():
rules = [BlankLinesRule({'rule_settings': "error"})]
src = """
def write_TSV(filename, features, labels):
with open(filename, "w") as f:
f.write(header)
def main():
# Get credentials and set up acces to Gmail API
pass
"""
expected = []
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_blank_lines_missing_newline_error():
rules = [BlankLinesRule({'rule_settings': "error"})]
src = """
def test():
pass
class Two(object):
pass
"""
expected = [{
"name": "blank_lines",
"filename": "",
"lineno": 5,
"msg": "expected 2 blank lines, found 1",
}]
actual = linter(src, rules, fix=False)
assert actual['errors'] == expected
def test_blank_lines_missing_multiple_newlines_fix():
rules = [BlankLinesRule()]
src = """
def test():
pass
class Two(object):
pass
"""
expected = """
def test():
pass
class Two(object):
pass
"""
actual = linter(src, rules, fix=True)
assert src_equal(actual, expected)
