def fmtop(bot, trigger):
user = trigger.group(2)
api = bot.config.lastfm.api
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'lastfm_user')
if not user:
bot.say('User not given or set. Use .fmset to set your user')
return
r = requests.get('http://ws.audioscrobbler.com/2.0/'
'?method=user.gettopartists&user={}&'
'api_key={}&format=json'
'&period=7day&limit=3'.format(user, api))
if 'topartists' not in r.json():
bot.say('User {} not found'.format(user))
return
if len(r.json()['topartists']['artist']) == 0:
bot.say('{} hasn\'t listened to any tracks yet'.format(user))
return
artists = ' * '.join(['{} ({})'.format(i['name'], i['playcount'])
for i in r.json()['topartists']['artist']])
out = '{}\'s top artists (7 days): {}'.format(user, artists)
bot.say(out)
def test_get_nick_id_migration(db: SopelDB):
"""Test nicks with wrong casemapping are properly migrated."""
nick = 'Test[User]'
old_nick = Identifier._lower_swapped(nick)
# sanity check
assert Identifier(nick).lower() != old_nick, (
'Previous casemapping should be different from the new one')
# insert old version
with db.session() as session:
nickname = Nicknames(
nick_id=42,
slug=Identifier._lower_swapped(nick),
canonical=nick,
)
session.add(nickname)
session.commit()
assert db.get_nick_id(nick) == 42, 'Old nick must be converted.'
with db.session() as session:
nicknames = session.execute(select(Nicknames)).scalars().fetchall()
assert len(nicknames) == 1, (
'There should be only one instance of Nicknames.')
nickname_found = nicknames[0]
assert nickname_found.nick_id == 42
assert nickname_found.slug == Identifier(nick).lower()
assert nickname_found.canonical == nick
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 traktstats(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'trakt_user')
if not user:
bot.say('User not given or set. Use .traktset to set your user')
return
stats_r = requests.get(bot.memory['trakt']['stats_url'].format(user),
headers=bot.memory['trakt']['headers'])
if stats_r.status_code == 404:
bot.say('User {} does not exist'.format(user))
return
ratings_r = requests.get(bot.memory['trakt']['r_url'].format(user),
headers=bot.memory['trakt']['headers'])
stats = stats_r.json()
ratings = ratings_r.json()
r_counter = Counter(i['rating'] for i in ratings)
ratings_dist = '/'.join(str(i) for i in r_counter.values())
meta = [user,
stats['movies']['watched'],
stats['shows']['watched'],
stats['episodes']['watched'],
sum(r_counter.values()),
ratings_dist]
out = ('{} has watched {} films and {} shows with {} episodes. They have '
'rated {} films with the following distribution: {}').format(*meta)
bot.say(out)
def fm(bot, trigger):
user = trigger.group(2)
api = bot.config.lastfm.api
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'lastfm_user')
if not user:
bot.say('User not given or set. Use .fmset to set your user')
return
r = requests.get('http://ws.audioscrobbler.com/2.0/'
'?method=user.getrecenttracks&user={}&'
'api_key={}&format=json&limit=1'.format(user, api))
if 'recenttracks' not in r.json():
bot.say('User {} not found'.format(user))
return
if len(r.json()['recenttracks']['track']) == 0:
bot.say('{} hasn\'t listened to any tracks yet'.format(user))
return
last = r.json()['recenttracks']['track'][0]
if '@attr' in last and last['@attr']['nowplaying'] == 'true':
action = 'is listening to'
else:
action = 'last listened to'
meta = (user, action, last['artist']['#text'], last['name'],
last['album']['#text'])
out = '♫ {} {} {} - {} ({}) ♫'.format(*meta)
bot.say(out)
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_execute(db: SopelDB):
# todo: remove in Sopel 8.1
results = db.execute('SELECT * FROM nicknames')
assert results.fetchall() == []
results = db.execute(text('SELECT * FROM nicknames'))
assert results.fetchall() == []
def twit(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'twit_user')
if not user:
bot.say('User not given or set. Use .twitset to set your user')
return
url = ('https://api.twitter.com/1.1/statuses/'
'user_timeline.json?screen_name={}').format(user)
response, content = bot.memory['twitter']['client'].request(url)
content_json = json.loads(content.decode('utf-8'))
if response['status'] == '401':
bot.say('User {}\'s tweets are private'.format(user))
return
if response['status'] == '404':
bot.say('User {} not found'.format(user))
return
last = content_json[0]
message = ('[Twitter] {last[text]} | {last[user][name]} '
'(@{last[user][screen_name]}) | {last[retweet_count]} RTs '
'| {last[favorite_count]} ♥s').format(last=last)
bot.say(message)
def test_unalias_nick(db: SopelDB):
nick = 'Embolalia'
nick_id = 42
with db.session() as session:
nn = Nicknames(
nick_id=nick_id,
slug=Identifier(nick).lower(),
canonical=nick,
)
session.add(nn)
session.commit()
aliases = ['EmbölaliÅ', 'Embo`work', 'Embo']
with db.session() as session:
for alias in aliases:
nn = Nicknames(
nick_id=nick_id,
slug=Identifier(alias).lower(),
canonical=alias,
)
session.add(nn)
session.commit()
for alias in aliases:
db.unalias_nick(alias)
with db.session() as session:
found = session.scalar(
select(func.count()).select_from(Nicknames).where(
Nicknames.nick_id == nick_id))
assert found == 1
def test_delete_plugin_value(db: SopelDB):
db.set_plugin_value('plugin', 'testkey', 'todelete')
db.set_plugin_value('plugin', 'nodelete', 'tokeep')
assert db.get_plugin_value('plugin', 'testkey') == 'todelete'
assert db.get_plugin_value('plugin', 'nodelete') == 'tokeep'
db.delete_plugin_value('plugin', 'testkey')
assert db.get_plugin_value('plugin', 'testkey') is None
assert db.get_plugin_value('plugin', 'nodelete') == 'tokeep'
def test_get_plugin_value(db: SopelDB):
session = db.ssession()
pv = PluginValues(plugin='plugname', key='qwer', value='\"zxcv\"')
session.add(pv)
session.commit()
result = db.get_plugin_value('plugname', 'qwer')
assert result == 'zxcv'
session.close()
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_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_get_nick_id_casemapping(db: SopelDB, name, slug, variant):
"""Test get_nick_id is case-insensitive through an Identifier."""
nick = Identifier(name)
# Create the nick ID
nick_id = db.get_nick_id(nick, create=True)
with db.session() as session:
registered = session.execute(
select(Nicknames).where(
Nicknames.canonical == name)).scalars().fetchall()
assert len(registered) == 1
assert registered[0].slug == slug
assert registered[0].canonical == name
# Check that the retrieval actually is idempotent
assert nick_id == db.get_nick_id(name)
# Even if the case is different
assert nick_id == db.get_nick_id(variant)
# And no other nick IDs are created (even with create=True)
assert nick_id == db.get_nick_id(name, create=True)
assert nick_id == db.get_nick_id(variant, create=True)
with db.session() as session:
assert 1 == session.scalar(select(func.count()).select_from(NickIDs))
# But a truly different name means a new nick ID
new_nick_id = db.get_nick_id(name + '_test', create=True)
assert new_nick_id != nick_id
with db.session() as session:
assert 2 == session.scalar(select(func.count()).select_from(NickIDs))
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_channel_value(db: SopelDB):
with db.session() as session:
channel_value = ChannelValues(
channel='#channel',
key='testkey',
value='\"value\"',
)
session.add(channel_value)
session.commit()
result = db.get_channel_value('#channel', 'testkey')
assert result == 'value'
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 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 test_connect(db: SopelDB):
"""Test it's possible to get a raw connection and to use it properly."""
nick_id = db.get_nick_id('MrEricPraline', create=True)
connection = db.connect()
try:
cursor_obj = connection.cursor()
cursor_obj.execute("SELECT nick_id, canonical, slug FROM nicknames")
results = cursor_obj.fetchall()
cursor_obj.close()
assert results == [(nick_id, 'MrEricPraline', 'mrericpraline')]
finally:
connection.close()
def qwins(bot, trigger):
db = SopelDB(bot.config)
winners = db.execute(
'SELECT canonical, value from nicknames JOIN nick_values '
'ON nicknames.nick_id = nick_values.nick_id '
'WHERE key = ?',
['quiz_wins']).fetchall()
if winners:
bot.say('Overall quiz win counts')
for user, count in sorted(winners, key=lambda x: x[1], reverse=True):
bot.say('{}: {}'.format(user, count))
else:
bot.say('No one has won yet!')
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 _fixture_bot_setup(request):
bot = MockSopel('Sopel')
bot = rss._config_define(bot)
bot.config.core.db_filename = tempfile.mkstemp()[1]
bot.db = SopelDB(bot.config)
bot.output = ''
# monkey patch bot
def join(self, channel):
if channel not in bot.channels:
bot.config.core.channels.append(channel)
bot.join = types.MethodType(join, bot)
def say(self, message, channel=''):
bot.output += message + "\n"
bot.say = types.MethodType(say, bot)
# tear down bot
def fin():
os.remove(bot.config.filename)
os.remove(bot.config.core.db_filename)
request.addfinalizer(fin)
return bot
def test_get_nick_value(db: SopelDB, value):
nick = 'TerryGilliam'
nick_id = db.get_nick_id(nick, create=True)
with db.session() as session:
nick_value = NickValues(
nick_id=nick_id,
key='testkey',
value=json.dumps(value, ensure_ascii=False),
)
session.add(nick_value)
session.commit()
assert db.get_nick_value(nick, 'testkey') == value
assert db.get_nick_value(nick, 'otherkey') is None
assert db.get_nick_value('NotTestUser', 'testkey') is None, (
'This key must be defined for TerryGilliam only.')
def test_get_nick_id(db: SopelDB):
"""Test get_nick_id does not create NickID by default."""
nick = Identifier('MrEricPraline')
# Attempt to get nick ID: it is not created by default
with pytest.raises(ValueError):
db.get_nick_id(nick)
# Create the nick ID
nick_id = db.get_nick_id(nick, create=True)
# Check that one and only one nickname exists with that ID
with db.session() as session:
nickname = session.execute(
select(Nicknames).where(Nicknames.nick_id == nick_id)).scalar_one(
) # will raise if not one and exactly one
assert nickname.canonical == 'MrEricPraline'
assert nickname.slug == nick.lower()
def strava(bot, trigger):
db = SopelDB(bot.config)
strava_token = db.get_nick_value(trigger.nick, 'strava_token')
if not strava_token:
bot.say('Strava token not set. Use .stravaset (through PMs) to set')
return
client = stravalib.client.Client()
client.access_token = strava_token
action = trigger.group(2)
action_funs = {
'lastact': strava_lastact,
'bikes': strava_bikes,
'koms': strava_koms
}
action_fun = action_funs.get(action, strava_help)
action_fun(bot, trigger, client)
def test_alias_nick(db: SopelDB):
nick = 'MrEricPraline'
aliases = ['MrÉrïcPrâliné', 'John`Cleese', 'DeadParrot']
nick_id = db.get_nick_id(nick, create=True)
for alias in aliases:
db.alias_nick(nick, alias)
for alias in aliases:
assert db.get_nick_id(alias) == nick_id
db.alias_nick('both', 'arenew') # Shouldn't fail.
with pytest.raises(ValueError):
db.alias_nick('Eve', nick)
with pytest.raises(ValueError):
db.alias_nick(nick, nick)
def test_delete_channel_value(db: SopelDB):
# assert you can delete a non-existing key (without error)
db.delete_channel_value('#channel', 'testkey')
# assert you can delete an existing key
db.set_channel_value('#channel', 'testkey', 'channel-value')
db.delete_channel_value('#channel', 'testkey')
assert db.get_channel_value('#channel', 'testkey') is None
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 test_forget_channel(db: SopelDB):
db.set_channel_value('#channel', 'testkey1', 'value1')
db.set_channel_value('#channel', 'testkey2', 'value2')
assert db.get_channel_value('#channel', 'testkey1') == 'value1'
assert db.get_channel_value('#channel', 'testkey2') == 'value2'
db.forget_channel('#channel')
assert db.get_channel_value('#channel', 'wasd') is None
assert db.get_channel_value('#channel', 'asdf') is None
def test_forget_plugin(db: SopelDB):
db.set_plugin_value('plugin', 'wasd', 'uldr')
db.set_plugin_value('plugin', 'asdf', 'hjkl')
assert db.get_plugin_value('plugin', 'wasd') == 'uldr'
assert db.get_plugin_value('plugin', 'asdf') == 'hjkl'
db.forget_plugin('plugin')
assert db.get_plugin_value('plugin', 'wasd') is None
assert db.get_plugin_value('plugin', 'asdf') is None
def godstats(bot, trigger):
god = trigger.group(2)
if not god:
db = SopelDB(bot.config)
god = db.get_nick_value(trigger.nick, 'god')
if not god:
bot.say('God not given or set. Use .godset to set your god')
return
r = requests.get('http://godvillegame.com/gods/api/{}.json'.format(god))
hero = r.json()
if 'clan' not in hero:
hero['clan'] = 'no clan'
hero['clan_position'] = 'member'
out = ('{h[godname]}\'s hero {h[name]}: '
'A level {h[level]} {h[alignment]} {h[gender]}, '
'{h[clan]} {h[clan_position]}, {h[arena_won]} arena wins, '
'{h[arena_lost]} arena losses. {h[motto]}.').format(h=hero)
bot.say(out)
def trakt(bot, trigger):
user = trigger.group(2)
if not user:
db = SopelDB(bot.config)
user = db.get_nick_value(trigger.nick, 'trakt_user')
if not user:
bot.say('User not given or set. Use .traktset to set your user')
return
r = requests.get(bot.memory['trakt']['hist_url'].format(user),
headers=bot.memory['trakt']['headers'])
if r.status_code == 404:
bot.say('User {} does not exist'.format(user))
return
if len(r.json()) == 0:
bot.say('User {} has no history'.format(user))
return
last = r.json()[0]
if last['type'] == 'episode':
meta = [user,
last['show']['title'],
last['episode']['season'],
last['episode']['number'],
last['episode']['title']]
out = '{} last watched: {} {}x{:02} - {}'.format(*meta)
elif last['type'] == 'movie':
meta = [user,
last['movie']['title'],
last['movie']['year']]
out = '{} last watched: {} ({})'.format(*meta)
bot.say(out)
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)
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_unalias_nick_one_or_none(db: SopelDB):
# this will create the first version of the nick
db.get_nick_id('MrEricPraline', create=True)
# assert you can't unalias a unique nick
with pytest.raises(ValueError):
db.unalias_nick('MrEricPraline')
# and you can't either with a non-existing nick
with pytest.raises(ValueError):
db.unalias_nick('gumbys')
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 test_get_channel_slug_with_migration(db: SopelDB):
channel = db.make_identifier('#[channel]')
db.set_channel_value(channel, 'testkey', 'cval')
assert db.get_channel_slug(channel) == channel.lower()
assert db.get_channel_value(channel, 'testkey') == 'cval'
# insert a value with the wrong casemapping
old_channel = Identifier._lower_swapped('#[channel]')
assert old_channel == '#[channel]'
assert channel.lower() == '#{channel}'
with db.session() as session:
channel_value = ChannelValues(
channel=old_channel,
key='oldkey',
value='"value"' # result from json.dumps
)
session.add(channel_value)
session.commit()
assert db.get_channel_slug(old_channel) == channel.lower(), (
'Channel with previous casemapping must return the new version.')
assert db.get_channel_value(old_channel, 'oldkey') == 'value', (
'Key associated to an old version must be migrated to the new one')
def test_set_plugin_value(db: SopelDB):
# set new value
db.set_plugin_value('plugname', 'qwer', 'zxcv')
with db.session() as session:
result = session.query(PluginValues.value) \
.filter(PluginValues.plugin == 'plugname') \
.filter(PluginValues.key == 'qwer') \
.scalar()
assert result == '"zxcv"'
# update pre-existing value
db.set_plugin_value('plugname', 'qwer', 'new_zxcv')
with db.session() as session:
result = session.query(PluginValues.value) \
.filter(PluginValues.plugin == 'plugname') \
.filter(PluginValues.key == 'qwer') \
.scalar()
assert result == '"new_zxcv"'
def test_set_channel_value(db: SopelDB):
# set new value
db.set_channel_value('#channel', 'testkey', 'channel-value')
with db.session() as session:
result = session.query(ChannelValues.value) \
.filter(ChannelValues.channel == '#channel') \
.filter(ChannelValues.key == 'testkey') \
.scalar()
assert result == '"channel-value"'
# update pre-existing value
db.set_channel_value('#channel', 'testkey', 'new_channel-value')
with db.session() as session:
result = session.query(ChannelValues.value) \
.filter(ChannelValues.channel == '#channel') \
.filter(ChannelValues.key == 'testkey') \
.scalar()
assert result == '"new_channel-value"'
def db(configfactory):
content = TMP_CONFIG.format(db_filename=db_filename)
settings = configfactory('default.cfg', content)
db = SopelDB(settings)
# TODO add tests to ensure db creation works properly, too.
return db
def db():
config = MockConfig()
config.core.db_filename = db_filename
db = SopelDB(config)
# TODO add tests to ensure db creation works properly, too.
return db
