Initial commit
This commit is contained in:
535
venv/lib/python3.8/site-packages/tests/unittest_objects.py
Normal file
535
venv/lib/python3.8/site-packages/tests/unittest_objects.py
Normal file
@@ -0,0 +1,535 @@
|
||||
# Copyright (c) 2015-2016, 2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
|
||||
# Copyright (c) 2015-2016 Ceridwen <ceridwenv@gmail.com>
|
||||
# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
|
||||
# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
|
||||
|
||||
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
|
||||
# For details: https://github.com/PyCQA/astroid/blob/master/COPYING.LESSER
|
||||
|
||||
|
||||
import unittest
|
||||
|
||||
from astroid import bases
|
||||
from astroid import builder
|
||||
from astroid import exceptions
|
||||
from astroid import nodes
|
||||
from astroid import objects
|
||||
from astroid import test_utils
|
||||
|
||||
|
||||
class ObjectsTest(unittest.TestCase):
|
||||
def test_frozenset(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
frozenset({1: 2, 2: 3}) #@
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
self.assertIsInstance(inferred, objects.FrozenSet)
|
||||
|
||||
self.assertEqual(inferred.pytype(), "%s.frozenset" % bases.BUILTINS)
|
||||
|
||||
itered = inferred.itered()
|
||||
self.assertEqual(len(itered), 2)
|
||||
self.assertIsInstance(itered[0], nodes.Const)
|
||||
self.assertEqual([const.value for const in itered], [1, 2])
|
||||
|
||||
proxied = inferred._proxied
|
||||
self.assertEqual(inferred.qname(), "%s.frozenset" % bases.BUILTINS)
|
||||
self.assertIsInstance(proxied, nodes.ClassDef)
|
||||
|
||||
|
||||
class SuperTests(unittest.TestCase):
|
||||
def test_inferring_super_outside_methods(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class Module(object):
|
||||
pass
|
||||
class StaticMethod(object):
|
||||
@staticmethod
|
||||
def static():
|
||||
# valid, but we don't bother with it.
|
||||
return super(StaticMethod, StaticMethod) #@
|
||||
# super outside methods aren't inferred
|
||||
super(Module, Module) #@
|
||||
# no argument super is not recognised outside methods as well.
|
||||
super() #@
|
||||
"""
|
||||
)
|
||||
in_static = next(ast_nodes[0].value.infer())
|
||||
self.assertIsInstance(in_static, bases.Instance)
|
||||
self.assertEqual(in_static.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
module_level = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(module_level, bases.Instance)
|
||||
self.assertEqual(in_static.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
no_arguments = next(ast_nodes[2].infer())
|
||||
self.assertIsInstance(no_arguments, bases.Instance)
|
||||
self.assertEqual(no_arguments.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
def test_inferring_unbound_super_doesnt_work(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
class Test(object):
|
||||
def __init__(self):
|
||||
super(Test) #@
|
||||
"""
|
||||
)
|
||||
unbounded = next(node.infer())
|
||||
self.assertIsInstance(unbounded, bases.Instance)
|
||||
self.assertEqual(unbounded.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
def test_use_default_inference_on_not_inferring_args(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class Test(object):
|
||||
def __init__(self):
|
||||
super(Lala, self) #@
|
||||
super(Test, lala) #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, bases.Instance)
|
||||
self.assertEqual(first.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, bases.Instance)
|
||||
self.assertEqual(second.qname(), "%s.super" % bases.BUILTINS)
|
||||
|
||||
@test_utils.require_version(minver="3.0")
|
||||
def test_no_arguments_super(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class First(object): pass
|
||||
class Second(First):
|
||||
def test(self):
|
||||
super() #@
|
||||
@classmethod
|
||||
def test_classmethod(cls):
|
||||
super() #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, objects.Super)
|
||||
self.assertIsInstance(first.type, bases.Instance)
|
||||
self.assertEqual(first.type.name, "Second")
|
||||
self.assertIsInstance(first.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(first.mro_pointer.name, "Second")
|
||||
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, objects.Super)
|
||||
self.assertIsInstance(second.type, nodes.ClassDef)
|
||||
self.assertEqual(second.type.name, "Second")
|
||||
self.assertIsInstance(second.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(second.mro_pointer.name, "Second")
|
||||
|
||||
def test_super_simple_cases(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class First(object): pass
|
||||
class Second(First): pass
|
||||
class Third(First):
|
||||
def test(self):
|
||||
super(Third, self) #@
|
||||
super(Second, self) #@
|
||||
|
||||
# mro position and the type
|
||||
super(Third, Third) #@
|
||||
super(Third, Second) #@
|
||||
super(Fourth, Fourth) #@
|
||||
|
||||
class Fourth(Third):
|
||||
pass
|
||||
"""
|
||||
)
|
||||
|
||||
# .type is the object which provides the mro.
|
||||
# .mro_pointer is the position in the mro from where
|
||||
# the lookup should be done.
|
||||
|
||||
# super(Third, self)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, objects.Super)
|
||||
self.assertIsInstance(first.type, bases.Instance)
|
||||
self.assertEqual(first.type.name, "Third")
|
||||
self.assertIsInstance(first.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(first.mro_pointer.name, "Third")
|
||||
|
||||
# super(Second, self)
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, objects.Super)
|
||||
self.assertIsInstance(second.type, bases.Instance)
|
||||
self.assertEqual(second.type.name, "Third")
|
||||
self.assertIsInstance(first.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(second.mro_pointer.name, "Second")
|
||||
|
||||
# super(Third, Third)
|
||||
third = next(ast_nodes[2].infer())
|
||||
self.assertIsInstance(third, objects.Super)
|
||||
self.assertIsInstance(third.type, nodes.ClassDef)
|
||||
self.assertEqual(third.type.name, "Third")
|
||||
self.assertIsInstance(third.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(third.mro_pointer.name, "Third")
|
||||
|
||||
# super(Third, second)
|
||||
fourth = next(ast_nodes[3].infer())
|
||||
self.assertIsInstance(fourth, objects.Super)
|
||||
self.assertIsInstance(fourth.type, nodes.ClassDef)
|
||||
self.assertEqual(fourth.type.name, "Second")
|
||||
self.assertIsInstance(fourth.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(fourth.mro_pointer.name, "Third")
|
||||
|
||||
# Super(Fourth, Fourth)
|
||||
fifth = next(ast_nodes[4].infer())
|
||||
self.assertIsInstance(fifth, objects.Super)
|
||||
self.assertIsInstance(fifth.type, nodes.ClassDef)
|
||||
self.assertEqual(fifth.type.name, "Fourth")
|
||||
self.assertIsInstance(fifth.mro_pointer, nodes.ClassDef)
|
||||
self.assertEqual(fifth.mro_pointer.name, "Fourth")
|
||||
|
||||
def test_super_infer(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
class Super(object):
|
||||
def __init__(self):
|
||||
super(Super, self) #@
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
self.assertIsInstance(inferred, objects.Super)
|
||||
reinferred = next(inferred.infer())
|
||||
self.assertIsInstance(reinferred, objects.Super)
|
||||
self.assertIs(inferred, reinferred)
|
||||
|
||||
def test_inferring_invalid_supers(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class Super(object):
|
||||
def __init__(self):
|
||||
# MRO pointer is not a type
|
||||
super(1, self) #@
|
||||
# MRO type is not a subtype
|
||||
super(Super, 1) #@
|
||||
# self is not a subtype of Bupper
|
||||
super(Bupper, self) #@
|
||||
class Bupper(Super):
|
||||
pass
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, objects.Super)
|
||||
with self.assertRaises(exceptions.SuperError) as cm:
|
||||
first.super_mro()
|
||||
self.assertIsInstance(cm.exception.super_.mro_pointer, nodes.Const)
|
||||
self.assertEqual(cm.exception.super_.mro_pointer.value, 1)
|
||||
for node, invalid_type in zip(ast_nodes[1:], (nodes.Const, bases.Instance)):
|
||||
inferred = next(node.infer())
|
||||
self.assertIsInstance(inferred, objects.Super, node)
|
||||
with self.assertRaises(exceptions.SuperError) as cm:
|
||||
inferred.super_mro()
|
||||
self.assertIsInstance(cm.exception.super_.type, invalid_type)
|
||||
|
||||
def test_proxied(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
class Super(object):
|
||||
def __init__(self):
|
||||
super(Super, self) #@
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
proxied = inferred._proxied
|
||||
self.assertEqual(proxied.qname(), "%s.super" % bases.BUILTINS)
|
||||
self.assertIsInstance(proxied, nodes.ClassDef)
|
||||
|
||||
def test_super_bound_model(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class First(object):
|
||||
def method(self):
|
||||
pass
|
||||
@classmethod
|
||||
def class_method(cls):
|
||||
pass
|
||||
class Super_Type_Type(First):
|
||||
def method(self):
|
||||
super(Super_Type_Type, Super_Type_Type).method #@
|
||||
super(Super_Type_Type, Super_Type_Type).class_method #@
|
||||
@classmethod
|
||||
def class_method(cls):
|
||||
super(Super_Type_Type, Super_Type_Type).method #@
|
||||
super(Super_Type_Type, Super_Type_Type).class_method #@
|
||||
|
||||
class Super_Type_Object(First):
|
||||
def method(self):
|
||||
super(Super_Type_Object, self).method #@
|
||||
super(Super_Type_Object, self).class_method #@
|
||||
"""
|
||||
)
|
||||
# Super(type, type) is the same for both functions and classmethods.
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, nodes.FunctionDef)
|
||||
self.assertEqual(first.name, "method")
|
||||
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, bases.BoundMethod)
|
||||
self.assertEqual(second.bound.name, "First")
|
||||
self.assertEqual(second.type, "classmethod")
|
||||
|
||||
third = next(ast_nodes[2].infer())
|
||||
self.assertIsInstance(third, nodes.FunctionDef)
|
||||
self.assertEqual(third.name, "method")
|
||||
|
||||
fourth = next(ast_nodes[3].infer())
|
||||
self.assertIsInstance(fourth, bases.BoundMethod)
|
||||
self.assertEqual(fourth.bound.name, "First")
|
||||
self.assertEqual(fourth.type, "classmethod")
|
||||
|
||||
# Super(type, obj) can lead to different attribute bindings
|
||||
# depending on the type of the place where super was called.
|
||||
fifth = next(ast_nodes[4].infer())
|
||||
self.assertIsInstance(fifth, bases.BoundMethod)
|
||||
self.assertEqual(fifth.bound.name, "First")
|
||||
self.assertEqual(fifth.type, "method")
|
||||
|
||||
sixth = next(ast_nodes[5].infer())
|
||||
self.assertIsInstance(sixth, bases.BoundMethod)
|
||||
self.assertEqual(sixth.bound.name, "First")
|
||||
self.assertEqual(sixth.type, "classmethod")
|
||||
|
||||
def test_super_getattr_single_inheritance(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class First(object):
|
||||
def test(self): pass
|
||||
class Second(First):
|
||||
def test2(self): pass
|
||||
class Third(Second):
|
||||
test3 = 42
|
||||
def __init__(self):
|
||||
super(Third, self).test2 #@
|
||||
super(Third, self).test #@
|
||||
# test3 is local, no MRO lookup is done.
|
||||
super(Third, self).test3 #@
|
||||
super(Third, self) #@
|
||||
|
||||
# Unbounds.
|
||||
super(Third, Third).test2 #@
|
||||
super(Third, Third).test #@
|
||||
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, bases.BoundMethod)
|
||||
self.assertEqual(first.bound.name, "Second")
|
||||
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, bases.BoundMethod)
|
||||
self.assertEqual(second.bound.name, "First")
|
||||
|
||||
with self.assertRaises(exceptions.InferenceError):
|
||||
next(ast_nodes[2].infer())
|
||||
fourth = next(ast_nodes[3].infer())
|
||||
with self.assertRaises(exceptions.AttributeInferenceError):
|
||||
fourth.getattr("test3")
|
||||
with self.assertRaises(exceptions.AttributeInferenceError):
|
||||
next(fourth.igetattr("test3"))
|
||||
|
||||
first_unbound = next(ast_nodes[4].infer())
|
||||
self.assertIsInstance(first_unbound, nodes.FunctionDef)
|
||||
self.assertEqual(first_unbound.name, "test2")
|
||||
self.assertEqual(first_unbound.parent.name, "Second")
|
||||
|
||||
second_unbound = next(ast_nodes[5].infer())
|
||||
self.assertIsInstance(second_unbound, nodes.FunctionDef)
|
||||
self.assertEqual(second_unbound.name, "test")
|
||||
self.assertEqual(second_unbound.parent.name, "First")
|
||||
|
||||
def test_super_invalid_mro(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
class A(object):
|
||||
test = 42
|
||||
class Super(A, A):
|
||||
def __init__(self):
|
||||
super(Super, self) #@
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
with self.assertRaises(exceptions.AttributeInferenceError):
|
||||
next(inferred.getattr("test"))
|
||||
|
||||
def test_super_complex_mro(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class A(object):
|
||||
def spam(self): return "A"
|
||||
def foo(self): return "A"
|
||||
@staticmethod
|
||||
def static(self): pass
|
||||
class B(A):
|
||||
def boo(self): return "B"
|
||||
def spam(self): return "B"
|
||||
class C(A):
|
||||
def boo(self): return "C"
|
||||
class E(C, B):
|
||||
def __init__(self):
|
||||
super(E, self).boo #@
|
||||
super(C, self).boo #@
|
||||
super(E, self).spam #@
|
||||
super(E, self).foo #@
|
||||
super(E, self).static #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, bases.BoundMethod)
|
||||
self.assertEqual(first.bound.name, "C")
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, bases.BoundMethod)
|
||||
self.assertEqual(second.bound.name, "B")
|
||||
third = next(ast_nodes[2].infer())
|
||||
self.assertIsInstance(third, bases.BoundMethod)
|
||||
self.assertEqual(third.bound.name, "B")
|
||||
fourth = next(ast_nodes[3].infer())
|
||||
self.assertEqual(fourth.bound.name, "A")
|
||||
static = next(ast_nodes[4].infer())
|
||||
self.assertIsInstance(static, nodes.FunctionDef)
|
||||
self.assertEqual(static.parent.scope().name, "A")
|
||||
|
||||
def test_super_data_model(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class X(object): pass
|
||||
class A(X):
|
||||
def __init__(self):
|
||||
super(A, self) #@
|
||||
super(A, A) #@
|
||||
super(X, A) #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
thisclass = first.getattr("__thisclass__")[0]
|
||||
self.assertIsInstance(thisclass, nodes.ClassDef)
|
||||
self.assertEqual(thisclass.name, "A")
|
||||
selfclass = first.getattr("__self_class__")[0]
|
||||
self.assertIsInstance(selfclass, nodes.ClassDef)
|
||||
self.assertEqual(selfclass.name, "A")
|
||||
self_ = first.getattr("__self__")[0]
|
||||
self.assertIsInstance(self_, bases.Instance)
|
||||
self.assertEqual(self_.name, "A")
|
||||
cls = first.getattr("__class__")[0]
|
||||
self.assertEqual(cls, first._proxied)
|
||||
|
||||
second = next(ast_nodes[1].infer())
|
||||
thisclass = second.getattr("__thisclass__")[0]
|
||||
self.assertEqual(thisclass.name, "A")
|
||||
self_ = second.getattr("__self__")[0]
|
||||
self.assertIsInstance(self_, nodes.ClassDef)
|
||||
self.assertEqual(self_.name, "A")
|
||||
|
||||
third = next(ast_nodes[2].infer())
|
||||
thisclass = third.getattr("__thisclass__")[0]
|
||||
self.assertEqual(thisclass.name, "X")
|
||||
selfclass = third.getattr("__self_class__")[0]
|
||||
self.assertEqual(selfclass.name, "A")
|
||||
|
||||
def assertEqualMro(self, klass, expected_mro):
|
||||
self.assertEqual([member.name for member in klass.super_mro()], expected_mro)
|
||||
|
||||
def test_super_mro(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
class A(object): pass
|
||||
class B(A): pass
|
||||
class C(A): pass
|
||||
class E(C, B):
|
||||
def __init__(self):
|
||||
super(E, self) #@
|
||||
super(C, self) #@
|
||||
super(B, self) #@
|
||||
|
||||
super(B, 1) #@
|
||||
super(1, B) #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertEqualMro(first, ["C", "B", "A", "object"])
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertEqualMro(second, ["B", "A", "object"])
|
||||
third = next(ast_nodes[2].infer())
|
||||
self.assertEqualMro(third, ["A", "object"])
|
||||
|
||||
fourth = next(ast_nodes[3].infer())
|
||||
with self.assertRaises(exceptions.SuperError):
|
||||
fourth.super_mro()
|
||||
fifth = next(ast_nodes[4].infer())
|
||||
with self.assertRaises(exceptions.SuperError):
|
||||
fifth.super_mro()
|
||||
|
||||
def test_super_yes_objects(self):
|
||||
ast_nodes = builder.extract_node(
|
||||
"""
|
||||
from collections import Missing
|
||||
class A(object):
|
||||
def __init__(self):
|
||||
super(Missing, self) #@
|
||||
super(A, Missing) #@
|
||||
"""
|
||||
)
|
||||
first = next(ast_nodes[0].infer())
|
||||
self.assertIsInstance(first, bases.Instance)
|
||||
second = next(ast_nodes[1].infer())
|
||||
self.assertIsInstance(second, bases.Instance)
|
||||
|
||||
def test_super_invalid_types(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
import collections
|
||||
class A(object):
|
||||
def __init__(self):
|
||||
super(A, collections) #@
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
with self.assertRaises(exceptions.SuperError):
|
||||
inferred.super_mro()
|
||||
with self.assertRaises(exceptions.SuperError):
|
||||
inferred.super_mro()
|
||||
|
||||
def test_super_properties(self):
|
||||
node = builder.extract_node(
|
||||
"""
|
||||
class Foo(object):
|
||||
@property
|
||||
def dict(self):
|
||||
return 42
|
||||
|
||||
class Bar(Foo):
|
||||
@property
|
||||
def dict(self):
|
||||
return super(Bar, self).dict
|
||||
|
||||
Bar().dict
|
||||
"""
|
||||
)
|
||||
inferred = next(node.infer())
|
||||
self.assertIsInstance(inferred, nodes.Const)
|
||||
self.assertEqual(inferred.value, 42)
|
||||
|
||||
def test_super_qname(self):
|
||||
"""Make sure a Super object generates a qname
|
||||
equivalent to super.__qname__
|
||||
"""
|
||||
# See issue 533
|
||||
code = """
|
||||
class C:
|
||||
def foo(self): return super()
|
||||
C().foo() #@
|
||||
"""
|
||||
super_obj = next(builder.extract_node(code).infer())
|
||||
self.assertEqual(super_obj.qname(), "super")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user