def test_get_preferred_value_none(db: SopelDB):
"""Test method when there is no preferred value"""
db.set_nick_value('testuser', 'userkey', 'uservalue')
db.set_channel_value('#channel', 'channelkey', 'channelvalue')
names = ['notuser', '#notchannel']
assert db.get_preferred_value(names, 'userkey') is None
assert db.get_preferred_value(names, 'channelkey') is None
def handle_quiz(bot, trigger):
if not bot.memory['quiz']:
return
quiz = bot.memory['quiz']
if quiz.question.attempt(trigger.args[1]) and not quiz.question.answered:
quiz.question.answered = True
bot.say(color('Correct! The answer was {}'.format(quiz.question.answer),
colors.GREEN))
quiz.award_user(trigger.nick, quiz.question.value
if bot.config.quiz.win_method == 'score' else 1)
score = bot.memory['quiz'].get_scores()[trigger.nick]
bot.say('{} has {} point{}!'.format(trigger.nick, score,
's' * (score > 1)))
if bot.config.quiz.win_method == 'points':
win_value = bot.config.quiz.points_to_win
else:
win_value = bot.config.quiz.score_to_win
if score >= win_value:
bot.say('{} is the winner!'.format(trigger.nick))
qscores(bot)
db = SopelDB(bot.config)
db_users = bot.config.quiz.db_users
if not db_users or quiz.starter in db_users:
wins = (db.get_nick_value(trigger.nick, 'quiz_wins') or 0) + 1
db.set_nick_value(trigger.nick, 'quiz_wins', wins)
bot.say('{} has won {} time{}'.format(trigger.nick, wins,
's' * (wins > 1)))
bot.memory['quiz'] = None
return
next_q(bot)
def test_get_preferred_value(db: SopelDB):
db.set_nick_value('asdf', 'qwer', 'poiu')
db.set_channel_value('#asdf', 'qwer', '/.,m')
db.set_channel_value('#asdf', 'lkjh', '1234')
names = ['asdf', '#asdf']
assert db.get_preferred_value(names, 'qwer') == 'poiu'
assert db.get_preferred_value(names, 'lkjh') == '1234'
def test_forget_nick_group(db: SopelDB):
session = db.ssession()
aliases = ['MrEricPraline', 'Praline']
nick_id = 42
for alias in aliases:
nn = Nicknames(nick_id=nick_id,
slug=Identifier(alias).lower(),
canonical=alias)
session.add(nn)
session.commit()
db.set_nick_value(aliases[0], 'foo', 'bar')
db.set_nick_value(aliases[1], 'spam', 'eggs')
db.forget_nick_group(aliases[0])
with pytest.raises(ValueError):
db.forget_nick_group('Mister_Bradshaw')
# Nothing else has created values, so we know the tables are empty
nicks = session.query(Nicknames).all()
assert len(nicks) == 0
data = session.query(NickValues).first()
assert data is None
session.close()
def test_delete_nick_value(db: SopelDB):
nick = 'TerryGilliam'
db.set_nick_value(nick, 'testkey', 'test-value')
# sanity check
assert db.get_nick_value(nick, 'testkey') == 'test-value', (
'Check set_nick_value: this key must contain the correct value.')
# delete key
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None
def fmset(bot, trigger):
user = trigger.group(2)
if not user:
bot.say('no user given')
return
db = SopelDB(bot.config)
db.set_nick_value(trigger.nick, 'lastfm_user', user)
bot.say('{}\'s last.fm user is now set as {}'.format(trigger.nick, user))
def godset(bot, trigger):
god = trigger.group(2)
if not god:
bot.say('no god given')
return
db = SopelDB(bot.config)
db.set_nick_value(trigger.nick, 'god', god)
bot.say('{}\'s god is now set as {}'.format(trigger.nick, god))
def test_get_nick_or_channel_value_identifier(db: SopelDB):
db.set_nick_value('testuser', 'testkey', 'user-value')
db.set_channel_value('#channel', 'testkey', 'channel-value')
nick = Identifier('testuser')
channel = Identifier('#channel')
assert db.get_nick_or_channel_value(nick, 'testkey') == 'user-value'
assert db.get_nick_or_channel_value(nick, 'nokey') is None
assert db.get_nick_or_channel_value(nick, 'nokey', 'default') == 'default'
assert db.get_nick_or_channel_value(channel, 'testkey') == 'channel-value'
assert db.get_nick_or_channel_value(channel, 'nokey',
'default') == 'default'
def stravaset(bot, trigger):
strava_token = trigger.group(2)
if not strava_token:
bot.say('no access token given')
bot.say('Generate using https://stravacli-dlenski.rhcloud.com')
return
db = SopelDB(bot.config)
db.set_nick_value(trigger.nick, 'strava_token', strava_token)
bot.say('{}\'s token is now set as {}'.format(trigger.nick, strava_token))
def test_delete_nick_value_none(db: SopelDB):
"""Test method doesn't raise an error when there is nothing to delete."""
nick = 'TerryGilliam'
# this user doesn't even exist
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None, (
'Trying to delete a key must not create it.')
# create a key
db.set_nick_value(nick, 'otherkey', 'value')
# delete another key for that user
db.delete_nick_value(nick, 'testkey')
assert db.get_nick_value(nick, 'testkey') is None, (
'Trying to delete a key must not create it.')
# the nick still exists, and its key as well
assert db.get_nick_value(
nick,
'otherkey') == 'value', ('This key must not be deleted by error.')
def test_merge_nick_groups(db: SopelDB):
session = db.ssession()
aliases = ['MrEricPraline', 'Praline']
for nick_id, alias in enumerate(aliases):
nn = Nicknames(nick_id=nick_id,
slug=Identifier(alias).lower(),
canonical=alias)
session.add(nn)
session.commit()
finals = (('foo', 'bar'), ('bar', 'blue'), ('spam', 'eggs'))
db.set_nick_value(aliases[0], finals[0][0], finals[0][1])
db.set_nick_value(aliases[0], finals[1][0], finals[1][1])
db.set_nick_value(aliases[1], 'foo', 'baz')
db.set_nick_value(aliases[1], finals[2][0], finals[2][1])
db.merge_nick_groups(aliases[0], aliases[1])
nick_ids = session.query(Nicknames.nick_id).all()
nick_id = nick_ids[0][0]
alias_id = nick_ids[1][0]
assert nick_id == alias_id
for key, value in finals:
found = session.query(NickValues.value) \
.filter(NickValues.nick_id == nick_id) \
.filter(NickValues.key == key) \
.scalar()
assert json.loads(str(found)) == value
session.close()
def test_set_nick_value_update(db: SopelDB):
"""Test set_nick_value can update an existing value."""
db.set_nick_value('Pepperpots', 'testkey', 'first-value')
db.set_nick_value('Pepperpots', 'otherkey', 'other-value')
db.set_nick_value('Vikings', 'testkey', 'other-nick-value')
# sanity check: ensure every (nick, key, value) is correct
assert db.get_nick_value('Pepperpots', 'testkey') == 'first-value'
assert db.get_nick_value('Pepperpots', 'otherkey') == 'other-value'
assert db.get_nick_value('Vikings', 'testkey') == 'other-nick-value'
# update only one key
db.set_nick_value('Pepperpots', 'testkey', 'new-value')
# check new value while old values are still the same
assert db.get_nick_value('Pepperpots', 'testkey') == 'new-value'
assert db.get_nick_value('Pepperpots', 'otherkey') == 'other-value'
assert db.get_nick_value('Vikings', 'testkey') == 'other-nick-value'
def test_get_nick_or_channel_value(db: SopelDB):
db.set_nick_value('asdf', 'qwer', 'poiu')
db.set_channel_value('#asdf', 'qwer', '/.,m')
assert db.get_nick_or_channel_value('asdf', 'qwer') == 'poiu'
assert db.get_nick_or_channel_value('#asdf', 'qwer') == '/.,m'
def test_set_nick_value(db: SopelDB, value):
nick = 'Pepperpots'
db.set_nick_value(nick, 'testkey', value)
assert db.get_nick_value(nick, 'testkey') == value, (
'The value retrieved must be exactly what was stored.')
class BotDatabase():
def __init__(self):
SopelDB.nick_id_lock = threading.Lock()
sopel.db.NickIDs = NickIDs
sopel.db.Nicknames = Nicknames
sopel.db.NickValues = NickValues
SopelDB.get_nick_id = SpiceDB.get_nick_id
SopelDB.get_nick_value = SpiceDB.get_nick_value
SopelDB.set_nick_value = SpiceDB.set_nick_value
SopelDB.delete_nick_value = SpiceDB.delete_nick_value
SopelDB.adjust_nick_value = SpiceDB.adjust_nick_value
SopelDB.adjust_nick_list = SpiceDB.adjust_nick_list
sopel.db.ChannelValues = ChannelValues
SopelDB.get_channel_value = SpiceDB.get_channel_value
SopelDB.set_channel_value = SpiceDB.set_channel_value
SopelDB.delete_channel_value = SpiceDB.delete_channel_value
SopelDB.adjust_channel_value = SpiceDB.adjust_channel_value
SopelDB.adjust_channel_list = SpiceDB.adjust_channel_list
sopel.db.ServerValues = ServerValues
SopelDB.get_server_value = SpiceDB.get_server_value
SopelDB.set_server_value = SpiceDB.set_server_value
SopelDB.delete_server_value = SpiceDB.delete_server_value
SopelDB.adjust_server_value = SpiceDB.adjust_server_value
SopelDB.adjust_server_list = SpiceDB.adjust_server_list
sopel.db.PluginValues = PluginValues
SopelDB.get_plugin_value = SpiceDB.get_plugin_value
SopelDB.set_plugin_value = SpiceDB.set_plugin_value
SopelDB.delete_plugin_value = SpiceDB.delete_plugin_value
SopelDB.adjust_plugin_value = SpiceDB.adjust_plugin_value
SopelDB.adjust_plugin_list = SpiceDB.adjust_plugin_list
self.db = SopelDB(botconfig.config)
BASE.metadata.create_all(self.db.engine)
"""Nick"""
def get_nick_id(self, nick, create=True):
return self.db.get_nick_id(nick, create)
def alias_nick(self, nick, alias):
return self.db.alias_nick(nick, alias)
def unalias_nick(self, alias):
return self.db.unalias_nick(alias)
def check_nick_id(self, nick):
try:
self.db.get_nick_id(nick, create=False)
return True
except ValueError:
return False
def get_nick_value(self, nick, key, namespace='default'):
return self.db.get_nick_value(nick, key, namespace)
def set_nick_value(self, nick, key, value, namespace='default'):
return self.db.set_nick_value(nick, key, value, namespace)
def delete_nick_value(self, nick, key, namespace='default'):
return self.db.delete_nick_value(nick, key, namespace)
def adjust_nick_value(self, nick, key, value, namespace='default'):
return self.db.adjust_nick_value(nick, key, value, namespace)
def adjust_nick_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_nick_list(nick, key, entries, adjustmentdirection, namespace)
"""Bot"""
def get_bot_value(self, key, namespace='default'):
return self.db.get_nick_value(botconfig.nick, key, namespace)
def set_bot_value(self, key, value, namespace='default'):
return self.db.set_nick_value(botconfig.nick, key, value, namespace)
def delete_bot_value(self, key, namespace='default'):
return self.db.delete_nick_value(botconfig.nick, key, namespace)
def adjust_bot_value(self, key, value, namespace='default'):
return self.db.adjust_nick_value(botconfig.nick, key, value, namespace)
def adjust_bot_list(self, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_nick_list(botconfig.nick, key, entries, adjustmentdirection, namespace)
"""Channels"""
def get_channel_value(self, channel, key, namespace='default'):
return self.db.get_channel_value(channel, key, namespace)
def set_channel_value(self, channel, key, value, namespace='default'):
return self.db.set_channel_value(channel, key, value, namespace)
def delete_channel_value(self, channel, key, namespace='default'):
return self.db.delete_channel_value(channel, key, namespace)
def adjust_channel_value(self, channel, key, value, namespace='default'):
return self.db.adjust_channel_value(channel, key, value, namespace)
def adjust_channel_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_channel_list(nick, key, entries, adjustmentdirection, namespace)
"""Servers"""
def get_server_value(self, _server, key, namespace='default'):
return self.db.get__server_value(_server, key, namespace)
def set__server_value(self, _server, key, value, namespace='default'):
return self.db.set__server_value(_server, key, value, namespace)
def delete__server_value(self, _server, key, namespace='default'):
return self.db.delete__server_value(_server, key, namespace)
def adjust__server_value(self, _server, key, value, namespace='default'):
return self.db.adjust__server_value(_server, key, value, namespace)
def adjust__server_list(self, nick, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust__server_list(nick, key, entries, adjustmentdirection, namespace)
"""Plugins"""
def get_plugin_value(self, plugin, key, namespace='default'):
return self.db.get_plugin_value(plugin, key, namespace)
def set_plugin_value(self, plugin, key, value, namespace='default'):
return self.db.set_plugin_value(plugin, key, value, namespace)
def delete_plugin_value(self, plugin, key, namespace='default'):
return self.db.delete_plugin_value(plugin, key, namespace)
def adjust_plugin_value(self, plugin, key, value, namespace='default'):
return self.db.adjust_plugin_value(plugin, key, value, namespace)
def adjust_plugin_list(self, plugin, key, entries, adjustmentdirection, namespace='default'):
return self.db.adjust_plugin_list(plugin, key, entries, adjustmentdirection, namespace)
class BotDatabase():
def __init__(self):
self.db = None
self.dict = {
"bot": {
"nick": None,
},
}
def initialize(self, config):
SopelDB.adjust_nick_value = SpiceDB.adjust_nick_value
SopelDB.adjust_nick_list = SpiceDB.adjust_nick_list
SopelDB.adjust_channel_value = SpiceDB.adjust_channel_value
SopelDB.adjust_channel_list = SpiceDB.adjust_channel_list
SopelDB.adjust_plugin_value = SpiceDB.adjust_plugin_value
SopelDB.adjust_plugin_list = SpiceDB.adjust_plugin_list
self.db = SopelDB(config)
BASE.metadata.create_all(self.db.engine)
self.dict["bot"]["nick"] = config.core.nick
def __getattr__(self, name):
''' will only get called for undefined attributes '''
if hasattr(self.db, name):
return eval("self.db." + name)
else:
return None
"""Nick"""
def adjust_nick_value(self, nick, key, value):
return self.db.adjust_nick_value(nick, key, value)
def adjust_nick_list(self, nick, key, entries, adjustmentdirection):
return self.db.adjust_nick_list(nick, key, entries,
adjustmentdirection)
"""Bot"""
def get_bot_value(self, key):
return self.db.get_nick_value(self.dict["bot"]["nick"], key)
def set_bot_value(self, key, value):
return self.db.set_nick_value(self.dict["bot"]["nick"], key, value)
def delete_bot_value(self, key):
return self.db.delete_nick_value(self.dict["bot"]["nick"], key)
def adjust_bot_value(self, key, value):
return self.db.adjust_nick_value(self.dict["bot"]["nick"], key, value)
def adjust_bot_list(self, key, entries, adjustmentdirection):
return self.db.adjust_nick_list(self.dict["bot"]["nick"], key, entries,
adjustmentdirection)
"""Channels"""
def adjust_channel_value(self, channel, key, value):
return self.db.adjust_channel_value(channel, key, value)
def adjust_channel_list(self, nick, key, entries, adjustmentdirection):
return self.db.adjust_channel_list(nick, key, entries,
adjustmentdirection)
"""Plugins"""
def adjust_plugin_value(self, plugin, key, value):
return self.db.adjust_plugin_value(plugin, key, value)
def adjust_plugin_list(self, plugin, key, entries, adjustmentdirection):
return self.db.adjust_plugin_list(plugin, key, entries,
adjustmentdirection)