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_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 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 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_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 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 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.')
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)