pyrox.dev
1From 0080bf5c2792f5d8d678c4451b26cd1ad5341209 Mon Sep 17 00:00:00 2001
2From: Florian Klink <flokli@flokli.de>
3Date: Tue, 1 Apr 2025 16:27:42 +0100
4Subject: [PATCH 2/2] tests: self.assertEquals -> self.assertEqual
5
6This is how that assertion is called.
7---
8 tests/memprofiler_tests.py | 26 ++++----
9 tests/parser_tests.py | 124 ++++++++++++++++++-------------------
10 tests/protocol_tests.py | 6 +-
11 3 files changed, 78 insertions(+), 78 deletions(-)
12
13diff --git a/tests/memprofiler_tests.py b/tests/memprofiler_tests.py
14index 6945601..cddaec7 100644
15--- a/tests/memprofiler_tests.py
16+++ b/tests/memprofiler_tests.py
17@@ -65,27 +65,27 @@ class MemoryCallbackTestCase(unittest.TestCase):
18
19 def test_csv_with_expiry(self):
20 csv = get_csv('keys_with_expiry.rdb')
21- self.assertEquals(csv, CSV_WITH_EXPIRY)
22+ self.assertEqual(csv, CSV_WITH_EXPIRY)
23
24 def test_csv_without_expiry(self):
25 csv = get_csv('ziplist_that_compresses_easily.rdb')
26- self.assertEquals(csv, CSV_WITHOUT_EXPIRY)
27+ self.assertEqual(csv, CSV_WITHOUT_EXPIRY)
28
29 def test_csv_with_module(self):
30 csv = get_csv('redis_40_with_module.rdb')
31- self.assertEquals(csv, CSV_WITH_MODULE)
32+ self.assertEqual(csv, CSV_WITH_MODULE)
33
34 def test_expiry(self):
35 stats = get_stats('keys_with_expiry.rdb')
36
37 expiry = stats['expires_ms_precision'].expiry
38- self.assertEquals(expiry.year, 2022)
39- self.assertEquals(expiry.month, 12)
40- self.assertEquals(expiry.day, 25)
41- self.assertEquals(expiry.hour, 10)
42- self.assertEquals(expiry.minute, 11)
43- self.assertEquals(expiry.second, 12)
44- self.assertEquals(expiry.microsecond, 573000)
45+ self.assertEqual(expiry.year, 2022)
46+ self.assertEqual(expiry.month, 12)
47+ self.assertEqual(expiry.day, 25)
48+ self.assertEqual(expiry.hour, 10)
49+ self.assertEqual(expiry.minute, 11)
50+ self.assertEqual(expiry.second, 12)
51+ self.assertEqual(expiry.microsecond, 573000)
52
53 def test_len_largest_element(self):
54 stats = get_stats('ziplist_that_compresses_easily.rdb')
55@@ -100,11 +100,11 @@ class MemoryCallbackTestCase(unittest.TestCase):
56 expected_record = MemoryRecord(database=0, type='module', key='foo',
57 bytes=101, encoding='ReJSON-RL', size=1,
58 len_largest_element=101, expiry=None)
59- self.assertEquals(stats['foo'], expected_record)
60+ self.assertEqual(stats['foo'], expected_record)
61
62 def test_rdb_with_module_aux(self):
63 sums = get_sums('redis_60_with_module_aux.rdb')
64- self.assertEquals(sums['module'], 32)
65+ self.assertEqual(sums['module'], 32)
66
67 def test_rdb_with_stream(self):
68 stats = get_stats('redis_50_with_streams.rdb')
69@@ -113,4 +113,4 @@ class MemoryCallbackTestCase(unittest.TestCase):
70 expected_record = MemoryRecord(database=0, type='stream', key='mystream',
71 bytes=1976, encoding='listpack', size=1,
72 len_largest_element=184, expiry=None)
73- self.assertEquals(stats['mystream'], expected_record)
74+ self.assertEqual(stats['mystream'], expected_record)
75diff --git a/tests/parser_tests.py b/tests/parser_tests.py
76index af93fba..25fd825 100644
77--- a/tests/parser_tests.py
78+++ b/tests/parser_tests.py
79@@ -15,54 +15,54 @@ class RedisParserTestCase(unittest.TestCase):
80 r = load_rdb('empty_database.rdb')
81 self.assertIn('start_rdb', r.methods_called)
82 self.assertIn('end_rdb', r.methods_called)
83- self.assertEquals(len(r.databases), 0, msg = "didn't expect any databases")
84+ self.assertEqual(len(r.databases), 0, msg = "didn't expect any databases")
85
86 def test_multiple_databases(self):
87 r = load_rdb('multiple_databases.rdb')
88 self.assertEqual(len(r.databases), 2)
89 self.assertNotIn(1, r.databases)
90- self.assertEquals(r.databases[0][b"key_in_zeroth_database"], b"zero")
91- self.assertEquals(r.databases[2][b"key_in_second_database"], b"second")
92+ self.assertEqual(r.databases[0][b"key_in_zeroth_database"], b"zero")
93+ self.assertEqual(r.databases[2][b"key_in_second_database"], b"second")
94
95 def test_keys_with_expiry(self):
96 r = load_rdb('keys_with_expiry.rdb')
97 expiry = r.expiry[0][b'expires_ms_precision']
98- self.assertEquals(expiry.year, 2022)
99- self.assertEquals(expiry.month, 12)
100- self.assertEquals(expiry.day, 25)
101- self.assertEquals(expiry.hour, 10)
102- self.assertEquals(expiry.minute, 11)
103- self.assertEquals(expiry.second, 12)
104- self.assertEquals(expiry.microsecond, 573000)
105+ self.assertEqual(expiry.year, 2022)
106+ self.assertEqual(expiry.month, 12)
107+ self.assertEqual(expiry.day, 25)
108+ self.assertEqual(expiry.hour, 10)
109+ self.assertEqual(expiry.minute, 11)
110+ self.assertEqual(expiry.second, 12)
111+ self.assertEqual(expiry.microsecond, 573000)
112
113 def test_integer_keys(self):
114 r = load_rdb('integer_keys.rdb')
115- self.assertEquals(r.databases[0][125], b"Positive 8 bit integer")
116- self.assertEquals(r.databases[0][0xABAB], b"Positive 16 bit integer")
117- self.assertEquals(r.databases[0][0x0AEDD325], b"Positive 32 bit integer")
118+ self.assertEqual(r.databases[0][125], b"Positive 8 bit integer")
119+ self.assertEqual(r.databases[0][0xABAB], b"Positive 16 bit integer")
120+ self.assertEqual(r.databases[0][0x0AEDD325], b"Positive 32 bit integer")
121
122 def test_negative_integer_keys(self):
123 r = load_rdb('integer_keys.rdb')
124- self.assertEquals(r.databases[0][-123], b"Negative 8 bit integer")
125- self.assertEquals(r.databases[0][-0x7325], b"Negative 16 bit integer")
126- self.assertEquals(r.databases[0][-0x0AEDD325], b"Negative 32 bit integer")
127+ self.assertEqual(r.databases[0][-123], b"Negative 8 bit integer")
128+ self.assertEqual(r.databases[0][-0x7325], b"Negative 16 bit integer")
129+ self.assertEqual(r.databases[0][-0x0AEDD325], b"Negative 32 bit integer")
130
131 def test_string_key_with_compression(self):
132 r = load_rdb('easily_compressible_string_key.rdb')
133 key = b"".join(b'a' for x in range(0, 200))
134 value = b"Key that redis should compress easily"
135- self.assertEquals(r.databases[0][key], value)
136+ self.assertEqual(r.databases[0][key], value)
137
138 def test_zipmap_thats_compresses_easily(self):
139 r = load_rdb('zipmap_that_compresses_easily.rdb')
140- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"a"], b"aa")
141- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"aa"], b"aaaa")
142- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"aaaaa"], b"aaaaaaaaaaaaaa")
143+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"a"], b"aa")
144+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"aa"], b"aaaa")
145+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"aaaaa"], b"aaaaaaaaaaaaaa")
146
147 def test_zipmap_that_doesnt_compress(self):
148 r = load_rdb('zipmap_that_doesnt_compress.rdb')
149- self.assertEquals(r.databases[0][b"zimap_doesnt_compress"][b"MKD1G6"], 2)
150- self.assertEquals(r.databases[0][b"zimap_doesnt_compress"][b"YNNXK"], b"F7TI")
151+ self.assertEqual(r.databases[0][b"zimap_doesnt_compress"][b"MKD1G6"], 2)
152+ self.assertEqual(r.databases[0][b"zimap_doesnt_compress"][b"YNNXK"], b"F7TI")
153
154 def test_zipmap_with_big_values(self):
155 ''' See issue https://github.com/sripathikrishnan/redis-rdb-tools/issues/2
156@@ -75,36 +75,36 @@ class RedisParserTestCase(unittest.TestCase):
157 ziplist with a length encoding of 5 bytes.
158 '''
159 r = load_rdb('zipmap_with_big_values.rdb')
160- self.assertEquals(len(r.databases[0][b"zipmap_with_big_values"][b"253bytes"]), 253)
161- self.assertEquals(len(r.databases[0][b"zipmap_with_big_values"][b"254bytes"]), 254)
162- self.assertEquals(len(r.databases[0][b"zipmap_with_big_values"][b"255bytes"]), 255)
163- self.assertEquals(len(r.databases[0][b"zipmap_with_big_values"][b"300bytes"]), 300)
164- self.assertEquals(len(r.databases[0][b"zipmap_with_big_values"][b"20kbytes"]), 20000)
165+ self.assertEqual(len(r.databases[0][b"zipmap_with_big_values"][b"253bytes"]), 253)
166+ self.assertEqual(len(r.databases[0][b"zipmap_with_big_values"][b"254bytes"]), 254)
167+ self.assertEqual(len(r.databases[0][b"zipmap_with_big_values"][b"255bytes"]), 255)
168+ self.assertEqual(len(r.databases[0][b"zipmap_with_big_values"][b"300bytes"]), 300)
169+ self.assertEqual(len(r.databases[0][b"zipmap_with_big_values"][b"20kbytes"]), 20000)
170
171 def test_hash_as_ziplist(self):
172 '''In redis dump version = 4, hashmaps are stored as ziplists'''
173 r = load_rdb('hash_as_ziplist.rdb')
174- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"a"], b"aa")
175- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"aa"], b"aaaa")
176- self.assertEquals(r.databases[0][b"zipmap_compresses_easily"][b"aaaaa"], b"aaaaaaaaaaaaaa")
177+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"a"], b"aa")
178+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"aa"], b"aaaa")
179+ self.assertEqual(r.databases[0][b"zipmap_compresses_easily"][b"aaaaa"], b"aaaaaaaaaaaaaa")
180
181 def test_dictionary(self):
182 r = load_rdb('dictionary.rdb')
183- self.assertEquals(r.lengths[0][b"force_dictionary"], 1000)
184- self.assertEquals(r.databases[0][b"force_dictionary"][b"ZMU5WEJDG7KU89AOG5LJT6K7HMNB3DEI43M6EYTJ83VRJ6XNXQ"],
185+ self.assertEqual(r.lengths[0][b"force_dictionary"], 1000)
186+ self.assertEqual(r.databases[0][b"force_dictionary"][b"ZMU5WEJDG7KU89AOG5LJT6K7HMNB3DEI43M6EYTJ83VRJ6XNXQ"],
187 b"T63SOS8DQJF0Q0VJEZ0D1IQFCYTIPSBOUIAI9SB0OV57MQR1FI")
188- self.assertEquals(r.databases[0][b"force_dictionary"][b"UHS5ESW4HLK8XOGTM39IK1SJEUGVV9WOPK6JYA5QBZSJU84491"],
189+ self.assertEqual(r.databases[0][b"force_dictionary"][b"UHS5ESW4HLK8XOGTM39IK1SJEUGVV9WOPK6JYA5QBZSJU84491"],
190 b"6VULTCV52FXJ8MGVSFTZVAGK2JXZMGQ5F8OVJI0X6GEDDR27RZ")
191
192 def test_ziplist_that_compresses_easily(self):
193 r = load_rdb('ziplist_that_compresses_easily.rdb')
194- self.assertEquals(r.lengths[0][b"ziplist_compresses_easily"], 6)
195+ self.assertEqual(r.lengths[0][b"ziplist_compresses_easily"], 6)
196 for idx, length in enumerate([6, 12, 18, 24, 30, 36]) :
197- self.assertEquals((b"".join(b"a" for x in range(length))), r.databases[0][b"ziplist_compresses_easily"][idx])
198+ self.assertEqual((b"".join(b"a" for x in range(length))), r.databases[0][b"ziplist_compresses_easily"][idx])
199
200 def test_ziplist_that_doesnt_compress(self):
201 r = load_rdb('ziplist_that_doesnt_compress.rdb')
202- self.assertEquals(r.lengths[0][b"ziplist_doesnt_compress"], 2)
203+ self.assertEqual(r.lengths[0][b"ziplist_doesnt_compress"], 2)
204 self.assertIn(b"aj2410", r.databases[0][b"ziplist_doesnt_compress"])
205 self.assertIn(b"cc953a17a8e096e76a44169ad3f9ac87c5f8248a403274416179aa9fbd852344",
206 r.databases[0][b"ziplist_doesnt_compress"])
207@@ -118,44 +118,44 @@ class RedisParserTestCase(unittest.TestCase):
208
209 expected_numbers += [-2, 13, 25, -61, 63, 16380, -16000, 65535, -65523, 4194304, 0x7fffffffffffffff]
210
211- self.assertEquals(r.lengths[0][b"ziplist_with_integers"], len(expected_numbers))
212+ self.assertEqual(r.lengths[0][b"ziplist_with_integers"], len(expected_numbers))
213
214 for num in expected_numbers :
215 self.assertIn(num, r.databases[0][b"ziplist_with_integers"], "Cannot find %d" % num)
216
217 def test_linkedlist(self):
218 r = load_rdb('linkedlist.rdb')
219- self.assertEquals(r.lengths[0][b"force_linkedlist"], 1000)
220+ self.assertEqual(r.lengths[0][b"force_linkedlist"], 1000)
221 self.assertIn(b"JYY4GIFI0ETHKP4VAJF5333082J4R1UPNPLE329YT0EYPGHSJQ", r.databases[0][b"force_linkedlist"])
222 self.assertIn(b"TKBXHJOX9Q99ICF4V78XTCA2Y1UYW6ERL35JCIL1O0KSGXS58S", r.databases[0][b"force_linkedlist"])
223
224 def test_intset_16(self):
225 r = load_rdb('intset_16.rdb')
226- self.assertEquals(r.lengths[0][b"intset_16"], 3)
227+ self.assertEqual(r.lengths[0][b"intset_16"], 3)
228 for num in (0x7ffe, 0x7ffd, 0x7ffc) :
229 self.assertIn(num, r.databases[0][b"intset_16"])
230
231 def test_intset_32(self):
232 r = load_rdb('intset_32.rdb')
233- self.assertEquals(r.lengths[0][b"intset_32"], 3)
234+ self.assertEqual(r.lengths[0][b"intset_32"], 3)
235 for num in (0x7ffefffe, 0x7ffefffd, 0x7ffefffc) :
236 self.assertIn(num, r.databases[0][b"intset_32"])
237
238 def test_intset_64(self):
239 r = load_rdb('intset_64.rdb')
240- self.assertEquals(r.lengths[0][b"intset_64"], 3)
241+ self.assertEqual(r.lengths[0][b"intset_64"], 3)
242 for num in (0x7ffefffefffefffe, 0x7ffefffefffefffd, 0x7ffefffefffefffc) :
243 self.assertIn(num, r.databases[0][b"intset_64"])
244
245 def test_regular_set(self):
246 r = load_rdb('regular_set.rdb')
247- self.assertEquals(r.lengths[0][b"regular_set"], 6)
248+ self.assertEqual(r.lengths[0][b"regular_set"], 6)
249 for member in (b"alpha", b"beta", b"gamma", b"delta", b"phi", b"kappa") :
250 self.assertIn(member, r.databases[0][b"regular_set"], msg=('%s missing' % member))
251
252 def test_sorted_set_as_ziplist(self):
253 r = load_rdb('sorted_set_as_ziplist.rdb')
254- self.assertEquals(r.lengths[0][b"sorted_set_as_ziplist"], 3)
255+ self.assertEqual(r.lengths[0][b"sorted_set_as_ziplist"], 3)
256 zset = r.databases[0][b"sorted_set_as_ziplist"]
257 self.assertTrue(floateq(zset[b'8b6ba6718a786daefa69438148361901'], 1))
258 self.assertTrue(floateq(zset[b'cb7a24bb7528f934b841b34c3a73e0c7'], 2.37))
259@@ -163,9 +163,9 @@ class RedisParserTestCase(unittest.TestCase):
260
261 def test_filtering_by_keys(self):
262 r = load_rdb('parser_filters.rdb', filters={"keys":"k[0-9]"})
263- self.assertEquals(r.databases[0][b'k1'], b"ssssssss")
264- self.assertEquals(r.databases[0][b'k3'], b"wwwwwwww")
265- self.assertEquals(len(r.databases[0]), 2)
266+ self.assertEqual(r.databases[0][b'k1'], b"ssssssss")
267+ self.assertEqual(r.databases[0][b'k3'], b"wwwwwwww")
268+ self.assertEqual(len(r.databases[0]), 2)
269
270 def test_filtering_by_type(self):
271 r = load_rdb('parser_filters.rdb', filters={"types":["sortedset"]})
272@@ -173,40 +173,40 @@ class RedisParserTestCase(unittest.TestCase):
273 self.assertIn(b'z2', r.databases[0])
274 self.assertIn(b'z3', r.databases[0])
275 self.assertIn(b'z4', r.databases[0])
276- self.assertEquals(len(r.databases[0]), 4)
277+ self.assertEqual(len(r.databases[0]), 4)
278
279 def test_filtering_by_database(self):
280 r = load_rdb('multiple_databases.rdb', filters={"dbs":[2]})
281 self.assertNotIn(b'key_in_zeroth_database', r.databases[0])
282 self.assertIn(b'key_in_second_database', r.databases[2])
283- self.assertEquals(len(r.databases[0]), 0)
284- self.assertEquals(len(r.databases[2]), 1)
285+ self.assertEqual(len(r.databases[0]), 0)
286+ self.assertEqual(len(r.databases[2]), 1)
287
288 def test_rdb_version_5_with_checksum(self):
289 r = load_rdb('rdb_version_5_with_checksum.rdb')
290- self.assertEquals(r.databases[0][b'abcd'], b'efgh')
291- self.assertEquals(r.databases[0][b'foo'], b'bar')
292- self.assertEquals(r.databases[0][b'bar'], b'baz')
293- self.assertEquals(r.databases[0][b'abcdef'], b'abcdef')
294- self.assertEquals(r.databases[0][b'longerstring'], b'thisisalongerstring.idontknowwhatitmeans')
295+ self.assertEqual(r.databases[0][b'abcd'], b'efgh')
296+ self.assertEqual(r.databases[0][b'foo'], b'bar')
297+ self.assertEqual(r.databases[0][b'bar'], b'baz')
298+ self.assertEqual(r.databases[0][b'abcdef'], b'abcdef')
299+ self.assertEqual(r.databases[0][b'longerstring'], b'thisisalongerstring.idontknowwhatitmeans')
300
301 def test_rdb_version_8_with_64b_length_and_scores(self):
302 r = load_rdb('rdb_version_8_with_64b_length_and_scores.rdb')
303- self.assertEquals(r.databases[0][b'foo'], b'bar')
304+ self.assertEqual(r.databases[0][b'foo'], b'bar')
305 zset = r.databases[0][b"bigset"]
306- self.assertEquals(len(zset), 1000)
307+ self.assertEqual(len(zset), 1000)
308 self.assertTrue(floateq(zset[b'finalfield'], 2.718))
309
310 def test_multiple_databases_stream(self):
311 r = load_rdb_stream('multiple_databases.rdb')
312- self.assertEquals(len(r.databases), 2)
313+ self.assertEqual(len(r.databases), 2)
314 self.assertNotIn(1, r.databases)
315- self.assertEquals(r.databases[0][b"key_in_zeroth_database"], b"zero")
316- self.assertEquals(r.databases[2][b"key_in_second_database"], b"second")
317+ self.assertEqual(r.databases[0][b"key_in_zeroth_database"], b"zero")
318+ self.assertEqual(r.databases[2][b"key_in_second_database"], b"second")
319
320 def test_rdb_version_8_with_module(self):
321 r = load_rdb('redis_40_with_module.rdb')
322- self.assertEquals(r.databases[0][b'foo']['module_name'], 'ReJSON-RL')
323+ self.assertEqual(r.databases[0][b'foo']['module_name'], 'ReJSON-RL')
324
325 def test_rdb_version_8_with_module_and_skip(self):
326 r = load_rdb('redis_40_with_module.rdb', {"keys": "bar"}) # skip foo module
327@@ -214,8 +214,8 @@ class RedisParserTestCase(unittest.TestCase):
328
329 def test_rdb_version_9_with_stream(self):
330 r = load_rdb('redis_50_with_streams.rdb')
331- self.assertEquals(r.lengths[0][b"mystream"], 4)
332- self.assertEquals(len(r.databases[0][b'mystream']), 1)
333+ self.assertEqual(r.lengths[0][b"mystream"], 4)
334+ self.assertEqual(len(r.databases[0][b'mystream']), 1)
335
336
337 def floateq(f1, f2) :
338diff --git a/tests/protocol_tests.py b/tests/protocol_tests.py
339index cb91d18..1ccfb8d 100644
340--- a/tests/protocol_tests.py
341+++ b/tests/protocol_tests.py
342@@ -26,7 +26,7 @@ class ProtocolExpireTestCase(unittest.TestCase):
343 buf = BytesIO()
344 parser = RdbParser(ProtocolCallback(buf))
345 parser.parse(self.dumpfile)
346- self.assertEquals(buf.getvalue(), expected)
347+ self.assertEqual(buf.getvalue(), expected)
348
349
350 def test_amend_expiry(self):
351@@ -40,7 +40,7 @@ class ProtocolExpireTestCase(unittest.TestCase):
352 buf = BytesIO()
353 parser = RdbParser(ProtocolCallback(buf, amend_expire=2000))
354 parser.parse(self.dumpfile)
355- self.assertEquals(buf.getvalue(), expected)
356+ self.assertEqual(buf.getvalue(), expected)
357
358
359 def test_skip_expiry(self):
360@@ -52,6 +52,6 @@ class ProtocolExpireTestCase(unittest.TestCase):
361 buf = BytesIO()
362 parser = RdbParser(ProtocolCallback(buf, emit_expire=False))
363 parser.parse(self.dumpfile)
364- self.assertEquals(buf.getvalue(), expected)
365+ self.assertEqual(buf.getvalue(), expected)
366
367
368--
3692.48.1
370