def test_va_diff_new_column_and_del_column(self):
p = UserTable(**self.p1)
p._updated_by = '1'
self._add_and_test_version(p, 0)
print("111", p.__table__.c)
self.addTestNullableColumn()
p = self.session.query(UserTable).get(p.id)
print("222", p.__table__.c)
p.col1 = 'test'
p.test_column1 = 'tc1'
p._updated_by = '2'
self.session.commit()
res = UserTable.va_diff(self.session, va_id=p.va_id)
print("RESULT", res)
self.assertEqual(
res, {
'va_prev_version': 0,
'va_version': 1,
'prev_user_id': '1',
'user_id': '2',
'change': {
'col1': {
'this': 'test',
'prev': 'foobar'
},
'test_column1': {
'prev': None,
'this': 'tc1',
}
}
})
print("PASSED")
self.deleteTestNullableColumn()
print("DELETED")
p = self.session.query(UserTable).get(p.id)
print("P COLS", p.__table__.c)
p.col1 = 'test2'
p._updated_by = '1'
self.session.commit()
res = UserTable.va_diff(self.session, va_id=p.va_id)
print("ANOTHER RES", res)
self.assertEqual(
res, {
'va_prev_version': 1,
'va_version': 2,
'prev_user_id': '2',
'user_id': '1',
'change': {
'col1': {
'this': 'test2',
'prev': 'test'
},
'test_column1': {
'prev': 'tc1',
'this': None,
}
}
})
def test_va_diff_basic_va_version(self):
p = UserTable(**self.p1)
p._updated_by = '1'
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
p.col1 = 'test'
p._updated_by = '2'
self.session.commit()
log = self.session.query(ArchiveTable).get(p.va_id)
res = UserTable.va_diff(self.session, log.va_version)
self.assertEqual(
res, {
'va_prev_version': 0,
'va_version': 1,
'prev_user_id': '1',
'user_id': '2',
'change': {
'col1': {
'this': 'test',
'prev': 'foobar'
}
}
})
def test_va_list_by_pk_fail(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
p.col1 = 'test'
self.session.commit()
with self.assertRaises(LogIdentifyError):
UserTable.va_list_by_pk(self.session)
def test_va_diff_2parallel_history(self):
p1 = UserTable(**self.p1)
p2 = UserTable(**self.p2)
p1._updated_by = '1'
p2._updated_by = '1'
self._add_and_test_version(p1, 0)
self._add_and_test_version(p2, 0)
p1 = self.session.query(UserTable).get(p1.id)
p2 = self.session.query(UserTable).get(p2.id)
p1.col1 = 'test1'
p2.col1 = 'test2'
p1._updated_by = '2'
p2._updated_by = '2'
self.session.commit()
res_p1 = UserTable.va_diff(self.session, va_id=p1.va_id)
self.assertEqual(
res_p1, {
'va_prev_version': 0,
'va_version': 1,
'prev_user_id': '1',
'user_id': '2',
'change': {
'col1': {
'this': 'test1',
'prev': 'foobar'
}
}
})
res_p2 = UserTable.va_diff(self.session, va_id=p2.va_id)
self.assertEqual(
res_p2, {
'va_prev_version': 0,
'va_version': 1,
'prev_user_id': '1',
'user_id': '2',
'change': {
'col1': {
'this': 'test2',
'prev': 'baz'
}
}
})
def setUp(self):
super(TestGetAPI, self).setUp()
self.p1_history, self.p2_history, self.p3_history = [], [], []
self.t1 = datetime.utcfromtimestamp(10)
p1 = UserTable(**self.p1)
p3 = UserTable(**self.p3)
with mock.patch('versionalchemy.models.datetime') as p:
p.now.return_value = self.t1
self.session.add_all([p1, p3])
self.session.flush()
self.p1_history.append(self._history(p1, self.t1, 0))
self.p3_history.append(self._history(p3, self.t1, 0))
self.t2 = datetime.utcfromtimestamp(20)
p1.col1 = 'change1'
p2 = UserTable(**self.p2)
with mock.patch('versionalchemy.models.datetime') as p:
p.now.return_value = self.t2
self.session.add_all([p1, p2])
self.session.flush()
self.p1_history.append(self._history(p1, self.t2, 1))
self.p2_history.append(self._history(p2, self.t2, 0))
self.t3 = datetime.utcfromtimestamp(30)
p1.col3 = False
p1.col1 = 'change2'
with mock.patch('versionalchemy.models.datetime') as p:
p.now.return_value = self.t3
self.session.add(p1)
self.session.flush()
self.p1_history.append(self._history(p1, self.t3, 2))
self.t4 = datetime.utcfromtimestamp(40)
p1.col2 = 15
p2.col2 = 12
with mock.patch('versionalchemy.models.datetime') as p:
p.now.return_value = self.t4
self.session.add_all([p1, p2])
self.session.flush()
self.p1_history.append(self._history(p1, self.t4, 3))
self.p2_history.append(self._history(p2, self.t4, 1))
def test_update_no_changes(self):
'''
Add an unchanged row and make sure the version does not get bumped.
'''
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p.col1 = self.p1['col1']
self.session.add(p)
self.session.commit()
self._verify_archive(self.p1, 0)
self.assertEqual(len(self.session.query(ArchiveTable).all()), 1)
def test_va_diff_all(self):
p = UserTable(**self.p1)
p._updated_by = '1'
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
p.col1 = 'test'
p._updated_by = '2'
self.session.commit()
res = UserTable.va_diff_all_by_pk(self.session,
product_id=p.product_id)
expected_result = [{
'va_prev_version': None,
'va_version': 0,
'prev_user_id': None,
'user_id': '1',
'change': {
'col1': {
'this': 'foobar',
'prev': None
},
'col2': {
'this': 10,
'prev': None
},
'col3': {
'prev': None,
'this': 1
},
'product_id': {
'prev': None,
'this': 10
},
'id': {
'this': 1,
'prev': None
}
}
}, {
'va_prev_version': 0,
'va_version': 1,
'prev_user_id': '1',
'user_id': '2',
'change': {
'col1': {
'this': 'test',
'prev': 'foobar'
}
}
}]
self.assertEqual(res, expected_result)
res = p.va_diff_all(self.session)
self.assertEqual(res, expected_result)
def setUp(self):
super(TestDeleteAPI, self).setUp()
p1 = UserTable(**self.p1)
p3 = UserTable(**self.p3)
self.session.add_all([p1, p3])
self.session.flush()
p1.col1 = 'change1'
p2 = UserTable(**self.p2)
self.session.add_all([p1, p2])
self.session.flush()
p1.col3 = False
p1.col1 = 'change2'
self.session.add(p1)
self.session.flush()
p1.col2 = 15
p2.col2 = 12
self.session.add_all([p1, p2])
self.session.flush()
def test_multiple_product_updates(self):
"""
Update a product multiple times and ensure each one gets
correctly versioned.
"""
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p.col1 = 'new'
p.col2 = -1
self._add_and_test_version(p, 1)
p.col1 = 'third change'
p.col2 = 139
p.col3 = False
self._add_and_test_version(p, 2)
self._verify_row(
dict(self.p1, **{
'col1': 'third change',
'col2': 139,
'col3': False,
}), 1)
self._verify_archive(self.p1, 0)
self._verify_archive(dict(self.p1, **{
'col1': 'new',
'col2': -1,
}), 1)
self._verify_archive(dict(
self.p1, **{
'col1': 'third change',
'col2': 139,
'col3': False,
}),
2,
log_id=p.va_id)
def test_product_update(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p.col1 = 'new'
p.col2 = -1
self._add_and_test_version(p, 1)
self._verify_row(dict(self.p1, **{'col1': 'new', 'col2': -1}), 1)
self._verify_archive(self.p1, 0)
self._verify_archive(dict(self.p1, **{
'col1': 'new',
'col2': -1,
}),
1,
log_id=p.va_id)
def test_restore_row_with_non_default_column(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
first_version = p.va_id
p.col1 = 'test'
self.session.commit()
p = self.session.query(UserTable).get(p.id)
self.assertEqual(p.col1, 'test')
self.assertEqual(p.va_id, first_version + 1,
'Version should be increased')
self.addTestNoDefaultNoNullColumn()
p = self.session.query(UserTable).get(p.id)
with self.assertRaises(RestoreError):
p.va_restore(self.session, first_version)
def test_product_update_with_user(self):
p = UserTable(**self.p1)
p.updated_by('test_user1')
self._add_and_test_version(p, 0)
p.col1 = 'new'
p.col2 = -1
p.updated_by('test_user2')
self._add_and_test_version(p, 1)
self._verify_row(dict(self.p1, **{'col1': 'new', 'col2': -1}), 1)
self._verify_archive(self.p1, 0, user='******')
self._verify_archive(dict(self.p1, **{
'col1': 'new',
'col2': -1,
}),
1,
user='******',
log_id=p.va_id)
def test_restore_row_with_new_nullable_column_by_va_version(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
log = self.session.query(ArchiveTable).get(p.va_id)
first_va_version = log.va_version
p.col1 = 'test'
p.col2 = 10
self.session.commit()
p = self.session.query(UserTable).get(p.id)
self.assertEqual(p.col1, 'test')
self.assertEqual(p.col2, 10)
self.addTestNullableColumn()
p = self.session.query(UserTable).get(p.id)
p.va_restore(self.session, first_va_version)
p = self.session.query(UserTable).get(p.id)
self.assertEqual(p.col1, self.p1['col1'])
self.assertEqual(p.col2, self.p1['col2'])
self.assertEqual(p.test_column1, None)
def test_restore_row_with_new_nullable_column_by_va_id(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
first_va_id = p.va_id
p.col1 = 'test'
p.col2 = 10
self.session.commit()
p = self.session.query(UserTable).get(p.id)
self.assertEqual(p.col1, 'test')
self.assertEqual(p.col2, 10)
self.assertEqual(p.va_id, first_va_id + 1, 'va_id should be increased')
self.addTestNullableColumn()
p = self.session.query(UserTable).get(p.id)
p.va_restore(self.session, va_id=first_va_id)
p = self.session.query(UserTable).get(p.id)
self.assertEqual(p.col1, self.p1['col1'])
self.assertEqual(p.col2, self.p1['col2'])
self.assertEqual(p.test_column1, None)
self.assertEqual(p.va_id, first_va_id + 2)
def test_concurrent_product_updates(self):
"""
Assert that if two separate sessions try to update a product row,
one succeeds and the other fails.
"""
p1 = UserTable(**self.p1)
# Create two sessions
session1 = self.Session1()
session2 = self.Session2()
# Add the initial row and flush it to the table
session1.add(p1)
session1.commit()
# Update 1 in session1
p1.col1 = 'changed col 1'
session1.add(p1)
# Update 2 in session 2
p2 = session2.query(UserTable).all()[0]
p2.col2 = 1245600
session2.add(p2)
# this flush should succeed
session2.commit()
session2.close()
# this flush should fail
session1.commit()
session1.close()
final = dict(self.p1, **{'col1': 'changed col 1', 'col2': 1245600})
self._verify_row(final, 2, session=session1)
history = [self.p1, dict(self.p1, **{'col2': 1245600}), final]
for i, expected in enumerate(history):
self._verify_archive(expected, i, session=session1)
def test_va_get_all(self):
p = UserTable(**self.p1)
p._updated_by = '1'
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
p.col1 = 'test'
p._updated_by = '2'
self.session.commit()
expected_result = [{
'record': {
'col1': 'foobar',
'col2': 10,
'col3': 1,
'id': 1,
'other_name': None,
'product_id': 10
},
'user_id': '1',
'va_id': 1,
'va_version': 0
}, {
'record': {
'col1': 'test',
'col2': 10,
'col3': 1,
'id': 1,
'other_name': None,
'product_id': 10
},
'user_id': '2',
'va_id': 2,
'va_version': 1
}]
res = p.va_get_all(self.session)
self.assertEqual(res, expected_result)
res = UserTable.va_get_all_by_pk(self.session, product_id=p.product_id)
self.assertEqual(res, expected_result)
def test_va_list(self):
p = UserTable(**self.p1)
self._add_and_test_version(p, 0)
p = self.session.query(UserTable).get(p.id)
first_version = p.va_id
p.col1 = 'test'
self.session.commit()
res = p.va_list(self.session)
expected_response = [
{
'va_id': first_version,
'user_id': None,
'va_version': 0
},
{
'va_id': first_version + 1,
'user_id': None,
'va_version': 1
},
]
self.assertEqual(res, expected_response)
res = UserTable.va_list_by_pk(self.session, product_id=p.product_id)
self.assertEqual(res, expected_response)
