8000 Using pytest [assertEqual] · postgrespro/testgres@89784a8 · GitHub
[go: up one dir, main page]
Skip to content

Commit 89784a8

Browse files
dmitry-lipetskdmitry-lipetsk
committed
Using pytest [assertEqual]
1 parent e2e7e8b commit 89784a8

File tree

2 files changed

+117
-117
lines changed

2 files changed

+117
-117
lines changed

‎tests/test_simple.py

Lines changed: 68 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -210,10 +210,10 @@ def test_restart(self):
210210

211211
# restart, ok
212212
res = node.execute('select 1')
213-
self.assertEqual(res, [(1, )])
213+
assert (res == [(1, )])
214214
node.restart()
215215
res = node.execute('select 2')
216-
self.assertEqual(res, [(2, )])
216+
assert (res == [(2, )])
217217

218218
# restart, fail
219219
with pytest.raises(expected_exception=StartNodeException):
@@ -233,7 +233,7 @@ def test_reload(self):
233233

234234
# check new value
235235
cmm_new = node.execute('show client_min_messages')
236-
self.assertEqual('debug1', cmm_new[0][0].lower())
236+
assert ('debug1' == cmm_new[0][0].lower())
237237
self.assertNotEqual(cmm_old, cmm_new)
238238

239239
def test_pg_ctl(self):
@@ -250,62 +250,62 @@ def test_status(self):
250250

251251
# check statuses after each operation
252252
with get_new_node() as node:
253-
self.assertEqual(node.pid, 0)
254-
self.assertEqual(node.status(), NodeStatus.Uninitialized)
253+
assert (node.pid == 0)
254+
assert (node.status() == NodeStatus.Uninitialized)
255255

256256
node.init()
257257

258-
self.assertEqual(node.pid, 0)
259-
self.assertEqual(node.status(), NodeStatus.Stopped)
258+
assert (node.pid == 0)
259+
assert (node.status() == NodeStatus.Stopped)
260260

261261
node.start()
262262

263263
self.assertNotEqual(node.pid, 0)
264-
self.assertEqual(node.status(), NodeStatus.Running)
264+
assert (node.status() == NodeStatus.Running)
265265

266266
node.stop()
267267

268-
self.assertEqual(node.pid, 0)
269-
self.assertEqual(node.status(), NodeStatus.Stopped)
268+
assert (node.pid == 0)
269+
assert (node.status() == NodeStatus.Stopped)
270270

271271
node.cleanup()
272272

273-
self.assertEqual(node.pid, 0)
274-
self.assertEqual(node.status(), NodeStatus.Uninitialized)
273+
assert (node.pid == 0)
274+
assert (node.status() == NodeStatus.Uninitialized)
275275

276276
def test_psql(self):
277277
with get_new_node().init().start() as node:
278278

279279
# check returned values (1 arg)
280280
res = node.psql('select 1')
281-
self.assertEqual(rm_carriage_returns(res), (0, b'1\n', b''))
281+
assert (rm_carriage_returns(res) == (0, b'1\n', b''))
282282

283283
# check returned values (2 args)
284284
res = node.psql('postgres', 'select 2')
285-
self.assertEqual(rm_carriage_returns(res), (0, b'2\n', b''))
285+
assert (rm_carriage_returns(res) == (0, b'2\n', b''))
286286

287287
# check returned values (named)
288288
res = node.psql(query='select 3', dbname='postgres')
289-
self.assertEqual(rm_carriage_returns(res), (0, b'3\n', b''))
289+
assert (rm_carriage_returns(res) == (0, b'3\n', b''))
290290

291291
# check returned values (1 arg)
292292
res = node.safe_psql('select 4')
293-
self.assertEqual(rm_carriage_returns(res), b'4\n')
293+
assert (rm_carriage_returns(res) == b'4\n')
294294

295295
# check returned values (2 args)
296296
res = node.safe_psql('postgres', 'select 5')
297-
self.assertEqual(rm_carriage_returns(res), b'5\n')
297+
assert (rm_carriage_returns(res) == b'5\n')
298298

299299
# check returned values (named)
300300
res = node.safe_psql(query='select 6', dbname='postgres')
301-
self.assertEqual(rm_carriage_returns(res), b'6\n')
301+
assert (rm_carriage_returns(res) == b'6\n')
302302

303303
# check feeding input
304304
node.safe_psql('create table horns (w int)')
305305
node.safe_psql('copy horns from stdin (format csv)',
306306
input=b"1\n2\n3\n\\.\n")
307307
_sum = node.safe_psql('select sum(w) from horns')
308-
self.assertEqual(rm_carriage_returns(_sum), b'6\n')
308+
assert (rm_carriage_returns(_sum) == b'6\n')
309309

310310
# check psql's default args, fails
311311
with pytest.raises(expected_exception=QueryException):
@@ -333,7 +333,7 @@ def test_safe_psql__expect_error(self):
333333

334334
# ---------
335335
res = node.safe_psql("select 1;", expect_error=False)
336-
self.assertEqual(rm_carriage_returns(res), b'1\n')
336+
assert (rm_carriage_returns(res) == b'1\n')
337337

338338
def test_transactions(self):
339339
with get_new_node().init().start() as node:
@@ -475,11 +475,11 @@ def test_synchronous_replication(self):
475475
standby2.start()
476476

477477
# check formatting
478-
self.assertEqual(
479-
'1 ("{}", "{}")'.format(standby1.name, standby2.name),
478+
assert (
479+
'1 ("{}", "{}")'.format(standby1.name, standby2.name) ==
480480
str(First(1, (standby1, standby2)))) # yapf: disable
481-
self.assertEqual(
482-
'ANY 1 ("{}", "{}")'.format(standby1.name, standby2.name),
481+
assert (
482+
'ANY 1 ("{}", "{}")'.format(standby1.name, standby2.name) ==
483483
str(Any(1, (standby1, standby2)))) # yapf: disable
484484

485485
# set synchronous_standby_names
@@ -498,7 +498,7 @@ def test_synchronous_replication(self):
498498
master.safe_psql(
499499
'insert into abc select generate_series(1, 1000000)')
500500
res = standby1.safe_psql('select count(*) from abc')
501-
self.assertEqual(rm_carriage_returns(res), b'1000000\n')
501+
assert (rm_carriage_returns(res) == b'1000000\n')
502502

503503
# @unittest.skipUnless(pg_version_ge('10'), 'requires 10+')
504504
def test_logical_replication(self):
@@ -638,7 +638,7 @@ def test_promotion(self):
638638
# make standby becomes writable master
639639
replica.safe_psql('insert into abc values (1)')
640640
res = replica.safe_psql('select * from abc')
641-
self.assertEqual(rm_carriage_returns(res), b'1\n')
641+
assert (rm_carriage_returns(res) == b'1\n')
642642

643643
def test_dump(self):
644644
query_create = 'create table test as select generate_series(1, 2) as val'
@@ -664,7 +664,7 @@ def test_users(self):
664664
node.psql('create role test_user login')
665665
value = node.safe_psql('select 1', username='test_user')
666666
value = rm_carriage_returns(value)
667-
self.assertEqual(value, b'1\n')
667+
assert (value == b'1\n')
668668

669669
def test_poll_query_until(self):
670670
with get_new_node() as node:
@@ -804,7 +804,7 @@ def test_pg_config(self):
804804
# check same instances
805805
a = get_pg_config()
806806
b = get_pg_config()
807-
self.assertEqual(id(a), id(b))
807+
assert (id(a) == id(b))
808808

809809
# save right before config change
810810
c1 = get_pg_config()
@@ -839,7 +839,7 @@ def test_config_stack(self):
839839
d2 = 'dummy_def'
840840

841841
with scoped_config(cached_initdb_dir=d1) as c1:
842-
self.assertEqual(c1.cached_initdb_dir, d1)
842+
assert (c1.cached_initdb_dir == d1)
843843

844844
with scoped_config(cached_initdb_dir=d2) as c2:
845845
stack_size = len(testgres.config.config_stack)
@@ -849,12 +849,12 @@ def test_config_stack(self):
849849
with scoped_config(dummy=True):
850850
pass
851851

852-
self.assertEqual(c2.cached_initdb_dir, d2)
853-
self.assertEqual(len(testgres.config.config_stack), stack_size)
852+
assert (c2.cached_initdb_dir == d2)
853+
assert (len(testgres.config.config_stack) == stack_size)
854854

855-
self.assertEqual(c1.cached_initdb_dir, d1)
855+
assert (c1.cached_initdb_dir == d1)
856856

857-
self.assertEqual(TestgresConfig.cached_initdb_dir, d0)
857+
assert (TestgresConfig.cached_initdb_dir == d0)
858858

859859
def test_unix_sockets(self):
860860
with get_new_node() as node:
@@ -897,13 +897,13 @@ def test_file_tail(self):
897897

898898
f.seek(0)
899899
lines = file_tail(f, 3)
900-
self.assertEqual(lines[0], s1)
901-
self.assertEqual(lines[1], s2)
902-
self.assertEqual(lines[2], s3)
900+
assert (lines[0] == s1)
901+
assert (lines[1] == s2)
902+
assert (lines[2] == s3)
903903

904904
f.seek(0)
905905
lines = file_tail(f, 1)
906-
self.assertEqual(lines[0], s3)
906+
assert (lines[0] == s3)
907907

908908
def test_isolation_levels(self):
909909
with get_new_node().init().start() as node:
@@ -926,19 +926,19 @@ def test_isolation_levels(self):
926926

927927
def test_ports_management(self):
928928
# check that no ports have been bound yet
929-
self.assertEqual(len(bound_ports), 0)
929+
assert (len(bound_ports) == 0)
930930

931931
with get_new_node() as node:
932932
# check that we've just bound a port
933-
self.assertEqual(len(bound_ports), 1)
933+
assert (len(bound_ports) == 1)
934934

935935
# check that bound_ports contains our port
936936
port_1 = list(bound_ports)[0]
937937
port_2 = node.port
938-
self.assertEqual(port_1, port_2)
938+
assert (port_1 == port_2)
939939

940940
# check that port has been freed successfully
941-
self.assertEqual(len(bound_ports), 0)
941+
assert (len(bound_ports) == 0)
942942

943943
def test_exceptions(self):
944944
str(StartNodeException('msg', [('file', 'lines')]))
@@ -972,7 +972,7 @@ def test_version_management(self):
972972
with get_new_node() as node:
973973
assert (isinstance(version, six.string_types))
974974
assert (isinstance(node.version, PgVer))
975-
self.assertEqual(node.version, PgVer(version))
975+
assert (node.version == PgVer(version))
976976

977977
def test_child_pids(self):
978978
master_processes = [
@@ -1018,10 +1018,10 @@ def test_child_pids(self):
10181018
self.assertIn(ptype, replica_pids)
10191019

10201020
# there should be exactly 1 source walsender for replica
1021-
self.assertEqual(len(master_pids[ProcessType.WalSender]), 1)
1021+
assert (len(master_pids[ProcessType.WalSender]) == 1)
10221022
pid1 = master_pids[ProcessType.WalSender][0]
10231023
pid2 = replica.source_walsender.pid
1024-
self.assertEqual(pid1, pid2)
1024+
assert (pid1 == pid2)
10251025

10261026
replica.stop()
10271027

@@ -1034,7 +1034,7 @@ def test_child_process_dies(self):
10341034
cmd = ["timeout", "60"] if os.name == 'nt' else ["sleep", "60"]
10351035

10361036
with subprocess.Popen(cmd, shell=True) as process: # shell=True might be needed on Windows
1037-
self.assertEqual(process.poll(), None)
1037+
assert (process.poll() == None)
10381038
# collect list of processes currently running
10391039
children = psutil.Process(os.getpid()).children()
10401040
# kill a process, so received children dictionary becomes invalid
@@ -1070,13 +1070,13 @@ def test_the_same_port(self):
10701070
with get_new_node() as node:
10711071
node.init().start()
10721072
assert (node._should_free_port)
1073-
self.assertEqual(type(node.port), int)
1073+
assert (type(node.port) == int)
10741074
node_port_copy = node.port
1075-
self.assertEqual(rm_carriage_returns(node.safe_psql("SELECT 1;")), b'1\n')
1075+
assert (rm_carriage_returns(node.safe_psql("SELECT 1;")) == b'1\n')
10761076

10771077
with get_new_node(port=node.port) as node2:
1078-
self.assertEqual(type(node2.port), int)
1079-
self.assertEqual(node2.port, node.port)
1078+
assert (type(node2.port) == int)
1079+
assert (node2.port == node.port)
10801080
assert not (node2._should_free_port)
10811081

10821082
with pytest.raises(
@@ -1086,9 +1086,9 @@ def test_the_same_port(self):
10861086
node2.init().start()
10871087

10881088
# node is still working
1089-
self.assertEqual(node.port, node_port_copy)
1089+
assert (node.port == node_port_copy)
10901090
assert (node._should_free_port)
1091-
self.assertEqual(rm_carriage_returns(node.safe_psql("SELECT 3;")), b'3\n')
1091+
assert (rm_carriage_returns(node.safe_psql("SELECT 3;")) == b'3\n')
10921092

10931093
class tagPortManagerProxy:
10941094
sm_prev_testgres_reserve_port = None
@@ -1194,30 +1194,30 @@ def test_port_rereserve_during_node_start(self):
11941194
with get_new_node() as node1:
11951195
node1.init().start()
11961196
assert (node1._should_free_port)
1197-
self.assertEqual(type(node1.port), int) # noqa: E721
1197+
assert (type(node1.port) == int) # noqa: E721
11981198
node1_port_copy = node1.port
1199-
self.assertEqual(rm_carriage_returns(node1.safe_psql("SELECT 1;")), b'1\n')
1199+
assert (rm_carriage_returns(node1.safe_psql("SELECT 1;")) == b'1\n')
12001200

12011201
with __class__.tagPortManagerProxy(node1.port, C_COUNT_OF_BAD_PORT_USAGE):
12021202
assert __class__.tagPortManagerProxy.sm_DummyPortNumber == node1.port
12031203
with get_new_node() as node2:
12041204
assert (node2._should_free_port)
1205-
self.assertEqual(node2.port, node1.port)
1205+
assert (node2.port == node1.port)
12061206

12071207
node2.init().start()
12081208

12091209
self.assertNotEqual(node2.port, node1.port)
12101210
assert (node2._should_free_port)
1211-
self.assertEqual(__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage, 0)
1212-
self.assertEqual(__class__.tagPortManagerProxy.sm_DummyPortTotalUsage, C_COUNT_OF_BAD_PORT_USAGE)
1211+
assert (__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage == 0)
1212+
assert (__class__.tagPortManagerProxy.sm_DummyPortTotalUsage == C_COUNT_OF_BAD_PORT_USAGE)
12131213
assert (node2.is_started)
12141214

1215-
self.assertEqual(rm_carriage_returns(node2.safe_psql("SELECT 2;")), b'2\n')
1215+
assert (rm_carriage_returns(node2.safe_psql("SELECT 2;")) == b'2\n')
12161216

12171217
# node1 is still working
1218-
self.assertEqual(node1.port, node1_port_copy)
1218+
assert (node1.port == node1_port_copy)
12191219
assert (node1._should_free_port)
1220-
self.assertEqual(rm_carriage_returns(node1.safe_psql("SELECT 3;")), b'3\n')
1220+
assert (rm_carriage_returns(node1.safe_psql("SELECT 3;")) == b'3\n')
12211221

12221222
def test_port_conflict(self):
12231223
assert testgres.PostgresNode._C_MAX_START_ATEMPTS > 1
@@ -1227,35 +1227,35 @@ def test_port_conflict(self):
12271227
with get_new_node() as node1:
12281228
node1.init().start()
12291229
assert (node1._should_free_port)
1230-
self.assertEqual(type(node1.port), int) # noqa: E721
1230+
assert (type(node1.port) == int) # noqa: E721
12311231
node1_port_copy = node1.port
1232-
self.assertEqual(rm_carriage_returns(node1.safe_psql("SELECT 1;")), b'1\n')
1232+
assert (rm_carriage_returns(node1.safe_psql("SELECT 1;")) == b'1\n')
12331233

12341234
with __class__.tagPortManagerProxy(node1.port, C_COUNT_OF_BAD_PORT_USAGE):
12351235
assert __class__.tagPortManagerProxy.sm_DummyPortNumber == node1.port
12361236
with get_new_node() as node2:
12371237
assert (node2._should_free_port)
1238-
self.assertEqual(node2.port, node1.port)
1238+
assert (node2.port == node1.port)
12391239

12401240
with pytest.raises(
12411241
expected_exception=StartNodeException,
12421242
match=re.escape("Cannot start node after multiple attempts")
12431243
):
12441244
node2.init().start()
12451245

1246-
self.assertEqual(node2.port, node1.port)
1246+
assert (node2.port == node1.port)
12471247
assert (node2._should_free_port)
1248-
self.assertEqual(__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage, 1)
1249-
self.assertEqual(__class__.tagPortManagerProxy.sm_DummyPortTotalUsage, C_COUNT_OF_BAD_PORT_USAGE)
1248+
assert (__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage == 1)
1249+
assert (__class__.tagPortManagerProxy.sm_DummyPortTotalUsage == C_COUNT_OF_BAD_PORT_USAGE)
12501250
assert not (node2.is_started)
12511251

12521252
# node2 must release our dummyPort (node1.port)
1253-
self.assertEqual(__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage, 0)
1253+
assert (__class__.tagPortManagerProxy.sm_DummyPortCurrentUsage == 0)
12541254

12551255
# node1 is still working
1256-
self.assertEqual(node1.port, node1_port_copy)
1256+
assert (node1.port == node1_port_copy)
12571257
assert (node1._should_free_port)
1258-
self.assertEqual(rm_carriage_returns(node1.safe_psql("SELECT 3;")), b'3\n')
1258+
assert (rm_carriage_returns(node1.safe_psql("SELECT 3;")) == b'3\n')
12591259

12601260
def test_simple_with_bin_dir(self):
12611261
with get_new_node() as node:

0 commit comments

Comments
 (0)
0