after review

Author: albertedwardson

tests/fixtures/noqa/noqa.py

@@ -122,20 +122,13 @@ class Nested:  # noqa: WPS431
 
     def nested():  # noqa: WPS430
         ...
-    
-    def factory():  # ok
-        if some_condition():
-            def deep_nested():  # noqa: WPS430
-                    ...
-        else:
-            def wrapper(): # ok
-                ...
-            if some_other_condition():
-                def deep_nested():  # noqa: WPS430
-                    ...
-            else:
-                def decorator(): # ok
-                    ...
+
+    if some_condition():
+        def deep_nested():  # noqa: WPS430
+            ...
+    else:
+        async def deep_nested():  # noqa: WPS430
+            ...
 
 
 del {'a': 1}['a']  # noqa: WPS420

tests/test_visitors/test_ast/test_complexity/test_nested/test_nested_functions.py

@@ -234,6 +234,34 @@ def test_whitelist_nested_functions(
     [
         nested_function_in_if,
         nested_function_in_if_else,
+    ],
+)
+def test_deep_whitelist_nested_functions_allowed(
+    assert_errors,
+    assert_error_text,
+    parse_ast_tree,
+    whitelist_name,
+    code,
+    default_options,
+    mode,
+):
+    """
+    Test for allowed whitelisted functions inside single if(/else) block.
+
+    See: https://github.com/wemake-services/wemake-python-styleguide/issues/3589
+    """
+    tree = parse_ast_tree(mode(code.format(whitelist_name)))
+
+    visitor = NestedComplexityVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [])
+
+
+@pytest.mark.parametrize('whitelist_name', NESTED_FUNCTIONS_WHITELIST)
+@pytest.mark.parametrize(
+    'code',
+    [
         nested_function_while_loop,
         nested_function_in_for_loop,
         nested_function_in_try,
@@ -251,13 +279,14 @@ def test_deep_whitelist_nested_functions(
     default_options,
     mode,
 ):
-    """Testing that it is possible to nest whitelisted functions."""
+    """Testing that it is restricted to nest even whitelisted functions."""
     tree = parse_ast_tree(mode(code.format(whitelist_name)))
 
     visitor = NestedComplexityVisitor(default_options, tree=tree)
     visitor.run()
 
-    assert_errors(visitor, [])
+    assert_errors(visitor, [NestedFunctionViolation])
+    assert_error_text(visitor, whitelist_name)
 
 
 @pytest.mark.parametrize(

wemake_python_styleguide/visitors/ast/complexity/nested.py

@@ -56,16 +56,23 @@ def visit_Lambda(self, node: ast.Lambda) -> None:
         self.generic_visit(node)
 
     def _check_nested_function(self, node: AnyFunctionDef) -> None:
-        is_inside_function = isinstance(get_context(node), FunctionNodes)
+        if not isinstance(get_context(node), FunctionNodes):
+            return
 
-        is_not_whitelisted = node.name not in NESTED_FUNCTIONS_WHITELIST
-        is_direct = isinstance(get_parent(node), FunctionNodes)
-        is_bad = is_direct and is_not_whitelisted
+        parent = get_parent(node)
 
-        if is_bad or (
-            is_inside_function and not is_direct and is_not_whitelisted
+        is_direct = isinstance(parent, FunctionNodes)
+
+        is_single_if = isinstance(parent, ast.If) and isinstance(
+            get_parent(parent), FunctionNodes
+        )
+
+        if node.name not in NESTED_FUNCTIONS_WHITELIST or not (
+            is_direct or is_single_if
         ):
-            self.add_violation(NestedFunctionViolation(node, text=node.name))
+            self.add_violation(
+                NestedFunctionViolation(node, text=node.name),
+            )
 
     def _check_nested_classes(self, node: ast.ClassDef) -> None:
         parent_context = get_context(node)