同城生活平台定制选型：信息修改后怎样拒绝旧版本审核

import copy
import json

def validate(row):
    if not isinstance(row.get('owner'), str) or not row['owner']:
        raise ValueError('invalid_owner')
    if type(row.get('revision')) is not int or row['revision'] < 1:
        raise ValueError('invalid_revision')
    if row.get('state') not in {'pending','public','offline'}:
        raise ValueError('invalid_state')
    if row['state'] == 'public':
        if type(row.get('approved_revision')) is not int or row['approved_revision'] != row['revision']:
            raise ValueError('invalid_approval')
    elif row.get('approved_revision') is not None:
        raise ValueError('unexpected_approval')

def edit(row, actor, expected_revision, body):
    validate(row)
    if actor != row['owner']:
        raise PermissionError('wrong_owner')
    if row['revision'] != expected_revision:
        raise ValueError('stale_revision')
    if not isinstance(body, str) or not body.strip():
        raise ValueError('empty_body')
    if row['state'] == 'offline':
        raise ValueError('offline')
    row.update(body=body, revision=row['revision'] + 1,
               state='pending', approved_revision=None)

def approve(row, can_review, expected_revision):
    validate(row)
    if can_review is not True:
        raise PermissionError('not_reviewer')
    if row['revision'] != expected_revision or row['state'] != 'pending':
        raise ValueError('not_current_pending')
    row.update(state='public', approved_revision=expected_revision)

def visible(row):
    return (row['state'] == 'public' and
            row['approved_revision'] == row['revision'])

if __name__ == '__main__':
    row = dict(owner='u1', body='old place', revision=1,
               state='pending', approved_revision=None)
    assert not visible(row)
    approve(row, True, 1)
    assert visible(row)
    edit(row, 'u1', 1, 'new place')
    assert row['revision'] == 2 and not visible(row)
    for operation, error in [
        (lambda: approve(row, True, 1), ValueError),
        (lambda: edit(row, 'u2', 2, 'bad'), PermissionError),
        (lambda: edit(row, 'u1', 1, 'stale'), ValueError),
        (lambda: approve(row, False, 2), PermissionError),
        (lambda: edit(row, 'u1', 2, ' '), ValueError),
    ]:
        before = copy.deepcopy(row)
        try:
            operation()
        except error:
            pass
        else:
            raise AssertionError('invalid operation accepted')
        assert row == before
    approve(row, True, 2)
    assert visible(row)
    row.update(state='offline', approved_revision=None)
    before = copy.deepcopy(row)
    try:
        approve(row, True, 2)
    except ValueError:
        pass
    else:
        raise AssertionError('offline approved')
    assert row == before and not visible(row)
    before = copy.deepcopy(row)
    try:
        edit(row, 'u1', 2, 'cannot restore')
    except ValueError:
        pass
    else:
        raise AssertionError('offline edited')
    assert row == before
    for patch in [dict(owner=''), dict(revision=True),
                  dict(state='public', approved_revision=1)]:
        damaged = {**row, **patch}
        before = copy.deepcopy(damaged)
        try:
            approve(damaged, True, damaged['revision'])
        except ValueError:
            pass
        else:
            raise AssertionError('damaged input approved')
        assert damaged == before
    print(json.dumps({'checks':14, 'revision':row['revision'],
                      'state':row['state'], 'visible':visible(row)}))