mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-06 04:52:55 +00:00
3aca717f3d
Merge batch_others and batch_pg_regress. The original idea was to split all the python tests into multiple "batches" and run each batch in parallel as a separate CI job. However, the batch_pg_regress batch was pretty short compared to all the tests in batch_others. We could split batch_others into multiple batches, but it actually seems better to just treat them as one big pool of tests and use pytest's handle the parallelism on its own. If we need to split them across multiple nodes in the future, we could use pytest-shard or something else, instead of managing the batches ourselves. Merge test_neon_regress.py, test_pg_regress.py and test_isolation.py into one file, test_pg_regress.py. Seems more clear to group all pg_regress-based tests into one file, now that they would all be in the same directory.
70 lines
2.3 KiB
Python
70 lines
2.3 KiB
Python
from fixtures.neon_fixtures import NeonEnvBuilder
|
|
|
|
|
|
# Test safekeeper sync and pageserver catch up
|
|
# while initial compute node is down and pageserver is lagging behind safekeepers.
|
|
# Ensure that basebackup after restart of all components is correct
|
|
# and new compute node contains all data.
|
|
def test_pageserver_catchup_while_compute_down(neon_env_builder: NeonEnvBuilder):
|
|
neon_env_builder.num_safekeepers = 3
|
|
env = neon_env_builder.init_start()
|
|
|
|
env.neon_cli.create_branch("test_pageserver_catchup_while_compute_down")
|
|
# Make shared_buffers large to ensure we won't query pageserver while it is down.
|
|
pg = env.postgres.create_start(
|
|
"test_pageserver_catchup_while_compute_down", config_lines=["shared_buffers=512MB"]
|
|
)
|
|
|
|
pg_conn = pg.connect()
|
|
cur = pg_conn.cursor()
|
|
|
|
# Create table, and insert some rows.
|
|
cur.execute("CREATE TABLE foo (t text)")
|
|
cur.execute(
|
|
"""
|
|
INSERT INTO foo
|
|
SELECT 'long string to consume some space' || g
|
|
FROM generate_series(1, 10000) g
|
|
"""
|
|
)
|
|
|
|
cur.execute("SELECT count(*) FROM foo")
|
|
assert cur.fetchone() == (10000,)
|
|
|
|
# Stop and restart pageserver. This is a more or less graceful shutdown, although
|
|
# the page server doesn't currently have a shutdown routine so there's no difference
|
|
# between stopping and crashing.
|
|
env.pageserver.stop()
|
|
|
|
# insert some more rows
|
|
# since pageserver is shut down, these will be only on safekeepers
|
|
cur.execute(
|
|
"""
|
|
INSERT INTO foo
|
|
SELECT 'long string to consume some space' || g
|
|
FROM generate_series(1, 10000) g
|
|
"""
|
|
)
|
|
|
|
# stop safekeepers gracefully
|
|
env.safekeepers[0].stop()
|
|
env.safekeepers[1].stop()
|
|
env.safekeepers[2].stop()
|
|
|
|
# start everything again
|
|
# safekeepers must synchronize and pageserver must catch up
|
|
env.pageserver.start()
|
|
env.safekeepers[0].start()
|
|
env.safekeepers[1].start()
|
|
env.safekeepers[2].start()
|
|
|
|
# restart compute node
|
|
pg.stop_and_destroy().create_start("test_pageserver_catchup_while_compute_down")
|
|
|
|
# Ensure that basebackup went correct and pageserver returned all data
|
|
pg_conn = pg.connect()
|
|
cur = pg_conn.cursor()
|
|
|
|
cur.execute("SELECT count(*) FROM foo")
|
|
assert cur.fetchone() == (20000,)
|