Storm

Merge lp:~cjwatson/storm/old-assert-methods into lp:storm

  1. old-assert-methods
  2. Merge into trunk
Proposed by Colin Watson
Status: Merged
Merged at revision: 541
Proposed branch: lp:~cjwatson/storm/old-assert-methods
Merge into: lp:storm
Diff against target: 12145 lines (+2416/-2408)
22 files modified
NEWS (+8/-0)
storm/tests/base.py (+2/-2)
storm/tests/cache.py (+28/-28)
storm/tests/database.py (+55/-55)
storm/tests/databases/base.py (+34/-34)
storm/tests/databases/postgres.py (+71/-71)
storm/tests/databases/sqlite.py (+16/-16)
storm/tests/event.py (+5/-5)
storm/tests/expr.py (+633/-633)
storm/tests/helper.py (+5/-5)
storm/tests/info.py (+65/-65)
storm/tests/mocker.py (+1/-1)
storm/tests/properties.py (+219/-219)
storm/tests/schema/patch.py (+13/-13)
storm/tests/schema/schema.py (+13/-13)
storm/tests/sqlobject.py (+178/-178)
storm/tests/store/base.py (+827/-827)
storm/tests/store/postgres.py (+9/-9)
storm/tests/tracer.py (+10/-10)
storm/tests/uri.py (+64/-64)
storm/tests/variables.py (+149/-149)
storm/tests/zope/zstorm.py (+11/-11)
To merge this branch: bzr merge lp:~cjwatson/storm/old-assert-methods
Reviewer Review Type Date Requested Status
Simon Poirier (community) Approve
Review via email: mp+375842@code.launchpad.net

Commit message

Stop using deprecated assertEquals/assertNotEquals unittest methods.

Description of the change

This is a giant commit, but it's essentially mechanical (I actually did it by hand to keep whitespace lined up nicely, but there was no actual creativity involved).

To post a comment you must log in.
Revision history for this message
Simon Poirier (simpoir) wrote :

+1 LGTM
Thanks for keeping it easy to review.

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'NEWS'
2--- NEWS 2019-11-21 11:13:46 +0000
3+++ NEWS 2019-11-21 16:09:19 +0000
4@@ -1,3 +1,11 @@
5+0.23 (XXXX-XX-XX)
6+=================
7+
8+Bug fixes
9+---------
10+
11+- Stop using deprecated assertEquals/assertNotEquals unittest methods.
12+
13 0.22 (2019-11-21)
14 =================
15
16
17=== modified file 'storm/tests/base.py'
18--- storm/tests/base.py 2019-08-11 17:51:37 +0000
19+++ storm/tests/base.py 2019-11-21 16:09:19 +0000
20@@ -35,7 +35,7 @@
21 class Class(Storm):
22 __storm_table__ = "table_name"
23 prop = Property(primary=True)
24- self.assertEquals(type(Class), PropertyPublisherMeta)
25+ self.assertEqual(type(Class), PropertyPublisherMeta)
26
27 def test_class_is_collectable(self):
28 class Class(Storm):
29@@ -46,4 +46,4 @@
30 obj_ref = weakref.ref(obj)
31 del obj
32 gc.collect()
33- self.assertEquals(obj_ref(), None)
34+ self.assertEqual(obj_ref(), None)
35
36=== modified file 'storm/tests/cache.py'
37--- storm/tests/cache.py 2019-08-12 17:07:08 +0000
38+++ storm/tests/cache.py 2019-11-21 16:09:19 +0000
39@@ -58,8 +58,8 @@
40 cache.add(self.obj1)
41 cache.add(self.obj2)
42 cache.add(self.obj3)
43- self.assertEquals(sorted(cache.get_cached()),
44- [self.obj1, self.obj2, self.obj3])
45+ self.assertEqual(sorted(cache.get_cached()),
46+ [self.obj1, self.obj2, self.obj3])
47
48 def test_adding_similar_obj_infos(self):
49 """If __eq__ is broken, this fails."""
50@@ -70,9 +70,9 @@
51 cache.add(obj_info2)
52 cache.add(obj_info2)
53 cache.add(obj_info1)
54- self.assertEquals(sorted([hash(obj_info)
55- for obj_info in cache.get_cached()]),
56- sorted([hash(obj_info1), hash(obj_info2)]))
57+ self.assertEqual(sorted([hash(obj_info)
58+ for obj_info in cache.get_cached()]),
59+ sorted([hash(obj_info1), hash(obj_info2)]))
60
61 def test_remove(self):
62 cache = self.Cache(5)
63@@ -80,8 +80,8 @@
64 cache.add(self.obj2)
65 cache.add(self.obj3)
66 cache.remove(self.obj2)
67- self.assertEquals(sorted(cache.get_cached()),
68- [self.obj1, self.obj3])
69+ self.assertEqual(sorted(cache.get_cached()),
70+ [self.obj1, self.obj3])
71
72 def test_add_existing(self):
73 cache = self.Cache(5)
74@@ -89,8 +89,8 @@
75 cache.add(self.obj2)
76 cache.add(self.obj3)
77 cache.add(self.obj2)
78- self.assertEquals(sorted(cache.get_cached()),
79- [self.obj1, self.obj2, self.obj3])
80+ self.assertEqual(sorted(cache.get_cached()),
81+ [self.obj1, self.obj2, self.obj3])
82
83 def test_add_with_size_zero(self):
84 """Cache is disabled entirely on add() if size is 0."""
85@@ -99,7 +99,7 @@
86 # Ensure that we don't even check if obj_info is in the
87 # cache, by testing if it was hashed. Hopefully, that means
88 # we got a faster path.
89- self.assertEquals(self.obj1.hashed, False)
90+ self.assertEqual(self.obj1.hashed, False)
91
92 def test_remove_with_size_zero(self):
93 """Cache is disabled entirely on remove() if size is 0."""
94@@ -112,12 +112,12 @@
95 for obj_info in self.obj_infos:
96 cache.add(obj_info)
97 cache.clear()
98- self.assertEquals(cache.get_cached(), [])
99+ self.assertEqual(cache.get_cached(), [])
100
101 # Just an additional check ensuring that any additional structures
102 # which may be used were cleaned properly as well.
103 for obj_info in self.obj_infos:
104- self.assertEquals(cache.remove(obj_info), False)
105+ self.assertEqual(cache.remove(obj_info), False)
106
107 def test_set_zero_size(self):
108 """
109@@ -127,7 +127,7 @@
110 cache.add(self.obj1)
111 cache.add(self.obj2)
112 cache.set_size(0)
113- self.assertEquals(cache.get_cached(), [])
114+ self.assertEqual(cache.get_cached(), [])
115
116 def test_fit_size(self):
117 """
118@@ -146,8 +146,8 @@
119 cache = Cache(5)
120 for obj_info in self.obj_infos:
121 cache.add(obj_info)
122- self.assertEquals([obj_info.id for obj_info in cache.get_cached()],
123- [9, 8, 7, 6, 5])
124+ self.assertEqual([obj_info.id for obj_info in cache.get_cached()],
125+ [9, 8, 7, 6, 5])
126
127 def test_reduce_max_size_to_zero(self):
128 """When setting the size to zero, there's an optimization."""
129@@ -156,39 +156,39 @@
130 cache.add(obj_info)
131 obj_info.hashed = False
132 cache.set_size(0)
133- self.assertEquals(cache.get_cached(), [])
134+ self.assertEqual(cache.get_cached(), [])
135 # Ensure that we don't even check if obj_info is in the
136 # cache, by testing if it was hashed. Hopefully, that means
137 # we got a faster path.
138- self.assertEquals(obj_info.hashed, False)
139+ self.assertEqual(obj_info.hashed, False)
140
141 def test_reduce_max_size(self):
142 cache = Cache(5)
143 for obj_info in self.obj_infos:
144 cache.add(obj_info)
145 cache.set_size(3)
146- self.assertEquals([obj_info.id for obj_info in cache.get_cached()],
147- [9, 8, 7])
148+ self.assertEqual([obj_info.id for obj_info in cache.get_cached()],
149+ [9, 8, 7])
150
151 # Adding items past the new maximum size should drop older ones.
152 for obj_info in self.obj_infos[:2]:
153 cache.add(obj_info)
154- self.assertEquals([obj_info.id for obj_info in cache.get_cached()],
155- [1, 0, 9])
156+ self.assertEqual([obj_info.id for obj_info in cache.get_cached()],
157+ [1, 0, 9])
158
159 def test_increase_max_size(self):
160 cache = Cache(5)
161 for obj_info in self.obj_infos:
162 cache.add(obj_info)
163 cache.set_size(10)
164- self.assertEquals([obj_info.id for obj_info in cache.get_cached()],
165- [9, 8, 7, 6, 5])
166+ self.assertEqual([obj_info.id for obj_info in cache.get_cached()],
167+ [9, 8, 7, 6, 5])
168
169 # Adding items past the new maximum size should drop older ones.
170 for obj_info in self.obj_infos[:6]:
171 cache.add(obj_info)
172- self.assertEquals([obj_info.id for obj_info in cache.get_cached()],
173- [5, 4, 3, 2, 1, 0, 9, 8, 7, 6])
174+ self.assertEqual([obj_info.id for obj_info in cache.get_cached()],
175+ [5, 4, 3, 2, 1, 0, 9, 8, 7, 6])
176
177
178 class TestGenerationalCache(BaseCacheTest):
179@@ -258,7 +258,7 @@
180 cache = GenerationalCache(size)
181 for value in range(5 * size):
182 cache.add(StubObjectInfo(value))
183- self.assertEquals(len(cache.get_cached()), size * 2)
184+ self.assertEqual(len(cache.get_cached()), size * 2)
185
186 def test_set_size_smaller_than_current_size(self):
187 """
188@@ -272,7 +272,7 @@
189 cache.add(StubObjectInfo(i))
190 cache.set_size(100)
191 cached = cache.get_cached()
192- self.assertEquals(len(cached), 100)
193+ self.assertEqual(len(cached), 100)
194 for obj_info in cache.get_cached():
195 self.assertTrue(obj_info.id >= 100)
196
197@@ -301,7 +301,7 @@
198 cache.set_size(size)
199 for value in range(size * 10):
200 cache.add(StubObjectInfo(value))
201- self.assertEquals(len(cache.get_cached()), size * 2)
202+ self.assertEqual(len(cache.get_cached()), size * 2)
203
204 def test_two_generations(self):
205 """
206
207=== modified file 'storm/tests/database.py'
208--- storm/tests/database.py 2019-08-12 17:07:08 +0000
209+++ storm/tests/database.py 2019-11-21 16:09:19 +0000
210@@ -156,39 +156,39 @@
211 def test_execute(self):
212 result = self.connection.execute("something")
213 self.assertTrue(isinstance(result, Result))
214- self.assertEquals(self.executed, [("something", marker)])
215+ self.assertEqual(self.executed, [("something", marker)])
216
217 def test_execute_params(self):
218 result = self.connection.execute("something", (1,2,3))
219 self.assertTrue(isinstance(result, Result))
220- self.assertEquals(self.executed, [("something", (1,2,3))])
221+ self.assertEqual(self.executed, [("something", (1,2,3))])
222
223 def test_execute_noresult(self):
224 result = self.connection.execute("something", noresult=True)
225- self.assertEquals(result, None)
226- self.assertEquals(self.executed, [("something", marker), "RCLOSE"])
227+ self.assertEqual(result, None)
228+ self.assertEqual(self.executed, [("something", marker), "RCLOSE"])
229
230 def test_execute_convert_param_style(self):
231 class MyConnection(Connection):
232 param_mark = "%s"
233 connection = MyConnection(self.database)
234 result = connection.execute("'?' ? '?' ? '?'")
235- self.assertEquals(self.executed, [("'?' %s '?' %s '?'", marker)])
236+ self.assertEqual(self.executed, [("'?' %s '?' %s '?'", marker)])
237
238 # TODO: Unsupported for now.
239 #result = connection.execute("$$?$$ ? $asd$'?$asd$ ? '?'")
240- #self.assertEquals(self.executed,
241- # [("'?' %s '?' %s '?'", marker),
242- # ("$$?$$ %s $asd'?$asd$ %s '?'", marker)])
243+ #self.assertEqual(self.executed,
244+ # [("'?' %s '?' %s '?'", marker),
245+ # ("$$?$$ %s $asd'?$asd$ %s '?'", marker)])
246
247 def test_execute_select(self):
248 select = Select([SQLToken("column1"), SQLToken("column2")],
249 tables=[SQLToken("table1"), SQLToken("table2")])
250 result = self.connection.execute(select)
251 self.assertTrue(isinstance(result, Result))
252- self.assertEquals(self.executed,
253- [("SELECT column1, column2 FROM table1, table2",
254- marker)])
255+ self.assertEqual(self.executed,
256+ [("SELECT column1, column2 FROM table1, table2",
257+ marker)])
258
259 def test_execute_select_and_params(self):
260 select = Select(["column1", "column2"], tables=["table1", "table2"])
261@@ -204,17 +204,17 @@
262 tracer = FakeTracer()
263 install_tracer(tracer)
264 self.connection.execute("something")
265- self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
266- "something", ()),
267- ("SUCCESS", self.connection, RawCursor,
268- "something", ())])
269+ self.assertEqual(tracer.seen, [("EXECUTE", self.connection, RawCursor,
270+ "something", ()),
271+ ("SUCCESS", self.connection, RawCursor,
272+ "something", ())])
273
274 del tracer.seen[:]
275 self.connection.execute("something", (1, 2))
276- self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
277- "something", (1, 2)),
278- ("SUCCESS", self.connection, RawCursor,
279- "something", (1, 2))])
280+ self.assertEqual(tracer.seen, [("EXECUTE", self.connection, RawCursor,
281+ "something", (1, 2)),
282+ ("SUCCESS", self.connection, RawCursor,
283+ "something", (1, 2))])
284
285 def test_raw_execute_error_tracing(self):
286 cursor_mock = self.mocker.patch(RawCursor)
287@@ -228,10 +228,10 @@
288 install_tracer(tracer)
289 self.assertRaises(ZeroDivisionError,
290 self.connection.execute, "something")
291- self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
292- "something", ()),
293- ("ERROR", self.connection, RawCursor,
294- "something", (), error)])
295+ self.assertEqual(tracer.seen, [("EXECUTE", self.connection, RawCursor,
296+ "something", ()),
297+ ("ERROR", self.connection, RawCursor,
298+ "something", (), error)])
299
300 def test_raw_execute_setup_error_tracing(self):
301 """
302@@ -248,8 +248,8 @@
303 install_tracer(tracer)
304 self.assertRaises(ZeroDivisionError,
305 self.connection.execute, "something")
306- self.assertEquals(tracer.seen, [("ERROR", self.connection, RawCursor,
307- "something", (), error)])
308+ self.assertEqual(tracer.seen, [("ERROR", self.connection, RawCursor,
309+ "something", (), error)])
310
311 def test_tracing_check_disconnect(self):
312 tracer = FakeTracer()
313@@ -304,46 +304,46 @@
314
315 def test_commit(self):
316 self.connection.commit()
317- self.assertEquals(self.executed, ["COMMIT"])
318+ self.assertEqual(self.executed, ["COMMIT"])
319
320 def test_commit_tracing(self):
321 self.assertMethodsMatch(FakeTracer, DebugTracer)
322 tracer = FakeTracer()
323 install_tracer(tracer)
324 self.connection.commit()
325- self.assertEquals(tracer.seen, [("COMMIT", self.connection, None)])
326+ self.assertEqual(tracer.seen, [("COMMIT", self.connection, None)])
327
328 def test_rollback(self):
329 self.connection.rollback()
330- self.assertEquals(self.executed, ["ROLLBACK"])
331+ self.assertEqual(self.executed, ["ROLLBACK"])
332
333 def test_rollback_tracing(self):
334 self.assertMethodsMatch(FakeTracer, DebugTracer)
335 tracer = FakeTracer()
336 install_tracer(tracer)
337 self.connection.rollback()
338- self.assertEquals(tracer.seen, [("ROLLBACK", self.connection, None)])
339+ self.assertEqual(tracer.seen, [("ROLLBACK", self.connection, None)])
340
341 def test_close(self):
342 self.connection.close()
343- self.assertEquals(self.executed, ["CCLOSE"])
344+ self.assertEqual(self.executed, ["CCLOSE"])
345
346 def test_close_twice(self):
347 self.connection.close()
348 self.connection.close()
349- self.assertEquals(self.executed, ["CCLOSE"])
350+ self.assertEqual(self.executed, ["CCLOSE"])
351
352 def test_close_deallocates_raw_connection(self):
353 refs_before = len(gc.get_referrers(self.raw_connection))
354 self.connection.close()
355 refs_after = len(gc.get_referrers(self.raw_connection))
356- self.assertEquals(refs_after, refs_before-1)
357+ self.assertEqual(refs_after, refs_before-1)
358
359 def test_del_deallocates_raw_connection(self):
360 refs_before = len(gc.get_referrers(self.raw_connection))
361 self.connection.__del__()
362 refs_after = len(gc.get_referrers(self.raw_connection))
363- self.assertEquals(refs_after, refs_before-1)
364+ self.assertEqual(refs_after, refs_before-1)
365
366 def test_wb_del_with_previously_deallocated_connection(self):
367 self.connection._raw_connection = None
368@@ -457,47 +457,47 @@
369 self.result = Result(FakeConnection(), self.raw_cursor)
370
371 def test_get_one(self):
372- self.assertEquals(self.result.get_one(), ("fetchone0",))
373- self.assertEquals(self.result.get_one(), ("fetchone1",))
374- self.assertEquals(self.result.get_one(), ("fetchone2",))
375- self.assertEquals(self.result.get_one(), None)
376+ self.assertEqual(self.result.get_one(), ("fetchone0",))
377+ self.assertEqual(self.result.get_one(), ("fetchone1",))
378+ self.assertEqual(self.result.get_one(), ("fetchone2",))
379+ self.assertEqual(self.result.get_one(), None)
380
381 def test_get_all(self):
382- self.assertEquals(self.result.get_all(),
383- [("fetchall0",), ("fetchall1",)])
384- self.assertEquals(self.result.get_all(), [])
385+ self.assertEqual(self.result.get_all(),
386+ [("fetchall0",), ("fetchall1",)])
387+ self.assertEqual(self.result.get_all(), [])
388
389 def test_iter(self):
390 result = Result(FakeConnection(), RawCursor(2))
391- self.assertEquals([item for item in result],
392- [("fetchmany0",), ("fetchmany1",), ("fetchmany2",),
393- ("fetchmany3",), ("fetchmany4",)])
394+ self.assertEqual([item for item in result],
395+ [("fetchmany0",), ("fetchmany1",), ("fetchmany2",),
396+ ("fetchmany3",), ("fetchmany4",)])
397
398 def test_set_variable(self):
399 variable = Variable()
400 self.result.set_variable(variable, marker)
401- self.assertEquals(variable.get(), marker)
402+ self.assertEqual(variable.get(), marker)
403
404 def test_close(self):
405 self.result.close()
406- self.assertEquals(self.executed, ["RCLOSE"])
407+ self.assertEqual(self.executed, ["RCLOSE"])
408
409 def test_close_twice(self):
410 self.result.close()
411 self.result.close()
412- self.assertEquals(self.executed, ["RCLOSE"])
413+ self.assertEqual(self.executed, ["RCLOSE"])
414
415 def test_close_deallocates_raw_cursor(self):
416 refs_before = len(gc.get_referrers(self.raw_cursor))
417 self.result.close()
418 refs_after = len(gc.get_referrers(self.raw_cursor))
419- self.assertEquals(refs_after, refs_before-1)
420+ self.assertEqual(refs_after, refs_before-1)
421
422 def test_del_deallocates_raw_cursor(self):
423 refs_before = len(gc.get_referrers(self.raw_cursor))
424 self.result.__del__()
425 refs_after = len(gc.get_referrers(self.raw_cursor))
426- self.assertEquals(refs_after, refs_before-1)
427+ self.assertEqual(refs_after, refs_before-1)
428
429 def test_wb_del_with_previously_deallocated_cursor(self):
430 self.result._raw_cursor = None
431@@ -506,15 +506,15 @@
432 def test_set_arraysize(self):
433 """When the arraysize is 1, change it to a better value."""
434 raw_cursor = RawCursor()
435- self.assertEquals(raw_cursor.arraysize, 1)
436+ self.assertEqual(raw_cursor.arraysize, 1)
437 result = Result(FakeConnection(), raw_cursor)
438- self.assertEquals(raw_cursor.arraysize, 10)
439+ self.assertEqual(raw_cursor.arraysize, 10)
440
441 def test_preserve_arraysize(self):
442 """When the arraysize is not 1, preserve it."""
443 raw_cursor = RawCursor(arraysize=123)
444 result = Result(FakeConnection(), raw_cursor)
445- self.assertEquals(raw_cursor.arraysize, 123)
446+ self.assertEqual(raw_cursor.arraysize, 123)
447
448
449 class CreateDatabaseTest(TestHelper):
450@@ -536,14 +536,14 @@
451 def test_create_database_with_str(self):
452 create_database("db_module:db")
453 self.assertTrue(self.uri)
454- self.assertEquals(self.uri.scheme, "db_module")
455- self.assertEquals(self.uri.database, "db")
456+ self.assertEqual(self.uri.scheme, "db_module")
457+ self.assertEqual(self.uri.database, "db")
458
459 def test_create_database_with_unicode(self):
460 create_database(u"db_module:db")
461 self.assertTrue(self.uri)
462- self.assertEquals(self.uri.scheme, "db_module")
463- self.assertEquals(self.uri.database, "db")
464+ self.assertEqual(self.uri.scheme, "db_module")
465+ self.assertEqual(self.uri.database, "db")
466
467 def test_create_database_with_uri(self):
468 uri = URI("db_module:db")
469
470=== modified file 'storm/tests/databases/base.py'
471--- storm/tests/databases/base.py 2019-09-29 14:05:31 +0000
472+++ storm/tests/databases/base.py 2019-11-21 16:09:19 +0000
473@@ -151,7 +151,7 @@
474 result = self.connection.execute(u"SELECT title FROM test")
475 self.assertTrue(isinstance(result, Result))
476 row = result.get_one()
477- self.assertEquals(row, ("Title 10",))
478+ self.assertEqual(row, ("Title 10",))
479 self.assertTrue(isinstance(row[0], six.text_type))
480
481 def test_execute_params(self):
482@@ -176,17 +176,17 @@
483
484 def test_get_one(self):
485 result = self.connection.execute("SELECT * FROM test ORDER BY id")
486- self.assertEquals(result.get_one(), (10, "Title 10"))
487+ self.assertEqual(result.get_one(), (10, "Title 10"))
488
489 def test_get_all(self):
490 result = self.connection.execute("SELECT * FROM test ORDER BY id")
491- self.assertEquals(result.get_all(),
492- [(10, "Title 10"), (20, "Title 20")])
493+ self.assertEqual(result.get_all(),
494+ [(10, "Title 10"), (20, "Title 20")])
495
496 def test_iter(self):
497 result = self.connection.execute("SELECT * FROM test ORDER BY id")
498- self.assertEquals([item for item in result],
499- [(10, "Title 10"), (20, "Title 20")])
500+ self.assertEqual([item for item in result],
501+ [(10, "Title 10"), (20, "Title 20")])
502
503 def test_simultaneous_iter(self):
504 result1 = self.connection.execute("SELECT * FROM test "
505@@ -195,10 +195,10 @@
506 "ORDER BY id DESC")
507 iter1 = iter(result1)
508 iter2 = iter(result2)
509- self.assertEquals(next(iter1), (10, "Title 10"))
510- self.assertEquals(next(iter2), (20, "Title 20"))
511- self.assertEquals(next(iter1), (20, "Title 20"))
512- self.assertEquals(next(iter2), (10, "Title 10"))
513+ self.assertEqual(next(iter1), (10, "Title 10"))
514+ self.assertEqual(next(iter2), (20, "Title 20"))
515+ self.assertEqual(next(iter1), (20, "Title 20"))
516+ self.assertEqual(next(iter2), (10, "Title 10"))
517 self.assertRaises(StopIteration, next, iter1)
518 self.assertRaises(StopIteration, next, iter2)
519
520@@ -210,7 +210,7 @@
521 expr = result.get_insert_identity(primary_key, primary_variables)
522 select = Select(Column("title", SQLToken("test")), expr)
523 result = self.connection.execute(select)
524- self.assertEquals(result.get_one(), ("Title 30",))
525+ self.assertEqual(result.get_one(), ("Title 30",))
526
527 def test_get_insert_identity_composed(self):
528 result = self.connection.execute("INSERT INTO test (title) "
529@@ -221,7 +221,7 @@
530 expr = result.get_insert_identity(primary_key, primary_variables)
531 select = Select(Column("title", SQLToken("test")), expr)
532 result = self.connection.execute(select)
533- self.assertEquals(result.get_one(), ("Title 30",))
534+ self.assertEqual(result.get_one(), ("Title 30",))
535
536 def test_datetime(self):
537 value = datetime(1977, 4, 5, 12, 34, 56, 78)
538@@ -232,7 +232,7 @@
539 result.set_variable(variable, result.get_one()[0])
540 if not self.supports_microseconds:
541 value = value.replace(microsecond=0)
542- self.assertEquals(variable.get(), value)
543+ self.assertEqual(variable.get(), value)
544
545 def test_date(self):
546 value = date(1977, 4, 5)
547@@ -241,7 +241,7 @@
548 result = self.connection.execute("SELECT d FROM datetime_test")
549 variable = DateVariable()
550 result.set_variable(variable, result.get_one()[0])
551- self.assertEquals(variable.get(), value)
552+ self.assertEqual(variable.get(), value)
553
554 def test_time(self):
555 value = time(12, 34, 56, 78)
556@@ -252,7 +252,7 @@
557 result.set_variable(variable, result.get_one()[0])
558 if not self.supports_microseconds:
559 value = value.replace(microsecond=0)
560- self.assertEquals(variable.get(), value)
561+ self.assertEqual(variable.get(), value)
562
563 def test_timedelta(self):
564 value = timedelta(12, 34, 56)
565@@ -261,7 +261,7 @@
566 result = self.connection.execute("SELECT td FROM datetime_test")
567 variable = TimeDeltaVariable()
568 result.set_variable(variable, result.get_one()[0])
569- self.assertEquals(variable.get(), value)
570+ self.assertEqual(variable.get(), value)
571
572 def test_pickle(self):
573 value = {"a": 1, "b": 2}
574@@ -271,7 +271,7 @@
575 result = self.connection.execute("SELECT b FROM bin_test")
576 variable = PickleVariable()
577 result.set_variable(variable, result.get_one()[0])
578- self.assertEquals(variable.get(), value)
579+ self.assertEqual(variable.get(), value)
580
581 def test_binary(self):
582 """Ensure database works with high bits and embedded zeros."""
583@@ -281,7 +281,7 @@
584 result = self.connection.execute("SELECT b FROM bin_test")
585 variable = RawStrVariable()
586 result.set_variable(variable, result.get_one()[0])
587- self.assertEquals(variable.get(), value)
588+ self.assertEqual(variable.get(), value)
589
590 def test_binary_ascii(self):
591 """Some databases like pysqlite2 may return unicode for strings."""
592@@ -290,7 +290,7 @@
593 variable = RawStrVariable()
594 # If the following doesn't raise a TypeError we're good.
595 result.set_variable(variable, result.get_one()[0])
596- self.assertEquals(variable.get(), b"Value")
597+ self.assertEqual(variable.get(), b"Value")
598
599 def test_order_by_group_by(self):
600 self.connection.execute("INSERT INTO test VALUES (100, 'Title 10')")
601@@ -299,7 +299,7 @@
602 title = Column("title", "test")
603 expr = Select(Count(id), group_by=title, order_by=Count(id))
604 result = self.connection.execute(expr)
605- self.assertEquals(result.get_all(), [(1,), (3,)])
606+ self.assertEqual(result.get_all(), [(1,), (3,)])
607
608 def test_set_decimal_variable_from_str_column(self):
609 self.connection.execute("INSERT INTO test VALUES (40, '40.5')")
610@@ -312,7 +312,7 @@
611 variable.set("40.5", from_db=True)
612 self.connection.execute("INSERT INTO test VALUES (40, ?)", (variable,))
613 result = self.connection.execute("SELECT title FROM test WHERE id=40")
614- self.assertEquals(result.get_one()[0], "40.5")
615+ self.assertEqual(result.get_one()[0], "40.5")
616
617 def test_quoting(self):
618 # FIXME "with'quote" should be in the list below, but it doesn't
619@@ -322,7 +322,7 @@
620 expr = Select(reserved_name,
621 tables=Alias(Select(Alias(1, reserved_name))))
622 result = self.connection.execute(expr)
623- self.assertEquals(result.get_one(), (1,))
624+ self.assertEqual(result.get_one(), (1,))
625
626 def test_concurrent_behavior(self):
627 """The default behavior should be to handle transactions in isolation.
628@@ -342,15 +342,15 @@
629 connection2 = self.database.connect()
630 try:
631 result = connection1.execute("SELECT title FROM test WHERE id=10")
632- self.assertEquals(result.get_one(), ("Title 10",))
633+ self.assertEqual(result.get_one(), ("Title 10",))
634 try:
635 connection2.execute("UPDATE test SET title='Title 100' "
636 "WHERE id=10")
637 connection2.commit()
638 except OperationalError as e:
639- self.assertEquals(str(e), "database is locked") # SQLite blocks
640+ self.assertEqual(str(e), "database is locked") # SQLite blocks
641 result = connection1.execute("SELECT title FROM test WHERE id=10")
642- self.assertEquals(result.get_one(), ("Title 10",))
643+ self.assertEqual(result.get_one(), ("Title 10",))
644 finally:
645 connection1.rollback()
646
647@@ -376,34 +376,34 @@
648 def test_wb_result_get_one_goes_through_from_database(self):
649 result = self.connection.execute("SELECT one, two FROM number")
650 result.from_database = self.from_database
651- self.assertEquals(result.get_one(), (2, 3))
652+ self.assertEqual(result.get_one(), (2, 3))
653
654 def test_wb_result_get_all_goes_through_from_database(self):
655 result = self.connection.execute("SELECT one, two FROM number")
656 result.from_database = self.from_database
657- self.assertEquals(result.get_all(), [(2, 3)])
658+ self.assertEqual(result.get_all(), [(2, 3)])
659
660 def test_wb_result_iter_goes_through_from_database(self):
661 result = self.connection.execute("SELECT one, two FROM number")
662 result.from_database = self.from_database
663- self.assertEquals(next(iter(result)), (2, 3))
664+ self.assertEqual(next(iter(result)), (2, 3))
665
666 def test_rowcount_insert(self):
667 # All supported backends support rowcount, so far.
668 result = self.connection.execute(
669 "INSERT INTO test VALUES (999, '999')")
670- self.assertEquals(result.rowcount, 1)
671+ self.assertEqual(result.rowcount, 1)
672
673 def test_rowcount_delete(self):
674 # All supported backends support rowcount, so far.
675 result = self.connection.execute("DELETE FROM test")
676- self.assertEquals(result.rowcount, 2)
677+ self.assertEqual(result.rowcount, 2)
678
679 def test_rowcount_update(self):
680 # All supported backends support rowcount, so far.
681 result = self.connection.execute(
682 "UPDATE test SET title='whatever'")
683- self.assertEquals(result.rowcount, 2)
684+ self.assertEqual(result.rowcount, 2)
685
686 def test_expr_startswith(self):
687 self.connection.execute("INSERT INTO test VALUES (30, '!!_%blah')")
688@@ -412,7 +412,7 @@
689 title = Column("title", SQLToken("test"))
690 expr = Select(id, title.startswith(u"!!_%"))
691 result = list(self.connection.execute(expr))
692- self.assertEquals(result, [(30,)])
693+ self.assertEqual(result, [(30,)])
694
695 def test_expr_endswith(self):
696 self.connection.execute("INSERT INTO test VALUES (30, 'blah_%!!')")
697@@ -421,7 +421,7 @@
698 title = Column("title", SQLToken("test"))
699 expr = Select(id, title.endswith(u"_%!!"))
700 result = list(self.connection.execute(expr))
701- self.assertEquals(result, [(30,)])
702+ self.assertEqual(result, [(30,)])
703
704 def test_expr_contains_string(self):
705 self.connection.execute("INSERT INTO test VALUES (30, 'blah_%!!x')")
706@@ -430,7 +430,7 @@
707 title = Column("title", SQLToken("test"))
708 expr = Select(id, title.contains_string(u"_%!!"))
709 result = list(self.connection.execute(expr))
710- self.assertEquals(result, [(30,)])
711+ self.assertEqual(result, [(30,)])
712
713 def test_block_access(self):
714 """Access to the connection is blocked by block_access()."""
715
716=== modified file 'storm/tests/databases/postgres.py'
717--- storm/tests/databases/postgres.py 2019-09-29 14:05:31 +0000
718+++ storm/tests/databases/postgres.py 2019-11-21 16:09:19 +0000
719@@ -140,25 +140,25 @@
720 def test_wb_create_database(self):
721 database = create_database("postgres://un:pw@ht:12/db")
722 self.assertTrue(isinstance(database, Postgres))
723- self.assertEquals(database._dsn,
724- "dbname=db host=ht port=12 user=un password=pw")
725+ self.assertEqual(database._dsn,
726+ "dbname=db host=ht port=12 user=un password=pw")
727
728 def test_wb_version(self):
729 version = self.database._version
730- self.assertEquals(type(version), int)
731+ self.assertEqual(type(version), int)
732 try:
733 result = self.connection.execute("SHOW server_version_num")
734 except ProgrammingError:
735- self.assertEquals(version, 0)
736+ self.assertEqual(version, 0)
737 else:
738 server_version = int(result.get_one()[0])
739- self.assertEquals(version, server_version)
740+ self.assertEqual(version, server_version)
741
742 def test_utf8_client_encoding(self):
743 connection = self.database.connect()
744 result = connection.execute("SHOW client_encoding")
745 encoding = result.get_one()[0]
746- self.assertEquals(encoding.upper(), "UTF8")
747+ self.assertEqual(encoding.upper(), "UTF8")
748
749 def test_unicode(self):
750 raw_str = b"\xc3\xa1\xc3\xa9\xc3\xad\xc3\xb3\xc3\xba"
751@@ -172,7 +172,7 @@
752 title = result.get_one()[0]
753
754 self.assertTrue(isinstance(title, six.text_type))
755- self.assertEquals(title, uni_str)
756+ self.assertEqual(title, uni_str)
757
758 def test_unicode_array(self):
759 raw_str = b"\xc3\xa1\xc3\xa9\xc3\xad\xc3\xb3\xc3\xba"
760@@ -181,34 +181,34 @@
761 connection = self.database.connect()
762 result = connection.execute(
763 (b"""SELECT '{"%s"}'::TEXT[]""" % raw_str).decode("UTF-8"))
764- self.assertEquals(result.get_one()[0], [uni_str])
765+ self.assertEqual(result.get_one()[0], [uni_str])
766 result = connection.execute("""SELECT ?::TEXT[]""", ([uni_str],))
767- self.assertEquals(result.get_one()[0], [uni_str])
768+ self.assertEqual(result.get_one()[0], [uni_str])
769
770 def test_time(self):
771 connection = self.database.connect()
772 value = time(12, 34)
773 result = connection.execute("SELECT ?::TIME", (value,))
774- self.assertEquals(result.get_one()[0], value)
775+ self.assertEqual(result.get_one()[0], value)
776
777 def test_date(self):
778 connection = self.database.connect()
779 value = date(2007, 6, 22)
780 result = connection.execute("SELECT ?::DATE", (value,))
781- self.assertEquals(result.get_one()[0], value)
782+ self.assertEqual(result.get_one()[0], value)
783
784 def test_interval(self):
785 connection = self.database.connect()
786 value = timedelta(365)
787 result = connection.execute("SELECT ?::INTERVAL", (value,))
788- self.assertEquals(result.get_one()[0], value)
789+ self.assertEqual(result.get_one()[0], value)
790
791 def test_datetime_with_none(self):
792 self.connection.execute("INSERT INTO datetime_test (dt) VALUES (NULL)")
793 result = self.connection.execute("SELECT dt FROM datetime_test")
794 variable = DateTimeVariable()
795 result.set_variable(variable, result.get_one()[0])
796- self.assertEquals(variable.get(), None)
797+ self.assertEqual(variable.get(), None)
798
799 def test_array_support(self):
800 try:
801@@ -237,7 +237,7 @@
802
803 variable = ListVariable(IntVariable)
804 result.set_variable(variable, array)
805- self.assertEquals(variable.get(), [1,2,3,4])
806+ self.assertEqual(variable.get(), [1,2,3,4])
807
808 def test_array_support_with_empty(self):
809 try:
810@@ -266,7 +266,7 @@
811
812 variable = ListVariable(IntVariable)
813 result.set_variable(variable, array)
814- self.assertEquals(variable.get(), [])
815+ self.assertEqual(variable.get(), [])
816
817 def test_expressions_in_union_order_by(self):
818 # The following statement breaks in postgres:
819@@ -282,14 +282,14 @@
820
821 state = State()
822 statement = compile(expr, state)
823- self.assertEquals(statement,
824- 'SELECT * FROM '
825- '((SELECT 1 AS id) UNION ALL (SELECT 1)) AS "_1" '
826- 'ORDER BY id+? LIMIT 1 OFFSET 1')
827+ self.assertEqual(statement,
828+ 'SELECT * FROM '
829+ '((SELECT 1 AS id) UNION ALL (SELECT 1)) AS "_1" '
830+ 'ORDER BY id+? LIMIT 1 OFFSET 1')
831 self.assertVariablesEqual(state.parameters, [Variable(1)])
832
833 result = self.connection.execute(expr)
834- self.assertEquals(result.get_one(), (1,))
835+ self.assertEqual(result.get_one(), (1,))
836
837 def test_expressions_in_union_in_union_order_by(self):
838 column = SQLRaw("1")
839@@ -298,7 +298,7 @@
840 limit=1, offset=1, all=True)
841 expr = Union(expr, expr, order_by=alias+1, all=True)
842 result = self.connection.execute(expr)
843- self.assertEquals(result.get_all(), [(1,), (1,)])
844+ self.assertEqual(result.get_all(), [(1,), (1,)])
845
846 def test_sequence(self):
847 expr1 = Select(Sequence("test_id_seq"))
848@@ -306,54 +306,54 @@
849 value1 = self.connection.execute(expr1).get_one()[0]
850 value2 = self.connection.execute(expr2).get_one()[0]
851 value3 = self.connection.execute(expr1).get_one()[0]
852- self.assertEquals(value1, value2)
853- self.assertEquals(value3-value1, 1)
854+ self.assertEqual(value1, value2)
855+ self.assertEqual(value3-value1, 1)
856
857 def test_like_case(self):
858 expr = Like("name", "value")
859 statement = compile(expr)
860- self.assertEquals(statement, "? LIKE ?")
861+ self.assertEqual(statement, "? LIKE ?")
862 expr = Like("name", "value", case_sensitive=True)
863 statement = compile(expr)
864- self.assertEquals(statement, "? LIKE ?")
865+ self.assertEqual(statement, "? LIKE ?")
866 expr = Like("name", "value", case_sensitive=False)
867 statement = compile(expr)
868- self.assertEquals(statement, "? ILIKE ?")
869+ self.assertEqual(statement, "? ILIKE ?")
870
871 def test_case_default_like(self):
872
873 like = Like(SQLRaw("description"), u"%hullah%")
874 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
875 result = self.connection.execute(expr)
876- self.assertEquals(result.get_all(), [(1,)])
877+ self.assertEqual(result.get_all(), [(1,)])
878
879 like = Like(SQLRaw("description"), u"%HULLAH%")
880 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
881 result = self.connection.execute(expr)
882- self.assertEquals(result.get_all(), [(2,)])
883+ self.assertEqual(result.get_all(), [(2,)])
884
885 def test_case_sensitive_like(self):
886
887 like = Like(SQLRaw("description"), u"%hullah%", case_sensitive=True)
888 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
889 result = self.connection.execute(expr)
890- self.assertEquals(result.get_all(), [(1,)])
891+ self.assertEqual(result.get_all(), [(1,)])
892
893 like = Like(SQLRaw("description"), u"%HULLAH%", case_sensitive=True)
894 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
895 result = self.connection.execute(expr)
896- self.assertEquals(result.get_all(), [(2,)])
897+ self.assertEqual(result.get_all(), [(2,)])
898
899 def test_case_insensitive_like(self):
900
901 like = Like(SQLRaw("description"), u"%hullah%", case_sensitive=False)
902 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
903 result = self.connection.execute(expr)
904- self.assertEquals(result.get_all(), [(1,), (2,)])
905+ self.assertEqual(result.get_all(), [(1,), (2,)])
906 like = Like(SQLRaw("description"), u"%HULLAH%", case_sensitive=False)
907 expr = Select(SQLRaw("id"), like, tables=["like_case_insensitive_test"])
908 result = self.connection.execute(expr)
909- self.assertEquals(result.get_all(), [(1,), (2,)])
910+ self.assertEqual(result.get_all(), [(1,), (2,)])
911
912 def test_none_on_string_variable(self):
913 """
914@@ -362,15 +362,15 @@
915 """
916 variable = RawStrVariable(value=None)
917 result = self.connection.execute(Select(variable))
918- self.assertEquals(result.get_one(), (None,))
919+ self.assertEqual(result.get_one(), (None,))
920
921 def test_compile_table_with_schema(self):
922 class Foo(object):
923 __storm_table__ = "my schema.my table"
924 id = Int("my.column", primary=True)
925- self.assertEquals(compile(Select(Foo.id)),
926- 'SELECT "my schema"."my table"."my.column" '
927- 'FROM "my schema"."my table"')
928+ self.assertEqual(compile(Select(Foo.id)),
929+ 'SELECT "my schema"."my table"."my.column" '
930+ 'FROM "my schema"."my table"')
931
932 def test_compile_case(self):
933 """The Case expr is compiled in a Postgres' CASE expression."""
934@@ -414,66 +414,66 @@
935 expr = currval(Column("thecolumn", "theschema.thetable"))
936 statement = compile(expr)
937 expected = """currval('theschema.thetable_thecolumn_seq')"""
938- self.assertEquals(statement, expected)
939+ self.assertEqual(statement, expected)
940
941 def test_currval_escaped_schema(self):
942 expr = currval(Column("thecolumn", "the schema.thetable"))
943 statement = compile(expr)
944 expected = """currval('"the schema".thetable_thecolumn_seq')"""
945- self.assertEquals(statement, expected)
946+ self.assertEqual(statement, expected)
947
948 def test_currval_escaped_table(self):
949 expr = currval(Column("thecolumn", "theschema.the table"))
950 statement = compile(expr)
951 expected = """currval('theschema."the table_thecolumn_seq"')"""
952- self.assertEquals(statement, expected)
953+ self.assertEqual(statement, expected)
954
955 def test_currval_escaped_column(self):
956 expr = currval(Column("the column", "theschema.thetable"))
957 statement = compile(expr)
958 expected = """currval('theschema."thetable_the column_seq"')"""
959- self.assertEquals(statement, expected)
960+ self.assertEqual(statement, expected)
961
962 def test_currval_escaped_column_no_schema(self):
963 expr = currval(Column("the column", "thetable"))
964 statement = compile(expr)
965 expected = """currval('"thetable_the column_seq"')"""
966- self.assertEquals(statement, expected)
967+ self.assertEqual(statement, expected)
968
969 def test_currval_escaped_schema_table_and_column(self):
970 expr = currval(Column("the column", "the schema.the table"))
971 statement = compile(expr)
972 expected = """currval('"the schema"."the table_the column_seq"')"""
973- self.assertEquals(statement, expected)
974+ self.assertEqual(statement, expected)
975
976 def test_get_insert_identity(self):
977 column = Column("thecolumn", "thetable")
978 variable = IntVariable()
979 result = self.connection.execute("SELECT 1")
980 where = result.get_insert_identity((column,), (variable,))
981- self.assertEquals(compile(where),
982- "thetable.thecolumn = "
983- "(SELECT currval('thetable_thecolumn_seq'))")
984+ self.assertEqual(compile(where),
985+ "thetable.thecolumn = "
986+ "(SELECT currval('thetable_thecolumn_seq'))")
987
988 def test_returning_column_context(self):
989 column2 = TrackContext()
990 insert = Insert({column1: elem1}, table1, primary_columns=column2)
991 compile(Returning(insert))
992- self.assertEquals(column2.context, COLUMN)
993+ self.assertEqual(column2.context, COLUMN)
994
995 def test_returning_update(self):
996 update = Update({column1: elem1}, table=table1,
997 primary_columns=(column2, column3))
998- self.assertEquals(compile(Returning(update)),
999- 'UPDATE "table 1" SET column1=elem1 '
1000- 'RETURNING column2, column3')
1001+ self.assertEqual(compile(Returning(update)),
1002+ 'UPDATE "table 1" SET column1=elem1 '
1003+ 'RETURNING column2, column3')
1004
1005 def test_returning_update_with_columns(self):
1006 update = Update({column1: elem1}, table=table1,
1007 primary_columns=(column2, column3))
1008- self.assertEquals(compile(Returning(update, columns=[column3])),
1009- 'UPDATE "table 1" SET column1=elem1 '
1010- 'RETURNING column3')
1011+ self.assertEqual(compile(Returning(update, columns=[column3])),
1012+ 'UPDATE "table 1" SET column1=elem1 '
1013+ 'RETURNING column3')
1014
1015 def test_execute_insert_returning(self):
1016 if self.database._version < 80200:
1017@@ -490,11 +490,11 @@
1018 self.assertTrue(variable1.is_defined())
1019 self.assertTrue(variable2.is_defined())
1020
1021- self.assertEquals(variable1.get(), 123)
1022- self.assertEquals(variable2.get(), 456)
1023+ self.assertEqual(variable1.get(), 123)
1024+ self.assertEqual(variable2.get(), 456)
1025
1026 result = self.connection.execute("SELECT * FROM returning_test")
1027- self.assertEquals(result.get_one(), (123, 456))
1028+ self.assertEqual(result.get_one(), (123, 456))
1029
1030 def test_wb_execute_insert_returning_not_used_with_old_postgres(self):
1031 """Shouldn't try to use RETURNING with PostgreSQL < 8.2."""
1032@@ -512,7 +512,7 @@
1033 self.assertFalse(variable2.is_defined())
1034
1035 result = self.connection.execute("SELECT * FROM returning_test")
1036- self.assertEquals(result.get_one(), (123, 456))
1037+ self.assertEqual(result.get_one(), (123, 456))
1038
1039 def test_execute_insert_returning_without_columns(self):
1040 """Without primary_columns, the RETURNING system won't be used."""
1041@@ -524,7 +524,7 @@
1042 self.assertFalse(variable1.is_defined())
1043
1044 result = self.connection.execute("SELECT * FROM returning_test")
1045- self.assertEquals(result.get_one(), (123, 456))
1046+ self.assertEqual(result.get_one(), (123, 456))
1047
1048 def test_execute_insert_returning_without_variables(self):
1049 """Without primary_variables, the RETURNING system won't be used."""
1050@@ -534,7 +534,7 @@
1051
1052 result = self.connection.execute("SELECT * FROM returning_test")
1053
1054- self.assertEquals(result.get_one(), (123, 456))
1055+ self.assertEqual(result.get_one(), (123, 456))
1056
1057 def test_execute_update_returning(self):
1058 if self.database._version < 80200:
1059@@ -547,7 +547,7 @@
1060 update = Update({"id2": 3}, column1 == 1,
1061 primary_columns=(column1, column2))
1062 result = self.connection.execute(Returning(update))
1063- self.assertEquals(result.get_one(), (1, 3))
1064+ self.assertEqual(result.get_one(), (1, 3))
1065
1066 def test_isolation_autocommit(self):
1067 database = create_database(
1068@@ -558,13 +558,13 @@
1069
1070 result = connection.execute("SHOW TRANSACTION ISOLATION LEVEL")
1071 # It matches read committed in Postgres internel
1072- self.assertEquals(result.get_one()[0], u"read committed")
1073+ self.assertEqual(result.get_one()[0], u"read committed")
1074
1075 connection.execute("INSERT INTO bin_test VALUES (1, 'foo')")
1076
1077 result = self.connection.execute("SELECT id FROM bin_test")
1078 # I didn't commit, but data should already be there
1079- self.assertEquals(result.get_all(), [(1,)])
1080+ self.assertEqual(result.get_all(), [(1,)])
1081 connection.rollback()
1082
1083 def test_isolation_read_committed(self):
1084@@ -575,25 +575,25 @@
1085 self.addCleanup(connection.close)
1086
1087 result = connection.execute("SHOW TRANSACTION ISOLATION LEVEL")
1088- self.assertEquals(result.get_one()[0], u"read committed")
1089+ self.assertEqual(result.get_one()[0], u"read committed")
1090
1091 connection.execute("INSERT INTO bin_test VALUES (1, 'foo')")
1092
1093 result = self.connection.execute("SELECT id FROM bin_test")
1094 # Data should not be there already
1095- self.assertEquals(result.get_all(), [])
1096+ self.assertEqual(result.get_all(), [])
1097 connection.rollback()
1098
1099 # Start a transaction
1100 result = connection.execute("SELECT 1")
1101- self.assertEquals(result.get_one(), (1,))
1102+ self.assertEqual(result.get_one(), (1,))
1103
1104 self.connection.execute("INSERT INTO bin_test VALUES (1, 'foo')")
1105 self.connection.commit()
1106
1107 result = connection.execute("SELECT id FROM bin_test")
1108 # Data is already here!
1109- self.assertEquals(result.get_one(), (1,))
1110+ self.assertEqual(result.get_one(), (1,))
1111 connection.rollback()
1112
1113 def test_isolation_serializable(self):
1114@@ -604,18 +604,18 @@
1115 self.addCleanup(connection.close)
1116
1117 result = connection.execute("SHOW TRANSACTION ISOLATION LEVEL")
1118- self.assertEquals(result.get_one()[0], u"serializable")
1119+ self.assertEqual(result.get_one()[0], u"serializable")
1120
1121 # Start a transaction
1122 result = connection.execute("SELECT 1")
1123- self.assertEquals(result.get_one(), (1,))
1124+ self.assertEqual(result.get_one(), (1,))
1125
1126 self.connection.execute("INSERT INTO bin_test VALUES (1, 'foo')")
1127 self.connection.commit()
1128
1129 result = connection.execute("SELECT id FROM bin_test")
1130 # We can't see data yet, because transaction started before
1131- self.assertEquals(result.get_one(), None)
1132+ self.assertEqual(result.get_one(), None)
1133 connection.rollback()
1134
1135 def test_default_isolation(self):
1136@@ -627,9 +627,9 @@
1137 import psycopg2
1138 psycopg2_version = psycopg2.__version__.split(None, 1)[0]
1139 if psycopg2_version < "2.4.2":
1140- self.assertEquals(result.get_one()[0], u"serializable")
1141+ self.assertEqual(result.get_one()[0], u"serializable")
1142 else:
1143- self.assertEquals(result.get_one()[0], u"repeatable read")
1144+ self.assertEqual(result.get_one()[0], u"repeatable read")
1145
1146 def test_unknown_serialization(self):
1147 self.assertRaises(ValueError, create_database,
1148@@ -909,7 +909,7 @@
1149
1150 def test_set_statement_timeout(self):
1151 result = self.connection.execute("SHOW statement_timeout")
1152- self.assertEquals(result.get_one(), ("10500ms",))
1153+ self.assertEqual(result.get_one(), ("10500ms",))
1154
1155 def test_connection_raw_execute_error(self):
1156 statement = "SELECT pg_sleep(0.5)"
1157
1158=== modified file 'storm/tests/databases/sqlite.py'
1159--- storm/tests/databases/sqlite.py 2019-08-11 17:51:37 +0000
1160+++ storm/tests/databases/sqlite.py 2019-11-21 16:09:19 +0000
1161@@ -60,7 +60,7 @@
1162 def test_wb_create_database(self):
1163 database = create_database("sqlite:")
1164 self.assertTrue(isinstance(database, SQLite))
1165- self.assertEquals(database._filename, ":memory:")
1166+ self.assertEqual(database._filename, ":memory:")
1167
1168 def test_concurrent_behavior(self):
1169 pass # We can't connect to the in-memory database twice, so we can't
1170@@ -73,8 +73,8 @@
1171 (self.get_path(), value)))
1172 connection = database.connect()
1173 result = connection.execute("PRAGMA synchronous")
1174- self.assertEquals(result.get_one()[0],
1175- synchronous_values[value])
1176+ self.assertEqual(result.get_one()[0],
1177+ synchronous_values[value])
1178
1179 def test_sqlite_specific_reserved_words(self):
1180 """Check sqlite-specific reserved words are recognized.
1181@@ -103,7 +103,7 @@
1182 filename = self.make_path()
1183 database = create_database("sqlite:%s" % filename)
1184 self.assertTrue(isinstance(database, SQLite))
1185- self.assertEquals(database._filename, filename)
1186+ self.assertEqual(database._filename, filename)
1187
1188 def test_timeout(self):
1189 database = create_database("sqlite:%s?timeout=0.3" % self.get_path())
1190@@ -116,7 +116,7 @@
1191 try:
1192 connection2.execute("INSERT INTO test VALUES (2)")
1193 except OperationalError as exception:
1194- self.assertEquals(str(exception), "database is locked")
1195+ self.assertEqual(str(exception), "database is locked")
1196 self.assertTrue(time.time()-started >= 0.3)
1197 else:
1198 self.fail("OperationalError not raised")
1199@@ -143,7 +143,7 @@
1200 try:
1201 connection1.commit()
1202 except OperationalError as exception:
1203- self.assertEquals(str(exception), "database is locked")
1204+ self.assertEqual(str(exception), "database is locked")
1205 # In 0.10, the next assertion failed because the timeout wasn't
1206 # enforced for the "COMMIT" statement.
1207 self.assertTrue(time.time()-started >= 0.3)
1208@@ -182,8 +182,8 @@
1209 connection1.commit()
1210
1211 # Check that the correct data is present
1212- self.assertEquals(connection1.execute("SELECT id FROM test").get_all(),
1213- [(1,), (2,)])
1214+ self.assertEqual(connection1.execute("SELECT id FROM test").get_all(),
1215+ [(1,), (2,)])
1216
1217 def test_journal(self):
1218 journal_values = {"DELETE": u'delete', "TRUNCATE": u'truncate',
1219@@ -194,8 +194,8 @@
1220 (self.get_path(), value)))
1221 connection = database.connect()
1222 result = connection.execute("PRAGMA journal_mode").get_one()[0]
1223- self.assertEquals(result,
1224- journal_values[value])
1225+ self.assertEqual(result,
1226+ journal_values[value])
1227
1228 def test_journal_persistency_to_rollback(self):
1229 journal_values = {"DELETE": u'delete', "TRUNCATE": u'truncate',
1230@@ -208,8 +208,8 @@
1231 connection.execute("CREATE TABLE test (id INTEGER PRIMARY KEY)")
1232 connection.rollback()
1233 result = connection.execute("PRAGMA journal_mode").get_one()[0]
1234- self.assertEquals(result,
1235- journal_values[value])
1236+ self.assertEqual(result,
1237+ journal_values[value])
1238
1239 def test_foreign_keys(self):
1240 foreign_keys_values = {"ON": 1, "OFF": 0}
1241@@ -218,8 +218,8 @@
1242 (self.get_path(), value)))
1243 connection = database.connect()
1244 result = connection.execute("PRAGMA foreign_keys").get_one()[0]
1245- self.assertEquals(result,
1246- foreign_keys_values[value])
1247+ self.assertEqual(result,
1248+ foreign_keys_values[value])
1249
1250 def test_foreign_keys_persistency_to_rollback(self):
1251 foreign_keys_values = {"ON": 1, "OFF": 0}
1252@@ -230,8 +230,8 @@
1253 connection.execute("CREATE TABLE test (id INTEGER PRIMARY KEY)")
1254 connection.rollback()
1255 result = connection.execute("PRAGMA foreign_keys").get_one()[0]
1256- self.assertEquals(result,
1257- foreign_keys_values[value])
1258+ self.assertEqual(result,
1259+ foreign_keys_values[value])
1260
1261 class SQLiteUnsupportedTest(UnsupportedDatabaseTest, TestHelper):
1262
1263
1264=== modified file 'storm/tests/event.py'
1265--- storm/tests/event.py 2019-08-11 17:51:37 +0000
1266+++ storm/tests/event.py 2019-11-21 16:09:19 +0000
1267@@ -58,11 +58,11 @@
1268 self.event.emit("two", 3, 4)
1269 self.event.emit("three", 5, 6)
1270
1271- self.assertEquals(sorted(called1), [
1272+ self.assertEqual(sorted(called1), [
1273 (marker, 1, 2),
1274 (marker, 5, 6),
1275 ])
1276- self.assertEquals(sorted(called2), [
1277+ self.assertEqual(sorted(called2), [
1278 (marker, 1, 2, 10, 20),
1279 (marker, 3, 4, 10, 20),
1280 (marker, 3, 4, 30, 40),
1281@@ -82,7 +82,7 @@
1282 self.event.emit("event")
1283 self.event.emit("event")
1284
1285- self.assertEquals(called, [marker, marker])
1286+ self.assertEqual(called, [marker, marker])
1287
1288 def test_weak_reference(self):
1289 marker = Marker()
1290@@ -96,9 +96,9 @@
1291 self.event.hook("event", callback)
1292 self.event.emit("event")
1293
1294- self.assertEquals(called, [marker])
1295+ self.assertEqual(called, [marker])
1296 del called[:]
1297
1298 del marker
1299 self.event.emit("event")
1300- self.assertEquals(called, [])
1301+ self.assertEqual(called, [])
1302
1303=== modified file 'storm/tests/expr.py'
1304--- storm/tests/expr.py 2019-09-17 09:35:10 +0000
1305+++ storm/tests/expr.py 2019-11-21 16:09:19 +0000
1306@@ -60,134 +60,134 @@
1307
1308 def test_select_default(self):
1309 expr = Select(())
1310- self.assertEquals(expr.columns, ())
1311- self.assertEquals(expr.where, Undef)
1312- self.assertEquals(expr.tables, Undef)
1313- self.assertEquals(expr.default_tables, Undef)
1314- self.assertEquals(expr.order_by, Undef)
1315- self.assertEquals(expr.group_by, Undef)
1316- self.assertEquals(expr.limit, Undef)
1317- self.assertEquals(expr.offset, Undef)
1318- self.assertEquals(expr.distinct, False)
1319+ self.assertEqual(expr.columns, ())
1320+ self.assertEqual(expr.where, Undef)
1321+ self.assertEqual(expr.tables, Undef)
1322+ self.assertEqual(expr.default_tables, Undef)
1323+ self.assertEqual(expr.order_by, Undef)
1324+ self.assertEqual(expr.group_by, Undef)
1325+ self.assertEqual(expr.limit, Undef)
1326+ self.assertEqual(expr.offset, Undef)
1327+ self.assertEqual(expr.distinct, False)
1328
1329 def test_select_constructor(self):
1330 objects = [object() for i in range(9)]
1331 expr = Select(*objects)
1332- self.assertEquals(expr.columns, objects[0])
1333- self.assertEquals(expr.where, objects[1])
1334- self.assertEquals(expr.tables, objects[2])
1335- self.assertEquals(expr.default_tables, objects[3])
1336- self.assertEquals(expr.order_by, objects[4])
1337- self.assertEquals(expr.group_by, objects[5])
1338- self.assertEquals(expr.limit, objects[6])
1339- self.assertEquals(expr.offset, objects[7])
1340- self.assertEquals(expr.distinct, objects[8])
1341+ self.assertEqual(expr.columns, objects[0])
1342+ self.assertEqual(expr.where, objects[1])
1343+ self.assertEqual(expr.tables, objects[2])
1344+ self.assertEqual(expr.default_tables, objects[3])
1345+ self.assertEqual(expr.order_by, objects[4])
1346+ self.assertEqual(expr.group_by, objects[5])
1347+ self.assertEqual(expr.limit, objects[6])
1348+ self.assertEqual(expr.offset, objects[7])
1349+ self.assertEqual(expr.distinct, objects[8])
1350
1351 def test_insert_default(self):
1352 expr = Insert(None)
1353- self.assertEquals(expr.map, None)
1354- self.assertEquals(expr.table, Undef)
1355- self.assertEquals(expr.default_table, Undef)
1356- self.assertEquals(expr.primary_columns, Undef)
1357- self.assertEquals(expr.primary_variables, Undef)
1358+ self.assertEqual(expr.map, None)
1359+ self.assertEqual(expr.table, Undef)
1360+ self.assertEqual(expr.default_table, Undef)
1361+ self.assertEqual(expr.primary_columns, Undef)
1362+ self.assertEqual(expr.primary_variables, Undef)
1363
1364 def test_insert_constructor(self):
1365 objects = [object() for i in range(5)]
1366 expr = Insert(*objects)
1367- self.assertEquals(expr.map, objects[0])
1368- self.assertEquals(expr.table, objects[1])
1369- self.assertEquals(expr.default_table, objects[2])
1370- self.assertEquals(expr.primary_columns, objects[3])
1371- self.assertEquals(expr.primary_variables, objects[4])
1372+ self.assertEqual(expr.map, objects[0])
1373+ self.assertEqual(expr.table, objects[1])
1374+ self.assertEqual(expr.default_table, objects[2])
1375+ self.assertEqual(expr.primary_columns, objects[3])
1376+ self.assertEqual(expr.primary_variables, objects[4])
1377
1378 def test_update_default(self):
1379 expr = Update(None)
1380- self.assertEquals(expr.map, None)
1381- self.assertEquals(expr.where, Undef)
1382- self.assertEquals(expr.table, Undef)
1383- self.assertEquals(expr.default_table, Undef)
1384+ self.assertEqual(expr.map, None)
1385+ self.assertEqual(expr.where, Undef)
1386+ self.assertEqual(expr.table, Undef)
1387+ self.assertEqual(expr.default_table, Undef)
1388
1389 def test_update_constructor(self):
1390 objects = [object() for i in range(4)]
1391 expr = Update(*objects)
1392- self.assertEquals(expr.map, objects[0])
1393- self.assertEquals(expr.where, objects[1])
1394- self.assertEquals(expr.table, objects[2])
1395- self.assertEquals(expr.default_table, objects[3])
1396+ self.assertEqual(expr.map, objects[0])
1397+ self.assertEqual(expr.where, objects[1])
1398+ self.assertEqual(expr.table, objects[2])
1399+ self.assertEqual(expr.default_table, objects[3])
1400
1401 def test_delete_default(self):
1402 expr = Delete()
1403- self.assertEquals(expr.where, Undef)
1404- self.assertEquals(expr.table, Undef)
1405+ self.assertEqual(expr.where, Undef)
1406+ self.assertEqual(expr.table, Undef)
1407
1408 def test_delete_constructor(self):
1409 objects = [object() for i in range(3)]
1410 expr = Delete(*objects)
1411- self.assertEquals(expr.where, objects[0])
1412- self.assertEquals(expr.table, objects[1])
1413- self.assertEquals(expr.default_table, objects[2])
1414+ self.assertEqual(expr.where, objects[0])
1415+ self.assertEqual(expr.table, objects[1])
1416+ self.assertEqual(expr.default_table, objects[2])
1417
1418 def test_and(self):
1419 expr = And(elem1, elem2, elem3)
1420- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1421+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1422
1423 def test_or(self):
1424 expr = Or(elem1, elem2, elem3)
1425- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1426+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1427
1428 def test_column_default(self):
1429 expr = Column()
1430- self.assertEquals(expr.name, Undef)
1431- self.assertEquals(expr.table, Undef)
1432+ self.assertEqual(expr.name, Undef)
1433+ self.assertEqual(expr.table, Undef)
1434 self.assertIdentical(expr.compile_cache, None)
1435
1436 # Test for identity. We don't want False there.
1437 self.assertTrue(expr.primary is 0)
1438
1439- self.assertEquals(expr.variable_factory, Variable)
1440+ self.assertEqual(expr.variable_factory, Variable)
1441
1442 def test_column_constructor(self):
1443 objects = [object() for i in range(3)]
1444 objects.insert(2, True)
1445 expr = Column(*objects)
1446- self.assertEquals(expr.name, objects[0])
1447- self.assertEquals(expr.table, objects[1])
1448+ self.assertEqual(expr.name, objects[0])
1449+ self.assertEqual(expr.table, objects[1])
1450
1451 # Test for identity. We don't want True there either.
1452 self.assertTrue(expr.primary is 1)
1453
1454- self.assertEquals(expr.variable_factory, objects[3])
1455+ self.assertEqual(expr.variable_factory, objects[3])
1456
1457 def test_func(self):
1458 expr = Func("myfunc", elem1, elem2)
1459- self.assertEquals(expr.name, "myfunc")
1460- self.assertEquals(expr.args, (elem1, elem2))
1461+ self.assertEqual(expr.name, "myfunc")
1462+ self.assertEqual(expr.args, (elem1, elem2))
1463
1464 def test_named_func(self):
1465 class MyFunc(NamedFunc):
1466 name = "myfunc"
1467 expr = MyFunc(elem1, elem2)
1468- self.assertEquals(expr.name, "myfunc")
1469- self.assertEquals(expr.args, (elem1, elem2))
1470+ self.assertEqual(expr.name, "myfunc")
1471+ self.assertEqual(expr.args, (elem1, elem2))
1472
1473 def test_like(self):
1474 expr = Like(elem1, elem2)
1475- self.assertEquals(expr.expr1, elem1)
1476- self.assertEquals(expr.expr2, elem2)
1477+ self.assertEqual(expr.expr1, elem1)
1478+ self.assertEqual(expr.expr2, elem2)
1479
1480 def test_like_escape(self):
1481 expr = Like(elem1, elem2, elem3)
1482- self.assertEquals(expr.expr1, elem1)
1483- self.assertEquals(expr.expr2, elem2)
1484- self.assertEquals(expr.escape, elem3)
1485+ self.assertEqual(expr.expr1, elem1)
1486+ self.assertEqual(expr.expr2, elem2)
1487+ self.assertEqual(expr.escape, elem3)
1488
1489 def test_like_case(self):
1490 expr = Like(elem1, elem2, elem3)
1491- self.assertEquals(expr.case_sensitive, None)
1492+ self.assertEqual(expr.case_sensitive, None)
1493 expr = Like(elem1, elem2, elem3, True)
1494- self.assertEquals(expr.case_sensitive, True)
1495+ self.assertEqual(expr.case_sensitive, True)
1496 expr = Like(elem1, elem2, elem3, False)
1497- self.assertEquals(expr.case_sensitive, False)
1498+ self.assertEqual(expr.case_sensitive, False)
1499
1500 def test_startswith(self):
1501 expr = Func1()
1502@@ -196,8 +196,8 @@
1503 like_expr = expr.startswith(u"abc!!_%")
1504 self.assertTrue(isinstance(like_expr, Like))
1505 self.assertTrue(like_expr.expr1 is expr)
1506- self.assertEquals(like_expr.expr2, u"abc!!!!!_!%%")
1507- self.assertEquals(like_expr.escape, u"!")
1508+ self.assertEqual(like_expr.expr2, u"abc!!!!!_!%%")
1509+ self.assertEqual(like_expr.escape, u"!")
1510
1511 def test_endswith(self):
1512 expr = Func1()
1513@@ -206,8 +206,8 @@
1514 like_expr = expr.endswith(u"abc!!_%")
1515 self.assertTrue(isinstance(like_expr, Like))
1516 self.assertTrue(like_expr.expr1 is expr)
1517- self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%")
1518- self.assertEquals(like_expr.escape, u"!")
1519+ self.assertEqual(like_expr.expr2, u"%abc!!!!!_!%")
1520+ self.assertEqual(like_expr.escape, u"!")
1521
1522 def test_contains_string(self):
1523 expr = Func1()
1524@@ -217,46 +217,46 @@
1525 like_expr = expr.contains_string(u"abc!!_%")
1526 self.assertTrue(isinstance(like_expr, Like))
1527 self.assertTrue(like_expr.expr1 is expr)
1528- self.assertEquals(like_expr.expr2, u"%abc!!!!!_!%%")
1529- self.assertEquals(like_expr.escape, u"!")
1530+ self.assertEqual(like_expr.expr2, u"%abc!!!!!_!%%")
1531+ self.assertEqual(like_expr.escape, u"!")
1532
1533 def test_eq(self):
1534 expr = Eq(elem1, elem2)
1535- self.assertEquals(expr.expr1, elem1)
1536- self.assertEquals(expr.expr2, elem2)
1537+ self.assertEqual(expr.expr1, elem1)
1538+ self.assertEqual(expr.expr2, elem2)
1539
1540 def test_sql_default(self):
1541 expr = SQL(None)
1542- self.assertEquals(expr.expr, None)
1543- self.assertEquals(expr.params, Undef)
1544- self.assertEquals(expr.tables, Undef)
1545+ self.assertEqual(expr.expr, None)
1546+ self.assertEqual(expr.params, Undef)
1547+ self.assertEqual(expr.tables, Undef)
1548
1549 def test_sql_constructor(self):
1550 objects = [object() for i in range(3)]
1551 expr = SQL(*objects)
1552- self.assertEquals(expr.expr, objects[0])
1553- self.assertEquals(expr.params, objects[1])
1554- self.assertEquals(expr.tables, objects[2])
1555+ self.assertEqual(expr.expr, objects[0])
1556+ self.assertEqual(expr.params, objects[1])
1557+ self.assertEqual(expr.tables, objects[2])
1558
1559 def test_join_expr_right(self):
1560 expr = JoinExpr(None)
1561- self.assertEquals(expr.right, None)
1562- self.assertEquals(expr.left, Undef)
1563- self.assertEquals(expr.on, Undef)
1564+ self.assertEqual(expr.right, None)
1565+ self.assertEqual(expr.left, Undef)
1566+ self.assertEqual(expr.on, Undef)
1567
1568 def test_join_expr_on(self):
1569 on = Expr()
1570 expr = JoinExpr(None, on)
1571- self.assertEquals(expr.right, None)
1572- self.assertEquals(expr.left, Undef)
1573- self.assertEquals(expr.on, on)
1574+ self.assertEqual(expr.right, None)
1575+ self.assertEqual(expr.left, Undef)
1576+ self.assertEqual(expr.on, on)
1577
1578 def test_join_expr_on_keyword(self):
1579 on = Expr()
1580 expr = JoinExpr(None, on=on)
1581- self.assertEquals(expr.right, None)
1582- self.assertEquals(expr.left, Undef)
1583- self.assertEquals(expr.on, on)
1584+ self.assertEqual(expr.right, None)
1585+ self.assertEqual(expr.left, Undef)
1586+ self.assertEqual(expr.on, on)
1587
1588 def test_join_expr_on_invalid(self):
1589 on = Expr()
1590@@ -265,59 +265,59 @@
1591 def test_join_expr_right_left(self):
1592 objects = [object() for i in range(2)]
1593 expr = JoinExpr(*objects)
1594- self.assertEquals(expr.left, objects[0])
1595- self.assertEquals(expr.right, objects[1])
1596- self.assertEquals(expr.on, Undef)
1597+ self.assertEqual(expr.left, objects[0])
1598+ self.assertEqual(expr.right, objects[1])
1599+ self.assertEqual(expr.on, Undef)
1600
1601 def test_join_expr_right_left_on(self):
1602 objects = [object() for i in range(3)]
1603 expr = JoinExpr(*objects)
1604- self.assertEquals(expr.left, objects[0])
1605- self.assertEquals(expr.right, objects[1])
1606- self.assertEquals(expr.on, objects[2])
1607+ self.assertEqual(expr.left, objects[0])
1608+ self.assertEqual(expr.right, objects[1])
1609+ self.assertEqual(expr.on, objects[2])
1610
1611 def test_join_expr_right_join(self):
1612 join = JoinExpr(None)
1613 expr = JoinExpr(None, join)
1614- self.assertEquals(expr.right, join)
1615- self.assertEquals(expr.left, None)
1616- self.assertEquals(expr.on, Undef)
1617+ self.assertEqual(expr.right, join)
1618+ self.assertEqual(expr.left, None)
1619+ self.assertEqual(expr.on, Undef)
1620
1621 def test_table(self):
1622 objects = [object() for i in range(1)]
1623 expr = Table(*objects)
1624- self.assertEquals(expr.name, objects[0])
1625+ self.assertEqual(expr.name, objects[0])
1626
1627 def test_alias_default(self):
1628 expr = Alias(None)
1629- self.assertEquals(expr.expr, None)
1630+ self.assertEqual(expr.expr, None)
1631 self.assertTrue(isinstance(expr.name, str))
1632
1633 def test_alias_constructor(self):
1634 objects = [object() for i in range(2)]
1635 expr = Alias(*objects)
1636- self.assertEquals(expr.expr, objects[0])
1637- self.assertEquals(expr.name, objects[1])
1638+ self.assertEqual(expr.expr, objects[0])
1639+ self.assertEqual(expr.name, objects[1])
1640
1641 def test_union(self):
1642 expr = Union(elem1, elem2, elem3)
1643- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1644+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1645
1646 def test_union_with_kwargs(self):
1647 expr = Union(elem1, elem2, all=True, order_by=(), limit=1, offset=2)
1648- self.assertEquals(expr.exprs, (elem1, elem2))
1649- self.assertEquals(expr.all, True)
1650- self.assertEquals(expr.order_by, ())
1651- self.assertEquals(expr.limit, 1)
1652- self.assertEquals(expr.offset, 2)
1653+ self.assertEqual(expr.exprs, (elem1, elem2))
1654+ self.assertEqual(expr.all, True)
1655+ self.assertEqual(expr.order_by, ())
1656+ self.assertEqual(expr.limit, 1)
1657+ self.assertEqual(expr.offset, 2)
1658
1659 def test_union_collapse(self):
1660 expr = Union(Union(elem1, elem2), elem3)
1661- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1662+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1663
1664 # Only first expression is collapsed.
1665 expr = Union(elem1, Union(elem2, elem3))
1666- self.assertEquals(expr.exprs[0], elem1)
1667+ self.assertEqual(expr.exprs[0], elem1)
1668 self.assertTrue(isinstance(expr.exprs[1], Union))
1669
1670 # Don't collapse if all is different.
1671@@ -326,7 +326,7 @@
1672 expr = Union(Union(elem1, elem2), elem3, all=True)
1673 self.assertTrue(isinstance(expr.exprs[0], Union))
1674 expr = Union(Union(elem1, elem2, all=True), elem3, all=True)
1675- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1676+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1677
1678 # Don't collapse if limit or offset are set.
1679 expr = Union(Union(elem1, elem2, limit=1), elem3)
1680@@ -342,23 +342,23 @@
1681
1682 def test_except(self):
1683 expr = Except(elem1, elem2, elem3)
1684- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1685+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1686
1687 def test_except_with_kwargs(self):
1688 expr = Except(elem1, elem2, all=True, order_by=(), limit=1, offset=2)
1689- self.assertEquals(expr.exprs, (elem1, elem2))
1690- self.assertEquals(expr.all, True)
1691- self.assertEquals(expr.order_by, ())
1692- self.assertEquals(expr.limit, 1)
1693- self.assertEquals(expr.offset, 2)
1694+ self.assertEqual(expr.exprs, (elem1, elem2))
1695+ self.assertEqual(expr.all, True)
1696+ self.assertEqual(expr.order_by, ())
1697+ self.assertEqual(expr.limit, 1)
1698+ self.assertEqual(expr.offset, 2)
1699
1700 def test_except_collapse(self):
1701 expr = Except(Except(elem1, elem2), elem3)
1702- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1703+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1704
1705 # Only first expression is collapsed.
1706 expr = Except(elem1, Except(elem2, elem3))
1707- self.assertEquals(expr.exprs[0], elem1)
1708+ self.assertEqual(expr.exprs[0], elem1)
1709 self.assertTrue(isinstance(expr.exprs[1], Except))
1710
1711 # Don't collapse if all is different.
1712@@ -367,7 +367,7 @@
1713 expr = Except(Except(elem1, elem2), elem3, all=True)
1714 self.assertTrue(isinstance(expr.exprs[0], Except))
1715 expr = Except(Except(elem1, elem2, all=True), elem3, all=True)
1716- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1717+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1718
1719 # Don't collapse if limit or offset are set.
1720 expr = Except(Except(elem1, elem2, limit=1), elem3)
1721@@ -383,24 +383,24 @@
1722
1723 def test_intersect(self):
1724 expr = Intersect(elem1, elem2, elem3)
1725- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1726+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1727
1728 def test_intersect_with_kwargs(self):
1729 expr = Intersect(
1730 elem1, elem2, all=True, order_by=(), limit=1, offset=2)
1731- self.assertEquals(expr.exprs, (elem1, elem2))
1732- self.assertEquals(expr.all, True)
1733- self.assertEquals(expr.order_by, ())
1734- self.assertEquals(expr.limit, 1)
1735- self.assertEquals(expr.offset, 2)
1736+ self.assertEqual(expr.exprs, (elem1, elem2))
1737+ self.assertEqual(expr.all, True)
1738+ self.assertEqual(expr.order_by, ())
1739+ self.assertEqual(expr.limit, 1)
1740+ self.assertEqual(expr.offset, 2)
1741
1742 def test_intersect_collapse(self):
1743 expr = Intersect(Intersect(elem1, elem2), elem3)
1744- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1745+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1746
1747 # Only first expression is collapsed.
1748 expr = Intersect(elem1, Intersect(elem2, elem3))
1749- self.assertEquals(expr.exprs[0], elem1)
1750+ self.assertEqual(expr.exprs[0], elem1)
1751 self.assertTrue(isinstance(expr.exprs[1], Intersect))
1752
1753 # Don't collapse if all is different.
1754@@ -409,7 +409,7 @@
1755 expr = Intersect(Intersect(elem1, elem2), elem3, all=True)
1756 self.assertTrue(isinstance(expr.exprs[0], Intersect))
1757 expr = Intersect(Intersect(elem1, elem2, all=True), elem3, all=True)
1758- self.assertEquals(expr.exprs, (elem1, elem2, elem3))
1759+ self.assertEqual(expr.exprs, (elem1, elem2, elem3))
1760
1761 # Don't collapse if limit or offset are set.
1762 expr = Intersect(Intersect(elem1, elem2, limit=1), elem3)
1763@@ -425,12 +425,12 @@
1764
1765 def test_auto_tables(self):
1766 expr = AutoTables(elem1, [elem2])
1767- self.assertEquals(expr.expr, elem1)
1768- self.assertEquals(expr.tables, [elem2])
1769+ self.assertEqual(expr.expr, elem1)
1770+ self.assertEqual(expr.tables, [elem2])
1771
1772 def test_sequence(self):
1773 expr = Sequence(elem1)
1774- self.assertEquals(expr.name, elem1)
1775+ self.assertEqual(expr.name, elem1)
1776
1777
1778 class StateTest(TestHelper):
1779@@ -440,29 +440,29 @@
1780 self.state = State()
1781
1782 def test_attrs(self):
1783- self.assertEquals(self.state.parameters, [])
1784- self.assertEquals(self.state.auto_tables, [])
1785- self.assertEquals(self.state.context, None)
1786+ self.assertEqual(self.state.parameters, [])
1787+ self.assertEqual(self.state.auto_tables, [])
1788+ self.assertEqual(self.state.context, None)
1789
1790 def test_push_pop(self):
1791 self.state.parameters.extend([1, 2])
1792 self.state.push("parameters", [])
1793- self.assertEquals(self.state.parameters, [])
1794+ self.assertEqual(self.state.parameters, [])
1795 self.state.pop()
1796- self.assertEquals(self.state.parameters, [1, 2])
1797+ self.assertEqual(self.state.parameters, [1, 2])
1798 self.state.push("parameters")
1799- self.assertEquals(self.state.parameters, [1, 2])
1800+ self.assertEqual(self.state.parameters, [1, 2])
1801 self.state.parameters.append(3)
1802- self.assertEquals(self.state.parameters, [1, 2, 3])
1803+ self.assertEqual(self.state.parameters, [1, 2, 3])
1804 self.state.pop()
1805- self.assertEquals(self.state.parameters, [1, 2])
1806+ self.assertEqual(self.state.parameters, [1, 2])
1807
1808 def test_push_pop_unexistent(self):
1809 self.state.push("nonexistent")
1810- self.assertEquals(self.state.nonexistent, None)
1811+ self.assertEqual(self.state.nonexistent, None)
1812 self.state.nonexistent = "something"
1813 self.state.pop()
1814- self.assertEquals(self.state.nonexistent, None)
1815+ self.assertEqual(self.state.nonexistent, None)
1816
1817
1818 class CompileTest(TestHelper):
1819@@ -470,7 +470,7 @@
1820 def test_simple_inheritance(self):
1821 custom_compile = compile.create_child()
1822 statement = custom_compile(Func1())
1823- self.assertEquals(statement, "func1()")
1824+ self.assertEqual(statement, "func1()")
1825
1826 def test_customize(self):
1827 custom_compile = compile.create_child()
1828@@ -478,7 +478,7 @@
1829 def compile_none(compile, state, expr):
1830 return "None"
1831 statement = custom_compile(Func1(None))
1832- self.assertEquals(statement, "func1(None)")
1833+ self.assertEqual(statement, "func1(None)")
1834
1835 def test_customize_inheritance(self):
1836 class C(object): pass
1837@@ -489,25 +489,25 @@
1838 def compile_in_parent(compile, state, expr):
1839 return "parent"
1840 statement = compile_child(C())
1841- self.assertEquals(statement, "parent")
1842+ self.assertEqual(statement, "parent")
1843
1844 @compile_child.when(C)
1845 def compile_in_child(compile, state, expr):
1846 return "child"
1847 statement = compile_child(C())
1848- self.assertEquals(statement, "child")
1849+ self.assertEqual(statement, "child")
1850
1851 def test_precedence(self):
1852 e = [SQLRaw('%d' % i) for i in range(10)]
1853 expr = And(e[1], Or(e[2], e[3]),
1854 Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9]))))))
1855 statement = compile(expr)
1856- self.assertEquals(statement, "1 AND (2 OR 3) AND 4+5*(6-7/(8/9))")
1857+ self.assertEqual(statement, "1 AND (2 OR 3) AND 4+5*(6-7/(8/9))")
1858
1859 expr = Func1(Select(Count()), [Select(Count())])
1860 statement = compile(expr)
1861- self.assertEquals(statement,
1862- "func1((SELECT COUNT(*)), (SELECT COUNT(*)))")
1863+ self.assertEqual(statement,
1864+ "func1((SELECT COUNT(*)), (SELECT COUNT(*)))")
1865
1866 def test_get_precedence(self):
1867 self.assertTrue(compile.get_precedence(Or) <
1868@@ -524,15 +524,15 @@
1869
1870 custom_compile.set_precedence(11, Or)
1871 statement = custom_compile(expr)
1872- self.assertEquals(statement, "elem1 AND elem2 OR elem3")
1873+ self.assertEqual(statement, "elem1 AND elem2 OR elem3")
1874
1875 custom_compile.set_precedence(10, Or)
1876 statement = custom_compile(expr)
1877- self.assertEquals(statement, "elem1 AND elem2 OR elem3")
1878+ self.assertEqual(statement, "elem1 AND elem2 OR elem3")
1879
1880 custom_compile.set_precedence(9, Or)
1881 statement = custom_compile(expr)
1882- self.assertEquals(statement, "elem1 AND (elem2 OR elem3)")
1883+ self.assertEqual(statement, "elem1 AND (elem2 OR elem3)")
1884
1885 def test_customize_precedence_inheritance(self):
1886 compile_parent = compile.create_child()
1887@@ -543,27 +543,27 @@
1888 compile_parent.set_precedence(10, And)
1889
1890 compile_parent.set_precedence(11, Or)
1891- self.assertEquals(compile_child.get_precedence(Or), 11)
1892- self.assertEquals(compile_parent.get_precedence(Or), 11)
1893+ self.assertEqual(compile_child.get_precedence(Or), 11)
1894+ self.assertEqual(compile_parent.get_precedence(Or), 11)
1895 statement = compile_child(expr)
1896- self.assertEquals(statement, "elem1 AND elem2 OR elem3")
1897+ self.assertEqual(statement, "elem1 AND elem2 OR elem3")
1898
1899 compile_parent.set_precedence(10, Or)
1900- self.assertEquals(compile_child.get_precedence(Or), 10)
1901- self.assertEquals(compile_parent.get_precedence(Or), 10)
1902+ self.assertEqual(compile_child.get_precedence(Or), 10)
1903+ self.assertEqual(compile_parent.get_precedence(Or), 10)
1904 statement = compile_child(expr)
1905- self.assertEquals(statement, "elem1 AND elem2 OR elem3")
1906+ self.assertEqual(statement, "elem1 AND elem2 OR elem3")
1907
1908 compile_child.set_precedence(9, Or)
1909- self.assertEquals(compile_child.get_precedence(Or), 9)
1910- self.assertEquals(compile_parent.get_precedence(Or), 10)
1911+ self.assertEqual(compile_child.get_precedence(Or), 9)
1912+ self.assertEqual(compile_parent.get_precedence(Or), 10)
1913 statement = compile_child(expr)
1914- self.assertEquals(statement, "elem1 AND (elem2 OR elem3)")
1915+ self.assertEqual(statement, "elem1 AND (elem2 OR elem3)")
1916
1917 def test_compile_sequence(self):
1918 expr = [elem1, Func1(), (Func2(), None)]
1919 statement = compile(expr)
1920- self.assertEquals(statement, "elem1, func1(), func2(), NULL")
1921+ self.assertEqual(statement, "elem1, func1(), func2(), NULL")
1922
1923 def test_compile_invalid(self):
1924 self.assertRaises(CompileError, compile, object())
1925@@ -572,19 +572,19 @@
1926 def test_bytes(self):
1927 state = State()
1928 statement = compile(b"str", state)
1929- self.assertEquals(statement, "?")
1930+ self.assertEqual(statement, "?")
1931 self.assertVariablesEqual(state.parameters, [RawStrVariable(b"str")])
1932
1933 def test_unicode(self):
1934 state = State()
1935 statement = compile(u"str", state)
1936- self.assertEquals(statement, "?")
1937+ self.assertEqual(statement, "?")
1938 self.assertVariablesEqual(state.parameters, [UnicodeVariable(u"str")])
1939
1940 def test_int(self):
1941 state = State()
1942 statement = compile(1, state)
1943- self.assertEquals(statement, "?")
1944+ self.assertEqual(statement, "?")
1945 self.assertVariablesEqual(state.parameters, [IntVariable(1)])
1946
1947 @unittest.skipUnless(six.PY2, "Python 3 has no separate long type")
1948@@ -592,25 +592,25 @@
1949 state = State()
1950 # 1L was more idiomatic in Python 2, but is a syntax error in Python 3.
1951 statement = compile(long(1), state)
1952- self.assertEquals(statement, "?")
1953+ self.assertEqual(statement, "?")
1954 self.assertVariablesEqual(state.parameters, [IntVariable(1)])
1955
1956 def test_bool(self):
1957 state = State()
1958 statement = compile(True, state)
1959- self.assertEquals(statement, "?")
1960+ self.assertEqual(statement, "?")
1961 self.assertVariablesEqual(state.parameters, [BoolVariable(1)])
1962
1963 def test_float(self):
1964 state = State()
1965 statement = compile(1.1, state)
1966- self.assertEquals(statement, "?")
1967+ self.assertEqual(statement, "?")
1968 self.assertVariablesEqual(state.parameters, [FloatVariable(1.1)])
1969
1970 def test_decimal(self):
1971 state = State()
1972 statement = compile(Decimal("1.1"), state)
1973- self.assertEquals(statement, "?")
1974+ self.assertEqual(statement, "?")
1975 self.assertVariablesEqual(
1976 state.parameters, [DecimalVariable(Decimal("1.1"))])
1977
1978@@ -618,60 +618,60 @@
1979 dt = datetime(1977, 5, 4, 12, 34)
1980 state = State()
1981 statement = compile(dt, state)
1982- self.assertEquals(statement, "?")
1983+ self.assertEqual(statement, "?")
1984 self.assertVariablesEqual(state.parameters, [DateTimeVariable(dt)])
1985
1986 def test_date(self):
1987 d = date(1977, 5, 4)
1988 state = State()
1989 statement = compile(d, state)
1990- self.assertEquals(statement, "?")
1991+ self.assertEqual(statement, "?")
1992 self.assertVariablesEqual(state.parameters, [DateVariable(d)])
1993
1994 def test_time(self):
1995 t = time(12, 34)
1996 state = State()
1997 statement = compile(t, state)
1998- self.assertEquals(statement, "?")
1999+ self.assertEqual(statement, "?")
2000 self.assertVariablesEqual(state.parameters, [TimeVariable(t)])
2001
2002 def test_timedelta(self):
2003 td = timedelta(days=1, seconds=2, microseconds=3)
2004 state = State()
2005 statement = compile(td, state)
2006- self.assertEquals(statement, "?")
2007+ self.assertEqual(statement, "?")
2008 self.assertVariablesEqual(state.parameters, [TimeDeltaVariable(td)])
2009
2010 def test_none(self):
2011 state = State()
2012 statement = compile(None, state)
2013- self.assertEquals(statement, "NULL")
2014- self.assertEquals(state.parameters, [])
2015+ self.assertEqual(statement, "NULL")
2016+ self.assertEqual(state.parameters, [])
2017
2018 def test_select(self):
2019 expr = Select([column1, column2])
2020 state = State()
2021 statement = compile(expr, state)
2022- self.assertEquals(statement, "SELECT column1, column2")
2023- self.assertEquals(state.parameters, [])
2024+ self.assertEqual(statement, "SELECT column1, column2")
2025+ self.assertEqual(state.parameters, [])
2026
2027 def test_select_distinct(self):
2028 expr = Select([column1, column2], Undef, [table1], distinct=True)
2029 state = State()
2030 statement = compile(expr, state)
2031- self.assertEquals(statement,
2032- 'SELECT DISTINCT column1, column2 FROM "table 1"')
2033- self.assertEquals(state.parameters, [])
2034+ self.assertEqual(statement,
2035+ 'SELECT DISTINCT column1, column2 FROM "table 1"')
2036+ self.assertEqual(state.parameters, [])
2037
2038 def test_select_distinct_on(self):
2039 expr = Select([column1, column2], Undef, [table1],
2040 distinct=[column2, column1])
2041 state = State()
2042 statement = compile(expr, state)
2043- self.assertEquals(statement,
2044- 'SELECT DISTINCT ON (column2, column1) '
2045- 'column1, column2 FROM "table 1"')
2046- self.assertEquals(state.parameters, [])
2047+ self.assertEqual(statement,
2048+ 'SELECT DISTINCT ON (column2, column1) '
2049+ 'column1, column2 FROM "table 1"')
2050+ self.assertEqual(state.parameters, [])
2051
2052 def test_select_where(self):
2053 expr = Select([column1, Func1()],
2054@@ -682,13 +682,13 @@
2055 limit=3, offset=4)
2056 state = State()
2057 statement = compile(expr, state)
2058- self.assertEquals(statement, 'SELECT column1, func1() '
2059- 'FROM "table 1", func1() '
2060- 'WHERE func1() '
2061- 'GROUP BY column3, func1() '
2062- 'ORDER BY column2, func1() '
2063- 'LIMIT 3 OFFSET 4')
2064- self.assertEquals(state.parameters, [])
2065+ self.assertEqual(statement, 'SELECT column1, func1() '
2066+ 'FROM "table 1", func1() '
2067+ 'WHERE func1() '
2068+ 'GROUP BY column3, func1() '
2069+ 'ORDER BY column2, func1() '
2070+ 'LIMIT 3 OFFSET 4')
2071+ self.assertEqual(state.parameters, [])
2072
2073 def test_select_join_where(self):
2074 expr = Select(column1,
2075@@ -696,20 +696,20 @@
2076 Join(table1, Func2() == "value2"))
2077 state = State()
2078 statement = compile(expr, state)
2079- self.assertEquals(statement, 'SELECT column1 FROM '
2080- 'JOIN "table 1" ON func2() = ? '
2081- 'WHERE func1() = ?')
2082- self.assertEquals([variable.get() for variable in state.parameters],
2083- ["value2", "value1"])
2084+ self.assertEqual(statement, 'SELECT column1 FROM '
2085+ 'JOIN "table 1" ON func2() = ? '
2086+ 'WHERE func1() = ?')
2087+ self.assertEqual([variable.get() for variable in state.parameters],
2088+ ["value2", "value1"])
2089
2090 def test_select_auto_table(self):
2091 expr = Select(Column(column1, table1),
2092 Column(column2, table2) == 1),
2093 state = State()
2094 statement = compile(expr, state)
2095- self.assertEquals(statement, 'SELECT "table 1".column1 '
2096- 'FROM "table 1", "table 2" '
2097- 'WHERE "table 2".column2 = ?')
2098+ self.assertEqual(statement, 'SELECT "table 1".column1 '
2099+ 'FROM "table 1", "table 2" '
2100+ 'WHERE "table 2".column2 = ?')
2101 self.assertVariablesEqual(state.parameters, [Variable(1)])
2102
2103 def test_select_auto_table_duplicated(self):
2104@@ -717,9 +717,9 @@
2105 Column(column2, table1) == 1),
2106 state = State()
2107 statement = compile(expr, state)
2108- self.assertEquals(statement, 'SELECT "table 1".column1 '
2109- 'FROM "table 1" WHERE '
2110- '"table 1".column2 = ?')
2111+ self.assertEqual(statement, 'SELECT "table 1".column1 '
2112+ 'FROM "table 1" WHERE '
2113+ '"table 1".column2 = ?')
2114 self.assertVariablesEqual(state.parameters, [Variable(1)])
2115
2116 def test_select_auto_table_default(self):
2117@@ -728,8 +728,8 @@
2118 default_tables=table1),
2119 state = State()
2120 statement = compile(expr, state)
2121- self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
2122- 'WHERE column2 = ?')
2123+ self.assertEqual(statement, 'SELECT column1 FROM "table 1" '
2124+ 'WHERE column2 = ?')
2125 self.assertVariablesEqual(state.parameters, [Variable(1)])
2126
2127 def test_select_auto_table_default_with_joins(self):
2128@@ -737,85 +737,85 @@
2129 default_tables=[table1, Join(table2)]),
2130 state = State()
2131 statement = compile(expr, state)
2132- self.assertEquals(statement, 'SELECT column1 '
2133- 'FROM "table 1" JOIN "table 2"')
2134- self.assertEquals(state.parameters, [])
2135+ self.assertEqual(statement, 'SELECT column1 '
2136+ 'FROM "table 1" JOIN "table 2"')
2137+ self.assertEqual(state.parameters, [])
2138
2139 def test_select_auto_table_unknown(self):
2140 statement = compile(Select(elem1))
2141- self.assertEquals(statement, "SELECT elem1")
2142+ self.assertEqual(statement, "SELECT elem1")
2143
2144 def test_select_auto_table_sub(self):
2145 col1 = Column(column1, table1)
2146 col2 = Column(column2, table2)
2147 expr = Select(col1, In(elem1, Select(col2, col1 == col2, col2.table)))
2148 statement = compile(expr)
2149- self.assertEquals(statement,
2150- 'SELECT "table 1".column1 FROM "table 1" WHERE '
2151- 'elem1 IN (SELECT "table 2".column2 FROM "table 2" '
2152- 'WHERE "table 1".column1 = "table 2".column2)')
2153+ self.assertEqual(statement,
2154+ 'SELECT "table 1".column1 FROM "table 1" WHERE '
2155+ 'elem1 IN (SELECT "table 2".column2 FROM "table 2" '
2156+ 'WHERE "table 1".column1 = "table 2".column2)')
2157
2158 def test_select_join(self):
2159 expr = Select([column1, Func1()], Func1(),
2160 [table1, Join(table2), Join(table3)])
2161 state = State()
2162 statement = compile(expr, state)
2163- self.assertEquals(statement, 'SELECT column1, func1() '
2164- 'FROM "table 1" JOIN "table 2"'
2165- ' JOIN "table 3" '
2166- 'WHERE func1()')
2167- self.assertEquals(state.parameters, [])
2168+ self.assertEqual(statement, 'SELECT column1, func1() '
2169+ 'FROM "table 1" JOIN "table 2"'
2170+ ' JOIN "table 3" '
2171+ 'WHERE func1()')
2172+ self.assertEqual(state.parameters, [])
2173
2174 def test_select_join_right_left(self):
2175 expr = Select([column1, Func1()], Func1(),
2176 [table1, Join(table2, table3)])
2177 state = State()
2178 statement = compile(expr, state)
2179- self.assertEquals(statement, 'SELECT column1, func1() '
2180- 'FROM "table 1", "table 2" '
2181- 'JOIN "table 3" WHERE func1()')
2182- self.assertEquals(state.parameters, [])
2183+ self.assertEqual(statement, 'SELECT column1, func1() '
2184+ 'FROM "table 1", "table 2" '
2185+ 'JOIN "table 3" WHERE func1()')
2186+ self.assertEqual(state.parameters, [])
2187
2188 def test_select_with_strings(self):
2189 expr = Select(column1, "1 = 2", table1, order_by="column1",
2190 group_by="column2")
2191 state = State()
2192 statement = compile(expr, state)
2193- self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
2194- 'WHERE 1 = 2 GROUP BY column2 '
2195- 'ORDER BY column1')
2196- self.assertEquals(state.parameters, [])
2197+ self.assertEqual(statement, 'SELECT column1 FROM "table 1" '
2198+ 'WHERE 1 = 2 GROUP BY column2 '
2199+ 'ORDER BY column1')
2200+ self.assertEqual(state.parameters, [])
2201
2202 def test_select_with_unicode(self):
2203 expr = Select(column1, u"1 = 2", table1, order_by=u"column1",
2204 group_by=[u"column2"])
2205 state = State()
2206 statement = compile(expr, state)
2207- self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
2208- 'WHERE 1 = 2 GROUP BY column2 '
2209- 'ORDER BY column1')
2210- self.assertEquals(state.parameters, [])
2211+ self.assertEqual(statement, 'SELECT column1 FROM "table 1" '
2212+ 'WHERE 1 = 2 GROUP BY column2 '
2213+ 'ORDER BY column1')
2214+ self.assertEqual(state.parameters, [])
2215
2216 def test_select_having(self):
2217 expr = Select(column1, tables=table1, order_by=u"column1",
2218 group_by=[u"column2"], having=u"1 = 2")
2219 state = State()
2220 statement = compile(expr, state)
2221- self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
2222- 'GROUP BY column2 HAVING 1 = 2 '
2223- 'ORDER BY column1')
2224- self.assertEquals(state.parameters, [])
2225+ self.assertEqual(statement, 'SELECT column1 FROM "table 1" '
2226+ 'GROUP BY column2 HAVING 1 = 2 '
2227+ 'ORDER BY column1')
2228+ self.assertEqual(state.parameters, [])
2229
2230 def test_select_contexts(self):
2231 column, where, table, order_by, group_by = track_contexts(5)
2232 expr = Select(column, where, table,
2233 order_by=order_by, group_by=group_by)
2234 compile(expr)
2235- self.assertEquals(column.context, COLUMN)
2236- self.assertEquals(where.context, EXPR)
2237- self.assertEquals(table.context, TABLE)
2238- self.assertEquals(order_by.context, EXPR)
2239- self.assertEquals(group_by.context, EXPR)
2240+ self.assertEqual(column.context, COLUMN)
2241+ self.assertEqual(where.context, EXPR)
2242+ self.assertEqual(table.context, TABLE)
2243+ self.assertEqual(order_by.context, EXPR)
2244+ self.assertEqual(group_by.context, EXPR)
2245
2246 def test_insert(self):
2247 expr = Insert({column1: elem1, Func1(): Func2()}, Func2())
2248@@ -826,7 +826,7 @@
2249 "VALUES (elem1, func2())",
2250 "INSERT INTO func2() (func1(), column1) "
2251 "VALUES (func2(), elem1)"), statement)
2252- self.assertEquals(state.parameters, [])
2253+ self.assertEqual(state.parameters, [])
2254
2255 def test_insert_with_columns(self):
2256 expr = Insert({Column(column1, table1): elem1,
2257@@ -838,39 +838,39 @@
2258 'VALUES (elem1, elem2)',
2259 'INSERT INTO "table 2" (column2, column1) '
2260 'VALUES (elem2, elem1)'), statement)
2261- self.assertEquals(state.parameters, [])
2262+ self.assertEqual(state.parameters, [])
2263
2264 def test_insert_with_columns_to_escape(self):
2265 expr = Insert({Column("column 1", table1): elem1}, table2)
2266 state = State()
2267 statement = compile(expr, state)
2268- self.assertEquals(statement,
2269- 'INSERT INTO "table 2" ("column 1") VALUES (elem1)')
2270- self.assertEquals(state.parameters, [])
2271+ self.assertEqual(statement,
2272+ 'INSERT INTO "table 2" ("column 1") VALUES (elem1)')
2273+ self.assertEqual(state.parameters, [])
2274
2275 def test_insert_with_columns_as_raw_strings(self):
2276 expr = Insert({"column 1": elem1}, table2)
2277 state = State()
2278 statement = compile(expr, state)
2279- self.assertEquals(statement,
2280- 'INSERT INTO "table 2" ("column 1") VALUES (elem1)')
2281- self.assertEquals(state.parameters, [])
2282+ self.assertEqual(statement,
2283+ 'INSERT INTO "table 2" ("column 1") VALUES (elem1)')
2284+ self.assertEqual(state.parameters, [])
2285
2286 def test_insert_auto_table(self):
2287 expr = Insert({Column(column1, table1): elem1})
2288 state = State()
2289 statement = compile(expr, state)
2290- self.assertEquals(statement, 'INSERT INTO "table 1" (column1) '
2291- 'VALUES (elem1)')
2292- self.assertEquals(state.parameters, [])
2293+ self.assertEqual(statement, 'INSERT INTO "table 1" (column1) '
2294+ 'VALUES (elem1)')
2295+ self.assertEqual(state.parameters, [])
2296
2297 def test_insert_auto_table_default(self):
2298 expr = Insert({Column(column1): elem1}, default_table=table1)
2299 state = State()
2300 statement = compile(expr, state)
2301- self.assertEquals(statement, 'INSERT INTO "table 1" (column1) '
2302- 'VALUES (elem1)')
2303- self.assertEquals(state.parameters, [])
2304+ self.assertEqual(statement, 'INSERT INTO "table 1" (column1) '
2305+ 'VALUES (elem1)')
2306+ self.assertEqual(state.parameters, [])
2307
2308 def test_insert_auto_table_unknown(self):
2309 expr = Insert({Column(column1): elem1})
2310@@ -880,20 +880,20 @@
2311 column, value, table = track_contexts(3)
2312 expr = Insert({column: value}, table)
2313 compile(expr)
2314- self.assertEquals(column.context, COLUMN_NAME)
2315- self.assertEquals(value.context, EXPR)
2316- self.assertEquals(table.context, TABLE)
2317+ self.assertEqual(column.context, COLUMN_NAME)
2318+ self.assertEqual(value.context, EXPR)
2319+ self.assertEqual(table.context, TABLE)
2320
2321 def test_insert_bulk(self):
2322 expr = Insert((Column(column1, table1), Column(column2, table1)),
2323 values=[(elem1, elem2), (elem3, elem4)])
2324 state = State()
2325 statement = compile(expr, state)
2326- self.assertEquals(
2327+ self.assertEqual(
2328 statement,
2329 'INSERT INTO "table 1" (column1, column2) '
2330 'VALUES (elem1, elem2), (elem3, elem4)')
2331- self.assertEquals(state.parameters, [])
2332+ self.assertEqual(state.parameters, [])
2333
2334 def test_insert_select(self):
2335 expr = Insert((Column(column1, table1), Column(column2, table1)),
2336@@ -901,12 +901,12 @@
2337 (Column(column3, table3), Column(column4, table4))))
2338 state = State()
2339 statement = compile(expr, state)
2340- self.assertEquals(
2341+ self.assertEqual(
2342 statement,
2343 'INSERT INTO "table 1" (column1, column2) '
2344 'SELECT "table 3".column3, "table 4".column4 '
2345 'FROM "table 3", "table 4"')
2346- self.assertEquals(state.parameters, [])
2347+ self.assertEqual(state.parameters, [])
2348
2349 def test_update(self):
2350 expr = Update({column1: elem1, Func1(): Func2()}, table=Func1())
2351@@ -916,51 +916,51 @@
2352 "UPDATE func1() SET column1=elem1, func1()=func2()",
2353 "UPDATE func1() SET func1()=func2(), column1=elem1"
2354 ), statement)
2355- self.assertEquals(state.parameters, [])
2356+ self.assertEqual(state.parameters, [])
2357
2358 def test_update_with_columns(self):
2359 expr = Update({Column(column1, table1): elem1}, table=table1)
2360 state = State()
2361 statement = compile(expr, state)
2362- self.assertEquals(statement, 'UPDATE "table 1" SET column1=elem1')
2363- self.assertEquals(state.parameters, [])
2364+ self.assertEqual(statement, 'UPDATE "table 1" SET column1=elem1')
2365+ self.assertEqual(state.parameters, [])
2366
2367 def test_update_with_columns_to_escape(self):
2368 expr = Update({Column("column x", table1): elem1}, table=table1)
2369 state = State()
2370 statement = compile(expr, state)
2371- self.assertEquals(statement, 'UPDATE "table 1" SET "column x"=elem1')
2372- self.assertEquals(state.parameters, [])
2373+ self.assertEqual(statement, 'UPDATE "table 1" SET "column x"=elem1')
2374+ self.assertEqual(state.parameters, [])
2375
2376 def test_update_with_columns_as_raw_strings(self):
2377 expr = Update({"column 1": elem1}, table=table2)
2378 state = State()
2379 statement = compile(expr, state)
2380- self.assertEquals(statement,
2381- 'UPDATE "table 2" SET "column 1"=elem1')
2382- self.assertEquals(state.parameters, [])
2383+ self.assertEqual(statement,
2384+ 'UPDATE "table 2" SET "column 1"=elem1')
2385+ self.assertEqual(state.parameters, [])
2386
2387 def test_update_where(self):
2388 expr = Update({column1: elem1}, Func1(), Func2())
2389 state = State()
2390 statement = compile(expr, state)
2391- self.assertEquals(statement,
2392- "UPDATE func2() SET column1=elem1 WHERE func1()")
2393- self.assertEquals(state.parameters, [])
2394+ self.assertEqual(statement,
2395+ "UPDATE func2() SET column1=elem1 WHERE func1()")
2396+ self.assertEqual(state.parameters, [])
2397
2398 def test_update_auto_table(self):
2399 expr = Update({Column(column1, table1): elem1})
2400 state = State()
2401 statement = compile(expr, state)
2402- self.assertEquals(statement, 'UPDATE "table 1" SET column1=elem1')
2403- self.assertEquals(state.parameters, [])
2404+ self.assertEqual(statement, 'UPDATE "table 1" SET column1=elem1')
2405+ self.assertEqual(state.parameters, [])
2406
2407 def test_update_auto_table_default(self):
2408 expr = Update({Column(column1): elem1}, default_table=table1)
2409 state = State()
2410 statement = compile(expr, state)
2411- self.assertEquals(statement, 'UPDATE "table 1" SET column1=elem1')
2412- self.assertEquals(state.parameters, [])
2413+ self.assertEqual(statement, 'UPDATE "table 1" SET column1=elem1')
2414+ self.assertEqual(state.parameters, [])
2415
2416 def test_update_auto_table_unknown(self):
2417 expr = Update({Column(column1): elem1})
2418@@ -970,54 +970,54 @@
2419 expr = Update({column1: elem1}, "1 = 2", table1)
2420 state = State()
2421 statement = compile(expr, state)
2422- self.assertEquals(statement,
2423- 'UPDATE "table 1" SET column1=elem1 WHERE 1 = 2')
2424- self.assertEquals(state.parameters, [])
2425+ self.assertEqual(statement,
2426+ 'UPDATE "table 1" SET column1=elem1 WHERE 1 = 2')
2427+ self.assertEqual(state.parameters, [])
2428
2429 def test_update_contexts(self):
2430 set_left, set_right, where, table = track_contexts(4)
2431 expr = Update({set_left: set_right}, where, table)
2432 compile(expr)
2433- self.assertEquals(set_left.context, COLUMN_NAME)
2434- self.assertEquals(set_right.context, COLUMN_NAME)
2435- self.assertEquals(where.context, EXPR)
2436- self.assertEquals(table.context, TABLE)
2437+ self.assertEqual(set_left.context, COLUMN_NAME)
2438+ self.assertEqual(set_right.context, COLUMN_NAME)
2439+ self.assertEqual(where.context, EXPR)
2440+ self.assertEqual(table.context, TABLE)
2441
2442 def test_delete(self):
2443 expr = Delete(table=table1)
2444 state = State()
2445 statement = compile(expr, state)
2446- self.assertEquals(statement, 'DELETE FROM "table 1"')
2447- self.assertEquals(state.parameters, [])
2448+ self.assertEqual(statement, 'DELETE FROM "table 1"')
2449+ self.assertEqual(state.parameters, [])
2450
2451 def test_delete_where(self):
2452 expr = Delete(Func1(), Func2())
2453 state = State()
2454 statement = compile(expr, state)
2455- self.assertEquals(statement, "DELETE FROM func2() WHERE func1()")
2456- self.assertEquals(state.parameters, [])
2457+ self.assertEqual(statement, "DELETE FROM func2() WHERE func1()")
2458+ self.assertEqual(state.parameters, [])
2459
2460 def test_delete_with_strings(self):
2461 expr = Delete("1 = 2", table1)
2462 state = State()
2463 statement = compile(expr, state)
2464- self.assertEquals(statement, 'DELETE FROM "table 1" WHERE 1 = 2')
2465- self.assertEquals(state.parameters, [])
2466+ self.assertEqual(statement, 'DELETE FROM "table 1" WHERE 1 = 2')
2467+ self.assertEqual(state.parameters, [])
2468
2469 def test_delete_auto_table(self):
2470 expr = Delete(Column(column1, table1) == 1)
2471 state = State()
2472 statement = compile(expr, state)
2473- self.assertEquals(statement,
2474- 'DELETE FROM "table 1" WHERE "table 1".column1 = ?')
2475+ self.assertEqual(statement,
2476+ 'DELETE FROM "table 1" WHERE "table 1".column1 = ?')
2477 self.assertVariablesEqual(state.parameters, [Variable(1)])
2478
2479 def test_delete_auto_table_default(self):
2480 expr = Delete(Column(column1) == 1, default_table=table1)
2481 state = State()
2482 statement = compile(expr, state)
2483- self.assertEquals(statement,
2484- 'DELETE FROM "table 1" WHERE column1 = ?')
2485+ self.assertEqual(statement,
2486+ 'DELETE FROM "table 1" WHERE column1 = ?')
2487 self.assertVariablesEqual(state.parameters, [Variable(1)])
2488
2489 def test_delete_auto_table_unknown(self):
2490@@ -1028,69 +1028,69 @@
2491 where, table = track_contexts(2)
2492 expr = Delete(where, table)
2493 compile(expr)
2494- self.assertEquals(where.context, EXPR)
2495- self.assertEquals(table.context, TABLE)
2496+ self.assertEqual(where.context, EXPR)
2497+ self.assertEqual(table.context, TABLE)
2498
2499 def test_column(self):
2500 expr = Column(column1)
2501 state = State()
2502 statement = compile(expr, state)
2503- self.assertEquals(statement, "column1")
2504- self.assertEquals(state.parameters, [])
2505- self.assertEquals(expr.compile_cache, "column1")
2506+ self.assertEqual(statement, "column1")
2507+ self.assertEqual(state.parameters, [])
2508+ self.assertEqual(expr.compile_cache, "column1")
2509
2510 def test_column_table(self):
2511 column = Column(column1, Func1())
2512 expr = Select(column)
2513 state = State()
2514 statement = compile(expr, state)
2515- self.assertEquals(statement, "SELECT func1().column1 FROM func1()")
2516- self.assertEquals(state.parameters, [])
2517- self.assertEquals(column.compile_cache, "column1")
2518+ self.assertEqual(statement, "SELECT func1().column1 FROM func1()")
2519+ self.assertEqual(state.parameters, [])
2520+ self.assertEqual(column.compile_cache, "column1")
2521
2522 def test_column_contexts(self):
2523 table, = track_contexts(1)
2524 expr = Column(column1, table)
2525 compile(expr)
2526- self.assertEquals(table.context, COLUMN_PREFIX)
2527+ self.assertEqual(table.context, COLUMN_PREFIX)
2528
2529 def test_column_with_reserved_words(self):
2530 expr = Select(Column("name 1", "table 1"))
2531 state = State()
2532 statement = compile(expr, state)
2533- self.assertEquals(statement,
2534- 'SELECT "table 1"."name 1" FROM "table 1"')
2535+ self.assertEqual(statement,
2536+ 'SELECT "table 1"."name 1" FROM "table 1"')
2537
2538 def test_row(self):
2539 expr = Row(column1, column2)
2540 statement = compile(expr)
2541- self.assertEquals(statement, "ROW(column1, column2)")
2542+ self.assertEqual(statement, "ROW(column1, column2)")
2543
2544 def test_variable(self):
2545 expr = Variable("value")
2546 state = State()
2547 statement = compile(expr, state)
2548- self.assertEquals(statement, "?")
2549+ self.assertEqual(statement, "?")
2550 self.assertVariablesEqual(state.parameters, [Variable("value")])
2551
2552 def test_eq(self):
2553 expr = Eq(Func1(), Func2())
2554 state = State()
2555 statement = compile(expr, state)
2556- self.assertEquals(statement, "func1() = func2()")
2557- self.assertEquals(state.parameters, [])
2558+ self.assertEqual(statement, "func1() = func2()")
2559+ self.assertEqual(state.parameters, [])
2560
2561 expr = Func1() == "value"
2562 state = State()
2563 statement = compile(expr, state)
2564- self.assertEquals(statement, "func1() = ?")
2565+ self.assertEqual(statement, "func1() = ?")
2566 self.assertVariablesEqual(state.parameters, [Variable("value")])
2567
2568 def test_is_in(self):
2569 expr = Func1().is_in(["Hello", "World"])
2570 state = State()
2571 statement = compile(expr, state)
2572- self.assertEquals(statement, "func1() IN (?, ?)")
2573+ self.assertEqual(statement, "func1() IN (?, ?)")
2574 self.assertVariablesEqual(
2575 state.parameters, [Variable("Hello"), Variable("World")])
2576
2577@@ -1098,15 +1098,15 @@
2578 expr = Func1().is_in([])
2579 state = State()
2580 statement = compile(expr, state)
2581- self.assertEquals(statement, "?")
2582+ self.assertEqual(statement, "?")
2583 self.assertVariablesEqual(state.parameters, [BoolVariable(False)])
2584
2585 def test_is_in_expr(self):
2586 expr = Func1().is_in(Select(column1))
2587 state = State()
2588 statement = compile(expr, state)
2589- self.assertEquals(statement, "func1() IN (SELECT column1)")
2590- self.assertEquals(state.parameters, [])
2591+ self.assertEqual(statement, "func1() IN (SELECT column1)")
2592+ self.assertEqual(state.parameters, [])
2593
2594 def test_eq_none(self):
2595 expr = Func1() == None
2596@@ -1115,20 +1115,20 @@
2597
2598 state = State()
2599 statement = compile(expr, state)
2600- self.assertEquals(statement, "func1() IS NULL")
2601- self.assertEquals(state.parameters, [])
2602+ self.assertEqual(statement, "func1() IS NULL")
2603+ self.assertEqual(state.parameters, [])
2604
2605 def test_ne(self):
2606 expr = Ne(Func1(), Func2())
2607 state = State()
2608 statement = compile(expr, state)
2609- self.assertEquals(statement, "func1() != func2()")
2610- self.assertEquals(state.parameters, [])
2611+ self.assertEqual(statement, "func1() != func2()")
2612+ self.assertEqual(state.parameters, [])
2613
2614 expr = Func1() != "value"
2615 state = State()
2616 statement = compile(expr, state)
2617- self.assertEquals(statement, "func1() != ?")
2618+ self.assertEqual(statement, "func1() != ?")
2619 self.assertVariablesEqual(state.parameters, [Variable("value")])
2620
2621 def test_ne_none(self):
2622@@ -1138,292 +1138,292 @@
2623
2624 state = State()
2625 statement = compile(expr, state)
2626- self.assertEquals(statement, "func1() IS NOT NULL")
2627- self.assertEquals(state.parameters, [])
2628+ self.assertEqual(statement, "func1() IS NOT NULL")
2629+ self.assertEqual(state.parameters, [])
2630
2631 def test_gt(self):
2632 expr = Gt(Func1(), Func2())
2633 state = State()
2634 statement = compile(expr, state)
2635- self.assertEquals(statement, "func1() > func2()")
2636- self.assertEquals(state.parameters, [])
2637+ self.assertEqual(statement, "func1() > func2()")
2638+ self.assertEqual(state.parameters, [])
2639
2640 expr = Func1() > "value"
2641 state = State()
2642 statement = compile(expr, state)
2643- self.assertEquals(statement, "func1() > ?")
2644+ self.assertEqual(statement, "func1() > ?")
2645 self.assertVariablesEqual(state.parameters, [Variable("value")])
2646
2647 def test_ge(self):
2648 expr = Ge(Func1(), Func2())
2649 state = State()
2650 statement = compile(expr, state)
2651- self.assertEquals(statement, "func1() >= func2()")
2652- self.assertEquals(state.parameters, [])
2653+ self.assertEqual(statement, "func1() >= func2()")
2654+ self.assertEqual(state.parameters, [])
2655
2656 expr = Func1() >= "value"
2657 state = State()
2658 statement = compile(expr, state)
2659- self.assertEquals(statement, "func1() >= ?")
2660+ self.assertEqual(statement, "func1() >= ?")
2661 self.assertVariablesEqual(state.parameters, [Variable("value")])
2662
2663 def test_lt(self):
2664 expr = Lt(Func1(), Func2())
2665 state = State()
2666 statement = compile(expr, state)
2667- self.assertEquals(statement, "func1() < func2()")
2668- self.assertEquals(state.parameters, [])
2669+ self.assertEqual(statement, "func1() < func2()")
2670+ self.assertEqual(state.parameters, [])
2671
2672 expr = Func1() < "value"
2673 statement = compile(expr, state)
2674- self.assertEquals(statement, "func1() < ?")
2675+ self.assertEqual(statement, "func1() < ?")
2676 self.assertVariablesEqual(state.parameters, [Variable("value")])
2677
2678 def test_le(self):
2679 expr = Le(Func1(), Func2())
2680 state = State()
2681 statement = compile(expr, state)
2682- self.assertEquals(statement, "func1() <= func2()")
2683- self.assertEquals(state.parameters, [])
2684+ self.assertEqual(statement, "func1() <= func2()")
2685+ self.assertEqual(state.parameters, [])
2686
2687 expr = Func1() <= "value"
2688 state = State()
2689 statement = compile(expr, state)
2690- self.assertEquals(statement, "func1() <= ?")
2691+ self.assertEqual(statement, "func1() <= ?")
2692 self.assertVariablesEqual(state.parameters, [Variable("value")])
2693
2694 def test_lshift(self):
2695 expr = LShift(Func1(), Func2())
2696 state = State()
2697 statement = compile(expr, state)
2698- self.assertEquals(statement, "func1()<<func2()")
2699- self.assertEquals(state.parameters, [])
2700+ self.assertEqual(statement, "func1()<<func2()")
2701+ self.assertEqual(state.parameters, [])
2702
2703 expr = Func1() << "value"
2704 state = State()
2705 statement = compile(expr, state)
2706- self.assertEquals(statement, "func1()<<?")
2707+ self.assertEqual(statement, "func1()<<?")
2708 self.assertVariablesEqual(state.parameters, [Variable("value")])
2709
2710 def test_rshift(self):
2711 expr = RShift(Func1(), Func2())
2712 state = State()
2713 statement = compile(expr, state)
2714- self.assertEquals(statement, "func1()>>func2()")
2715- self.assertEquals(state.parameters, [])
2716+ self.assertEqual(statement, "func1()>>func2()")
2717+ self.assertEqual(state.parameters, [])
2718
2719 expr = Func1() >> "value"
2720 state = State()
2721 statement = compile(expr, state)
2722- self.assertEquals(statement, "func1()>>?")
2723+ self.assertEqual(statement, "func1()>>?")
2724 self.assertVariablesEqual(state.parameters, [Variable("value")])
2725
2726 def test_like(self):
2727 expr = Like(Func1(), b"value")
2728 state = State()
2729 statement = compile(expr, state)
2730- self.assertEquals(statement, "func1() LIKE ?")
2731+ self.assertEqual(statement, "func1() LIKE ?")
2732 self.assertVariablesEqual(state.parameters, [RawStrVariable(b"value")])
2733
2734 expr = Func1().like("Hello")
2735 state = State()
2736 statement = compile(expr, state)
2737- self.assertEquals(statement, "func1() LIKE ?")
2738+ self.assertEqual(statement, "func1() LIKE ?")
2739 self.assertVariablesEqual(state.parameters, [Variable("Hello")])
2740
2741 def test_like_escape(self):
2742 expr = Like(Func1(), b"value", b"!")
2743 state = State()
2744 statement = compile(expr, state)
2745- self.assertEquals(statement, "func1() LIKE ? ESCAPE ?")
2746+ self.assertEqual(statement, "func1() LIKE ? ESCAPE ?")
2747 self.assertVariablesEqual(state.parameters,
2748 [RawStrVariable(b"value"), RawStrVariable(b"!")])
2749
2750 expr = Func1().like("Hello", b"!")
2751 state = State()
2752 statement = compile(expr, state)
2753- self.assertEquals(statement, "func1() LIKE ? ESCAPE ?")
2754+ self.assertEqual(statement, "func1() LIKE ? ESCAPE ?")
2755 self.assertVariablesEqual(state.parameters,
2756 [Variable("Hello"), RawStrVariable(b"!")])
2757
2758 def test_like_compareable_case(self):
2759 expr = Func1().like("Hello")
2760- self.assertEquals(expr.case_sensitive, None)
2761+ self.assertEqual(expr.case_sensitive, None)
2762 expr = Func1().like("Hello", case_sensitive=True)
2763- self.assertEquals(expr.case_sensitive, True)
2764+ self.assertEqual(expr.case_sensitive, True)
2765 expr = Func1().like("Hello", case_sensitive=False)
2766- self.assertEquals(expr.case_sensitive, False)
2767+ self.assertEqual(expr.case_sensitive, False)
2768
2769 def test_in(self):
2770 expr = In(Func1(), b"value")
2771 state = State()
2772 statement = compile(expr, state)
2773- self.assertEquals(statement, "func1() IN (?)")
2774+ self.assertEqual(statement, "func1() IN (?)")
2775 self.assertVariablesEqual(state.parameters, [RawStrVariable(b"value")])
2776
2777 expr = In(Func1(), elem1)
2778 state = State()
2779 statement = compile(expr, state)
2780- self.assertEquals(statement, "func1() IN (elem1)")
2781- self.assertEquals(state.parameters, [])
2782+ self.assertEqual(statement, "func1() IN (elem1)")
2783+ self.assertEqual(state.parameters, [])
2784
2785 def test_and(self):
2786 expr = And(elem1, elem2, And(elem3, elem4))
2787 state = State()
2788 statement = compile(expr, state)
2789- self.assertEquals(statement, "elem1 AND elem2 AND elem3 AND elem4")
2790- self.assertEquals(state.parameters, [])
2791+ self.assertEqual(statement, "elem1 AND elem2 AND elem3 AND elem4")
2792+ self.assertEqual(state.parameters, [])
2793
2794 expr = Func1() & "value"
2795 state = State()
2796 statement = compile(expr, state)
2797- self.assertEquals(statement, "func1() AND ?")
2798+ self.assertEqual(statement, "func1() AND ?")
2799 self.assertVariablesEqual(state.parameters, [Variable("value")])
2800
2801 def test_or(self):
2802 expr = Or(elem1, elem2, Or(elem3, elem4))
2803 state = State()
2804 statement = compile(expr, state)
2805- self.assertEquals(statement, "elem1 OR elem2 OR elem3 OR elem4")
2806- self.assertEquals(state.parameters, [])
2807+ self.assertEqual(statement, "elem1 OR elem2 OR elem3 OR elem4")
2808+ self.assertEqual(state.parameters, [])
2809
2810 expr = Func1() | "value"
2811 state = State()
2812 statement = compile(expr, state)
2813- self.assertEquals(statement, "func1() OR ?")
2814+ self.assertEqual(statement, "func1() OR ?")
2815 self.assertVariablesEqual(state.parameters, [Variable("value")])
2816
2817 def test_and_with_strings(self):
2818 expr = And("elem1", "elem2")
2819 state = State()
2820 statement = compile(expr, state)
2821- self.assertEquals(statement, "elem1 AND elem2")
2822- self.assertEquals(state.parameters, [])
2823+ self.assertEqual(statement, "elem1 AND elem2")
2824+ self.assertEqual(state.parameters, [])
2825
2826 def test_or_with_strings(self):
2827 expr = Or("elem1", "elem2")
2828 state = State()
2829 statement = compile(expr, state)
2830- self.assertEquals(statement, "elem1 OR elem2")
2831- self.assertEquals(state.parameters, [])
2832+ self.assertEqual(statement, "elem1 OR elem2")
2833+ self.assertEqual(state.parameters, [])
2834
2835 def test_add(self):
2836 expr = Add(elem1, elem2, Add(elem3, elem4))
2837 state = State()
2838 statement = compile(expr, state)
2839- self.assertEquals(statement, "elem1+elem2+elem3+elem4")
2840- self.assertEquals(state.parameters, [])
2841+ self.assertEqual(statement, "elem1+elem2+elem3+elem4")
2842+ self.assertEqual(state.parameters, [])
2843
2844 expr = Func1() + "value"
2845 state = State()
2846 statement = compile(expr, state)
2847- self.assertEquals(statement, "func1()+?")
2848+ self.assertEqual(statement, "func1()+?")
2849 self.assertVariablesEqual(state.parameters, [Variable("value")])
2850
2851 def test_sub(self):
2852 expr = Sub(elem1, Sub(elem2, elem3))
2853 state = State()
2854 statement = compile(expr, state)
2855- self.assertEquals(statement, "elem1-(elem2-elem3)")
2856- self.assertEquals(state.parameters, [])
2857+ self.assertEqual(statement, "elem1-(elem2-elem3)")
2858+ self.assertEqual(state.parameters, [])
2859
2860 expr = Sub(Sub(elem1, elem2), elem3)
2861 state = State()
2862 statement = compile(expr, state)
2863- self.assertEquals(statement, "elem1-elem2-elem3")
2864+ self.assertEqual(statement, "elem1-elem2-elem3")
2865 self.assertVariablesEqual(state.parameters, [])
2866
2867 expr = Func1() - "value"
2868 state = State()
2869 statement = compile(expr, state)
2870- self.assertEquals(statement, "func1()-?")
2871+ self.assertEqual(statement, "func1()-?")
2872 self.assertVariablesEqual(state.parameters, [Variable("value")])
2873
2874 def test_mul(self):
2875 expr = Mul(elem1, elem2, Mul(elem3, elem4))
2876 state = State()
2877 statement = compile(expr, state)
2878- self.assertEquals(statement, "elem1*elem2*elem3*elem4")
2879- self.assertEquals(state.parameters, [])
2880+ self.assertEqual(statement, "elem1*elem2*elem3*elem4")
2881+ self.assertEqual(state.parameters, [])
2882
2883 expr = Func1() * "value"
2884 state = State()
2885 statement = compile(expr, state)
2886- self.assertEquals(statement, "func1()*?")
2887+ self.assertEqual(statement, "func1()*?")
2888 self.assertVariablesEqual(state.parameters, [Variable("value")])
2889
2890 def test_div(self):
2891 expr = Div(elem1, Div(elem2, elem3))
2892 state = State()
2893 statement = compile(expr, state)
2894- self.assertEquals(statement, "elem1/(elem2/elem3)")
2895- self.assertEquals(state.parameters, [])
2896+ self.assertEqual(statement, "elem1/(elem2/elem3)")
2897+ self.assertEqual(state.parameters, [])
2898
2899 expr = Div(Div(elem1, elem2), elem3)
2900 state = State()
2901 statement = compile(expr, state)
2902- self.assertEquals(statement, "elem1/elem2/elem3")
2903- self.assertEquals(state.parameters, [])
2904+ self.assertEqual(statement, "elem1/elem2/elem3")
2905+ self.assertEqual(state.parameters, [])
2906
2907 expr = Func1() / "value"
2908 state = State()
2909 statement = compile(expr, state)
2910- self.assertEquals(statement, "func1()/?")
2911+ self.assertEqual(statement, "func1()/?")
2912 self.assertVariablesEqual(state.parameters, [Variable("value")])
2913
2914 def test_mod(self):
2915 expr = Mod(elem1, Mod(elem2, elem3))
2916 state = State()
2917 statement = compile(expr, state)
2918- self.assertEquals(statement, "elem1%(elem2%elem3)")
2919- self.assertEquals(state.parameters, [])
2920+ self.assertEqual(statement, "elem1%(elem2%elem3)")
2921+ self.assertEqual(state.parameters, [])
2922
2923 expr = Mod(Mod(elem1, elem2), elem3)
2924 state = State()
2925 statement = compile(expr, state)
2926- self.assertEquals(statement, "elem1%elem2%elem3")
2927- self.assertEquals(state.parameters, [])
2928+ self.assertEqual(statement, "elem1%elem2%elem3")
2929+ self.assertEqual(state.parameters, [])
2930
2931 expr = Func1() % "value"
2932 state = State()
2933 statement = compile(expr, state)
2934- self.assertEquals(statement, "func1()%?")
2935+ self.assertEqual(statement, "func1()%?")
2936 self.assertVariablesEqual(state.parameters, [Variable("value")])
2937
2938 def test_func(self):
2939 expr = Func("myfunc", elem1, Func1(elem2))
2940 state = State()
2941 statement = compile(expr, state)
2942- self.assertEquals(statement, "myfunc(elem1, func1(elem2))")
2943- self.assertEquals(state.parameters, [])
2944+ self.assertEqual(statement, "myfunc(elem1, func1(elem2))")
2945+ self.assertEqual(state.parameters, [])
2946
2947 def test_named_func(self):
2948 expr = Func1(elem1, Func2(elem2))
2949 state = State()
2950 statement = compile(expr, state)
2951- self.assertEquals(statement, "func1(elem1, func2(elem2))")
2952- self.assertEquals(state.parameters, [])
2953+ self.assertEqual(statement, "func1(elem1, func2(elem2))")
2954+ self.assertEqual(state.parameters, [])
2955
2956 def test_count(self):
2957 expr = Count(Func1())
2958 state = State()
2959 statement = compile(expr, state)
2960- self.assertEquals(statement, "COUNT(func1())")
2961- self.assertEquals(state.parameters, [])
2962+ self.assertEqual(statement, "COUNT(func1())")
2963+ self.assertEqual(state.parameters, [])
2964
2965 def test_count_all(self):
2966 expr = Count()
2967 state = State()
2968 statement = compile(expr, state)
2969- self.assertEquals(statement, "COUNT(*)")
2970- self.assertEquals(state.parameters, [])
2971+ self.assertEqual(statement, "COUNT(*)")
2972+ self.assertEqual(state.parameters, [])
2973
2974 def test_count_distinct(self):
2975 expr = Count(Func1(), distinct=True)
2976 state = State()
2977 statement = compile(expr, state)
2978- self.assertEquals(statement, "COUNT(DISTINCT func1())")
2979- self.assertEquals(state.parameters, [])
2980+ self.assertEqual(statement, "COUNT(DISTINCT func1())")
2981+ self.assertEqual(state.parameters, [])
2982
2983 def test_count_distinct_all(self):
2984 self.assertRaises(ValueError, Count, distinct=True)
2985@@ -1436,145 +1436,145 @@
2986 expr = Cast(Func1(), "TEXT")
2987 state = State()
2988 statement = compile(expr, state)
2989- self.assertEquals(statement, "CAST(func1() AS TEXT)")
2990- self.assertEquals(state.parameters, [])
2991+ self.assertEqual(statement, "CAST(func1() AS TEXT)")
2992+ self.assertEqual(state.parameters, [])
2993
2994 def test_max(self):
2995 expr = Max(Func1())
2996 state = State()
2997 statement = compile(expr, state)
2998- self.assertEquals(statement, "MAX(func1())")
2999- self.assertEquals(state.parameters, [])
3000+ self.assertEqual(statement, "MAX(func1())")
3001+ self.assertEqual(state.parameters, [])
3002
3003 def test_min(self):
3004 expr = Min(Func1())
3005 state = State()
3006 statement = compile(expr, state)
3007- self.assertEquals(statement, "MIN(func1())")
3008- self.assertEquals(state.parameters, [])
3009+ self.assertEqual(statement, "MIN(func1())")
3010+ self.assertEqual(state.parameters, [])
3011
3012 def test_avg(self):
3013 expr = Avg(Func1())
3014 state = State()
3015 statement = compile(expr, state)
3016- self.assertEquals(statement, "AVG(func1())")
3017- self.assertEquals(state.parameters, [])
3018+ self.assertEqual(statement, "AVG(func1())")
3019+ self.assertEqual(state.parameters, [])
3020
3021 def test_sum(self):
3022 expr = Sum(Func1())
3023 state = State()
3024 statement = compile(expr, state)
3025- self.assertEquals(statement, "SUM(func1())")
3026- self.assertEquals(state.parameters, [])
3027+ self.assertEqual(statement, "SUM(func1())")
3028+ self.assertEqual(state.parameters, [])
3029
3030 def test_lower(self):
3031 expr = Lower(Func1())
3032 state = State()
3033 statement = compile(expr, state)
3034- self.assertEquals(statement, "LOWER(func1())")
3035- self.assertEquals(state.parameters, [])
3036+ self.assertEqual(statement, "LOWER(func1())")
3037+ self.assertEqual(state.parameters, [])
3038
3039 expr = Func1().lower()
3040 state = State()
3041 statement = compile(expr, state)
3042- self.assertEquals(statement, "LOWER(func1())")
3043- self.assertEquals(state.parameters, [])
3044+ self.assertEqual(statement, "LOWER(func1())")
3045+ self.assertEqual(state.parameters, [])
3046
3047 def test_upper(self):
3048 expr = Upper(Func1())
3049 state = State()
3050 statement = compile(expr, state)
3051- self.assertEquals(statement, "UPPER(func1())")
3052- self.assertEquals(state.parameters, [])
3053+ self.assertEqual(statement, "UPPER(func1())")
3054+ self.assertEqual(state.parameters, [])
3055
3056 expr = Func1().upper()
3057 state = State()
3058 statement = compile(expr, state)
3059- self.assertEquals(statement, "UPPER(func1())")
3060- self.assertEquals(state.parameters, [])
3061+ self.assertEqual(statement, "UPPER(func1())")
3062+ self.assertEqual(state.parameters, [])
3063
3064 def test_coalesce(self):
3065 expr = Coalesce(Func1())
3066 state = State()
3067 statement = compile(expr, state)
3068- self.assertEquals(statement, "COALESCE(func1())")
3069- self.assertEquals(state.parameters, [])
3070+ self.assertEqual(statement, "COALESCE(func1())")
3071+ self.assertEqual(state.parameters, [])
3072
3073 def test_coalesce_with_many_arguments(self):
3074 expr = Coalesce(Func1(), Func2(), None)
3075 state = State()
3076 statement = compile(expr, state)
3077- self.assertEquals(statement, "COALESCE(func1(), func2(), NULL)")
3078- self.assertEquals(state.parameters, [])
3079+ self.assertEqual(statement, "COALESCE(func1(), func2(), NULL)")
3080+ self.assertEqual(state.parameters, [])
3081
3082 def test_not(self):
3083 expr = Not(Func1())
3084 state = State()
3085 statement = compile(expr, state)
3086- self.assertEquals(statement, "NOT func1()")
3087- self.assertEquals(state.parameters, [])
3088+ self.assertEqual(statement, "NOT func1()")
3089+ self.assertEqual(state.parameters, [])
3090
3091 def test_exists(self):
3092 expr = Exists(Func1())
3093 state = State()
3094 statement = compile(expr, state)
3095- self.assertEquals(statement, "EXISTS func1()")
3096- self.assertEquals(state.parameters, [])
3097+ self.assertEqual(statement, "EXISTS func1()")
3098+ self.assertEqual(state.parameters, [])
3099
3100 def test_neg(self):
3101 expr = Neg(Func1())
3102 state = State()
3103 statement = compile(expr, state)
3104- self.assertEquals(statement, "- func1()")
3105- self.assertEquals(state.parameters, [])
3106+ self.assertEqual(statement, "- func1()")
3107+ self.assertEqual(state.parameters, [])
3108
3109 expr = -Func1()
3110 state = State()
3111 statement = compile(expr, state)
3112- self.assertEquals(statement, "- func1()")
3113- self.assertEquals(state.parameters, [])
3114+ self.assertEqual(statement, "- func1()")
3115+ self.assertEqual(state.parameters, [])
3116
3117 def test_asc(self):
3118 expr = Asc(Func1())
3119 state = State()
3120 statement = compile(expr, state)
3121- self.assertEquals(statement, "func1() ASC")
3122- self.assertEquals(state.parameters, [])
3123+ self.assertEqual(statement, "func1() ASC")
3124+ self.assertEqual(state.parameters, [])
3125
3126 def test_desc(self):
3127 expr = Desc(Func1())
3128 state = State()
3129 statement = compile(expr, state)
3130- self.assertEquals(statement, "func1() DESC")
3131- self.assertEquals(state.parameters, [])
3132+ self.assertEqual(statement, "func1() DESC")
3133+ self.assertEqual(state.parameters, [])
3134
3135 def test_asc_with_string(self):
3136 expr = Asc("column")
3137 state = State()
3138 statement = compile(expr, state)
3139- self.assertEquals(statement, "column ASC")
3140- self.assertEquals(state.parameters, [])
3141+ self.assertEqual(statement, "column ASC")
3142+ self.assertEqual(state.parameters, [])
3143
3144 def test_desc_with_string(self):
3145 expr = Desc("column")
3146 state = State()
3147 statement = compile(expr, state)
3148- self.assertEquals(statement, "column DESC")
3149- self.assertEquals(state.parameters, [])
3150+ self.assertEqual(statement, "column DESC")
3151+ self.assertEqual(state.parameters, [])
3152
3153 def test_sql(self):
3154 expr = SQL("expression")
3155 state = State()
3156 statement = compile(expr, state)
3157- self.assertEquals(statement, "expression")
3158- self.assertEquals(state.parameters, [])
3159+ self.assertEqual(statement, "expression")
3160+ self.assertEqual(state.parameters, [])
3161
3162 def test_sql_params(self):
3163 expr = SQL("expression", ["params"])
3164 state = State()
3165 statement = compile(expr, state)
3166- self.assertEquals(statement, "expression")
3167- self.assertEquals(state.parameters, ["params"])
3168+ self.assertEqual(statement, "expression")
3169+ self.assertEqual(state.parameters, ["params"])
3170
3171 def test_sql_invalid_params(self):
3172 expr = SQL("expression", "not a list or tuple")
3173@@ -1584,270 +1584,270 @@
3174 expr = Select([column1, Func1()], SQL("expression", [], Func2()))
3175 state = State()
3176 statement = compile(expr, state)
3177- self.assertEquals(statement,
3178- "SELECT column1, func1() FROM func2() "
3179- "WHERE expression")
3180- self.assertEquals(state.parameters, [])
3181+ self.assertEqual(statement,
3182+ "SELECT column1, func1() FROM func2() "
3183+ "WHERE expression")
3184+ self.assertEqual(state.parameters, [])
3185
3186 def test_sql_tables_with_list_or_tuple(self):
3187 sql = SQL("expression", [], [Func1(), Func2()])
3188 expr = Select(column1, sql)
3189 state = State()
3190 statement = compile(expr, state)
3191- self.assertEquals(statement,
3192- "SELECT column1 FROM func1(), func2() "
3193- "WHERE expression")
3194- self.assertEquals(state.parameters, [])
3195+ self.assertEqual(statement,
3196+ "SELECT column1 FROM func1(), func2() "
3197+ "WHERE expression")
3198+ self.assertEqual(state.parameters, [])
3199
3200 sql = SQL("expression", [], (Func1(), Func2()))
3201 expr = Select(column1, sql)
3202 state = State()
3203 statement = compile(expr, state)
3204- self.assertEquals(statement,
3205- "SELECT column1 FROM func1(), func2() "
3206- "WHERE expression")
3207- self.assertEquals(state.parameters, [])
3208+ self.assertEqual(statement,
3209+ "SELECT column1 FROM func1(), func2() "
3210+ "WHERE expression")
3211+ self.assertEqual(state.parameters, [])
3212
3213 def test_sql_comparison(self):
3214 expr = SQL("expression1") & SQL("expression2")
3215 state = State()
3216 statement = compile(expr, state)
3217- self.assertEquals(statement, "(expression1) AND (expression2)")
3218- self.assertEquals(state.parameters, [])
3219+ self.assertEqual(statement, "(expression1) AND (expression2)")
3220+ self.assertEqual(state.parameters, [])
3221
3222 def test_table(self):
3223 expr = Table(table1)
3224 self.assertIdentical(expr.compile_cache, None)
3225 state = State()
3226 statement = compile(expr, state)
3227- self.assertEquals(statement, '"table 1"')
3228- self.assertEquals(state.parameters, [])
3229- self.assertEquals(expr.compile_cache, '"table 1"')
3230+ self.assertEqual(statement, '"table 1"')
3231+ self.assertEqual(state.parameters, [])
3232+ self.assertEqual(expr.compile_cache, '"table 1"')
3233
3234 def test_alias(self):
3235 expr = Alias(Table(table1), "name")
3236 state = State()
3237 statement = compile(expr, state)
3238- self.assertEquals(statement, "name")
3239- self.assertEquals(state.parameters, [])
3240+ self.assertEqual(statement, "name")
3241+ self.assertEqual(state.parameters, [])
3242
3243 def test_alias_in_tables(self):
3244 expr = Select(column1, tables=Alias(Table(table1), "alias 1"))
3245 state = State()
3246 statement = compile(expr, state)
3247- self.assertEquals(statement,
3248- 'SELECT column1 FROM "table 1" AS "alias 1"')
3249- self.assertEquals(state.parameters, [])
3250+ self.assertEqual(statement,
3251+ 'SELECT column1 FROM "table 1" AS "alias 1"')
3252+ self.assertEqual(state.parameters, [])
3253
3254 def test_alias_in_tables_auto_name(self):
3255 expr = Select(column1, tables=Alias(Table(table1)))
3256 state = State()
3257 statement = compile(expr, state)
3258- self.assertEquals(statement[:statement.rfind("_")+1],
3259- 'SELECT column1 FROM "table 1" AS "_')
3260- self.assertEquals(state.parameters, [])
3261+ self.assertEqual(statement[:statement.rfind("_")+1],
3262+ 'SELECT column1 FROM "table 1" AS "_')
3263+ self.assertEqual(state.parameters, [])
3264
3265 def test_alias_in_column_prefix(self):
3266 expr = Select(Column(column1, Alias(Table(table1), "alias 1")))
3267 state = State()
3268 statement = compile(expr, state)
3269- self.assertEquals(statement, 'SELECT "alias 1".column1 '
3270- 'FROM "table 1" AS "alias 1"')
3271- self.assertEquals(state.parameters, [])
3272+ self.assertEqual(statement, 'SELECT "alias 1".column1 '
3273+ 'FROM "table 1" AS "alias 1"')
3274+ self.assertEqual(state.parameters, [])
3275
3276 def test_alias_for_column(self):
3277 expr = Select(Alias(Column(column1, table1), "alias 1"))
3278 state = State()
3279 statement = compile(expr, state)
3280- self.assertEquals(statement, 'SELECT "table 1".column1 AS "alias 1" '
3281- 'FROM "table 1"')
3282- self.assertEquals(state.parameters, [])
3283+ self.assertEqual(statement, 'SELECT "table 1".column1 AS "alias 1" '
3284+ 'FROM "table 1"')
3285+ self.assertEqual(state.parameters, [])
3286
3287 def test_alias_union(self):
3288 union = Union(Select(elem1), Select(elem2))
3289 expr = Select(elem3, tables=Alias(union, "alias"))
3290 state = State()
3291 statement = compile(expr, state)
3292- self.assertEquals(statement,
3293- "SELECT elem3 FROM "
3294- "((SELECT elem1) UNION (SELECT elem2)) AS alias")
3295- self.assertEquals(state.parameters, [])
3296+ self.assertEqual(statement,
3297+ "SELECT elem3 FROM "
3298+ "((SELECT elem1) UNION (SELECT elem2)) AS alias")
3299+ self.assertEqual(state.parameters, [])
3300
3301 def test_distinct(self):
3302 """L{Distinct} adds a DISTINCT prefix to the given expression."""
3303 distinct = Distinct(Column(elem1))
3304 state = State()
3305 statement = compile(distinct, state)
3306- self.assertEquals(statement, "DISTINCT elem1")
3307- self.assertEquals(state.parameters, [])
3308+ self.assertEqual(statement, "DISTINCT elem1")
3309+ self.assertEqual(state.parameters, [])
3310
3311 def test_join(self):
3312 expr = Join(Func1())
3313 state = State()
3314 statement = compile(expr, state)
3315- self.assertEquals(statement, "JOIN func1()")
3316- self.assertEquals(state.parameters, [])
3317+ self.assertEqual(statement, "JOIN func1()")
3318+ self.assertEqual(state.parameters, [])
3319
3320 def test_join_on(self):
3321 expr = Join(Func1(), Func2() == "value")
3322 state = State()
3323 statement = compile(expr, state)
3324- self.assertEquals(statement, "JOIN func1() ON func2() = ?")
3325+ self.assertEqual(statement, "JOIN func1() ON func2() = ?")
3326 self.assertVariablesEqual(state.parameters, [Variable("value")])
3327
3328 def test_join_on_with_string(self):
3329 expr = Join(Func1(), on="a = b")
3330 state = State()
3331 statement = compile(expr, state)
3332- self.assertEquals(statement, "JOIN func1() ON a = b")
3333- self.assertEquals(state.parameters, [])
3334+ self.assertEqual(statement, "JOIN func1() ON a = b")
3335+ self.assertEqual(state.parameters, [])
3336
3337 def test_join_left_right(self):
3338 expr = Join(table1, table2)
3339 state = State()
3340 statement = compile(expr, state)
3341- self.assertEquals(statement, '"table 1" JOIN "table 2"')
3342- self.assertEquals(state.parameters, [])
3343+ self.assertEqual(statement, '"table 1" JOIN "table 2"')
3344+ self.assertEqual(state.parameters, [])
3345
3346 def test_join_nested(self):
3347 expr = Join(table1, Join(table2, table3))
3348 state = State()
3349 statement = compile(expr, state)
3350- self.assertEquals(statement, '"table 1" JOIN '
3351- '("table 2" JOIN "table 3")')
3352- self.assertEquals(state.parameters, [])
3353+ self.assertEqual(statement, '"table 1" JOIN '
3354+ '("table 2" JOIN "table 3")')
3355+ self.assertEqual(state.parameters, [])
3356
3357 def test_join_double_nested(self):
3358 expr = Join(Join(table1, table2), Join(table3, table4))
3359 state = State()
3360 statement = compile(expr, state)
3361- self.assertEquals(statement, '"table 1" JOIN "table 2" JOIN '
3362- '("table 3" JOIN "table 4")')
3363- self.assertEquals(state.parameters, [])
3364+ self.assertEqual(statement, '"table 1" JOIN "table 2" JOIN '
3365+ '("table 3" JOIN "table 4")')
3366+ self.assertEqual(state.parameters, [])
3367
3368 def test_join_table(self):
3369 expr = Join(Table(table1), Table(table2))
3370 state = State()
3371 statement = compile(expr, state)
3372- self.assertEquals(statement, '"table 1" JOIN "table 2"')
3373- self.assertEquals(state.parameters, [])
3374+ self.assertEqual(statement, '"table 1" JOIN "table 2"')
3375+ self.assertEqual(state.parameters, [])
3376
3377 def test_join_contexts(self):
3378 table1, table2, on = track_contexts(3)
3379 expr = Join(table1, table2, on)
3380 compile(expr)
3381- self.assertEquals(table1.context, None)
3382- self.assertEquals(table2.context, None)
3383- self.assertEquals(on.context, EXPR)
3384+ self.assertEqual(table1.context, None)
3385+ self.assertEqual(table2.context, None)
3386+ self.assertEqual(on.context, EXPR)
3387
3388 def test_left_join(self):
3389 expr = LeftJoin(Func1())
3390 state = State()
3391 statement = compile(expr, state)
3392- self.assertEquals(statement, "LEFT JOIN func1()")
3393- self.assertEquals(state.parameters, [])
3394+ self.assertEqual(statement, "LEFT JOIN func1()")
3395+ self.assertEqual(state.parameters, [])
3396
3397 def test_left_join_on(self):
3398 expr = LeftJoin(Func1(), Func2() == "value")
3399 state = State()
3400 statement = compile(expr, state)
3401- self.assertEquals(statement, "LEFT JOIN func1() ON func2() = ?")
3402+ self.assertEqual(statement, "LEFT JOIN func1() ON func2() = ?")
3403 self.assertVariablesEqual(state.parameters, [Variable("value")])
3404
3405 def test_right_join(self):
3406 expr = RightJoin(Func1())
3407 state = State()
3408 statement = compile(expr, state)
3409- self.assertEquals(statement, "RIGHT JOIN func1()")
3410- self.assertEquals(state.parameters, [])
3411+ self.assertEqual(statement, "RIGHT JOIN func1()")
3412+ self.assertEqual(state.parameters, [])
3413
3414 def test_right_join_on(self):
3415 expr = RightJoin(Func1(), Func2() == "value")
3416 state = State()
3417 statement = compile(expr, state)
3418- self.assertEquals(statement, "RIGHT JOIN func1() ON func2() = ?")
3419+ self.assertEqual(statement, "RIGHT JOIN func1() ON func2() = ?")
3420 self.assertVariablesEqual(state.parameters, [Variable("value")])
3421
3422 def test_natural_join(self):
3423 expr = NaturalJoin(Func1())
3424 state = State()
3425 statement = compile(expr, state)
3426- self.assertEquals(statement, "NATURAL JOIN func1()")
3427- self.assertEquals(state.parameters, [])
3428+ self.assertEqual(statement, "NATURAL JOIN func1()")
3429+ self.assertEqual(state.parameters, [])
3430
3431 def test_natural_join_on(self):
3432 expr = NaturalJoin(Func1(), Func2() == "value")
3433 state = State()
3434 statement = compile(expr, state)
3435- self.assertEquals(statement, "NATURAL JOIN func1() ON func2() = ?")
3436+ self.assertEqual(statement, "NATURAL JOIN func1() ON func2() = ?")
3437 self.assertVariablesEqual(state.parameters, [Variable("value")])
3438
3439 def test_natural_left_join(self):
3440 expr = NaturalLeftJoin(Func1())
3441 state = State()
3442 statement = compile(expr, state)
3443- self.assertEquals(statement, "NATURAL LEFT JOIN func1()")
3444- self.assertEquals(state.parameters, [])
3445+ self.assertEqual(statement, "NATURAL LEFT JOIN func1()")
3446+ self.assertEqual(state.parameters, [])
3447
3448 def test_natural_left_join_on(self):
3449 expr = NaturalLeftJoin(Func1(), Func2() == "value")
3450 state = State()
3451 statement = compile(expr, state)
3452- self.assertEquals(statement, "NATURAL LEFT JOIN func1() "
3453- "ON func2() = ?")
3454+ self.assertEqual(statement, "NATURAL LEFT JOIN func1() "
3455+ "ON func2() = ?")
3456 self.assertVariablesEqual(state.parameters, [Variable("value")])
3457
3458 def test_natural_right_join(self):
3459 expr = NaturalRightJoin(Func1())
3460 state = State()
3461 statement = compile(expr, state)
3462- self.assertEquals(statement, "NATURAL RIGHT JOIN func1()")
3463- self.assertEquals(state.parameters, [])
3464+ self.assertEqual(statement, "NATURAL RIGHT JOIN func1()")
3465+ self.assertEqual(state.parameters, [])
3466
3467 def test_natural_right_join_on(self):
3468 expr = NaturalRightJoin(Func1(), Func2() == "value")
3469 state = State()
3470 statement = compile(expr, state)
3471- self.assertEquals(statement, "NATURAL RIGHT JOIN func1() "
3472- "ON func2() = ?")
3473+ self.assertEqual(statement, "NATURAL RIGHT JOIN func1() "
3474+ "ON func2() = ?")
3475 self.assertVariablesEqual(state.parameters, [Variable("value")])
3476
3477 def test_union(self):
3478 expr = Union(Func1(), elem2, elem3)
3479 state = State()
3480 statement = compile(expr, state)
3481- self.assertEquals(statement, "func1() UNION elem2 UNION elem3")
3482- self.assertEquals(state.parameters, [])
3483+ self.assertEqual(statement, "func1() UNION elem2 UNION elem3")
3484+ self.assertEqual(state.parameters, [])
3485
3486 def test_union_all(self):
3487 expr = Union(Func1(), elem2, elem3, all=True)
3488 state = State()
3489 statement = compile(expr, state)
3490- self.assertEquals(statement, "func1() UNION ALL elem2 UNION ALL elem3")
3491- self.assertEquals(state.parameters, [])
3492+ self.assertEqual(statement, "func1() UNION ALL elem2 UNION ALL elem3")
3493+ self.assertEqual(state.parameters, [])
3494
3495 def test_union_order_by_limit_offset(self):
3496 expr = Union(elem1, elem2, order_by=Func1(), limit=1, offset=2)
3497 state = State()
3498 statement = compile(expr, state)
3499- self.assertEquals(statement, "elem1 UNION elem2 ORDER BY func1() "
3500- "LIMIT 1 OFFSET 2")
3501- self.assertEquals(state.parameters, [])
3502+ self.assertEqual(statement, "elem1 UNION elem2 ORDER BY func1() "
3503+ "LIMIT 1 OFFSET 2")
3504+ self.assertEqual(state.parameters, [])
3505
3506 def test_union_select(self):
3507 expr = Union(Select(elem1), Select(elem2))
3508 state = State()
3509 statement = compile(expr, state)
3510- self.assertEquals(statement, "(SELECT elem1) UNION (SELECT elem2)")
3511- self.assertEquals(state.parameters, [])
3512+ self.assertEqual(statement, "(SELECT elem1) UNION (SELECT elem2)")
3513+ self.assertEqual(state.parameters, [])
3514
3515 def test_union_select_nested(self):
3516 expr = Union(Select(elem1), Union(Select(elem2), Select(elem3)))
3517 state = State()
3518 statement = compile(expr, state)
3519- self.assertEquals(statement, "(SELECT elem1) UNION"
3520- " ((SELECT elem2) UNION (SELECT elem3))")
3521- self.assertEquals(state.parameters, [])
3522+ self.assertEqual(statement, "(SELECT elem1) UNION"
3523+ " ((SELECT elem2) UNION (SELECT elem3))")
3524+ self.assertEqual(state.parameters, [])
3525
3526 def test_union_order_by_and_select(self):
3527 """
3528@@ -1862,152 +1862,152 @@
3529 order_by=(column1, column2))
3530 state = State()
3531 statement = compile(expr, state)
3532- self.assertEquals(
3533+ self.assertEqual(
3534 statement,
3535 '(SELECT elem1 AS "_1") UNION (SELECT elem2 AS "_2") '
3536 'ORDER BY "_1", "_2"')
3537- self.assertEquals(state.parameters, [])
3538+ self.assertEqual(state.parameters, [])
3539
3540 def test_union_contexts(self):
3541 select1, select2, order_by = track_contexts(3)
3542 expr = Union(select1, select2, order_by=order_by)
3543 compile(expr)
3544- self.assertEquals(select1.context, SELECT)
3545- self.assertEquals(select2.context, SELECT)
3546- self.assertEquals(order_by.context, COLUMN_NAME)
3547+ self.assertEqual(select1.context, SELECT)
3548+ self.assertEqual(select2.context, SELECT)
3549+ self.assertEqual(order_by.context, COLUMN_NAME)
3550
3551 def test_except(self):
3552 expr = Except(Func1(), elem2, elem3)
3553 state = State()
3554 statement = compile(expr, state)
3555- self.assertEquals(statement, "func1() EXCEPT elem2 EXCEPT elem3")
3556- self.assertEquals(state.parameters, [])
3557+ self.assertEqual(statement, "func1() EXCEPT elem2 EXCEPT elem3")
3558+ self.assertEqual(state.parameters, [])
3559
3560 def test_except_all(self):
3561 expr = Except(Func1(), elem2, elem3, all=True)
3562 state = State()
3563 statement = compile(expr, state)
3564- self.assertEquals(statement, "func1() EXCEPT ALL elem2 "
3565- "EXCEPT ALL elem3")
3566- self.assertEquals(state.parameters, [])
3567+ self.assertEqual(statement, "func1() EXCEPT ALL elem2 "
3568+ "EXCEPT ALL elem3")
3569+ self.assertEqual(state.parameters, [])
3570
3571 def test_except_order_by_limit_offset(self):
3572 expr = Except(elem1, elem2, order_by=Func1(), limit=1, offset=2)
3573 state = State()
3574 statement = compile(expr, state)
3575- self.assertEquals(statement, "elem1 EXCEPT elem2 ORDER BY func1() "
3576- "LIMIT 1 OFFSET 2")
3577- self.assertEquals(state.parameters, [])
3578+ self.assertEqual(statement, "elem1 EXCEPT elem2 ORDER BY func1() "
3579+ "LIMIT 1 OFFSET 2")
3580+ self.assertEqual(state.parameters, [])
3581
3582 def test_except_select(self):
3583 expr = Except(Select(elem1), Select(elem2))
3584 state = State()
3585 statement = compile(expr, state)
3586- self.assertEquals(statement, "(SELECT elem1) EXCEPT (SELECT elem2)")
3587- self.assertEquals(state.parameters, [])
3588+ self.assertEqual(statement, "(SELECT elem1) EXCEPT (SELECT elem2)")
3589+ self.assertEqual(state.parameters, [])
3590
3591 def test_except_select_nested(self):
3592 expr = Except(Select(elem1), Except(Select(elem2), Select(elem3)))
3593 state = State()
3594 statement = compile(expr, state)
3595- self.assertEquals(statement, "(SELECT elem1) EXCEPT"
3596- " ((SELECT elem2) EXCEPT (SELECT elem3))")
3597- self.assertEquals(state.parameters, [])
3598+ self.assertEqual(statement, "(SELECT elem1) EXCEPT"
3599+ " ((SELECT elem2) EXCEPT (SELECT elem3))")
3600+ self.assertEqual(state.parameters, [])
3601
3602 def test_except_contexts(self):
3603 select1, select2, order_by = track_contexts(3)
3604 expr = Except(select1, select2, order_by=order_by)
3605 compile(expr)
3606- self.assertEquals(select1.context, SELECT)
3607- self.assertEquals(select2.context, SELECT)
3608- self.assertEquals(order_by.context, COLUMN_NAME)
3609+ self.assertEqual(select1.context, SELECT)
3610+ self.assertEqual(select2.context, SELECT)
3611+ self.assertEqual(order_by.context, COLUMN_NAME)
3612
3613 def test_intersect(self):
3614 expr = Intersect(Func1(), elem2, elem3)
3615 state = State()
3616 statement = compile(expr, state)
3617- self.assertEquals(statement, "func1() INTERSECT elem2 INTERSECT elem3")
3618- self.assertEquals(state.parameters, [])
3619+ self.assertEqual(statement, "func1() INTERSECT elem2 INTERSECT elem3")
3620+ self.assertEqual(state.parameters, [])
3621
3622 def test_intersect_all(self):
3623 expr = Intersect(Func1(), elem2, elem3, all=True)
3624 state = State()
3625 statement = compile(expr, state)
3626- self.assertEquals(
3627+ self.assertEqual(
3628 statement, "func1() INTERSECT ALL elem2 INTERSECT ALL elem3")
3629- self.assertEquals(state.parameters, [])
3630+ self.assertEqual(state.parameters, [])
3631
3632 def test_intersect_order_by_limit_offset(self):
3633 expr = Intersect(elem1, elem2, order_by=Func1(), limit=1, offset=2)
3634 state = State()
3635 statement = compile(expr, state)
3636- self.assertEquals(statement, "elem1 INTERSECT elem2 ORDER BY func1() "
3637- "LIMIT 1 OFFSET 2")
3638- self.assertEquals(state.parameters, [])
3639+ self.assertEqual(statement, "elem1 INTERSECT elem2 ORDER BY func1() "
3640+ "LIMIT 1 OFFSET 2")
3641+ self.assertEqual(state.parameters, [])
3642
3643 def test_intersect_select(self):
3644 expr = Intersect(Select(elem1), Select(elem2))
3645 state = State()
3646 statement = compile(expr, state)
3647- self.assertEquals(statement, "(SELECT elem1) INTERSECT (SELECT elem2)")
3648- self.assertEquals(state.parameters, [])
3649+ self.assertEqual(statement, "(SELECT elem1) INTERSECT (SELECT elem2)")
3650+ self.assertEqual(state.parameters, [])
3651
3652 def test_intersect_select_nested(self):
3653 expr = Intersect(
3654 Select(elem1), Intersect(Select(elem2), Select(elem3)))
3655 state = State()
3656 statement = compile(expr, state)
3657- self.assertEquals(
3658+ self.assertEqual(
3659 statement, "(SELECT elem1) INTERSECT"
3660 " ((SELECT elem2) INTERSECT (SELECT elem3))")
3661- self.assertEquals(state.parameters, [])
3662+ self.assertEqual(state.parameters, [])
3663
3664 def test_intersect_contexts(self):
3665 select1, select2, order_by = track_contexts(3)
3666 expr = Intersect(select1, select2, order_by=order_by)
3667 compile(expr)
3668- self.assertEquals(select1.context, SELECT)
3669- self.assertEquals(select2.context, SELECT)
3670- self.assertEquals(order_by.context, COLUMN_NAME)
3671+ self.assertEqual(select1.context, SELECT)
3672+ self.assertEqual(select2.context, SELECT)
3673+ self.assertEqual(order_by.context, COLUMN_NAME)
3674
3675 def test_auto_table(self):
3676 expr = Select(AutoTables(1, [table1]))
3677 state = State()
3678 statement = compile(expr, state)
3679- self.assertEquals(statement, 'SELECT ? FROM "table 1"')
3680+ self.assertEqual(statement, 'SELECT ? FROM "table 1"')
3681 self.assertVariablesEqual(state.parameters, [IntVariable(1)])
3682
3683 def test_auto_tables_with_column(self):
3684 expr = Select(AutoTables(Column(elem1, table1), [table2]))
3685 state = State()
3686 statement = compile(expr, state)
3687- self.assertEquals(statement, 'SELECT "table 1".elem1 '
3688- 'FROM "table 1", "table 2"')
3689- self.assertEquals(state.parameters, [])
3690+ self.assertEqual(statement, 'SELECT "table 1".elem1 '
3691+ 'FROM "table 1", "table 2"')
3692+ self.assertEqual(state.parameters, [])
3693
3694 def test_auto_tables_with_column_and_replace(self):
3695 expr = Select(AutoTables(Column(elem1, table1), [table2], replace=True))
3696 state = State()
3697 statement = compile(expr, state)
3698- self.assertEquals(statement, 'SELECT "table 1".elem1 FROM "table 2"')
3699- self.assertEquals(state.parameters, [])
3700+ self.assertEqual(statement, 'SELECT "table 1".elem1 FROM "table 2"')
3701+ self.assertEqual(state.parameters, [])
3702
3703 def test_auto_tables_with_join(self):
3704 expr = Select(AutoTables(Column(elem1, table1), [LeftJoin(table2)]))
3705 state = State()
3706 statement = compile(expr, state)
3707- self.assertEquals(statement, 'SELECT "table 1".elem1 FROM "table 1" '
3708- 'LEFT JOIN "table 2"')
3709- self.assertEquals(state.parameters, [])
3710+ self.assertEqual(statement, 'SELECT "table 1".elem1 FROM "table 1" '
3711+ 'LEFT JOIN "table 2"')
3712+ self.assertEqual(state.parameters, [])
3713
3714 def test_auto_tables_with_join_with_left_table(self):
3715 expr = Select(AutoTables(Column(elem1, table1),
3716 [LeftJoin(table1, table2)]))
3717 state = State()
3718 statement = compile(expr, state)
3719- self.assertEquals(statement, 'SELECT "table 1".elem1 FROM "table 1" '
3720- 'LEFT JOIN "table 2"')
3721- self.assertEquals(state.parameters, [])
3722+ self.assertEqual(statement, 'SELECT "table 1".elem1 FROM "table 1" '
3723+ 'LEFT JOIN "table 2"')
3724+ self.assertEqual(state.parameters, [])
3725
3726 def test_auto_tables_duplicated(self):
3727 expr = Select([AutoTables(Column(elem1, table1), [Join(table2)]),
3728@@ -2018,12 +2018,12 @@
3729 [Join(table4, table5)])])
3730 state = State()
3731 statement = compile(expr, state)
3732- self.assertEquals(statement,
3733- 'SELECT "table 1".elem1, "table 2".elem2, '
3734- '"table 1".elem3, "table 3".elem4, "table 1".elem5 '
3735- 'FROM "table 3", "table 4" JOIN "table 5" JOIN '
3736- '"table 1" JOIN "table 2"')
3737- self.assertEquals(state.parameters, [])
3738+ self.assertEqual(statement,
3739+ 'SELECT "table 1".elem1, "table 2".elem2, '
3740+ '"table 1".elem3, "table 3".elem4, "table 1".elem5 '
3741+ 'FROM "table 3", "table 4" JOIN "table 5" JOIN '
3742+ '"table 1" JOIN "table 2"')
3743+ self.assertEqual(state.parameters, [])
3744
3745 def test_auto_tables_duplicated_nested(self):
3746 expr = Select(AutoTables(Column(elem1, table1), [Join(table2)]),
3747@@ -2031,33 +2031,33 @@
3748 [Join(table2)]))))
3749 state = State()
3750 statement = compile(expr, state)
3751- self.assertEquals(statement,
3752- 'SELECT "table 1".elem1 FROM "table 1" JOIN '
3753- '"table 2" WHERE ? IN (SELECT "table 1".elem1 '
3754- 'FROM "table 1" JOIN "table 2")')
3755+ self.assertEqual(statement,
3756+ 'SELECT "table 1".elem1 FROM "table 1" JOIN '
3757+ '"table 2" WHERE ? IN (SELECT "table 1".elem1 '
3758+ 'FROM "table 1" JOIN "table 2")')
3759 self.assertVariablesEqual(state.parameters, [IntVariable(1)])
3760
3761 def test_sql_token(self):
3762 expr = SQLToken("something")
3763 state = State()
3764 statement = compile(expr, state)
3765- self.assertEquals(statement, "something")
3766- self.assertEquals(state.parameters, [])
3767+ self.assertEqual(statement, "something")
3768+ self.assertEqual(state.parameters, [])
3769
3770 def test_sql_token_spaces(self):
3771 expr = SQLToken("some thing")
3772 statement = compile(expr)
3773- self.assertEquals(statement, '"some thing"')
3774+ self.assertEqual(statement, '"some thing"')
3775
3776 def test_sql_token_quotes(self):
3777 expr = SQLToken("some'thing")
3778 statement = compile(expr)
3779- self.assertEquals(statement, '"some\'thing"')
3780+ self.assertEqual(statement, '"some\'thing"')
3781
3782 def test_sql_token_double_quotes(self):
3783 expr = SQLToken('some"thing')
3784 statement = compile(expr)
3785- self.assertEquals(statement, '"some""thing"')
3786+ self.assertEqual(statement, '"some""thing"')
3787
3788 def test_sql_token_reserved(self):
3789 custom_compile = compile.create_child()
3790@@ -2065,18 +2065,18 @@
3791 expr = SQLToken("something")
3792 state = State()
3793 statement = custom_compile(expr, state)
3794- self.assertEquals(statement, '"something"')
3795- self.assertEquals(state.parameters, [])
3796+ self.assertEqual(statement, '"something"')
3797+ self.assertEqual(state.parameters, [])
3798
3799 def test_sql_token_reserved_from_parent(self):
3800 expr = SQLToken("something")
3801 parent_compile = compile.create_child()
3802 child_compile = parent_compile.create_child()
3803 statement = child_compile(expr)
3804- self.assertEquals(statement, "something")
3805+ self.assertEqual(statement, "something")
3806 parent_compile.add_reserved_words(["something"])
3807 statement = child_compile(expr)
3808- self.assertEquals(statement, '"something"')
3809+ self.assertEqual(statement, '"something"')
3810
3811 def test_sql_token_remove_reserved_word_on_child(self):
3812 expr = SQLToken("something")
3813@@ -2084,19 +2084,19 @@
3814 parent_compile.add_reserved_words(["something"])
3815 child_compile = parent_compile.create_child()
3816 statement = child_compile(expr)
3817- self.assertEquals(statement, '"something"')
3818+ self.assertEqual(statement, '"something"')
3819 child_compile.remove_reserved_words(["something"])
3820 statement = child_compile(expr)
3821- self.assertEquals(statement, "something")
3822+ self.assertEqual(statement, "something")
3823
3824 def test_is_reserved_word(self):
3825 parent_compile = compile.create_child()
3826 child_compile = parent_compile.create_child()
3827- self.assertEquals(child_compile.is_reserved_word("someTHING"), False)
3828+ self.assertEqual(child_compile.is_reserved_word("someTHING"), False)
3829 parent_compile.add_reserved_words(["SOMEthing"])
3830- self.assertEquals(child_compile.is_reserved_word("somETHing"), True)
3831+ self.assertEqual(child_compile.is_reserved_word("somETHing"), True)
3832 child_compile.remove_reserved_words(["soMETHing"])
3833- self.assertEquals(child_compile.is_reserved_word("somethING"), False)
3834+ self.assertEqual(child_compile.is_reserved_word("somethING"), False)
3835
3836 def test_sql1992_reserved_words(self):
3837 reserved_words = """
3838@@ -2128,7 +2128,7 @@
3839 where with work write year zone
3840 """.split()
3841 for word in reserved_words:
3842- self.assertEquals(compile.is_reserved_word(word), True)
3843+ self.assertEqual(compile.is_reserved_word(word), True)
3844
3845
3846 class CompilePythonTest(TestHelper):
3847@@ -2138,7 +2138,7 @@
3848 expr = And(e[1], Or(e[2], e[3]),
3849 Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9]))))))
3850 py_expr = compile_python(expr)
3851- self.assertEquals(py_expr, "1 and (2 or 3) and 4+5*(6-7/(8/9))")
3852+ self.assertEqual(py_expr, "1 and (2 or 3) and 4+5*(6-7/(8/9))")
3853
3854 def test_get_precedence(self):
3855 self.assertTrue(compile_python.get_precedence(Or) <
3856@@ -2152,8 +2152,8 @@
3857 expr = [elem1, Variable(1), (Variable(2), None)]
3858 state = State()
3859 py_expr = compile_python(expr, state)
3860- self.assertEquals(py_expr, "elem1, _0, _1, None")
3861- self.assertEquals(state.parameters, [1, 2])
3862+ self.assertEqual(py_expr, "elem1, _0, _1, None")
3863+ self.assertEqual(state.parameters, [1, 2])
3864
3865 def test_compile_invalid(self):
3866 self.assertRaises(CompileError, compile_python, object())
3867@@ -2165,199 +2165,199 @@
3868
3869 def test_bytes(self):
3870 py_expr = compile_python(b"str")
3871- self.assertEquals(py_expr, "b'str'" if six.PY3 else "'str'")
3872+ self.assertEqual(py_expr, "b'str'" if six.PY3 else "'str'")
3873
3874 def test_unicode(self):
3875 py_expr = compile_python(u"str")
3876- self.assertEquals(py_expr, "'str'" if six.PY3 else "u'str'")
3877+ self.assertEqual(py_expr, "'str'" if six.PY3 else "u'str'")
3878
3879 def test_int(self):
3880 py_expr = compile_python(1)
3881- self.assertEquals(py_expr, "1")
3882+ self.assertEqual(py_expr, "1")
3883
3884 @unittest.skipUnless(six.PY2, "Python 3 has no separate long type")
3885 def test_long(self):
3886 # 1L was more idiomatic in Python 2, but is a syntax error in Python 3.
3887 py_expr = compile_python(long(1))
3888- self.assertEquals(py_expr, "1L")
3889+ self.assertEqual(py_expr, "1L")
3890
3891 def test_bool(self):
3892 state = State()
3893 py_expr = compile_python(True, state)
3894- self.assertEquals(py_expr, "_0")
3895- self.assertEquals(state.parameters, [True])
3896+ self.assertEqual(py_expr, "_0")
3897+ self.assertEqual(state.parameters, [True])
3898
3899 def test_float(self):
3900 py_expr = compile_python(1.1)
3901- self.assertEquals(py_expr, repr(1.1))
3902+ self.assertEqual(py_expr, repr(1.1))
3903
3904 def test_datetime(self):
3905 dt = datetime(1977, 5, 4, 12, 34)
3906 state = State()
3907 py_expr = compile_python(dt, state)
3908- self.assertEquals(py_expr, "_0")
3909- self.assertEquals(state.parameters, [dt])
3910+ self.assertEqual(py_expr, "_0")
3911+ self.assertEqual(state.parameters, [dt])
3912
3913 def test_date(self):
3914 d = date(1977, 5, 4)
3915 state = State()
3916 py_expr = compile_python(d, state)
3917- self.assertEquals(py_expr, "_0")
3918- self.assertEquals(state.parameters, [d])
3919+ self.assertEqual(py_expr, "_0")
3920+ self.assertEqual(state.parameters, [d])
3921
3922 def test_time(self):
3923 t = time(12, 34)
3924 state = State()
3925 py_expr = compile_python(t, state)
3926- self.assertEquals(py_expr, "_0")
3927- self.assertEquals(state.parameters, [t])
3928+ self.assertEqual(py_expr, "_0")
3929+ self.assertEqual(state.parameters, [t])
3930
3931 def test_timedelta(self):
3932 td = timedelta(days=1, seconds=2, microseconds=3)
3933 state = State()
3934 py_expr = compile_python(td, state)
3935- self.assertEquals(py_expr, "_0")
3936- self.assertEquals(state.parameters, [td])
3937+ self.assertEqual(py_expr, "_0")
3938+ self.assertEqual(state.parameters, [td])
3939
3940 def test_none(self):
3941 py_expr = compile_python(None)
3942- self.assertEquals(py_expr, "None")
3943+ self.assertEqual(py_expr, "None")
3944
3945 def test_column(self):
3946 expr = Column(column1)
3947 state = State()
3948 py_expr = compile_python(expr, state)
3949- self.assertEquals(py_expr, "get_column(_0)")
3950- self.assertEquals(state.parameters, [expr])
3951+ self.assertEqual(py_expr, "get_column(_0)")
3952+ self.assertEqual(state.parameters, [expr])
3953
3954 def test_column_table(self):
3955 expr = Column(column1, table1)
3956 state = State()
3957 py_expr = compile_python(expr, state)
3958- self.assertEquals(py_expr, "get_column(_0)")
3959- self.assertEquals(state.parameters, [expr])
3960+ self.assertEqual(py_expr, "get_column(_0)")
3961+ self.assertEqual(state.parameters, [expr])
3962
3963 def test_variable(self):
3964 expr = Variable("value")
3965 state = State()
3966 py_expr = compile_python(expr, state)
3967- self.assertEquals(py_expr, "_0")
3968- self.assertEquals(state.parameters, ["value"])
3969+ self.assertEqual(py_expr, "_0")
3970+ self.assertEqual(state.parameters, ["value"])
3971
3972 def test_eq(self):
3973 expr = Eq(Variable(1), Variable(2))
3974 state = State()
3975 py_expr = compile_python(expr, state)
3976- self.assertEquals(py_expr, "_0 == _1")
3977- self.assertEquals(state.parameters, [1, 2])
3978+ self.assertEqual(py_expr, "_0 == _1")
3979+ self.assertEqual(state.parameters, [1, 2])
3980
3981 def test_ne(self):
3982 expr = Ne(Variable(1), Variable(2))
3983 state = State()
3984 py_expr = compile_python(expr, state)
3985- self.assertEquals(py_expr, "_0 != _1")
3986- self.assertEquals(state.parameters, [1, 2])
3987+ self.assertEqual(py_expr, "_0 != _1")
3988+ self.assertEqual(state.parameters, [1, 2])
3989
3990 def test_gt(self):
3991 expr = Gt(Variable(1), Variable(2))
3992 state = State()
3993 py_expr = compile_python(expr, state)
3994- self.assertEquals(py_expr, "_0 > _1")
3995- self.assertEquals(state.parameters, [1, 2])
3996+ self.assertEqual(py_expr, "_0 > _1")
3997+ self.assertEqual(state.parameters, [1, 2])
3998
3999 def test_ge(self):
4000 expr = Ge(Variable(1), Variable(2))
4001 state = State()
4002 py_expr = compile_python(expr, state)
4003- self.assertEquals(py_expr, "_0 >= _1")
4004- self.assertEquals(state.parameters, [1, 2])
4005+ self.assertEqual(py_expr, "_0 >= _1")
4006+ self.assertEqual(state.parameters, [1, 2])
4007
4008 def test_lt(self):
4009 expr = Lt(Variable(1), Variable(2))
4010 state = State()
4011 py_expr = compile_python(expr, state)
4012- self.assertEquals(py_expr, "_0 < _1")
4013- self.assertEquals(state.parameters, [1, 2])
4014+ self.assertEqual(py_expr, "_0 < _1")
4015+ self.assertEqual(state.parameters, [1, 2])
4016
4017 def test_le(self):
4018 expr = Le(Variable(1), Variable(2))
4019 state = State()
4020 py_expr = compile_python(expr, state)
4021- self.assertEquals(py_expr, "_0 <= _1")
4022- self.assertEquals(state.parameters, [1, 2])
4023+ self.assertEqual(py_expr, "_0 <= _1")
4024+ self.assertEqual(state.parameters, [1, 2])
4025
4026 def test_lshift(self):
4027 expr = LShift(Variable(1), Variable(2))
4028 state = State()
4029 py_expr = compile_python(expr, state)
4030- self.assertEquals(py_expr, "_0<<_1")
4031- self.assertEquals(state.parameters, [1, 2])
4032+ self.assertEqual(py_expr, "_0<<_1")
4033+ self.assertEqual(state.parameters, [1, 2])
4034
4035 def test_rshift(self):
4036 expr = RShift(Variable(1), Variable(2))
4037 state = State()
4038 py_expr = compile_python(expr, state)
4039- self.assertEquals(py_expr, "_0>>_1")
4040- self.assertEquals(state.parameters, [1, 2])
4041+ self.assertEqual(py_expr, "_0>>_1")
4042+ self.assertEqual(state.parameters, [1, 2])
4043
4044 def test_in(self):
4045 expr = In(Variable(1), Variable(2))
4046 state = State()
4047 py_expr = compile_python(expr, state)
4048- self.assertEquals(py_expr, "_0 in (_1,)")
4049- self.assertEquals(state.parameters, [1, 2])
4050+ self.assertEqual(py_expr, "_0 in (_1,)")
4051+ self.assertEqual(state.parameters, [1, 2])
4052
4053 def test_and(self):
4054 expr = And(elem1, elem2, And(elem3, elem4))
4055 py_expr = compile_python(expr)
4056- self.assertEquals(py_expr, "elem1 and elem2 and elem3 and elem4")
4057+ self.assertEqual(py_expr, "elem1 and elem2 and elem3 and elem4")
4058
4059 def test_or(self):
4060 expr = Or(elem1, elem2, Or(elem3, elem4))
4061 py_expr = compile_python(expr)
4062- self.assertEquals(py_expr, "elem1 or elem2 or elem3 or elem4")
4063+ self.assertEqual(py_expr, "elem1 or elem2 or elem3 or elem4")
4064
4065 def test_add(self):
4066 expr = Add(elem1, elem2, Add(elem3, elem4))
4067 py_expr = compile_python(expr)
4068- self.assertEquals(py_expr, "elem1+elem2+elem3+elem4")
4069+ self.assertEqual(py_expr, "elem1+elem2+elem3+elem4")
4070
4071 def test_neg(self):
4072 expr = Neg(elem1)
4073 py_expr = compile_python(expr)
4074- self.assertEquals(py_expr, "-elem1")
4075+ self.assertEqual(py_expr, "-elem1")
4076
4077 def test_sub(self):
4078 expr = Sub(elem1, Sub(elem2, elem3))
4079 py_expr = compile_python(expr)
4080- self.assertEquals(py_expr, "elem1-(elem2-elem3)")
4081+ self.assertEqual(py_expr, "elem1-(elem2-elem3)")
4082
4083 expr = Sub(Sub(elem1, elem2), elem3)
4084 py_expr = compile_python(expr)
4085- self.assertEquals(py_expr, "elem1-elem2-elem3")
4086+ self.assertEqual(py_expr, "elem1-elem2-elem3")
4087
4088 def test_mul(self):
4089 expr = Mul(elem1, elem2, Mul(elem3, elem4))
4090 py_expr = compile_python(expr)
4091- self.assertEquals(py_expr, "elem1*elem2*elem3*elem4")
4092+ self.assertEqual(py_expr, "elem1*elem2*elem3*elem4")
4093
4094 def test_div(self):
4095 expr = Div(elem1, Div(elem2, elem3))
4096 py_expr = compile_python(expr)
4097- self.assertEquals(py_expr, "elem1/(elem2/elem3)")
4098+ self.assertEqual(py_expr, "elem1/(elem2/elem3)")
4099
4100 expr = Div(Div(elem1, elem2), elem3)
4101 py_expr = compile_python(expr)
4102- self.assertEquals(py_expr, "elem1/elem2/elem3")
4103+ self.assertEqual(py_expr, "elem1/elem2/elem3")
4104
4105 def test_mod(self):
4106 expr = Mod(elem1, Mod(elem2, elem3))
4107 py_expr = compile_python(expr)
4108- self.assertEquals(py_expr, "elem1%(elem2%elem3)")
4109+ self.assertEqual(py_expr, "elem1%(elem2%elem3)")
4110
4111 expr = Mod(Mod(elem1, elem2), elem3)
4112 py_expr = compile_python(expr)
4113- self.assertEquals(py_expr, "elem1%elem2%elem3")
4114+ self.assertEqual(py_expr, "elem1%elem2%elem3")
4115
4116 def test_match(self):
4117 col1 = Column(column1)
4118
4119=== modified file 'storm/tests/helper.py'
4120--- storm/tests/helper.py 2019-08-12 17:07:08 +0000
4121+++ storm/tests/helper.py 2019-11-21 16:09:19 +0000
4122@@ -67,10 +67,10 @@
4123 super(TestHelper, self).run(result)
4124
4125 def assertVariablesEqual(self, checked, expected):
4126- self.assertEquals(len(checked), len(expected))
4127+ self.assertEqual(len(checked), len(expected))
4128 for check, expect in zip(checked, expected):
4129- self.assertEquals(check.__class__, expect.__class__)
4130- self.assertEquals(check.get(), expect.get())
4131+ self.assertEqual(check.__class__, expect.__class__)
4132+ self.assertEqual(check.get(), expect.get())
4133
4134
4135 class MakePath(object):
4136@@ -118,8 +118,8 @@
4137 self.old_handlers = logger.handlers
4138 # Sanity check; this might not be 100% what we want
4139 if self.old_handlers:
4140- test_case.assertEquals(len(self.old_handlers), 1)
4141- test_case.assertEquals(self.old_handlers[0].stream, sys.stderr)
4142+ test_case.assertEqual(len(self.old_handlers), 1)
4143+ test_case.assertEqual(self.old_handlers[0].stream, sys.stderr)
4144 logger.handlers = [handler]
4145
4146 def tear_down(self, test_case):
4147
4148=== modified file 'storm/tests/info.py'
4149--- storm/tests/info.py 2019-08-21 09:40:30 +0000
4150+++ storm/tests/info.py 2019-11-21 16:09:19 +0000
4151@@ -69,9 +69,9 @@
4152 def test_set_obj_info(self):
4153 obj_info1 = get_obj_info(self.obj)
4154 obj_info2 = ObjectInfo(self.obj)
4155- self.assertEquals(get_obj_info(self.obj), obj_info1)
4156+ self.assertEqual(get_obj_info(self.obj), obj_info1)
4157 set_obj_info(self.obj, obj_info2)
4158- self.assertEquals(get_obj_info(self.obj), obj_info2)
4159+ self.assertEqual(get_obj_info(self.obj), obj_info2)
4160
4161
4162 class ClassInfoTest(TestHelper):
4163@@ -90,19 +90,19 @@
4164 self.assertRaises(ClassInfoError, ClassInfo, Class)
4165
4166 def test_cls(self):
4167- self.assertEquals(self.cls_info.cls, self.Class)
4168+ self.assertEqual(self.cls_info.cls, self.Class)
4169
4170 def test_columns(self):
4171- self.assertEquals(self.cls_info.columns,
4172- (self.Class.prop1, self.Class.prop2))
4173+ self.assertEqual(self.cls_info.columns,
4174+ (self.Class.prop1, self.Class.prop2))
4175
4176 def test_table(self):
4177- self.assertEquals(self.cls_info.table.name, "table")
4178+ self.assertEqual(self.cls_info.table.name, "table")
4179
4180 def test_primary_key(self):
4181 # Can't use == for props.
4182 self.assertTrue(self.cls_info.primary_key[0] is self.Class.prop1)
4183- self.assertEquals(len(self.cls_info.primary_key), 1)
4184+ self.assertEqual(len(self.cls_info.primary_key), 1)
4185
4186 def test_primary_key_with_attribute(self):
4187 class SubClass(self.Class):
4188@@ -111,7 +111,7 @@
4189 cls_info = get_cls_info(SubClass)
4190
4191 self.assertTrue(cls_info.primary_key[0] is SubClass.prop2)
4192- self.assertEquals(len(self.cls_info.primary_key), 1)
4193+ self.assertEqual(len(self.cls_info.primary_key), 1)
4194
4195 def test_primary_key_composed(self):
4196 class Class(object):
4197@@ -123,7 +123,7 @@
4198 # Can't use == for props, since they're columns.
4199 self.assertTrue(cls_info.primary_key[0] is Class.prop2)
4200 self.assertTrue(cls_info.primary_key[1] is Class.prop1)
4201- self.assertEquals(len(cls_info.primary_key), 2)
4202+ self.assertEqual(len(cls_info.primary_key), 2)
4203
4204 def test_primary_key_composed_with_attribute(self):
4205 class Class(object):
4206@@ -138,7 +138,7 @@
4207 # Can't use == for props, since they're columns.
4208 self.assertTrue(cls_info.primary_key[0] is Class.prop2)
4209 self.assertTrue(cls_info.primary_key[1] is Class.prop1)
4210- self.assertEquals(len(cls_info.primary_key), 2)
4211+ self.assertEqual(len(cls_info.primary_key), 2)
4212
4213 def test_primary_key_composed_duplicated(self):
4214 class Class(object):
4215@@ -169,7 +169,7 @@
4216 prop2 = Property("column2")
4217 prop3 = Property("column3", primary=1)
4218 cls_info = ClassInfo(Class)
4219- self.assertEquals(cls_info.primary_key_pos, (2, 0))
4220+ self.assertEqual(cls_info.primary_key_pos, (2, 0))
4221
4222
4223 class ObjectInfoTest(TestHelper):
4224@@ -188,7 +188,7 @@
4225 self.variable2 = self.obj_info.variables[Class.prop2]
4226
4227 def test_hashing(self):
4228- self.assertEquals(hash(self.obj_info), hash(self.obj_info))
4229+ self.assertEqual(hash(self.obj_info), hash(self.obj_info))
4230
4231 def test_equals(self):
4232 obj_info1 = self.obj_info
4233@@ -211,8 +211,8 @@
4234 self.assertTrue(isinstance(variable, Variable))
4235 self.assertTrue(variable.column is column)
4236
4237- self.assertEquals(len(self.obj_info.variables),
4238- len(self.cls_info.columns))
4239+ self.assertEqual(len(self.obj_info.variables),
4240+ len(self.cls_info.columns))
4241
4242 def test_variable_has_validator_object_factory(self):
4243 args = []
4244@@ -226,33 +226,33 @@
4245 obj = Class()
4246 get_obj_info(obj).variables[Class.prop].set(123)
4247
4248- self.assertEquals(args, [(obj, "prop", 123)])
4249+ self.assertEqual(args, [(obj, "prop", 123)])
4250
4251 def test_primary_vars(self):
4252 self.assertTrue(isinstance(self.obj_info.primary_vars, tuple))
4253
4254 for column, variable in zip(self.cls_info.primary_key,
4255 self.obj_info.primary_vars):
4256- self.assertEquals(self.obj_info.variables.get(column),
4257- variable)
4258+ self.assertEqual(self.obj_info.variables.get(column),
4259+ variable)
4260
4261- self.assertEquals(len(self.obj_info.primary_vars),
4262- len(self.cls_info.primary_key))
4263+ self.assertEqual(len(self.obj_info.primary_vars),
4264+ len(self.cls_info.primary_key))
4265
4266 def test_checkpoint(self):
4267 self.obj.prop1 = 10
4268 self.obj_info.checkpoint()
4269- self.assertEquals(self.obj.prop1, 10)
4270- self.assertEquals(self.variable1.has_changed(), False)
4271+ self.assertEqual(self.obj.prop1, 10)
4272+ self.assertEqual(self.variable1.has_changed(), False)
4273 self.obj.prop1 = 20
4274- self.assertEquals(self.obj.prop1, 20)
4275- self.assertEquals(self.variable1.has_changed(), True)
4276+ self.assertEqual(self.obj.prop1, 20)
4277+ self.assertEqual(self.variable1.has_changed(), True)
4278 self.obj_info.checkpoint()
4279- self.assertEquals(self.obj.prop1, 20)
4280- self.assertEquals(self.variable1.has_changed(), False)
4281+ self.assertEqual(self.obj.prop1, 20)
4282+ self.assertEqual(self.variable1.has_changed(), False)
4283 self.obj.prop1 = 20
4284- self.assertEquals(self.obj.prop1, 20)
4285- self.assertEquals(self.variable1.has_changed(), False)
4286+ self.assertEqual(self.obj.prop1, 20)
4287+ self.assertEqual(self.variable1.has_changed(), False)
4288
4289 def test_add_change_notification(self):
4290 changes1 = []
4291@@ -271,10 +271,10 @@
4292 self.obj.prop2 = 10
4293 self.obj.prop1 = 20
4294
4295- self.assertEquals(changes1,
4296+ self.assertEqual(changes1,
4297 [(1, self.obj_info, self.variable2, Undef, 10, False),
4298 (1, self.obj_info, self.variable1, Undef, 20, False)])
4299- self.assertEquals(changes2,
4300+ self.assertEqual(changes2,
4301 [(2, self.obj_info, self.variable2, Undef, 10, False),
4302 (2, self.obj_info, self.variable1, Undef, 20, False)])
4303
4304@@ -284,10 +284,10 @@
4305 self.obj.prop1 = None
4306 self.obj.prop2 = None
4307
4308- self.assertEquals(changes1,
4309+ self.assertEqual(changes1,
4310 [(1, self.obj_info, self.variable1, 20, None, False),
4311 (1, self.obj_info, self.variable2, 10, None, False)])
4312- self.assertEquals(changes2,
4313+ self.assertEqual(changes2,
4314 [(2, self.obj_info, self.variable1, 20, None, False),
4315 (2, self.obj_info, self.variable2, 10, None, False)])
4316
4317@@ -297,10 +297,10 @@
4318 del self.obj.prop1
4319 del self.obj.prop2
4320
4321- self.assertEquals(changes1,
4322+ self.assertEqual(changes1,
4323 [(1, self.obj_info, self.variable1, None, Undef, False),
4324 (1, self.obj_info, self.variable2, None, Undef, False)])
4325- self.assertEquals(changes2,
4326+ self.assertEqual(changes2,
4327 [(2, self.obj_info, self.variable1, None, Undef, False),
4328 (2, self.obj_info, self.variable2, None, Undef, False)])
4329
4330@@ -326,10 +326,10 @@
4331 self.obj.prop2 = 10
4332 self.obj.prop1 = 20
4333
4334- self.assertEquals(changes1,
4335+ self.assertEqual(changes1,
4336 [(1, self.obj_info, self.variable2, Undef, 10, False, obj),
4337 (1, self.obj_info, self.variable1, Undef, 20, False, obj)])
4338- self.assertEquals(changes2,
4339+ self.assertEqual(changes2,
4340 [(2, self.obj_info, self.variable2, Undef, 10, False, obj),
4341 (2, self.obj_info, self.variable1, Undef, 20, False, obj)])
4342
4343@@ -339,10 +339,10 @@
4344 self.obj.prop1 = None
4345 self.obj.prop2 = None
4346
4347- self.assertEquals(changes1,
4348+ self.assertEqual(changes1,
4349 [(1, self.obj_info, self.variable1, 20, None, False, obj),
4350 (1, self.obj_info, self.variable2, 10, None, False, obj)])
4351- self.assertEquals(changes2,
4352+ self.assertEqual(changes2,
4353 [(2, self.obj_info, self.variable1, 20, None, False, obj),
4354 (2, self.obj_info, self.variable2, 10, None, False, obj)])
4355
4356@@ -352,10 +352,10 @@
4357 del self.obj.prop1
4358 del self.obj.prop2
4359
4360- self.assertEquals(changes1,
4361+ self.assertEqual(changes1,
4362 [(1, self.obj_info, self.variable1, None, Undef, False, obj),
4363 (1, self.obj_info, self.variable2, None, Undef, False, obj)])
4364- self.assertEquals(changes2,
4365+ self.assertEqual(changes2,
4366 [(2, self.obj_info, self.variable1, None, Undef, False, obj),
4367 (2, self.obj_info, self.variable2, None, Undef, False, obj)])
4368
4369@@ -378,8 +378,8 @@
4370 self.obj.prop2 = 20
4371 self.obj.prop1 = 10
4372
4373- self.assertEquals(changes1, [])
4374- self.assertEquals(changes2,
4375+ self.assertEqual(changes1, [])
4376+ self.assertEqual(changes2,
4377 [(2, self.obj_info, self.variable2, Undef, 20, False),
4378 (2, self.obj_info, self.variable1, Undef, 10, False)])
4379
4380@@ -406,8 +406,8 @@
4381 self.obj.prop2 = 20
4382 self.obj.prop1 = 10
4383
4384- self.assertEquals(changes1, [])
4385- self.assertEquals(changes2,
4386+ self.assertEqual(changes1, [])
4387+ self.assertEqual(changes2,
4388 [(2, self.obj_info, self.variable2, Undef, 20, False, obj),
4389 (2, self.obj_info, self.variable1, Undef, 10, False, obj)])
4390
4391@@ -431,9 +431,9 @@
4392 self.obj.prop2 = 20
4393 self.obj.prop1 = 10
4394
4395- self.assertEquals(changes1,
4396+ self.assertEqual(changes1,
4397 [(1, self.obj_info, self.variable2, Undef, 20, False)])
4398- self.assertEquals(changes2,
4399+ self.assertEqual(changes2,
4400 [(2, self.obj_info, self.variable2, Undef, 20, False)])
4401
4402 def test_auto_remove_change_notification_with_arg(self):
4403@@ -460,9 +460,9 @@
4404 self.obj.prop2 = 20
4405 self.obj.prop1 = 10
4406
4407- self.assertEquals(changes1,
4408+ self.assertEqual(changes1,
4409 [(1, self.obj_info, self.variable2, Undef, 20, False, obj)])
4410- self.assertEquals(changes2,
4411+ self.assertEqual(changes2,
4412 [(2, self.obj_info, self.variable2, Undef, 20, False, obj)])
4413
4414 def test_get_obj(self):
4415@@ -491,7 +491,7 @@
4416 obj = self.Class()
4417 obj_info = get_obj_info(obj)
4418 del obj
4419- self.assertEquals(obj_info.get_obj(), None)
4420+ self.assertEqual(obj_info.get_obj(), None)
4421
4422 def test_object_deleted_notification(self):
4423 obj = self.Class()
4424@@ -503,7 +503,7 @@
4425 obj_info.event.hook("object-deleted", object_deleted)
4426 del obj_info
4427 del obj
4428- self.assertEquals(len(deleted), 1)
4429+ self.assertEqual(len(deleted), 1)
4430 self.assertTrue("tainted" in deleted[0])
4431
4432 def test_object_deleted_notification_after_set_obj(self):
4433@@ -518,7 +518,7 @@
4434 obj_info.event.hook("object-deleted", object_deleted)
4435 del obj_info
4436 del obj
4437- self.assertEquals(len(deleted), 1)
4438+ self.assertEqual(len(deleted), 1)
4439 self.assertTrue("tainted" in deleted[0])
4440
4441
4442@@ -534,35 +534,35 @@
4443
4444 def test_cls_info_cls(self):
4445 cls_info = get_cls_info(self.ClassAlias)
4446- self.assertEquals(cls_info.cls, self.Class)
4447- self.assertEquals(cls_info.table.name, "alias")
4448- self.assertEquals(self.ClassAlias.prop1.name, "column1")
4449- self.assertEquals(self.ClassAlias.prop1.table, self.ClassAlias)
4450+ self.assertEqual(cls_info.cls, self.Class)
4451+ self.assertEqual(cls_info.table.name, "alias")
4452+ self.assertEqual(self.ClassAlias.prop1.name, "column1")
4453+ self.assertEqual(self.ClassAlias.prop1.table, self.ClassAlias)
4454
4455 def test_compile(self):
4456 statement = compile(self.ClassAlias)
4457- self.assertEquals(statement, "alias")
4458+ self.assertEqual(statement, "alias")
4459
4460 def test_compile_with_reserved_keyword(self):
4461 Alias = ClassAlias(self.Class, "select")
4462 statement = compile(Alias)
4463- self.assertEquals(statement, '"select"')
4464+ self.assertEqual(statement, '"select"')
4465
4466 def test_compile_in_select(self):
4467 expr = Select(self.ClassAlias.prop1, self.ClassAlias.prop1 == 1,
4468 self.ClassAlias)
4469 statement = compile(expr)
4470- self.assertEquals(statement,
4471- 'SELECT alias.column1 FROM "table" AS alias '
4472- 'WHERE alias.column1 = ?')
4473+ self.assertEqual(statement,
4474+ 'SELECT alias.column1 FROM "table" AS alias '
4475+ 'WHERE alias.column1 = ?')
4476
4477 def test_compile_in_select_with_reserved_keyword(self):
4478 Alias = ClassAlias(self.Class, "select")
4479 expr = Select(Alias.prop1, Alias.prop1 == 1, Alias)
4480 statement = compile(expr)
4481- self.assertEquals(statement,
4482- 'SELECT "select".column1 FROM "table" AS "select" '
4483- 'WHERE "select".column1 = ?')
4484+ self.assertEqual(statement,
4485+ 'SELECT "select".column1 FROM "table" AS "select" '
4486+ 'WHERE "select".column1 = ?')
4487
4488 def test_crazy_metaclass(self):
4489 """We don't want metaclasses playing around when we build an alias."""
4490@@ -576,7 +576,7 @@
4491 __storm_table__ = "table"
4492 prop1 = Property("column1", primary=True)
4493 Alias = ClassAlias(Class, "USE_THIS")
4494- self.assertEquals(Alias.__storm_table__, "USE_THIS")
4495+ self.assertEqual(Alias.__storm_table__, "USE_THIS")
4496
4497 def test_cached_aliases(self):
4498 """
4499@@ -635,8 +635,8 @@
4500 __storm_table__ = Class1
4501 id = Property(primary=True)
4502 statement = compile(Class2)
4503- self.assertEquals(statement, "class1")
4504+ self.assertEqual(statement, "class1")
4505 alias = ClassAlias(Class2, "alias")
4506 statement = compile(Select(alias.id))
4507- self.assertEquals(statement, "SELECT alias.id FROM class1 AS alias")
4508+ self.assertEqual(statement, "SELECT alias.id FROM class1 AS alias")
4509
4510
4511=== modified file 'storm/tests/mocker.py'
4512--- storm/tests/mocker.py 2019-09-29 14:05:31 +0000
4513+++ storm/tests/mocker.py 2019-11-21 16:09:19 +0000
4514@@ -380,7 +380,7 @@
4515 mock.hello()
4516 self.mocker.result("Hi!")
4517 self.mocker.replay()
4518- self.assertEquals(mock.hello(), "Hi!")
4519+ self.assertEqual(mock.hello(), "Hi!")
4520 """
4521
4522 _recorders = []
4523
4524=== modified file 'storm/tests/properties.py'
4525--- storm/tests/properties.py 2019-08-21 09:40:30 +0000
4526+++ storm/tests/properties.py 2019-11-21 16:09:19 +0000
4527@@ -63,42 +63,42 @@
4528 self.assertTrue(isinstance(self.Class.prop1, Column))
4529
4530 def test_cls(self):
4531- self.assertEquals(self.Class.prop1.cls, self.Class)
4532- self.assertEquals(self.Class.prop2.cls, self.Class)
4533- self.assertEquals(self.SubClass.prop1.cls, self.SubClass)
4534- self.assertEquals(self.SubClass.prop2.cls, self.SubClass)
4535- self.assertEquals(self.Class.prop1.cls, self.Class)
4536- self.assertEquals(self.Class.prop2.cls, self.Class)
4537+ self.assertEqual(self.Class.prop1.cls, self.Class)
4538+ self.assertEqual(self.Class.prop2.cls, self.Class)
4539+ self.assertEqual(self.SubClass.prop1.cls, self.SubClass)
4540+ self.assertEqual(self.SubClass.prop2.cls, self.SubClass)
4541+ self.assertEqual(self.Class.prop1.cls, self.Class)
4542+ self.assertEqual(self.Class.prop2.cls, self.Class)
4543
4544 def test_cls_reverse(self):
4545- self.assertEquals(self.SubClass.prop1.cls, self.SubClass)
4546- self.assertEquals(self.SubClass.prop2.cls, self.SubClass)
4547- self.assertEquals(self.Class.prop1.cls, self.Class)
4548- self.assertEquals(self.Class.prop2.cls, self.Class)
4549- self.assertEquals(self.SubClass.prop1.cls, self.SubClass)
4550- self.assertEquals(self.SubClass.prop2.cls, self.SubClass)
4551+ self.assertEqual(self.SubClass.prop1.cls, self.SubClass)
4552+ self.assertEqual(self.SubClass.prop2.cls, self.SubClass)
4553+ self.assertEqual(self.Class.prop1.cls, self.Class)
4554+ self.assertEqual(self.Class.prop2.cls, self.Class)
4555+ self.assertEqual(self.SubClass.prop1.cls, self.SubClass)
4556+ self.assertEqual(self.SubClass.prop2.cls, self.SubClass)
4557
4558 def test_name(self):
4559- self.assertEquals(self.Class.prop1.name, "column1")
4560+ self.assertEqual(self.Class.prop1.name, "column1")
4561
4562 def test_auto_name(self):
4563- self.assertEquals(self.Class.prop2.name, "prop2")
4564+ self.assertEqual(self.Class.prop2.name, "prop2")
4565
4566 def test_auto_table(self):
4567- self.assertEquals(self.Class.prop1.table, self.Class)
4568- self.assertEquals(self.Class.prop2.table, self.Class)
4569+ self.assertEqual(self.Class.prop1.table, self.Class)
4570+ self.assertEqual(self.Class.prop2.table, self.Class)
4571
4572 def test_auto_table_subclass(self):
4573- self.assertEquals(self.Class.prop1.table, self.Class)
4574- self.assertEquals(self.Class.prop2.table, self.Class)
4575- self.assertEquals(self.SubClass.prop1.table, self.SubClass)
4576- self.assertEquals(self.SubClass.prop2.table, self.SubClass)
4577+ self.assertEqual(self.Class.prop1.table, self.Class)
4578+ self.assertEqual(self.Class.prop2.table, self.Class)
4579+ self.assertEqual(self.SubClass.prop1.table, self.SubClass)
4580+ self.assertEqual(self.SubClass.prop2.table, self.SubClass)
4581
4582 def test_auto_table_subclass_reverse_initialization(self):
4583- self.assertEquals(self.SubClass.prop1.table, self.SubClass)
4584- self.assertEquals(self.SubClass.prop2.table, self.SubClass)
4585- self.assertEquals(self.Class.prop1.table, self.Class)
4586- self.assertEquals(self.Class.prop2.table, self.Class)
4587+ self.assertEqual(self.SubClass.prop1.table, self.SubClass)
4588+ self.assertEqual(self.SubClass.prop2.table, self.SubClass)
4589+ self.assertEqual(self.Class.prop1.table, self.Class)
4590+ self.assertEqual(self.Class.prop2.table, self.Class)
4591
4592 def test_variable_factory(self):
4593 variable = self.Class.prop1.variable_factory()
4594@@ -125,29 +125,29 @@
4595 variable2 = Class2.prop2.variable_factory(validator=validator)
4596 variable1.set(1)
4597 variable2.set(2)
4598- self.assertEquals(args, [(None, "prop1", 1), (None, "prop2", 2)])
4599+ self.assertEqual(args, [(None, "prop1", 1), (None, "prop2", 2)])
4600
4601 def test_default(self):
4602 obj = self.SubClass()
4603- self.assertEquals(obj.prop1, None)
4604- self.assertEquals(obj.prop2, None)
4605- self.assertEquals(obj.prop3, 50)
4606+ self.assertEqual(obj.prop1, None)
4607+ self.assertEqual(obj.prop2, None)
4608+ self.assertEqual(obj.prop3, 50)
4609
4610 def test_set_get(self):
4611 obj = self.Class()
4612 obj.prop1 = 10
4613 obj.prop2 = 20
4614 obj.prop3 = 30
4615- self.assertEquals(obj.prop1, 10)
4616- self.assertEquals(obj.prop2, 20)
4617- self.assertEquals(obj.prop3, 30)
4618+ self.assertEqual(obj.prop1, 10)
4619+ self.assertEqual(obj.prop2, 20)
4620+ self.assertEqual(obj.prop3, 30)
4621
4622 def test_set_get_none(self):
4623 obj = self.Class()
4624 obj.prop1 = None
4625 obj.prop2 = None
4626- self.assertEquals(obj.prop1, None)
4627- self.assertEquals(obj.prop2, None)
4628+ self.assertEqual(obj.prop1, None)
4629+ self.assertEqual(obj.prop2, None)
4630 self.assertRaises(NoneError, setattr, obj, "prop3", None)
4631
4632 def test_set_with_validator(self):
4633@@ -163,17 +163,17 @@
4634 obj = Class()
4635 obj.prop = 21
4636
4637- self.assertEquals(args, [obj, "prop", 21])
4638- self.assertEquals(obj.prop, 42)
4639+ self.assertEqual(args, [obj, "prop", 21])
4640+ self.assertEqual(obj.prop, 42)
4641
4642 def test_set_get_subclass(self):
4643 obj = self.SubClass()
4644 obj.prop1 = 10
4645 obj.prop2 = 20
4646 obj.prop3 = 30
4647- self.assertEquals(obj.prop1, 10)
4648- self.assertEquals(obj.prop2, 20)
4649- self.assertEquals(obj.prop3, 30)
4650+ self.assertEqual(obj.prop1, 10)
4651+ self.assertEqual(obj.prop2, 20)
4652+ self.assertEqual(obj.prop3, 30)
4653
4654 def test_set_get_explicitly(self):
4655 obj = self.Class()
4656@@ -183,9 +183,9 @@
4657 prop1.__set__(obj, 10)
4658 prop2.__set__(obj, 20)
4659 prop3.__set__(obj, 30)
4660- self.assertEquals(prop1.__get__(obj), 10)
4661- self.assertEquals(prop2.__get__(obj), 20)
4662- self.assertEquals(prop3.__get__(obj), 30)
4663+ self.assertEqual(prop1.__get__(obj), 10)
4664+ self.assertEqual(prop2.__get__(obj), 20)
4665+ self.assertEqual(prop3.__get__(obj), 30)
4666
4667 def test_set_get_subclass_explicitly(self):
4668 obj = self.SubClass()
4669@@ -195,9 +195,9 @@
4670 prop1.__set__(obj, 10)
4671 prop2.__set__(obj, 20)
4672 prop3.__set__(obj, 30)
4673- self.assertEquals(prop1.__get__(obj), 10)
4674- self.assertEquals(prop2.__get__(obj), 20)
4675- self.assertEquals(prop3.__get__(obj), 30)
4676+ self.assertEqual(prop1.__get__(obj), 10)
4677+ self.assertEqual(prop2.__get__(obj), 20)
4678+ self.assertEqual(prop3.__get__(obj), 30)
4679
4680 def test_delete(self):
4681 obj = self.Class()
4682@@ -207,9 +207,9 @@
4683 del obj.prop1
4684 del obj.prop2
4685 del obj.prop3
4686- self.assertEquals(obj.prop1, None)
4687- self.assertEquals(obj.prop2, None)
4688- self.assertEquals(obj.prop3, None)
4689+ self.assertEqual(obj.prop1, None)
4690+ self.assertEqual(obj.prop2, None)
4691+ self.assertEqual(obj.prop3, None)
4692
4693 def test_delete_subclass(self):
4694 obj = self.SubClass()
4695@@ -219,9 +219,9 @@
4696 del obj.prop1
4697 del obj.prop2
4698 del obj.prop3
4699- self.assertEquals(obj.prop1, None)
4700- self.assertEquals(obj.prop2, None)
4701- self.assertEquals(obj.prop3, None)
4702+ self.assertEqual(obj.prop1, None)
4703+ self.assertEqual(obj.prop2, None)
4704+ self.assertEqual(obj.prop3, None)
4705
4706 def test_delete_explicitly(self):
4707 obj = self.Class()
4708@@ -231,9 +231,9 @@
4709 self.Class.prop1.__delete__(obj)
4710 self.Class.prop2.__delete__(obj)
4711 self.Class.prop3.__delete__(obj)
4712- self.assertEquals(obj.prop1, None)
4713- self.assertEquals(obj.prop2, None)
4714- self.assertEquals(obj.prop3, None)
4715+ self.assertEqual(obj.prop1, None)
4716+ self.assertEqual(obj.prop2, None)
4717+ self.assertEqual(obj.prop3, None)
4718
4719 def test_delete_subclass_explicitly(self):
4720 obj = self.SubClass()
4721@@ -243,9 +243,9 @@
4722 self.Class.prop1.__delete__(obj)
4723 self.Class.prop2.__delete__(obj)
4724 self.Class.prop3.__delete__(obj)
4725- self.assertEquals(obj.prop1, None)
4726- self.assertEquals(obj.prop2, None)
4727- self.assertEquals(obj.prop3, None)
4728+ self.assertEqual(obj.prop1, None)
4729+ self.assertEqual(obj.prop2, None)
4730+ self.assertEqual(obj.prop3, None)
4731
4732 def test_comparable_expr(self):
4733 prop1 = self.Class.prop1
4734@@ -256,10 +256,10 @@
4735 (prop3 == "value3"))
4736 state = State()
4737 statement = compile(expr, state)
4738- self.assertEquals(statement, "SELECT * FROM mytable WHERE "
4739- "mytable.column1 = ? AND "
4740- "mytable.prop2 = ? AND "
4741- "mytable.column3 = ?")
4742+ self.assertEqual(statement, "SELECT * FROM mytable WHERE "
4743+ "mytable.column1 = ? AND "
4744+ "mytable.prop2 = ? AND "
4745+ "mytable.column3 = ?")
4746
4747 self.assertVariablesEqual(
4748 state.parameters,
4749@@ -276,10 +276,10 @@
4750 (prop3 == "value3"))
4751 state = State()
4752 statement = compile(expr, state)
4753- self.assertEquals(statement, "SELECT * FROM mysubtable WHERE "
4754- "mysubtable.column1 = ? AND "
4755- "mysubtable.prop2 = ? AND "
4756- "mysubtable.column3 = ?")
4757+ self.assertEqual(statement, "SELECT * FROM mysubtable WHERE "
4758+ "mysubtable.column1 = ? AND "
4759+ "mysubtable.prop2 = ? AND "
4760+ "mysubtable.column3 = ?")
4761 self.assertVariablesEqual(
4762 state.parameters,
4763 [CustomVariable("value1"),
4764@@ -290,9 +290,9 @@
4765 obj = self.Class()
4766 get_obj_info(obj) # Ensure the obj_info exists for obj.
4767 self.Class.prop1.__set__(Wrapper(obj), 10)
4768- self.assertEquals(self.Class.prop1.__get__(Wrapper(obj)), 10)
4769+ self.assertEqual(self.Class.prop1.__get__(Wrapper(obj)), 10)
4770 self.Class.prop1.__delete__(Wrapper(obj))
4771- self.assertEquals(self.Class.prop1.__get__(Wrapper(obj)), None)
4772+ self.assertEqual(self.Class.prop1.__get__(Wrapper(obj)), None)
4773
4774 def test_reuse_of_instance(self):
4775 """Properties are dynamically bound to the class where they're used.
4776@@ -309,10 +309,10 @@
4777 class Class2(object):
4778 __storm_table__ = "table2"
4779 prop2 = prop
4780- self.assertEquals(Class1.prop1.name, "prop1")
4781- self.assertEquals(Class1.prop1.table, Class1)
4782- self.assertEquals(Class2.prop2.name, "prop2")
4783- self.assertEquals(Class2.prop2.table, Class2)
4784+ self.assertEqual(Class1.prop1.name, "prop1")
4785+ self.assertEqual(Class1.prop1.table, Class1)
4786+ self.assertEqual(Class2.prop2.name, "prop2")
4787+ self.assertEqual(Class2.prop2.table, Class2)
4788
4789
4790 class PropertyKindsTest(TestHelper):
4791@@ -340,17 +340,17 @@
4792
4793 self.assertTrue(isinstance(self.column1, Column))
4794 self.assertTrue(isinstance(self.column2, Column))
4795- self.assertEquals(self.column1.name, "column1")
4796- self.assertEquals(self.column1.table, self.SubClass)
4797- self.assertEquals(self.column2.name, "prop2")
4798- self.assertEquals(self.column2.table, self.SubClass)
4799+ self.assertEqual(self.column1.name, "column1")
4800+ self.assertEqual(self.column1.table, self.SubClass)
4801+ self.assertEqual(self.column2.name, "prop2")
4802+ self.assertEqual(self.column2.table, self.SubClass)
4803 self.assertTrue(isinstance(self.variable1, BoolVariable))
4804 self.assertTrue(isinstance(self.variable2, BoolVariable))
4805
4806- self.assertEquals(self.obj.prop1, True)
4807+ self.assertEqual(self.obj.prop1, True)
4808 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4809 self.obj.prop2 = None
4810- self.assertEquals(self.obj.prop2, None)
4811+ self.assertEqual(self.obj.prop2, None)
4812
4813 self.obj.prop1 = 1
4814 self.assertTrue(self.obj.prop1 is True)
4815@@ -362,39 +362,39 @@
4816
4817 self.assertTrue(isinstance(self.column1, Column))
4818 self.assertTrue(isinstance(self.column2, Column))
4819- self.assertEquals(self.column1.name, "column1")
4820- self.assertEquals(self.column1.table, self.SubClass)
4821- self.assertEquals(self.column2.name, "prop2")
4822- self.assertEquals(self.column2.table, self.SubClass)
4823+ self.assertEqual(self.column1.name, "column1")
4824+ self.assertEqual(self.column1.table, self.SubClass)
4825+ self.assertEqual(self.column2.name, "prop2")
4826+ self.assertEqual(self.column2.table, self.SubClass)
4827 self.assertTrue(isinstance(self.variable1, IntVariable))
4828 self.assertTrue(isinstance(self.variable2, IntVariable))
4829
4830- self.assertEquals(self.obj.prop1, 50)
4831+ self.assertEqual(self.obj.prop1, 50)
4832 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4833 self.obj.prop2 = None
4834- self.assertEquals(self.obj.prop2, None)
4835+ self.assertEqual(self.obj.prop2, None)
4836
4837 self.obj.prop1 = False
4838- self.assertEquals(self.obj.prop1, 0)
4839+ self.assertEqual(self.obj.prop1, 0)
4840 self.obj.prop1 = True
4841- self.assertEquals(self.obj.prop1, 1)
4842+ self.assertEqual(self.obj.prop1, 1)
4843
4844 def test_float(self):
4845 self.setup(Float, default=50.5, allow_none=False)
4846
4847 self.assertTrue(isinstance(self.column1, Column))
4848 self.assertTrue(isinstance(self.column2, Column))
4849- self.assertEquals(self.column1.name, "column1")
4850- self.assertEquals(self.column1.table, self.SubClass)
4851- self.assertEquals(self.column2.name, "prop2")
4852- self.assertEquals(self.column2.table, self.SubClass)
4853+ self.assertEqual(self.column1.name, "column1")
4854+ self.assertEqual(self.column1.table, self.SubClass)
4855+ self.assertEqual(self.column2.name, "prop2")
4856+ self.assertEqual(self.column2.table, self.SubClass)
4857 self.assertTrue(isinstance(self.variable1, FloatVariable))
4858 self.assertTrue(isinstance(self.variable2, FloatVariable))
4859
4860- self.assertEquals(self.obj.prop1, 50.5)
4861+ self.assertEqual(self.obj.prop1, 50.5)
4862 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4863 self.obj.prop2 = None
4864- self.assertEquals(self.obj.prop2, None)
4865+ self.assertEqual(self.obj.prop2, None)
4866
4867 self.obj.prop1 = 1
4868 self.assertTrue(isinstance(self.obj.prop1, float))
4869@@ -404,17 +404,17 @@
4870
4871 self.assertTrue(isinstance(self.column1, Column))
4872 self.assertTrue(isinstance(self.column2, Column))
4873- self.assertEquals(self.column1.name, "column1")
4874- self.assertEquals(self.column1.table, self.SubClass)
4875- self.assertEquals(self.column2.name, "prop2")
4876- self.assertEquals(self.column2.table, self.SubClass)
4877+ self.assertEqual(self.column1.name, "column1")
4878+ self.assertEqual(self.column1.table, self.SubClass)
4879+ self.assertEqual(self.column2.name, "prop2")
4880+ self.assertEqual(self.column2.table, self.SubClass)
4881 self.assertTrue(isinstance(self.variable1, DecimalVariable))
4882 self.assertTrue(isinstance(self.variable2, DecimalVariable))
4883
4884- self.assertEquals(self.obj.prop1, decimal("50.5"))
4885+ self.assertEqual(self.obj.prop1, decimal("50.5"))
4886 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4887 self.obj.prop2 = None
4888- self.assertEquals(self.obj.prop2, None)
4889+ self.assertEqual(self.obj.prop2, None)
4890
4891 self.obj.prop1 = 1
4892 self.assertTrue(isinstance(self.obj.prop1, decimal))
4893@@ -424,17 +424,17 @@
4894
4895 self.assertTrue(isinstance(self.column1, Column))
4896 self.assertTrue(isinstance(self.column2, Column))
4897- self.assertEquals(self.column1.name, "column1")
4898- self.assertEquals(self.column1.table, self.SubClass)
4899- self.assertEquals(self.column2.name, "prop2")
4900- self.assertEquals(self.column2.table, self.SubClass)
4901+ self.assertEqual(self.column1.name, "column1")
4902+ self.assertEqual(self.column1.table, self.SubClass)
4903+ self.assertEqual(self.column2.name, "prop2")
4904+ self.assertEqual(self.column2.table, self.SubClass)
4905 self.assertTrue(isinstance(self.variable1, RawStrVariable))
4906 self.assertTrue(isinstance(self.variable2, RawStrVariable))
4907
4908- self.assertEquals(self.obj.prop1, b"def")
4909+ self.assertEqual(self.obj.prop1, b"def")
4910 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4911 self.obj.prop2 = None
4912- self.assertEquals(self.obj.prop2, None)
4913+ self.assertEqual(self.obj.prop2, None)
4914
4915 self.assertRaises(TypeError, setattr, self.obj, "prop1", u"unicode")
4916
4917@@ -443,17 +443,17 @@
4918
4919 self.assertTrue(isinstance(self.column1, Column))
4920 self.assertTrue(isinstance(self.column2, Column))
4921- self.assertEquals(self.column1.name, "column1")
4922- self.assertEquals(self.column1.table, self.SubClass)
4923- self.assertEquals(self.column2.name, "prop2")
4924- self.assertEquals(self.column2.table, self.SubClass)
4925+ self.assertEqual(self.column1.name, "column1")
4926+ self.assertEqual(self.column1.table, self.SubClass)
4927+ self.assertEqual(self.column2.name, "prop2")
4928+ self.assertEqual(self.column2.table, self.SubClass)
4929 self.assertTrue(isinstance(self.variable1, UnicodeVariable))
4930 self.assertTrue(isinstance(self.variable2, UnicodeVariable))
4931
4932- self.assertEquals(self.obj.prop1, u"def")
4933+ self.assertEqual(self.obj.prop1, u"def")
4934 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4935 self.obj.prop2 = None
4936- self.assertEquals(self.obj.prop2, None)
4937+ self.assertEqual(self.obj.prop2, None)
4938
4939 self.assertRaises(TypeError, setattr, self.obj, "prop1", b"str")
4940
4941@@ -462,22 +462,22 @@
4942
4943 self.assertTrue(isinstance(self.column1, Column))
4944 self.assertTrue(isinstance(self.column2, Column))
4945- self.assertEquals(self.column1.name, "column1")
4946- self.assertEquals(self.column1.table, self.SubClass)
4947- self.assertEquals(self.column2.name, "prop2")
4948- self.assertEquals(self.column2.table, self.SubClass)
4949+ self.assertEqual(self.column1.name, "column1")
4950+ self.assertEqual(self.column1.table, self.SubClass)
4951+ self.assertEqual(self.column2.name, "prop2")
4952+ self.assertEqual(self.column2.table, self.SubClass)
4953 self.assertTrue(isinstance(self.variable1, DateTimeVariable))
4954 self.assertTrue(isinstance(self.variable2, DateTimeVariable))
4955
4956- self.assertEquals(self.obj.prop1, datetime.utcfromtimestamp(0))
4957+ self.assertEqual(self.obj.prop1, datetime.utcfromtimestamp(0))
4958 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4959 self.obj.prop2 = None
4960- self.assertEquals(self.obj.prop2, None)
4961+ self.assertEqual(self.obj.prop2, None)
4962
4963 self.obj.prop1 = 0.0
4964- self.assertEquals(self.obj.prop1, datetime.utcfromtimestamp(0))
4965+ self.assertEqual(self.obj.prop1, datetime.utcfromtimestamp(0))
4966 self.obj.prop1 = datetime(2006, 1, 1, 12, 34)
4967- self.assertEquals(self.obj.prop1, datetime(2006, 1, 1, 12, 34))
4968+ self.assertEqual(self.obj.prop1, datetime(2006, 1, 1, 12, 34))
4969
4970 self.assertRaises(TypeError, setattr, self.obj, "prop1", object())
4971
4972@@ -486,22 +486,22 @@
4973
4974 self.assertTrue(isinstance(self.column1, Column))
4975 self.assertTrue(isinstance(self.column2, Column))
4976- self.assertEquals(self.column1.name, "column1")
4977- self.assertEquals(self.column1.table, self.SubClass)
4978- self.assertEquals(self.column2.name, "prop2")
4979- self.assertEquals(self.column2.table, self.SubClass)
4980+ self.assertEqual(self.column1.name, "column1")
4981+ self.assertEqual(self.column1.table, self.SubClass)
4982+ self.assertEqual(self.column2.name, "prop2")
4983+ self.assertEqual(self.column2.table, self.SubClass)
4984 self.assertTrue(isinstance(self.variable1, DateVariable))
4985 self.assertTrue(isinstance(self.variable2, DateVariable))
4986
4987- self.assertEquals(self.obj.prop1, date(2006, 1, 1))
4988+ self.assertEqual(self.obj.prop1, date(2006, 1, 1))
4989 self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
4990 self.obj.prop2 = None
4991- self.assertEquals(self.obj.prop2, None)
4992+ self.assertEqual(self.obj.prop2, None)
4993
4994 self.obj.prop1 = datetime(2006, 1, 1, 12, 34, 56)
4995- self.assertEquals(self.obj.prop1, date(2006, 1, 1))
4996+ self.assertEqual(self.obj.prop1, date(2006, 1, 1))
4997 self.obj.prop1 = date(2006, 1, 1)
4998- self.assertEquals(self.obj.prop1, date(2006, 1, 1))
4999+ self.assertEqual(self.obj.prop1, date(2006, 1, 1))
5000
The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to status/vote changes: