Drop support for pytest, don't try to find node when executing fails (#15)

* Drop support for pytest, don't try to find node when executing fails

* Check that bytecode_nameof returns a valid identifier

* Test nameof failing under pytest

* pylint

Author: alexmojaki

tests/test_varname.py

@@ -1,4 +1,6 @@
 import sys
+import unittest
+
 import pytest
 from varname import (varname,
                      VarnameRetrievingWarning,
@@ -26,12 +28,6 @@ def nameof(*args):
 varname_module.nameof = nameof
 
 
-def test_original_nameof():
-    x = 1
-    assert original_nameof(x) == nameof(x) == _bytecode_nameof(x) == 'x'
-
-
-
 @pytest.fixture
 def no_getframe():
     """
@@ -258,74 +254,103 @@ def test_wrapper():
     assert str(val1) == 'True'
     assert repr(val1) == "<Wrapper (name='val1', value=True)>"
 
-def test_nameof():
-    a = 1
-    b = nameof(a)
-    assert b == 'a'
-    nameof2 = nameof
-    c = nameof2(a, b)
-    assert b == 'a'
-    assert c == ('a', 'b')
 
-    def func():
-        return varname() + 'abc'
+class TestNameof(unittest.TestCase):
+    def test_original_nameof(self):
+        x = 1
+        self.assertEqual(original_nameof(x), 'x')
+        self.assertEqual(nameof(x), 'x')
+        self.assertEqual(_bytecode_nameof(x), 'x')
 
-    f = func()
-    assert f == 'fabc'
+    def test_nameof(self):
+        a = 1
+        b = nameof(a)
+        assert b == 'a'
+        nameof2 = nameof
+        c = nameof2(a, b)
+        assert b == 'a'
+        assert c == ('a', 'b')
 
-    assert nameof(f) == 'f'
-    assert 'f' == nameof(f)
-    assert len(nameof(f)) == 1
+        def func():
+            return varname() + 'abc'
 
-    fname1 = fname = nameof(f)
-    assert fname1 == fname == 'f'
+        f = func()
+        assert f == 'fabc'
 
-    with pytest.raises(VarnameRetrievingError):
-        nameof(a==1)
+        self.assertEqual(nameof(f), 'f')
+        self.assertEqual('f', nameof(f))
+        self.assertEqual(len(nameof(f)), 1)
 
-    with pytest.raises(VarnameRetrievingError):
-        _bytecode_nameof(a == 1)
+        fname1 = fname = nameof(f)
+        self.assertEqual(fname, 'f')
+        self.assertEqual(fname1, 'f')
 
-    with pytest.raises(VarnameRetrievingError):
-        nameof()
+        with pytest.raises(VarnameRetrievingError):
+            nameof(a==1)
 
-def test_nameof_statements():
-    a = {'test': 1}
-    test = {}
-    del a[nameof(test)]
-    assert a == {}
+        with pytest.raises(VarnameRetrievingError):
+            _bytecode_nameof(a == 1)
 
-    def func():
-        return nameof(test)
+        with pytest.raises(VarnameRetrievingError):
+            nameof()
 
-    assert func() == 'test'
+    def test_nameof_statements(self):
+        a = {'test': 1}
+        test = {}
+        del a[nameof(test)]
+        assert a == {}
 
-    def func2():
-        yield nameof(test)
+        def func():
+            return nameof(test)
+
+        assert func() == 'test'
+
+        def func2():
+            yield nameof(test)
 
-    assert list(func2()) == ['test']
+        assert list(func2()) == ['test']
 
-    def func3():
-        raise ValueError(nameof(test))
+        def func3():
+            raise ValueError(nameof(test))
 
-    with pytest.raises(ValueError) as verr:
-        func3()
-    assert str(verr.value) == 'test'
+        with pytest.raises(ValueError) as verr:
+            func3()
+        assert str(verr.value) == 'test'
 
-    for i in [0]:
-        assert nameof(test) == 'test'
-        assert len(nameof(test)) == 4
+        for i in [0]:
+            self.assertEqual(nameof(test), 'test')
+            self.assertEqual(len(nameof(test)), 4)
 
-def test_nameof_expr():
-    test = {}
-    assert len(varname_module.nameof(test)) == 4
+    def test_nameof_expr(self):
+        test = {}
+        self.assertEqual(len(varname_module.nameof(test)), 4)
+
+        lam = lambda: 0
+        lam.a = 1
+        with pytest.raises(VarnameRetrievingError) as vrerr:
+            varname_module.nameof(test, lam.a)
+        assert str(vrerr.value) == ("Only variables should "
+                                    "be passed to nameof.")
+
+
+def test_nameof_pytest_fail():
+    with pytest.raises(
+        VarnameRetrievingError,
+        match="Couldn't retrieve the call node. "
+              "This may happen if you're using some other AST magic"
+    ):
+        assert nameof(nameof) == 'nameof'
+
+
+def test_bytecode_pytest_nameof_fail():
+    with pytest.raises(
+        VarnameRetrievingError,
+        match="Found the variable name '@py_assert2' which is obviously wrong.",
+    ):
+        lam = lambda: 0
+        lam.a = 1
+        assert _bytecode_nameof(lam.a) == 'a'
 
-    lam = lambda: 0
-    lam.a = 1
-    with pytest.raises(VarnameRetrievingError) as vrerr:
-        varname_module.nameof(test, lam.a)
-    assert str(vrerr.value) == ("Only variables should "
-                                "be passed to nameof.")
 
 def test_class_property():
     class C:
@@ -382,7 +407,8 @@ def do(self):
             return 'I will do something'
 
     c = C()
-    assert c.iwill.do() == 'I will do something'
+    result = c.iwill.do()
+    assert result == 'I will do something'
 
 def test_will_fail():
 

varname.py

@@ -50,7 +50,11 @@ def _get_node(caller):
         return exet.node
 
     if exet.source.text and exet.source.tree:
-        return list(exet.statements)[0]
+        raise VarnameRetrievingError(
+            "Couldn't retrieve the call node. "
+            "This may happen if you're using some other AST magic at the "
+            "same time, such as pytest, ipython, macropy, or birdseye."
+        )
 
     return None
 
@@ -64,53 +68,6 @@ def _lookfor_parent_assign(node):
             return node
     return None
 
-def _lookfor_child_nameof(node):
-    """Look for ast.Call with func=Name(id='nameof',...)"""
-    # pylint: disable=too-many-return-statements
-    if isinstance(node, ast.Call):
-        # if node.func.id == 'nameof':
-        #     return node
-
-        # We want to support alias for nameof, i.e. nameof2
-        # Or called like: varname.nameof(test)
-        # If all args are ast.Name, then if must be alias of nameof
-        # Since this is originated from it, and there is no other
-        # ast.Call node in args
-        if not any(isinstance(arg, ast.Call) for arg in node.args):
-            return node
-
-        # print(nameof(test))
-        for arg in node.args:
-            found = _lookfor_child_nameof(arg)
-            if found:
-                return found
-
-    elif isinstance(node, ast.Compare):
-        # nameof(test) == 'test'
-        found = _lookfor_child_nameof(node.left)
-        if found:
-            return found
-        # 'test' == nameof(test)
-        for comp in node.comparators:
-            found = _lookfor_child_nameof(comp)
-            if found:
-                return found
-
-    elif isinstance(node, ast.Assert):
-        # assert nameof(test) == 'test'
-        found = _lookfor_child_nameof(node.test)
-        if found:
-            return found
-
-    elif isinstance(node, ast.Expr): # pragma: no cover
-        # print(nameof(test)) in ipython's forloop
-        # issue #5
-        found = _lookfor_child_nameof(node.value)
-        if found:
-            return found
-
-    return None
-
 
 def varname(caller=1, raise_exc=False):
     """Get the variable name that assigned by function/class calls
@@ -245,6 +202,7 @@ def inject(obj):
         raise VarnameRetrievingError('Unable to inject __varname__.')
     return obj
 
+
 def nameof(*args, caller=1):
     """Get the names of the variables passed in
 
@@ -255,7 +213,6 @@ def nameof(*args, caller=1):
         tuple|str: The names of variables passed in
     """
     node = _get_node(caller - 1)
-    node = _lookfor_child_nameof(node)
     if not node:
         if len(args) == 1:
             return _bytecode_nameof(caller + 1)
@@ -293,7 +250,16 @@ def _bytecode_nameof_cached(code, offset):
     name_instruction = instructions[current_instruction_index - 1]
     if not name_instruction.opname.startswith("LOAD_"):
         raise VarnameRetrievingError("Argument must be a variable or attribute")
-    return name_instruction.argrepr
+
+    name: str = name_instruction.argrepr
+    if not name.isidentifier():
+        raise VarnameRetrievingError(
+            f"Found the variable name {name!r} which is obviously wrong. "
+            "This may happen if you're using some other AST magic at the "
+            "same time, such as pytest, ipython, macropy, or birdseye."
+        )
+
+    return name
 
 
 def namedtuple(*args, **kwargs):