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="******")