def test_bulk_archive_rows_with_user(session, row_dicts, rows_to_archive,
row_versions):
user_id = "test_user"
ArchiveTable.bulk_archive_rows(rows_to_archive, session, user_id=user_id)
for row, version in zip(row_dicts, row_versions):
verify_row(row, version, session)
verify_archive(row, version, session)
def test_insert_new_product_with_json(session, p1_dict, p1):
json_dict = {"foo": "bar"}
p1.jsonb_col = json_dict.copy()
version = add_and_return_version(p1, session)
expected = dict(jsonb_col=json_dict, **p1_dict)
verify_row(expected, version, session)
verify_archive(expected, version, session)
def test_insert_new_product(session, p1_dict, p1):
assert savage.is_initialized()
p1.col4 = 11
version = add_and_return_version(p1, session)
expected = dict(other_name=11, **p1_dict)
verify_row(expected, version, session)
verify_archive(expected, version, session)
def test_multi_insert(session, user_table, p1_dict, p1, p2_dict, p2, p3_dict,
p3):
versions = add_multiple_and_return_versions([p1, p2, p3], session)
# Assert the columns match
expected = [p1_dict, p2_dict, p3_dict]
for row, version in zip(expected, versions):
verify_row(row, version, session, user_table=user_table)
verify_archive(row, version, session, user_table=user_table)
def test_update(session, user_table, p1_dict, p1):
add_and_return_version(p1, session)
p1.col1 = "bar"
p1.col2 = 300
version_2 = add_and_return_version(p1, session)
version_2_dict = dict(p1_dict, col1="bar", col2=300)
verify_row(version_2_dict, version_2, session, user_table=user_table)
verify_archive(version_2_dict, version_2, session, user_table=user_table)
def test_product_update(session, p1_dict, p1):
version = add_and_return_version(p1, session)
p1.col1 = "new"
p1.col2 = -1
updated_version = add_and_return_version(p1, session)
updated_dict = dict(p1_dict, col1="new", col2=-1)
verify_row(updated_dict, updated_version, session)
verify_archive(p1_dict, version, session)
verify_archive(updated_dict, updated_version, session)
def test_product_update_with_json(session, p1_dict, p1):
version = add_and_return_version(p1, session)
json_dict = {"foo": "bar"}
p1.jsonb_col = json_dict.copy()
updated_version = add_and_return_version(p1, session)
updated_dict = dict(p1_dict, jsonb_col=json_dict)
verify_row(updated_dict, updated_version, session)
verify_archive(p1_dict, version, session)
verify_archive(updated_dict, updated_version, session)
def test_product_update_with_user(session, p1_dict, p1):
p1.updated_by("test_user1")
version = add_and_return_version(p1, session)
p1.col1 = "new"
p1.col2 = -1
p1.updated_by("test_user2")
updated_version = add_and_return_version(p1, session)
updated_dict = dict(p1_dict, col1="new", col2=-1)
verify_row(updated_dict, updated_version, session)
verify_archive(p1_dict, version, session, user="******")
verify_archive(updated_dict, updated_version, session, user="******")
def test_update_version_column(session, user_table, p1_dict, p1):
version = add_and_return_version(p1, session)
verify_row(p1_dict, version, session, user_table=user_table)
verify_archive(p1_dict, version, session, user_table=user_table)
p1.product_id_1 = 12
version_2 = add_and_return_version(p1, session)
version_2_dict = dict(p1_dict, product_id_1=12)
verify_row(version_2_dict, version_2, session, user_table=user_table)
verify_archive(version_2_dict, version_2, session, user_table=user_table)
verify_archive(p1_dict,
version_2,
session,
deleted=True,
user_table=user_table)
def test_insert_after_delete(session, user_table, p1_dict, p1):
version = add_and_return_version(p1, session)
session.delete(p1)
session.commit()
p_new = dict(
p1_dict,
**dict(product_id_1=11, product_id_2="foo", col1="new", col2=101))
q = user_table(**p_new)
new_version = add_and_return_version(q, session)
verify_row(p_new, new_version, session, user_table=user_table)
verify_archive(p1_dict, version, session, user_table=user_table)
deleted_version = verify_deleted_archive(p1_dict, p1, version, session,
user_table)
verify_archive(p_new, new_version, session, user_table=user_table)
assert new_version > deleted_version
def test_insert_after_delete(session, user_table, p1_dict, p1):
"""Inserting a row that has already been deleted should version where it left off
(not at 0).
"""
version = add_and_return_version(p1, session)
session.delete(p1)
session.commit()
p_new = dict(p1_dict, **{"col1": "changed", "col2": 139})
q = user_table(**p_new)
new_version = add_and_return_version(q, session)
verify_row(p_new, new_version, session)
verify_archive(p1_dict, version, session)
deleted_version = verify_deleted_archive(p1_dict, p1, version, session,
user_table)
verify_archive(p_new, new_version, session)
assert new_version > deleted_version
def test_multiple_product_updates(session, p1_dict, p1):
"""
Update a product multiple times and ensure each one gets
correctly versioned.
"""
version = add_and_return_version(p1, session)
p1.col1 = "new"
p1.col2 = -1
version_2 = add_and_return_version(p1, session)
version_2_dict = dict(p1_dict, col1="new", col2=-1)
p1.col1 = "third change"
p1.col2 = 139
p1.col3 = False
version_3 = add_and_return_version(p1, session)
version_3_dict = dict(p1_dict, col1="third change", col2=139, col3=False)
verify_row(version_3_dict, version_3, session)
verify_archive(p1_dict, version, session)
verify_archive(version_2_dict, version_2, session)
verify_archive(version_3_dict, version_3, session)
def test_concurrent_product_updates(engine_1, engine_2, user_table, p1_dict,
p1):
"""
Assert that if two separate sessions try to update a product row,
one succeeds and the other fails.
"""
session_1 = Session(bind=engine_1)
session_2 = Session(bind=engine_2)
try:
# Add the initial row and flush it to the table
version = add_and_return_version(p1, session_1)
# Update 1 in session
p1.col1 = "changed col 1"
session_1.add(p1)
# Update 2 in session 2
p2 = session_2.query(user_table).first()
p2.col2 = 1245600
# this flush should succeed
version_2 = add_and_return_version(p2, session_2)
# this flush should fail
with pytest.raises(StaleDataError):
session_1.commit()
final = dict(p1_dict, **dict(col2=1245600))
verify_row(final, version_2, session_2)
verify_archive(p1_dict, version, session_2)
verify_archive(final, version_2, session_2)
finally:
# Clean up
session_1.close()
session_2.close()
for t in (user_table, user_table.ArchiveTable):
engine_1.execute("delete from {}".format(t.__tablename__))
def test_insert(session, user_table, p1_dict, p1):
version = add_and_return_version(p1, session)
verify_row(p1_dict, version, session, user_table=user_table)
verify_archive(p1_dict, version, session, user_table=user_table)
def test_bulk_archive_rows(session, row_dicts, rows_to_archive, row_versions):
ArchiveTable.bulk_archive_rows(rows_to_archive, session)
for row, version in zip(row_dicts, row_versions):
verify_row(row, version, session)
verify_archive(row, version, session)
def test_insert_new_product_with_user(session, p1_dict, p1):
p1.updated_by("test_user")
version = add_and_return_version(p1, session)
verify_row(p1_dict, version, session)
verify_archive(p1_dict, version, session, user="******")
