def test_tip_flip(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " flip doge verify", None)
self.assertLessEqual(tip.amount, 2)
self.assertGreaterEqual(tip.amount, 1)
self.assertEqual("doge", tip.currency)
self.assertEqual(True, tip.verify)
def test_tip_random(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " random100 doge", None)
self.assertLess(tip.amount, 100)
self.assertGreater(tip.amount, 1)
self.assertEqual("doge", tip.currency)
self.assertEqual(False, tip.verify)
def test_tip_dogecar(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " dogecar doge verify",
None)
self.assertEqual(tip.amount, config.tip_keyword['dogecar'])
self.assertEqual("doge", tip.currency)
self.assertEqual(True, tip.verify)
def test_tip_user_mention_add(self):
tip = models.Tip()
tip.parse_message(
"+/u/" + config.bot_name + " +/u/just-an-dev 1000 doge", None)
self.assertEqual(1000, tip.amount)
self.assertEqual("doge", tip.currency)
self.assertEqual("just-an-dev", tip.receiver.username)
def replay_remove_pending_tip(reddit, tx_queue, failover_time):
# check if user have pending tips
list_tips = user_function.get_unregistered_tip()
if list_tips:
for arr_tip in list_tips:
tip = models.Tip().create_from_array(arr_tip)
bot_logger.logger.info("replay tipping check for %s" % str(tip.id))
# check if it's not too old & replay tipping
if not tip.is_expired():
if tip.receiver.is_registered():
bot_logger.logger.info(
"replay tipping %s - %s send %s to %s " %
(str(tip.id), tip.sender.username, tip.amount,
tip.receiver.username))
tip.tx_id = crypto.tip_user(tip.sender.address,
tip.receiver.address,
tip.amount, tx_queue,
failover_time)
if tip.tx_id:
tip.finish = True
user_function.remove_pending_tip(tip.id)
if tip.message_fullname is not None:
msg_id = re.sub(r't\d+_(?P<id>\w+)', r'\g<id>',
tip.message_fullname)
msg = Comment(reddit, msg_id)
msg.reply(
Template(lang.message_tip).render(
sender=tip.sender.username,
receiver=tip.receiver.username,
amount=str(tip.amount),
value_usd=str(tip.get_value_usd()),
txid=tip.tx_id))
else:
tip.status = "waiting registration of receiver"
bot_logger.logger.info(
"replay check for %s - user %s not registered " %
(str(tip.id), tip.receiver.username))
else:
tip.status = "receiver not registered in time"
tip.finish = ""
bot_logger.logger.info(
"delete old tipping - %s send %s to %s " %
(tip.sender.username, tip.amount, tip.receiver.username))
user_function.remove_pending_tip(tip.id)
# update tip status
history.update_tip(tip.sender.username, tip)
history.update_tip(tip.receiver.username, tip)
else:
bot_logger.logger.info("no pending tipping")
def test_update_history(self):
# get an old tip
data = models.HistoryStorage.get_user_history("just-an-dev")
tip_saved = models.Tip().create_from_array(data[1])
self.assertEqual(42122771, tip_saved.id)
# update tip info
tip_saved.finish = True
tip_saved.tx_id = "transaction id of tip"
models.HistoryStorage.update_tip('just-an-dev', tip_saved)
# check of update
data_verif = models.HistoryStorage.get_user_history("just-an-dev")
tip_verif = models.Tip().create_from_array(data_verif[1])
self.assertEqual(42122771, tip_verif.id)
self.assertEqual(True, tip_verif.finish)
self.assertEqual("transaction id of tip", tip_verif.tx_id)
def test_tip_address(self):
mock_rpc = MockRpc()
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " nnBKn39onxAuS1cr6KuLAoV2SdfFh1dpsR 1000 doge", mock_rpc)
tip.set_sender('just-an-dev')
self.assertEqual(1000, tip.amount)
self.assertEqual("doge", tip.currency)
self.assertEqual("nnBKn39onxAuS1cr6KuLAoV2SdfFh1dpsR", tip.receiver.address)
self.assertEqual("address-nnBKn39onxAuS1cr6KuLAoV2SdfFh1dpsR", tip.receiver.username)
def send_tip(user_from: models.User, user_to: models.User,
amount: int) -> models.Tip:
tip = models.Tip(from_user=user_from,
to_user=user_to,
amount=amount,
date=datetime.utcnow())
tx_hash = wallet.send_transaction(user_from.balance_wallet_address,
user_to.balance_wallet_address, amount)
tip.tx_hash = tx_hash
tip.save()
return tip
def test_create_from_array(self):
list_tips = user_function.get_unregistered_tip()
# make a copy for tests :)
list_tips_edit = copy.deepcopy(list_tips)
tip = models.Tip().create_from_array(list_tips_edit[1])
self.assertEqual(list_tips[1]['amount'], tip.amount)
self.assertEqual(list_tips[1]['sender'], tip.sender.username)
self.assertEqual(list_tips[1]['receiver'], tip.receiver.username)
self.assertEqual(list_tips[1]['message_fullname'],
tip.message_fullname)
self.assertEqual(list_tips[1]['time'], tip.time)
self.assertEqual(list_tips[1]['id'], tip.id)
def test_tip_unregistered(self):
list_tips = user_function.get_unregistered_tip()
tip = models.Tip().create_from_array(list_tips[2])
self.assertEqual(True, tip.is_expired())
def tip_user(reddit, msg, tx_queue, failover_time):
bot_logger.logger.info('An user mention detected ')
bot_logger.logger.debug("failover_time : %s " % (str(failover_time.value)))
# create an Tip
tip = models.Tip()
# update sender
tip.set_sender(msg.author.name)
# check user who use command is registered
if tip.sender.is_registered() is not True:
bot_logger.logger.info('user %s not registered (sender) ' %
msg.author.name)
msg.reply(
Template(lang.message_need_register +
lang.message_footer).render(username=msg.author.name))
return False
# parse message
tip.parse_message(msg.body)
# set reddit message id
tip.message_fullname = msg.fullname
# check amount of tip
if not utils.check_amount_valid(tip.amount):
# invalid amount
bot_logger.logger.info(lang.message_invalid_amount)
reddit.redditor(msg.author.name).message('invalid amount',
lang.message_invalid_amount)
return False
if tip.currency is None:
bot_logger.logger.info(lang.message_invalid_currency)
reddit.redditor(msg.author.name).message('invalid currency',
lang.message_invalid_currency)
return False
# update receiver
tip.set_receiver(msg.parent().author.name)
# check user not tip self
if tip.sender.username == tip.receiver.username:
reddit.redditor(tip.sender.username).message(
'cannot tip self',
Template(lang.message_recipient_self).render(
username=tip.sender.username))
return False
# check we have enough
user_spendable_balance = crypto.balance_user(msg, failover_time)
bot_logger.logger.debug('user_spendable_balance = %s' %
user_spendable_balance)
# in failover we need to use only user_balance
if tip.amount >= float(user_spendable_balance):
user_pending_balance = tip.sender.get_balance_unconfirmed()
# not enough for tip
if tip.amount < float(user_pending_balance):
reddit.redditor(tip.sender.username).message(
'pending tip',
Template(lang.message_balance_pending_tip).render(
username=tip.sender.username))
else:
bot_logger.logger.info(
'user %s not have enough to tip this amount (%s), balance = %s'
% (tip.sender.username, str(
tip.amount), str(user_spendable_balance)))
reddit.redditor(tip.sender.username).message(
'low balance',
Template(lang.message_balance_low_tip).render(
username=tip.sender.username))
else:
# add tip to history of sender & receiver
history.add_to_history_tip(tip.sender.username, "tip send", tip)
history.add_to_history_tip(tip.receiver.username, "tip receive", tip)
# check user who receive tip have an account
if tip.receiver.is_registered():
tip.tx_id = crypto.tip_user(tip.sender.address,
tip.receiver.address, tip.amount,
tx_queue, failover_time)
if tip.tx_id:
tip.finish = True
tip.status = 'ok'
bot_logger.logger.info(
'%s tip %s to %s' %
(msg.author.name, str(tip.amount), tip.receiver.username))
# if user have 'verify' in this command he will have confirmation
if tip.verify:
msg.reply(
Template(lang.message_tip).render(
sender=msg.author.name,
receiver=tip.receiver.username,
amount=str(int(tip.amount)),
value_usd=str(tip.get_value_usd()),
txid=tip.tx_id))
else:
bot_logger.logger.info('user %s not registered (receiver)' %
tip.receiver.username)
tip.status = "waiting registration of receiver"
# save tip
user_function.save_unregistered_tip(tip)
# send message to sender of tip
reddit.redditor(tip.sender.username).message(
'tipped user not registered',
Template(lang.message_recipient_register).render(
username=tip.receiver.username))
# send message to receiver
reddit.redditor(tip.receiver.username).message(
Template(lang.message_recipient_need_register_title).render(
amount=str(tip.amount)),
Template(lang.message_recipient_need_register_message).render(
username=tip.receiver.username,
sender=msg.author.name,
amount=str(tip.amount),
value_usd=str(tip.get_value_usd())))
# update tip status
history.update_tip(tip.sender.username, tip)
history.update_tip(tip.receiver.username, tip)
def test_tip_negative(self):
tip = models.Tip()
self.assertRaises(AttributeError, tip.parse_message,
"+/u/" + config.bot_name + " -99999999 doge verify",
None)
def test_tip_simple_verify(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " 100 doge verify", None)
self.assertEqual(100, tip.amount)
self.assertEqual("doge", tip.currency)
self.assertEqual(True, tip.verify)
def test_tip_simple_float_dot_long(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " 0.000000001 doge", None)
self.assertEqual(0.000000001, float(tip.amount))
self.assertEqual("doge", tip.currency)
self.assertEqual(False, tip.verify)
def test_tip_simple_float_dot(self):
tip = models.Tip()
tip.parse_message("+/u/" + config.bot_name + " 10.8 doge", None)
self.assertEqual(10, tip.amount)
self.assertEqual("doge", tip.currency)
self.assertEqual(False, tip.verify)
def test_tip_expired(self):
tip = models.Tip()
tip.time = datetime.datetime.now() - datetime.timedelta(days=5)
self.assertEqual(True, tip.is_expired())
def test_tip_not_expired(self):
tip = models.Tip()
tip.time = datetime.datetime.now()
self.assertEqual(False, tip.is_expired())
