Changes name-related rules

Changes:
1. Now we are using the same errors for every name violation
2. We now forbid private names, closes #45
3. Restricts `file` and `klass` as variable names, closes #42
4. Checks `flake --version` output, closes #41
5. Adds checks for errors to be correctly defined

Author: sobolevn

setup.cfg

@@ -42,7 +42,7 @@ addopts =
   --cov=wemake_python_styleguide
   --cov-report=term:skip-covered
   --cov-report=html
-  --cov-fail-under=95
+  --cov-fail-under=100
 
 
 [isort]

tests/fixtures/wrong_variable.py

@@ -45,6 +45,7 @@ class Fixture(object):
     def __init__(self, value):  # error here
         self.var = value  # error here only for `var`, not for `value`
         self.x = value  # error here only for `x`, not for `value`
+        self.__private = value  # error here for `__private`, not for `value`
 
 
 val = Fixture()  # error here

tests/test_checkers/test_wrong_variable.py

@@ -13,10 +13,7 @@ def test_wrong_variables_in_fixture(absolute_path):
     )
     stdout, _ = process.communicate()
 
-    assert stdout.count(b'WPS120') == 8
-    assert stdout.count(b'WPS121') == 3
-    assert stdout.count(b'WPS122') == 3
-    assert stdout.count(b'WPS123') == 2
-    assert stdout.count(b'WPS124') == 1
-    assert stdout.count(b'WPS125') == 1
-    assert stdout.count(b'WPS126') == 1
+    assert stdout.count(b'WPS120') == 12
+    assert stdout.count(b'WPS121') == 6
+    assert stdout.count(b'WPS122') == 1
+    assert stdout.count(b'WPS123') == 1

tests/test_errors.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+import inspect
+from operator import itemgetter
+
+import pytest
+
+from wemake_python_styleguide import errors
+
+
+def _is_error_class(cls) -> bool:
+    return (
+        inspect.isclass(cls) and
+        issubclass(cls, errors.BaseStyleViolation) and
+        cls is not errors.BaseStyleViolation
+    )
+
+
+@pytest.fixture(scope='module')
+def all_errors():
+    """Loads all errors from the package."""
+    return list(
+        map(itemgetter(1), inspect.getmembers(errors, _is_error_class)),
+    )
+
+
+def test_all_unique_error_codes(all_errors):
+    """Ensures that all errors have unique error codes."""
+    codes = []
+    for error in all_errors:
+        codes.append(error._code)
+
+    assert len(set(codes)) == len(all_errors)
+
+
+def test_all_errors_have_description_with_code(all_errors):
+    """Ensures that all errors have description with error code."""
+    for error in all_errors:
+        assert error._code in error.__doc__

tests/test_version.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+import subprocess
+
+
+def test_call_flake8_version():
+    """Checks that module is registered and visible in the meta data."""
+    output = subprocess.check_output(
+        ['flake8', '--version'],
+        stderr=subprocess.STDOUT,
+    )
+    assert b'wemake-python-styleguide' in output

tests/test_visitors/conftest.py

@@ -29,6 +29,7 @@ def assert_errors():
     """Helper function to assert visitor errors."""
     def factory(visiter: BaseNodeVisitor, errors: Sequence[str]):
         for index, error in enumerate(visiter.errors):
+            assert len(errors) > index, error._code
             assert error._code == errors[index]._code
 
         assert len(visiter.errors) == len(errors)

tests/test_visitors/test_wrong_import/test_nested_imports.py

@@ -7,6 +7,8 @@
     WrongImportVisitor,
 )
 
+# Incorrect imports:
+
 nested_function_import = """
 def function():
     import os
@@ -17,6 +19,11 @@ def function():
     from os import path
 """
 
+nested_conditional_import = """
+if True:
+    import os
+"""
+
 nested_method_import = """
 class Test:
     def with_import(self):
@@ -29,12 +36,31 @@ def with_import(self):
         from os import path
 """
 
+nested_try_import = """
+try:
+    from missing import some
+except ImportError:
+    some = None
+"""
+
+# Correct imports:
+
+regular_import = """
+import os
+"""
+
+regular_from_import = """
+from os import path
+"""
+
 
 @pytest.mark.parametrize('code', [
     nested_function_import,
     nested_function_from_import,
     nested_method_import,
     nested_method_from_import,
+    nested_conditional_import,
+    nested_try_import,
 ])
 def test_nested_import(assert_errors, parse_ast_tree, code):
     """Testing that nested imports are restricted."""
@@ -46,19 +72,13 @@ def test_nested_import(assert_errors, parse_ast_tree, code):
     assert_errors(visiter, [NestedImportViolation])
 
 
-def test_regular_import(assert_errors, parse_ast_tree):
+@pytest.mark.parametrize('code', [
+    regular_import,
+    regular_from_import,
+])
+def test_regular_imports(assert_errors, parse_ast_tree, code):
     """Testing that regular imports are allowed."""
-    tree = parse_ast_tree('import os')
-
-    visiter = WrongImportVisitor()
-    visiter.visit(tree)
-
-    assert_errors(visiter, [])
-
-
-def test_regular_from_import(assert_errors, parse_ast_tree):
-    """Testing that regular from imports are allowed."""
-    tree = parse_ast_tree('from os import path')
+    tree = parse_ast_tree(code)
 
     visiter = WrongImportVisitor()
     visiter.visit(tree)

tests/test_visitors/test_wrong_name/test_class_attributes.py

@@ -6,9 +6,8 @@
 
 from wemake_python_styleguide.visitors.wrong_name import (
     BAD_VARIABLE_NAMES,
-    TooShortAttributeNameViolation,
+    PrivateNameViolation,
     TooShortVariableNameViolation,
-    WrongAttributeNameViolation,
     WrongNameVisitor,
     WrongVariableNameViolation,
 )
@@ -26,45 +25,61 @@ def __init__(self):
 
 
 @pytest.mark.parametrize('bad_name', BAD_VARIABLE_NAMES)
-@pytest.mark.parametrize('code,error', [
-    (static_attribute, WrongVariableNameViolation),
-    (instance_attribute, WrongAttributeNameViolation),
+@pytest.mark.parametrize('code', [
+    static_attribute,
+    instance_attribute,
 ])
 def test_wrong_attributes_names(
-    assert_errors, parse_ast_tree, bad_name, code, error,
+    assert_errors, parse_ast_tree, bad_name, code,
 ):
     """Testing that attribute can not have blacklisted names."""
     tree = parse_ast_tree(code.format(bad_name))
 
     visiter = WrongNameVisitor()
     visiter.visit(tree)
 
-    assert_errors(visiter, [error])
+    assert_errors(visiter, [WrongVariableNameViolation])
 
 
 @pytest.mark.parametrize('short_name', string.ascii_letters)
-@pytest.mark.parametrize('code,error', [
-    (static_attribute, TooShortVariableNameViolation),
-    (instance_attribute, TooShortAttributeNameViolation),
+@pytest.mark.parametrize('code', [
+    static_attribute,
+    instance_attribute,
 ])
 def test_too_short_attribute_names(
-    assert_errors, parse_ast_tree, short_name, code, error,
+    assert_errors, parse_ast_tree, short_name, code,
 ):
     """Testing that attribute can not have too short names."""
     tree = parse_ast_tree(code.format(short_name))
 
     visiter = WrongNameVisitor()
     visiter.visit(tree)
 
-    assert_errors(visiter, [error])
+    assert_errors(visiter, [TooShortVariableNameViolation])
+
+
+@pytest.mark.parametrize('code', [
+    static_attribute,
+    instance_attribute,
+])
+def test_private_attribute_names(
+    assert_errors, parse_ast_tree, code,
+):
+    """Testing that attribute can not have private names."""
+    tree = parse_ast_tree(code.format('__private_name'))
+
+    visiter = WrongNameVisitor()
+    visiter.visit(tree)
+
+    assert_errors(visiter, [PrivateNameViolation])
 
 
 @pytest.mark.parametrize('correct_name', [
     'correct_name',
     'xy',
     'test1',
-    '__private',
     '_protected',
+    '__magic__',
 ])
 @pytest.mark.parametrize('code', [
     static_attribute,

tests/test_visitors/test_wrong_name/test_function_args_names.py

@@ -6,9 +6,10 @@
 
 from wemake_python_styleguide.visitors.wrong_name import (
     BAD_VARIABLE_NAMES,
-    TooShortArgumentNameViolation,
-    WrongArgumentNameViolation,
+    PrivateNameViolation,
+    TooShortVariableNameViolation,
     WrongNameVisitor,
+    WrongVariableNameViolation,
 )
 
 function_test = """
@@ -58,8 +59,8 @@ def test_wrong_function_arguments(
     visiter.visit(tree)
 
     assert_errors(visiter, [
-        TooShortArgumentNameViolation,
-        WrongArgumentNameViolation,
+        TooShortVariableNameViolation,
+        WrongVariableNameViolation,
     ])
 
 
@@ -82,8 +83,31 @@ def test_too_short_function_arguments(
     visiter.visit(tree)
 
     assert_errors(visiter, [
-        TooShortArgumentNameViolation,
-        WrongArgumentNameViolation,
+        TooShortVariableNameViolation,
+        WrongVariableNameViolation,
+    ])
+
+
+@pytest.mark.parametrize('code', [
+    function_test,
+    method_test,
+    function_kwargs_test,
+    method_kwargs_test,
+    function_args_kwargs_test,
+    method_args_kwargs_test,
+])
+def test_private_function_arguments(
+    assert_errors, parse_ast_tree, code,
+):
+    """Testing that function can not have private arguments."""
+    tree = parse_ast_tree(code.format('__private', '__name'))
+
+    visiter = WrongNameVisitor()
+    visiter.visit(tree)
+
+    assert_errors(visiter, [
+        PrivateNameViolation,
+        PrivateNameViolation,
     ])
 
 

tests/test_visitors/test_wrong_name/test_function_names.py

@@ -6,9 +6,10 @@
 
 from wemake_python_styleguide.visitors.wrong_name import (
     BAD_VARIABLE_NAMES,
-    TooShortFunctionNameViolation,
-    WrongFunctionNameViolation,
+    PrivateNameViolation,
+    TooShortVariableNameViolation,
     WrongNameVisitor,
+    WrongVariableNameViolation,
 )
 
 function_bad_name = """
@@ -35,7 +36,7 @@ def test_wrong_function_names(
     visiter = WrongNameVisitor()
     visiter.visit(tree)
 
-    assert_errors(visiter, [WrongFunctionNameViolation])
+    assert_errors(visiter, [WrongVariableNameViolation])
 
 
 @pytest.mark.parametrize('short_name', string.ascii_letters)
@@ -52,10 +53,32 @@ def test_too_short_function_names(
     visiter = WrongNameVisitor()
     visiter.visit(tree)
 
-    assert_errors(visiter, [TooShortFunctionNameViolation])
+    assert_errors(visiter, [TooShortVariableNameViolation])
 
 
-@pytest.mark.parametrize('correct_name', ['my_function', 'xy', 'test'])
+@pytest.mark.parametrize('code', [
+    function_bad_name,
+    method_bad_name,
+])
+def test_private_function_names(
+    assert_errors, parse_ast_tree, code,
+):
+    """Testing that function can not have too short names."""
+    tree = parse_ast_tree(code.format('__hidden'))
+
+    visiter = WrongNameVisitor()
+    visiter.visit(tree)
+
+    assert_errors(visiter, [PrivateNameViolation])
+
+
+@pytest.mark.parametrize('correct_name', [
+    'my_function',
+    'xy',
+    'test',
+    '_protected',
+    '__magic__',
+])
 @pytest.mark.parametrize('code', [
     function_bad_name,
     method_bad_name,