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