Coverage for tests/test_dict.py: 100%

167 statements  

« prev     ^ index     » next       coverage.py v7.4.1, created at 2024-02-29 10:26 +0100

1""" 

2test for Dict() 

3""" 

4import unittest 

5import json 

6 

7from stricto import String, Int, Dict, List, Bool, Error 

8 

9 

10class TestDict(unittest.TestCase): # pylint: disable=too-many-public-methods 

11 """ 

12 test for Dict() 

13 """ 

14 

15 def test_simple_type(self): 

16 """ 

17 Test type error 

18 """ 

19 a = Dict({"b": Int(), "c": Int()}) 

20 with self.assertRaises(Error) as e: 

21 a.set(12) 

22 self.assertEqual(e.exception.message, "Must be a dict") 

23 a.set({"b": 1, "c": 2}) 

24 self.assertEqual(a.b, 1) 

25 self.assertEqual(a.c, 2) 

26 self.assertEqual(a.b + a.c, 3) 

27 self.assertEqual(a.d, None) 

28 

29 def test_set_error(self): 

30 """ 

31 test set with error  

32 """ 

33 with self.assertRaises(Error) as e: 

34 Dict({"b": Int(), "c": Int(), "d": 23}) 

35 self.assertEqual(e.exception.message, "Not a schema") 

36 

37 def test_set_no_value(self): 

38 """ 

39 test set non existing value  

40 """ 

41 a = Dict({"b": Int(), "c": Int()}) 

42 with self.assertRaises(Error) as e: 

43 a.set({"b": 1, "c": 2, "d": "yolo"}) 

44 self.assertEqual(e.exception.message, "Unknown content") 

45 

46 def test_set_with_dict(self): 

47 """ 

48 test set non existing value  

49 """ 

50 a = Dict({"b": Int(), "c": Int()}) 

51 b = Dict({"b": Int(), "c": Int()}) 

52 a.set({"b": 1, "c": 2}) 

53 b.check(a) 

54 b.set(a) 

55 self.assertEqual(b.b, 1) 

56 

57 def test_locked(self): 

58 """ 

59 test locked 

60 """ 

61 a = Dict({"b": Int(), "c": Int()}) 

62 a.set({"b": 1, "c": 2}) 

63 with self.assertRaises(Error) as e: 

64 a.d = 22 

65 self.assertEqual(e.exception.message, "locked") 

66 

67 def test_get_keys(self): 

68 """ 

69 test get keys 

70 """ 

71 a = Dict({"b": Int(), "c": Int()}) 

72 self.assertEqual(a.keys(), [ "b", "c" ]) 

73 

74 def test_get_item(self): 

75 """ 

76 test get item 

77 """ 

78 a = Dict({"b": Int(), "c": Int()}) 

79 a.set({"b": 1, "c": 2}) 

80 self.assertEqual(a["b"], 1) 

81 self.assertEqual(a["yolo"], None) 

82 

83 def test_get(self): 

84 """ 

85 test get 

86 """ 

87 a = Dict({"b": Int( default=22 ), "c": Int()}) 

88 a.set({"c": 2}) 

89 self.assertEqual(a.get("b"), 22) 

90 self.assertEqual(a.get("c"), 2) 

91 self.assertEqual(a.get("notfound"), None) 

92 

93 def test_am_i_root(self): 

94 """ 

95 test am i root 

96 """ 

97 a = Dict({"b": Int(), "c": Int()}) 

98 a.set({"b": 1, "c": 2}) 

99 self.assertEqual( a.b.am_i_root(), False ) 

100 self.assertEqual( a.am_i_root(), True ) 

101 

102 def test_repr(self): 

103 """ 

104 test __repr__ 

105 """ 

106 a = Dict({"b": Int(), "c": Int()}) 

107 a.set({"b": 1, "c": 2}) 

108 c = repr( a ) 

109 self.assertEqual( type(c), str ) 

110 self.assertEqual( c, "{'b': 1, 'c': 2}" ) 

111 

112 def test_modify_schema(self): 

113 """ 

114 test schema modification 

115 """ 

116 a = Dict({"b": Int(), "c": Int()}) 

117 a.set({"b": 1, "c": 2}) 

118 a.add_to_model("d", String()) 

119 a.d = "oh yeah" 

120 self.assertEqual(a.d, "oh yeah") 

121 a.remove_model("d") 

122 with self.assertRaises(Error) as e: 

123 a.d = "oh yeah" 

124 self.assertEqual(e.exception.message, "locked") 

125 

126 def test_reference_type(self): 

127 """ 

128 Test references 

129 """ 

130 a = Dict({"b": Int(), "c": Int()}) 

131 a.set({"b": 1, "c": 2}) 

132 a.b = a.c 

133 a.c = 33 

134 self.assertEqual(a.b, 33) 

135 a.b = 22 

136 self.assertEqual(a.c, 22) 

137 

138 def test_equality(self): 

139 """ 

140 Test equality 

141 """ 

142 a = Dict({"b": Int(), "c": Int()}) 

143 a.set({"b": 1, "c": 2}) 

144 b=a.copy() 

145 self.assertEqual(a, b) 

146 self.assertEqual(a == b , True) 

147 self.assertEqual(a != b , False) 

148 b.b=22 

149 self.assertNotEqual(a, b) 

150 b = Dict({"b": Int(), "d": Int()}) 

151 b.set({"b": 1, "d": 2}) 

152 self.assertNotEqual(a, b) 

153 self.assertEqual(a != b, True) 

154 

155 def test_copy_type(self): 

156 """ 

157 Test copy 

158 """ 

159 a = Dict({"b": Int(), "c": Int()}) 

160 a.set({"b": 1, "c": 2}) 

161 a.b = a.c.copy() # pylint: disable=no-member 

162 a.c = 33 

163 self.assertEqual(a.b, 2) 

164 self.assertEqual(a.c, 33) 

165 

166 def test_copy_dict(self): 

167 """ 

168 Test copy all dict 

169 """ 

170 a = Dict({"b": Int(), "c": Int()}) 

171 a.set({"b": 1, "c": 2}) 

172 d = a.copy() 

173 self.assertEqual(type(d), type(a)) 

174 self.assertEqual(a, d) 

175 a.b = 22 

176 self.assertNotEqual(a, d) 

177 

178 def test_json(self): 

179 """ 

180 Test json <-> Dict 

181 """ 

182 model = {"b": Int(), "c": Int(), "e": List(String())} 

183 a = Dict(model) 

184 b = Dict(model) 

185 a.set({"b": 1, "c": 2, "e": ["aa", "bb"]}) 

186 

187 sa = json.dumps(a.get_value()) 

188 b.set(json.loads(sa)) 

189 self.assertEqual(b, a) 

190 

191 def test_auto_set(self): 

192 """ 

193 Test auto_set""" 

194 a = Dict( 

195 { 

196 "b": Int(default=12, set=lambda o: o.c + 1), 

197 "c": Int(default=0), 

198 } 

199 ) 

200 self.assertEqual(a.b, 12) 

201 a.set({"c": 2}) 

202 self.assertEqual(a.b, 3) 

203 a.c = 33 

204 self.assertEqual(a.b, 34) 

205 

206 def test_auto_set_2(self): 

207 """ 

208 Test autoset with lambda and cascading 

209 """ 

210 a = Dict( 

211 { 

212 "b": Int(default=0, set=lambda o: o.c + 1), 

213 "d": Int(default=0, set=lambda o: o.b + 1), 

214 "c": Int(), 

215 } 

216 ) 

217 a.set({"c": 2}) 

218 self.assertEqual(a.b, 3) 

219 self.assertEqual(a.d, 4) 

220 a.c = 33 

221 self.assertEqual(a.b, 34) 

222 self.assertEqual(a.d, 35) 

223 

224 def test_auto_set_error(self): 

225 """ 

226 try to modify an auto_set value 

227 """ 

228 a = Dict( 

229 { 

230 "b": Int(default=0, set=lambda o: o.c + 1), 

231 "d": Int(default=0, set=lambda o: o.b + 1), 

232 "c": Int(), 

233 } 

234 ) 

235 with self.assertRaises(Error) as e: 

236 a.set({"b": 2}) 

237 self.assertEqual(e.exception.message, "Cannot modify value") 

238 with self.assertRaises(Error) as e: 

239 a.b = 3 

240 self.assertEqual(e.exception.message, "Cannot modify value") 

241 

242 def test_auto_set_loop(self): 

243 """ 

244 loop in auto_set 

245 """ 

246 a = Dict( 

247 { 

248 "a": Int(), 

249 "b": Int(default=0, set=lambda o: o.c + 1), 

250 "c": Int(default=0, set=lambda o: o.b + 1), 

251 "d": Int(default=0, set=lambda o: o.c + 1), 

252 "e": Int(default=0, set=lambda o: o.d + 1), 

253 } 

254 ) 

255 a.set({"a": 2}) 

256 self.assertEqual(a.b, 1) 

257 self.assertEqual(a.c, 2) 

258 self.assertEqual(a.d, 3) 

259 self.assertEqual(a.e, 4) 

260 

261 

262 def test_not_exist(self): 

263 """ 

264 test not exist 

265 """ 

266 def check_exists(value, o): # pylint: disable=unused-argument 

267 """ 

268 return if exists or not 

269 """ 

270 return o.must_exists.get_value() 

271 

272 a = Dict( 

273 { 

274 "must_exists" : Bool( default=False), 

275 "a": Int(), 

276 "b": Int(default=1), 

277 "c": Int(default=2), 

278 "d": Int(default=3, required=True, exists=check_exists), 

279 "e": Int(default=4), 

280 } 

281 ) 

282 a.set({"a": 2}) 

283 with self.assertRaises(KeyError) as e: 

284 a.d=a.get_value()['d'] 

285 self.assertEqual(e.exception.args[0], "d") 

286 self.assertEqual(a.get('d'), None) 

287 self.assertEqual(repr (a), "{'must_exists': False, 'a': 2, 'b': 1, 'c': 2, 'e': 4}") 

288 

289 with self.assertRaises(Error) as e: 

290 a.set({"d": 2}) 

291 self.assertEqual(e.exception.message, "locked") 

292 with self.assertRaises(Error) as e: 

293 a.d=2 

294 self.assertEqual(e.exception.message, "locked") 

295 

296 a.must_exists = True 

297 self.assertEqual(a.get('d'), 3) 

298 self.assertEqual(a.get_value()['d'], 3) 

299 self.assertEqual(repr (a), "{'must_exists': True, 'a': 2, 'b': 1, 'c': 2, 'd': 3, 'e': 4}") 

300 a.set({"d": 2}) 

301 self.assertEqual(a.d, 2)