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