def test_delete_contact(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
client.add_contact(f"/add_contact {character_hash_2} somebody")
assert client.delete_contact(f"/delete_contact {character_hash_2}"
) == ADDRESS_RECORD_DELETION_MESSAGE
def test_admin_hail_users(database, mock_message):
User.create_admin(2, 2, database)
character_hash = User.create_user(4, 4, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
message_list = client.admin_hail_users("/hail_users TEST MESSAGE")
assert len(message_list) == 2
assert 2 not in [x.chat_id for x in message_list]
assert message_list[0].message == "TEST MESSAGE"
def test_hacker_validation(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(HackerError):
client.hacker_validation(0)
User.update_db_value(character_hash, "hacker_level", 1, database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(HackerError):
client.hacker_validation(2)
client.hacker_validation(0)
def test_inspect_pair_transactions(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}") == NO_MESSAGES_FOUND
assert client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}", character_hash_2, character_hash) == NO_MESSAGES_FOUND
reciever_chat_id, message = client.prepare_message(f"/message {character_hash_2} LaLaLaLa")
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}") != NO_MESSAGES_FOUND
assert client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}", character_hash_2, character_hash) != NO_MESSAGES_FOUND
assert client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}") == client.inspect_pair_history_messages(f"/messages_history_pair {character_hash_2}", character_hash_2, character_hash)
def test_inspect_messages(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_messages(True) == NO_MESSAGES_FOUND
assert client.inspect_messages(False) == NO_MESSAGES_FOUND
chat_id, message = client.prepare_message(f"/message {character_hash_2} LaLaLaLa")
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_messages(True) != NO_MESSAGES_FOUND
assert client.inspect_messages(False) == NO_MESSAGES_FOUND
assert client.inspect_messages(False, character_hash_2) != NO_MESSAGES_FOUND
def test_admin_inspect_transactions(database, mock_message):
User.create_admin(2, 2, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_3 = User.create_user(4, 4, "Test user 3", database)
client = BankingClientFactory(database).create_client(mock_message)
results = client.admin_inspect_transactions(
f"/admin_history_sent {character_hash_2}", True)
assert results == NO_TRANSACTIONS_FOUND
results = client.admin_inspect_transactions(
f"/admin_history_recieved {character_hash_2}", False)
assert results == NO_TRANSACTIONS_FOUND
results = client.admin_inspect_transactions(
f"/admin_history_recieved {character_hash_3}", False)
assert results == NO_TRANSACTIONS_FOUND
Transaction.create_transaction(character_hash_2, character_hash_3, 100,
database)
Transaction.create_transaction(character_hash_2, "0000000000", 100,
database)
results = client.admin_inspect_transactions(
f"/admin_history_sent {character_hash_2}", True)
assert results != NO_TRANSACTIONS_FOUND
results = client.admin_inspect_transactions(
f"/admin_history_recieved {character_hash_2}", False)
assert results == NO_TRANSACTIONS_FOUND
results = client.admin_inspect_transactions(
f"/admin_history_recieved {character_hash_3}", False)
assert results != NO_TRANSACTIONS_FOUND
def test_admin_inspect_messages(database, mock_message):
User.create_admin(2, 2, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_3 = User.create_user(4, 4, "Test user 3", database)
client = BankingClientFactory(database).create_client(mock_message)
results = client.admin_inspect_messages(
f"/admin_messages_history_sent {character_hash_2}", True)
assert results == NO_MESSAGES_FOUND
results = client.admin_inspect_messages(
f"/admin_messages_history_recieved {character_hash_2}", False)
assert results == NO_MESSAGES_FOUND
results = client.admin_inspect_messages(
f"/admin_messages_history_recieved {character_hash_3}", False)
assert results == NO_MESSAGES_FOUND
Message.create_message(character_hash_2, character_hash_3, "100", database)
Message.create_message(character_hash_2, "0000000000", "100", database)
results = client.admin_inspect_messages(
f"/admin_messages_history_sent {character_hash_2}", True)
assert results != NO_MESSAGES_FOUND
results = client.admin_inspect_messages(
f"/admin_messages_history_recieved {character_hash_2}", False)
assert results == NO_MESSAGES_FOUND
results = client.admin_inspect_messages(
f"/admin_messages_history_recieved {character_hash_3}", False)
assert results != NO_MESSAGES_FOUND
def test_inspect_transactions(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_transactions(True) == NO_TRANSACTIONS_FOUND
assert client.inspect_transactions(False) == NO_TRANSACTIONS_FOUND
half_amount = DEFAULT_FINANCES / 2
sender_chat_id, reciever_chat_id, message = client.create_transaction(
f"/send {character_hash_2} {half_amount}")
client = BankingClientFactory(database).create_client(mock_message)
assert client.inspect_transactions(True) != NO_TRANSACTIONS_FOUND
assert client.inspect_transactions(False) == NO_TRANSACTIONS_FOUND
assert client.inspect_transactions(
False, character_hash_2) != NO_TRANSACTIONS_FOUND
def test_user_validation(database, mock_message):
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.user_validation()
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
client.user_validation()
def test_create_admin(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.create_admin()
mock_message.json['from']['id'] = 1
client = BankingClientFactory(database).create_client(mock_message)
client.create_admin()
def test_hack_inspect_transactions(database, mock_message):
User.create_admin(1, 1, database)
character_hash_1 = User.create_user(2, 2, "Test user", database)
User.update_db_value(character_hash_1, "hacker_level", 1, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_3 = User.create_user(4, 4, "Test user 3", database)
character_hash_4 = User.create_user(5, 5, "Test user 4", database)
User.update_db_value(character_hash_3, "hacker_defence", 1, database)
client = BankingClientFactory(database).create_client(mock_message)
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_sent {character_hash_2}", True)
assert results == NO_TRANSACTIONS_FOUND
assert not show_hack
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_recieved {character_hash_2}", False)
assert results == NO_TRANSACTIONS_FOUND
assert not show_hack
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_recieved {character_hash_3}", False)
assert results == NO_TRANSACTIONS_FOUND
assert show_hack
Transaction.create_transaction(character_hash_2, character_hash_4, 100,
database)
Transaction.create_transaction(character_hash_2, character_hash_3, 100,
database)
Transaction.create_transaction(character_hash_2, "0000000000", 100,
database)
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_sent {character_hash_2}", True)
assert results != NO_TRANSACTIONS_FOUND
assert not show_hack
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_recieved {character_hash_2}", False)
assert results == NO_TRANSACTIONS_FOUND
assert not show_hack
results, chat_id, show_hack = client.hack_inspect_transactions(
f"/hack_history_recieved {character_hash_3}", False)
assert results != NO_TRANSACTIONS_FOUND
assert show_hack
with pytest.raises(HackerError):
client.hack_inspect_transactions(f"/hack_history_recieved 0000000000",
False)
def test_inspect_user(database, mock_message):
User.create_admin(2, 2, database)
character_hash = User.create_user(3, 3, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
user = client.get_user_by_user_hash("0000000000")
user2 = client.get_user_by_user_hash(character_hash)
assert client.inspect_user() == str(user)
assert client.inspect_user(character_hash) == str(user2)
with pytest.raises(UserError):
client.inspect_user("1234567890")
def test_delete_user(database, mock_message):
User.create_admin(2, 2, database)
character_hash = User.create_user(3, 3, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.get_user_by_user_hash(character_hash) is not None
client.delete_user(f"/delete {character_hash}")
with pytest.raises(UserError):
client.get_user_by_user_hash(character_hash)
def test_prepare_message(database, mock_message):
User.create_admin(1, 1, database)
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
admin = client.get_user_by_user_hash("0000000000")
with pytest.raises(UserError):
client.prepare_message("/message 1234567890 LaLaLaLa")
with pytest.raises(MessageError):
client.prepare_message(f"/message {client.user.character_hash} LaLaLaLa")
chat_id, message = client.prepare_message("/message 0000000000 LaLaLaLa")
assert message == "LaLaLaLa"
assert chat_id == admin.chat_id
def test_add_contact(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(AddressRecordError):
client.add_contact(f"/add_contact {character_hash} SELF")
assert client.add_contact(
f"/add_contact {character_hash_2} somebody") == ADDRESS_RECORD_ADDED
with pytest.raises(AddressRecordError):
client.add_contact(f"/add_contact {character_hash_2} somebody")
def test_admin_inspect_pair_messages(database, mock_message):
User.create_admin(2, 2, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_3 = User.create_user(4, 4, "Test user 3", database)
character_hash_4 = User.create_user(5, 5, "Test user 4", database)
client = BankingClientFactory(database).create_client(mock_message)
results = client.admin_inspect_pair_history_messages(
f"/admin_messages_history_pair {character_hash_2} {character_hash_3}")
assert results == NO_MESSAGES_FOUND
results = client.admin_inspect_pair_history_messages(
f"/admin_messages_history_pair {character_hash_4} {character_hash_3}")
assert results == NO_MESSAGES_FOUND
Message.create_message(character_hash_2, character_hash_4, "100", database)
Message.create_message(character_hash_2, character_hash_3, "100", database)
Message.create_message(character_hash_2, "0000000000", "100", database)
Message.create_message(character_hash_3, character_hash_4, "100", database)
results = client.admin_inspect_pair_history_messages(
f"/admin_messages_history_pair {character_hash_2} {character_hash_3}")
assert results != NO_MESSAGES_FOUND
results = client.admin_inspect_pair_history_messages(
f"/admin_messages_history_pair {character_hash_4} {character_hash_3}")
assert results != NO_MESSAGES_FOUND
def test_set_attribute(database, mock_message):
User.create_admin(2, 2, database)
character_hash = User.create_user(3, 3, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
user = client.get_user_by_user_hash(character_hash)
assert user.finances == DEFAULT_FINANCES
with pytest.raises(UserError):
client.set_attribute("/set_attribute 1234567890 finances 0")
assert client.set_attribute(f"/set_attribute {character_hash} finances 0"
) == ATTRIBUTE_UPDATE_MESSAGE
user = client.get_user_by_user_hash(character_hash)
assert user.finances == 0
def test_hack_inspect_pair_messages(database, mock_message):
User.create_admin(1, 1, database)
character_hash_1 = User.create_user(2, 2, "Test user", database)
User.update_db_value(character_hash_1, "hacker_level", 1, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_3 = User.create_user(4, 4, "Test user 3", database)
character_hash_4 = User.create_user(5, 5, "Test user 4", database)
User.update_db_value(character_hash_3, "hacker_defence", 1, database)
User.update_db_value(character_hash_4, "hacker_defence", 2, database)
client = BankingClientFactory(database).create_client(mock_message)
results, chat_id, hash_1, chat_2_id, hash_2, show_hack = client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_2} {character_hash_3}")
assert results == NO_MESSAGES_FOUND
assert not show_hack
results, chat_id, hash_1, chat_2_id, hash_2, show_hack = client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_4} {character_hash_3}")
assert results == NO_MESSAGES_FOUND
assert show_hack
with pytest.raises(HackerError):
client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_4} 0000000000")
Message.create_message(character_hash_2, character_hash_4, "100", database)
Message.create_message(character_hash_2, character_hash_3, "100", database)
Message.create_message(character_hash_2, "0000000000", "100", database)
Message.create_message(character_hash_3, character_hash_4, "100", database)
results, chat_id, hash_1, chat_2_id, hash_2, show_hack = client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_2} {character_hash_3}")
assert results != NO_MESSAGES_FOUND
assert not show_hack
results, chat_id, hash_1, chat_2_id, hash_2, show_hack = client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_2} 0000000000")
assert results != NO_MESSAGES_FOUND
assert not show_hack
results, chat_id, hash_1, chat_2_id, hash_2, show_hack = client.hack_inspect_pair_history_messages(
f"/hack_messages_history_pair {character_hash_4} {character_hash_3}")
assert results != NO_MESSAGES_FOUND
assert show_hack
def test_admin_inspect_contact_list(database, mock_message):
User.create_admin(2, 2, database)
character_hash = User.create_user(4, 4, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.admin_inspect_contact_list(
f"/admin_inspect_contact_list {character_hash}") == NO_ADDRESS_RECORDS
assert client.admin_inspect_contact_list(
f"/admin_inspect_contact_list {character_hash_2}"
) == NO_ADDRESS_RECORDS
client.admin_add_contact(
f"/admin_add_contact {character_hash} {character_hash_2} somebody")
assert client.admin_inspect_contact_list(
f"/admin_inspect_contact_list {character_hash}") != NO_ADDRESS_RECORDS
assert client.admin_inspect_contact_list(
f"/admin_inspect_contact_list {character_hash_2}"
) == NO_ADDRESS_RECORDS
def test_admin_inspect_user(database, mock_message):
User.create_admin(2, 2, database)
client = BankingClientFactory(database).create_client(mock_message)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
user2 = client.get_user_by_user_hash(character_hash_2)
with pytest.raises(UserError):
client.admin_inspect_user("/admin_inspect_user 1234567890")
resulting_data = client.admin_inspect_user(
f'/admin_inspect_user {character_hash_2}')
assert resulting_data == str(user2)
def test_hack_inspect_user(database, mock_message):
User.create_admin(1, 1, database)
character_hash = User.create_user(2, 2, "Test user", database)
User.update_db_value(character_hash, "hacker_level", 1, database)
client = BankingClientFactory(database).create_client(mock_message)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_4 = User.create_user(4, 4, "Test user 4", database)
User.update_db_value(character_hash_4, "hacker_defence", 1, database)
user2 = client.get_user_by_user_hash(character_hash_2)
user4 = client.get_user_by_user_hash(character_hash_4)
with pytest.raises(UserError):
client.hack_inspect_user("/hack 1234567890")
resulting_data, chat_id, show_hack = client.hack_inspect_user(
f'/hack {character_hash_2}')
assert resulting_data == user2.hack_result
assert chat_id == user2.chat_id
assert not show_hack
with pytest.raises(HackerError):
client.hack_inspect_user(f'/hack 0000000000')
resulting_data, chat_id, show_hack = client.hack_inspect_user(
f'/hack {character_hash_4}')
assert resulting_data == user4.hack_result
assert chat_id == user4.chat_id
assert show_hack
def test_hack_send_hacked_message(database, mock_message):
User.create_admin(1, 1, database)
character_hash = User.create_user(2, 2, "Test user", database)
User.update_db_value(character_hash, "hacker_level", 1, database)
client = BankingClientFactory(database).create_client(mock_message)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_4 = User.create_user(4, 4, "Test user 4", database)
User.update_db_value(character_hash_4, "hacker_defence", 1, database)
user2 = client.get_user_by_user_hash(character_hash_2)
user4 = client.get_user_by_user_hash(character_hash_4)
with pytest.raises(UserError):
client.prepare_hacker_message("/h@ck_message 1234567890 OLOLO")
chat_id, sent_message, show_hack = client.prepare_hacker_message(
f'/h@ck_message {character_hash_2} OLOLO')
assert sent_message == "OLOLO"
assert chat_id == user2.chat_id
assert not show_hack
with pytest.raises(HackerError):
client.hack_inspect_user(f'/h@ck_message 0000000000 OLOLO')
chat_id, sent_message, show_hack = client.prepare_hacker_message(
f'/h@ck_message {character_hash_4} OLOLO')
assert sent_message == "OLOLO"
assert chat_id == user4.chat_id
assert show_hack
def test_get_admins(database, mock_message):
User.create_admin(2, 2, database)
client = BankingClientFactory(database).create_client(mock_message)
admin_list = client.get_admins()
assert len(admin_list) == 1
def test_client_creation(database, mock_message):
client = BankingClientFactory(database).create_client(mock_message)
assert isinstance(client, BankingClient)
assert client.user_id == "2"
assert client.chat_id == "2"
assert client.user is None
def test_create_transaction(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
client = BankingClientFactory(database).create_client(mock_message)
double_amount = DEFAULT_FINANCES * 2
half_amount = DEFAULT_FINANCES / 2
user2 = client.get_user_by_user_hash(character_hash_2)
user1 = client.get_user_by_user_hash(character_hash)
assert user2.finances == DEFAULT_FINANCES
assert user1.finances == DEFAULT_FINANCES
with pytest.raises(TransactionError):
client.create_transaction(f"/send {character_hash_2} {double_amount}")
with pytest.raises(TransactionError):
client.create_transaction(f"/send {character_hash} {half_amount}")
with pytest.raises(TransactionError):
client.create_transaction(f"/send {character_hash_2} notanumber")
with pytest.raises(TransactionError):
client.create_transaction(f"/send {character_hash_2} 0")
with pytest.raises(UserError):
client.create_transaction(f"/send 1234567890 {half_amount}")
sender_chat_id, reciever_chat_id, message = client.create_transaction(
f"/send {character_hash_2} {half_amount}")
user2 = client.get_user_by_user_hash(character_hash_2)
user1 = client.get_user_by_user_hash(character_hash)
assert user2.finances == DEFAULT_FINANCES + half_amount
assert user1.finances == DEFAULT_FINANCES - half_amount
assert sender_chat_id == user1.chat_id
assert reciever_chat_id == user2.chat_id
def test_inspect_self(database, mock_message):
User.create_admin(2, 2, database)
client = BankingClientFactory(database).create_client(mock_message)
user = client.get_user_by_user_hash("0000000000")
assert client.inspect_self() == str(user)
def test_register_user(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.register_user("/register Peter Parker")
mock_message.json['from']['id'] = 1
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.register_user("/register")
client.register_user("/register Peter Parker")
mock_message.json['from']['id'] = 3
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.register_user("/register Peter Parker")
def test_get_user_by_user_hash(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
with pytest.raises(UserError):
client.get_user_by_user_hash("0000000000")
assert client.get_user_by_user_hash(character_hash) is not None
def test_get_user_by_name(database, mock_message):
character_hash = User.create_user(2, 2, "Test user", database)
client = BankingClientFactory(database).create_client(mock_message)
assert client.get_user_by_name("Mock") is None
assert client.get_user_by_name("Test user") is not None
def test_create_hacked_transaction_other(database, mock_message):
User.create_admin(1, 1, database)
character_hash = User.create_user(2, 2, "Test user", database)
User.update_db_value(character_hash, "hacker_level", 1, database)
character_hash_2 = User.create_user(3, 3, "Test user 2", database)
character_hash_4 = User.create_user(4, 4, "Test user 4", database)
character_hash_5 = User.create_user(5, 5, "Test user 5", database)
User.update_db_value(character_hash_4, "hacker_defence", 1, database)
client = BankingClientFactory(database).create_client(mock_message)
double_amount = DEFAULT_FINANCES * 2
half_amount = DEFAULT_FINANCES / 2
user2 = client.get_user_by_user_hash(character_hash_2)
user1 = client.get_user_by_user_hash(character_hash)
assert user2.finances == DEFAULT_FINANCES
assert user1.finances == DEFAULT_FINANCES
with pytest.raises(TransactionError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash_2} {character_hash_5} {double_amount}"
)
with pytest.raises(TransactionError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash} {character_hash_5} {half_amount}"
)
with pytest.raises(TransactionError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash_2} {character_hash_5} notanumber"
)
with pytest.raises(TransactionError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash_2} {character_hash_5} 0")
with pytest.raises(UserError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other 1234567890 {character_hash_5} {half_amount}")
with pytest.raises(HackerError):
client.create_hacker_transaction_other(
f"/h@ck_theft_other 0000000000 {character_hash_5} {half_amount}")
hacker_hash, victim_chat_id, profiteer_chat_id, transaction_message, show_hack = client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash_2} {character_hash_5} {half_amount}"
)
user2 = client.get_user_by_user_hash(character_hash_2)
user5 = client.get_user_by_user_hash(character_hash_5)
assert user2.finances == DEFAULT_FINANCES - half_amount
assert user5.finances == DEFAULT_FINANCES + half_amount
assert hacker_hash == client.user.character_hash
assert victim_chat_id == user2.chat_id
assert not show_hack
hacker_hash, victim_chat_id, profiteer_chat_id, transaction_message, show_hack = client.create_hacker_transaction_other(
f"/h@ck_theft_other {character_hash_4} {character_hash_5} {half_amount}"
)
user4 = client.get_user_by_user_hash(character_hash_4)
user5 = client.get_user_by_user_hash(character_hash_5)
assert hacker_hash == client.user.character_hash
assert victim_chat_id == user4.chat_id
assert user4.finances == DEFAULT_FINANCES - half_amount
assert user5.finances == DEFAULT_FINANCES + half_amount + half_amount
assert show_hack
