datacls/test_datacls.py at main · rec/datacls · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
from typing import Dict

import datacls


@datacls
class One:
    one: str = 'one'
    two: int = 2
    three: Dict = datacls.field(dict)


@datacls(frozen=False)
class OneMutable:
    one: str = 'one'
    two: int = 2
    three: Dict = datacls.field(dict)


def test_datacls():
    o = One()
    assert o.asdict() == {'one': 'one', 'two': 2, 'three': {}}
    assert o.astuple() == ('one', 2, {})

    assert [f.name for f in One.fields()] == ['one', 'two', 'three']


def test_replace():
    o = One()
    o2 = o.replace(one='seven', three={'nine': 9})
    assert o2 == One('seven', 2, {'nine': 9})


def test_frozen():
    o = One()
    try:
        o.one = 'three'
    except AttributeError:
        pass
    else:
        raise AttributeError('Was mutable!')

    om = OneMutable()
    om.one = 'three'
    assert str(om) == "OneMutable(one='three', two=2, three={})"


@datacls
class Overloads:
    one: str = 'one'
    asdict: int = 1
    astuple: int = 1
    fields: int = 1
    replace: int = 1


def test_overloads():
    ov = Overloads()
    assert ov.one == 'one'
    assert ov.asdict == 1
    assert ov.astuple == 1
    assert ov.fields == 1
    assert ov.replace == 1

    d = {'asdict': 1, 'astuple': 1, 'fields': 1, 'one': 'one', 'replace': 1}
    assert datacls.asdict(ov) == d
    assert datacls.astuple(ov) == ('one', 1, 1, 1, 1)


@datacls
class Hidden:
    one: str = 'one'
    two: str = datacls.hidden()
    three: str = datacls.hidden()

    def __post_init__(self):
        super().__setattr__('two', self.one + self.one)
        super().__setattr__('three', self.two + self.one)


def test_hidden():
    assert str(Hidden()) == "Hidden(one='one')"

    g, h = Hidden(), Hidden()
    assert g.two == h.two
    assert g == h
    assert hash(g) == hash(h)

    object.__setattr__(h, 'two', 'ninety nine')
    assert g.two != h.two
    assert g == h
    assert hash(g) == hash(h)

    object.__setattr__(h, 'three', 'ninety nine')
    assert g.three != h.three
    assert g == h
    assert hash(g) == hash(h)

    try:
        Hidden(two='two')
    except TypeError:
        pass
    else:
        raise ValueError
    try:
        Hidden('1', 'two')
    except TypeError:
        pass
    else:
        raise ValueError


@datacls
class Default:
    one: str = datacls.field(default='one')


def test_default():
    assert Default().one == 'one'


def test_make_dataclass():
    # https://docs.python.org/3/library/dataclasses.html
    #    #dataclasses.make_dataclass
    C = datacls.make_dataclass(
        'C',
        [('x', int), 'y', ('z', int, datacls.field(default=5))],
        namespace={'add_one': lambda self: self.x + 1},
    )

    assert sorted(c.name for c in C.fields()) == ['x', 'y', 'z']