def METHOD_NAME(self):
    tx = SlaveTransaction.create(**self.params)
    tx.sign(self.alice)
    addresses_state = dict(self.addresses_state)
    addresses_state[self.alice.address].pbdata.balance = 100
    state_container = StateContainer(addresses_state=addresses_state,
                                     tokens=Indexer(b'token', None),
                                     slaves=Indexer(b'slave', None),
                                     lattice_pk=Indexer(b'lattice_pk', None),
                                     multi_sig_spend_txs=dict(),
                                     votes_stats=dict(),
                                     block_number=1,
                                     total_coin_supply=100,
                                     current_dev_config=config.dev,
                                     write_access=True,
                                     my_db=self.state._db,
                                     batch=None)
    tx.apply(self.state, state_container)
    tx.revert(self.state, state_container)
    self.assertEqual(addresses_state[self.alice.address].balance, 100)
    storage_key = state_container.paginated_tx_hash.generate_key(self.alice.address, 1)
    self.assertIn(storage_key, state_container.paginated_tx_hash.key_value)
    self.assertEqual([], state_container.paginated_tx_hash.key_value[storage_key])
    self.assertIn((tx.addr_from, tx.slave_pks[0]), state_container.slaves.data)
    data = state_container.slaves.data[(tx.addr_from, tx.slave_pks[0])]
    self.assertIsInstance(data, SlaveMetadata)
    self.assertEqual(tx.access_types[0], data.access_type)
    self.assertEqual(tx.txhash, data.tx_hash)