Updated tests to cover the latest changes

Author: Sylvain MARIE

autoclass/tests/doc/test_readme_index.py

@@ -14,6 +14,23 @@
 from autoclass import autoargs, autoprops, setter_override, autoclass
 
 
+def test_readme_index_pyfields():
+    """ """
+    from pyfields import field
+
+    @autoclass
+    class House(object):
+        name = field(check_type=True, type_hint=str, doc="the name of your house")
+        nb_floors = field(default=100, check_type=True, type_hint=int, doc="the nb floors",
+                          validators={"should be positive": lambda x: x >= 0,
+                                      "should be a multiple of 100": lambda x: x % 100 == 0})
+
+    h = House(name="mine")
+    with pytest.raises(ValueError):
+        h.nb_floors = 101
+    assert str(h) == "House(name='mine', nb_floors=100)"
+
+
 def test_readme_index_basic():
     """ First basic example in the doc """
 
@@ -23,7 +40,7 @@ def __init__(self, name, nb_floors=1):
             pass
 
     a = House('my_house', 3)
-    assert str(a) == "House({'name': 'my_house', 'nb_floors': 3})"
+    assert str(a) == "House(name='my_house', nb_floors=3)"
     assert [att for att in a.keys()] == ['name', 'nb_floors']
     assert {a, a} == {a}
     assert a == {'name': 'my_house', 'nb_floors': 3}

autoclass/tests/doc/test_readme_usage.py

@@ -120,6 +120,29 @@ def __init__(self,
                  '_D__class_private': 't'}  # notice the name
 
 
+def test_readme_usage_autodict_4():
+
+    @autodict(only_constructor_args=False, only_public_fields=False)
+    @autoprops
+    class D(object):
+        @autoargs
+        def __init__(self,
+                     a,  # type: str
+                     b  # type: List[str]
+                     ):
+            self.non_constructor_arg = 'b'
+            self._private = 1
+            self.__class_private = 't'
+
+    o = D(1, 'r')
+    # o behaves like a read-only dict, all fields are now visible
+    assert o == dict(o)
+    assert o == {'a': 1, 'b': 'r',
+                 'non_constructor_arg': 'b',
+                 '_private': 1,
+                 '_D__class_private': 't'}  # notice the name
+
+
 def test_readme_usage_autohash_1():
     @autohash
     class A(object):

autoclass/tests/features/test_autoclass.py

@@ -50,7 +50,7 @@ def __init__(self, bar, foo1, foo2=0):
     assert list(a.keys()) == ['bar', 'foo1', 'foo2']
 
     # order in prints is same than in init
-    assert str(a) == "Bar({'bar': 2, 'foo1': 'th', 'foo2': 0})"
+    assert str(a) == "Bar(bar=2, foo1='th', foo2=0)"
 
 
 def test_autoclass_pickle_inheritance():
@@ -66,7 +66,7 @@ def test_autoclass_pickle_inheritance():
     assert list(a.keys()) == ['bar', 'foo1', 'foo2']
 
     # order in prints is fixed
-    assert str(a) == "Bar({'bar': 2, 'foo1': 'th', 'foo2': 0})"
+    assert str(a) == "Bar(bar=2, foo1='th', foo2=0)"
 
     # pickle
     pik = pickle.dumps(a)
@@ -99,7 +99,7 @@ def __init__(self, bar, foo1, foo2=0):
     assert list(a.keys()) == ['bar', 'foo1', 'foo2']
 
     # order in prints is fixed
-    assert str(a) == "Bar({'bar': 2, 'foo1': 'th', 'foo2': 0})"
+    assert str(a) == "Bar(bar=2, foo1='th', foo2=0)"
 
 
 def test_autoclass_pyfields():
@@ -126,4 +126,4 @@ class Bar(Foo):
     assert list(a.keys()) == ['foo1', 'foo2', 'bar']
 
     # order in prints is the same than in init
-    assert str(a) == "Bar({'foo1': 'th', 'foo2': 0, 'bar': 2})"
+    assert str(a) == "Bar(foo1='th', foo2=0, bar=2)"

autoclass/tests/features/test_autodict.py

@@ -145,7 +145,7 @@ class Foo(object):
         foo1 = field()
         foo2 = field(default=0)
 
-    @autodict
+    @autodict(legacy_str_repr=True)
     class Bar(Foo):
         bar = field()
 
@@ -163,5 +163,5 @@ class Bar(Foo):
     # iteration order is correct
     assert list(a.keys()) == ['foo1', 'foo2', 'bar']
 
-    # order in prints is correct
+    # order in prints is correct in legacy str mode
     assert str(a) == "Bar({'foo1': 'th', 'foo2': 0, 'bar': 2})"

autoclass/tests/features/test_autorepr.py

@@ -0,0 +1,109 @@
+#  Authors: Sylvain Marie <sylvain.marie@se.com>
+#
+#  Copyright (c) Schneider Electric Industries, 2019. All right reserved.
+import sys
+
+import pytest
+
+from autoclass import autorepr
+
+
+@pytest.mark.skipif(sys.version_info < (3, 6), reason="class vars order is not preserved")
+@pytest.mark.parametrize('only_public_fields', [True, False], ids=lambda x: 'only_public' if x else 'including class-private dunder fields')
+@pytest.mark.parametrize('only_known_fields', [True, False], ids=lambda x: 'only_constructor_args' if x else 'all_obj_fields')
+@pytest.mark.parametrize("curly_mode", [False, True], ids="curly_mode={}".format)
+def test_autorepr(only_known_fields, only_public_fields, curly_mode):
+    """ @autorepr functionality with various customization options for only_constructor_args/only_public_fields """
+
+    if curly_mode:
+        def format_pairs(cls, pairs):
+            return "%s(**{%s})" % (cls.__name__, ", ".join(["%r: %r" % pair for pair in pairs]))
+    else:
+        def format_pairs(cls, pairs):
+            return "%s(%s)" % (cls.__name__, ", ".join(["%s=%r" % pair for pair in pairs]))
+
+    @autorepr(only_known_fields=only_known_fields, only_public_fields=only_public_fields, curly_string_repr=curly_mode)
+    class FooConfigA(object):
+
+        dummy_class_field = 'just to be sure it does not appear'
+
+        def __init__(self,
+                     a,  # type: str,
+                     b   # type: List[str]
+                     ):
+            self.a = a
+            self.b = b
+            self.c = 't'
+            self._weak_private = 'r'
+            self.__class_private = 't'
+
+        def dummy_func(self):
+            """ we create this just to be sure the function is not in the dict view """
+            pass
+
+    t = FooConfigA('rhubarb', ['pie', 'pie2'])
+    t.new_field = 0
+    t._new_field_weak_private = 1
+    t.__new_field_class_private_incorrect = 0
+
+    class Dummy:
+        t.__new_field_class_private = 1
+
+    # check the str/repr
+    assert str(t) == repr(t)
+
+    if only_known_fields:
+        pairs = [('a', 'rhubarb'),  # only the two constructor fields appear
+                 ('b', ['pie', 'pie2'])]
+    elif only_public_fields:
+        pairs = [('a', 'rhubarb'),
+                 ('b', ['pie', 'pie2']),
+                 ('c', 't'),
+                 # _FooConfigA__class_private should not appear
+                 ('new_field', 0)
+                 #'_weak_private': 'r',
+                 #'_new_field_weak_private': 1,
+                 # private fields defined out of the objects class are still visible
+                 #'__new_field_class_private_incorrect': 0,
+                 #'_Dummy__new_field_class_private': 1
+                 ]
+    else:
+        pairs = [('a', 'rhubarb'),
+                 ('b', ['pie', 'pie2']),
+                 ('c', 't'),
+                 ('_weak_private', 'r'),
+                 ('_FooConfigA__class_private', 't'),  # <= this is the one private field that appears now
+                 ('new_field', 0),
+                 ('_new_field_weak_private', 1),
+                 # private fields defined out of the objects class are still visible
+                 ('__new_field_class_private_incorrect', 0),
+                 ('_Dummy__new_field_class_private', 1)]
+
+    assert str(t) == format_pairs(FooConfigA, pairs)
+
+
+@pytest.mark.parametrize("curly_mode", [False, True], ids="curly_mode={}".format)
+def test_autorepr_pyfields(curly_mode):
+    """tests that @autorepr works with pyfields"""
+
+    from pyfields import field
+
+    @autorepr
+    class Foo(object):
+        foo1 = field()
+        foo2 = field(default=0)
+
+    @autorepr(curly_string_repr=curly_mode)
+    class Bar(Foo):
+        bar = field()
+
+    # create an object manually
+    a = Bar()
+    a.bar = 2
+    a.foo1 = 'th'
+
+    # order in prints is correct in legacy str mode
+    if curly_mode:
+        assert str(a) == "Bar(**{'foo1': 'th', 'foo2': 0, 'bar': 2})"
+    else:
+        assert str(a) == "Bar(foo1='th', foo2=0, bar=2)"