Limnoria/test/test_irclib.py

1726 lines
66 KiB
Python
Raw Normal View History

##
2005-01-24 22:27:34 +01:00
# Copyright (c) 2002-2005, Jeremiah Fincher
# Copyright (c) 2010-2021, Valentin Lorentz
2005-01-19 14:14:38 +01:00
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
import copy
import pickle
2021-03-03 23:32:00 +01:00
import textwrap
import unittest.mock
from supybot.test import *
2005-01-19 14:14:38 +01:00
import supybot.conf as conf
import supybot.irclib as irclib
import supybot.drivers as drivers
2005-01-19 14:14:38 +01:00
import supybot.ircmsgs as ircmsgs
import supybot.ircutils as ircutils
2005-01-19 14:14:38 +01:00
# The test framework used to provide these, but not it doesn't. We'll add
# messages to as we find bugs (if indeed we find bugs).
msgs = []
rawmsgs = []
class CapNegMixin:
"""Utilities for handling the capability negotiation."""
def startCapNegociation(self, caps='sasl'):
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', caps)))
if caps:
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'sasl')
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'ACK', 'sasl')))
def endCapNegociation(self):
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('END',), m)
class IrcCommandDispatcherTestCase(SupyTestCase):
class DispatchedClass(irclib.IrcCommandDispatcher):
def doPrivmsg():
pass
def doCap():
pass
def doFail():
pass
class DispatchedClassSub(irclib.IrcCommandDispatcher):
def doPrivmsg():
pass
def doPrivmsgFoo():
pass
def doCapLs():
pass
def doFailFoo():
pass
def testCommandDispatch(self):
dispatcher = self.DispatchedClass()
self.assertEqual(
dispatcher.dispatchCommand('privmsg', ['foo']),
dispatcher.doPrivmsg)
self.assertEqual(
dispatcher.dispatchCommand('cap', ['*', 'ls']),
dispatcher.doCap)
self.assertEqual(
dispatcher.dispatchCommand('fail', ['foo', 'bar']),
dispatcher.doFail)
self.assertEqual(
dispatcher.dispatchCommand('foobar', ['*', 'ls']),
None)
def testSubCommandDispatch(self):
dispatcher = self.DispatchedClassSub()
self.assertEqual(
dispatcher.dispatchCommand('privmsg', ['foo']),
dispatcher.doPrivmsg)
self.assertEqual(
dispatcher.dispatchCommand('cap', ['*', 'ls']),
dispatcher.doCapLs)
self.assertEqual(
dispatcher.dispatchCommand('fail', ['foo', 'bar']),
dispatcher.doFailFoo)
self.assertEqual(
dispatcher.dispatchCommand('foobar', ['*', 'ls']),
None)
def testCommandDispatchMissingArgs(self):
dispatcher = self.DispatchedClass()
self.assertEqual(
dispatcher.dispatchCommand('privmsg', ['foo']),
dispatcher.doPrivmsg)
self.assertEqual(
dispatcher.dispatchCommand('cap', ['*']),
dispatcher.doCap)
self.assertEqual(
dispatcher.dispatchCommand('fail', []),
dispatcher.doFail)
self.assertEqual(
dispatcher.dispatchCommand('foobar', ['*']),
None)
def testCommandDispatchLegacy(self):
"""Tests the legacy parameters of dispatchCommand, without the "args"
argument."""
dispatcher = self.DispatchedClass()
with self.assertWarnsRegex(DeprecationWarning, "'args'"):
self.assertEqual(
dispatcher.dispatchCommand('privmsg'),
dispatcher.doPrivmsg)
with self.assertWarnsRegex(DeprecationWarning, "'args'"):
self.assertEqual(
dispatcher.dispatchCommand('cap'),
dispatcher.doCap)
with self.assertWarnsRegex(DeprecationWarning, "'args'"):
self.assertEqual(
dispatcher.dispatchCommand('fail'),
dispatcher.doFail)
with self.assertWarnsRegex(DeprecationWarning, "'args'"):
self.assertEqual(
dispatcher.dispatchCommand('foobar'),
None)
2005-01-19 14:14:38 +01:00
class IrcMsgQueueTestCase(SupyTestCase):
mode = ircmsgs.op('#foo', 'jemfinch')
msg = ircmsgs.privmsg('#foo', 'hey, you')
msgs = [ircmsgs.privmsg('#foo', str(i)) for i in range(10)]
kick = ircmsgs.kick('#foo', 'PeterB')
pong = ircmsgs.pong('123')
ping = ircmsgs.ping('123')
topic = ircmsgs.topic('#foo')
notice = ircmsgs.notice('jemfinch', 'supybot here')
join = ircmsgs.join('#foo')
who = ircmsgs.who('#foo')
def testInit(self):
q = irclib.IrcMsgQueue([self.msg, self.topic, self.ping])
self.assertEqual(len(q), 3)
def testLen(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
self.assertEqual(len(q), 1)
q.enqueue(self.mode)
self.assertEqual(len(q), 2)
q.enqueue(self.kick)
self.assertEqual(len(q), 3)
q.enqueue(self.topic)
self.assertEqual(len(q), 4)
q.dequeue()
self.assertEqual(len(q), 3)
q.dequeue()
self.assertEqual(len(q), 2)
q.dequeue()
self.assertEqual(len(q), 1)
q.dequeue()
self.assertEqual(len(q), 0)
def testContains(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
q.enqueue(self.msg)
q.enqueue(self.msg)
self.assertIn(self.msg, q)
q.dequeue()
self.assertIn(self.msg, q)
q.dequeue()
self.assertIn(self.msg, q)
q.dequeue()
self.assertNotIn(self.msg, q)
2005-01-19 14:14:38 +01:00
def testRepr(self):
q = irclib.IrcMsgQueue()
self.assertEqual(repr(q), 'IrcMsgQueue([])')
q.enqueue(self.msg)
try:
repr(q)
except Exception as e:
self.fail('repr(q) raised an exception: %s' %
utils.exnToString(e))
2005-01-19 14:14:38 +01:00
def testEmpty(self):
q = irclib.IrcMsgQueue()
self.assertFalse(q)
2005-01-19 14:14:38 +01:00
def testEnqueueDequeue(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
self.assertTrue(q)
2005-01-19 14:14:38 +01:00
self.assertEqual(self.msg, q.dequeue())
self.assertFalse(q)
2005-01-19 14:14:38 +01:00
q.enqueue(self.msg)
q.enqueue(self.notice)
self.assertEqual(self.msg, q.dequeue())
self.assertEqual(self.notice, q.dequeue())
for msg in self.msgs:
q.enqueue(msg)
for msg in self.msgs:
self.assertEqual(msg, q.dequeue())
def testPrioritizing(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
q.enqueue(self.mode)
self.assertEqual(self.mode, q.dequeue())
self.assertEqual(self.msg, q.dequeue())
q.enqueue(self.msg)
q.enqueue(self.kick)
self.assertEqual(self.kick, q.dequeue())
self.assertEqual(self.msg, q.dequeue())
q.enqueue(self.ping)
q.enqueue(self.msgs[0])
q.enqueue(self.kick)
q.enqueue(self.msgs[1])
q.enqueue(self.mode)
self.assertEqual(self.kick, q.dequeue())
self.assertEqual(self.mode, q.dequeue())
self.assertEqual(self.ping, q.dequeue())
self.assertEqual(self.msgs[0], q.dequeue())
self.assertEqual(self.msgs[1], q.dequeue())
def testNoIdenticals(self):
configVar = conf.supybot.protocols.irc.queuing.duplicates
original = configVar()
try:
configVar.setValue(True)
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
q.enqueue(self.msg)
self.assertEqual(self.msg, q.dequeue())
self.assertFalse(q)
finally:
configVar.setValue(original)
2005-01-19 14:14:38 +01:00
def testJoinBeforeWho(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.join)
q.enqueue(self.who)
self.assertEqual(self.join, q.dequeue())
self.assertEqual(self.who, q.dequeue())
## q.enqueue(self.who)
## q.enqueue(self.join)
## self.assertEqual(self.join, q.dequeue())
## self.assertEqual(self.who, q.dequeue())
2005-01-19 14:14:38 +01:00
def testTopicBeforePrivmsg(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
q.enqueue(self.topic)
self.assertEqual(self.topic, q.dequeue())
self.assertEqual(self.msg, q.dequeue())
def testModeBeforePrivmsg(self):
q = irclib.IrcMsgQueue()
q.enqueue(self.msg)
q.enqueue(self.mode)
self.assertEqual(self.mode, q.dequeue())
self.assertEqual(self.msg, q.dequeue())
q.enqueue(self.mode)
q.enqueue(self.msg)
self.assertEqual(self.mode, q.dequeue())
self.assertEqual(self.msg, q.dequeue())
class ChannelStateTestCase(SupyTestCase):
def testPickleCopy(self):
c = irclib.ChannelState()
self.assertEqual(pickle.loads(pickle.dumps(c)), c)
c.addUser('jemfinch')
c1 = pickle.loads(pickle.dumps(c))
self.assertEqual(c, c1)
c.removeUser('jemfinch')
self.assertNotIn('jemfinch', c.users)
self.assertIn('jemfinch', c1.users)
2005-01-19 14:14:38 +01:00
def testCopy(self):
c = irclib.ChannelState()
c.addUser('jemfinch')
c1 = copy.deepcopy(c)
c.removeUser('jemfinch')
self.assertNotIn('jemfinch', c.users)
self.assertIn('jemfinch', c1.users)
2005-01-19 14:14:38 +01:00
def testAddUser(self):
c = irclib.ChannelState()
c.addUser('foo')
self.assertIn('foo', c.users)
self.assertNotIn('foo', c.ops)
self.assertNotIn('foo', c.voices)
self.assertNotIn('foo', c.halfops)
2005-01-19 14:14:38 +01:00
c.addUser('+bar')
self.assertIn('bar', c.users)
self.assertIn('bar', c.voices)
self.assertNotIn('bar', c.ops)
self.assertNotIn('bar', c.halfops)
2005-01-19 14:14:38 +01:00
c.addUser('%baz')
self.assertIn('baz', c.users)
self.assertIn('baz', c.halfops)
self.assertNotIn('baz', c.voices)
self.assertNotIn('baz', c.ops)
2005-01-19 14:14:38 +01:00
c.addUser('@quuz')
self.assertIn('quuz', c.users)
self.assertIn('quuz', c.ops)
self.assertNotIn('quuz', c.halfops)
self.assertNotIn('quuz', c.voices)
2005-01-19 14:14:38 +01:00
class IrcStateTestCase(SupyTestCase):
class FakeIrc:
nick = 'nick'
prefix = 'nick!user@host'
def isChannel(self, s):
return ircutils.isChannel(s)
2005-01-19 14:14:38 +01:00
irc = FakeIrc()
def testKickRemovesChannel(self):
st = irclib.IrcState()
st.channels['#foo'] = irclib.ChannelState()
m = ircmsgs.kick('#foo', self.irc.nick, prefix=self.irc.prefix)
st.addMsg(self.irc, m)
self.assertNotIn('#foo', st.channels)
2005-01-19 14:14:38 +01:00
def testAddMsgRemovesOpsProperly(self):
st = irclib.IrcState()
st.channels['#foo'] = irclib.ChannelState()
st.channels['#foo'].ops.add('bar')
m = ircmsgs.mode('#foo', ('-o', 'bar'))
st.addMsg(self.irc, m)
self.assertNotIn('bar', st.channels['#foo'].ops)
2005-01-19 14:14:38 +01:00
def testNickChangesChangeChannelUsers(self):
st = irclib.IrcState()
st.channels['#foo'] = irclib.ChannelState()
st.channels['#foo'].addUser('@bar')
self.assertIn('bar', st.channels['#foo'].users)
self.assertTrue(st.channels['#foo'].isOp('bar'))
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.IrcMsg(':bar!asfd@asdf.com NICK baz'))
self.assertNotIn('bar', st.channels['#foo'].users)
self.assertFalse(st.channels['#foo'].isOp('bar'))
self.assertIn('baz', st.channels['#foo'].users)
self.assertTrue(st.channels['#foo'].isOp('baz'))
2005-01-19 14:14:38 +01:00
def testHistory(self):
if len(msgs) < 10:
return
maxHistoryLength = conf.supybot.protocols.irc.maxHistoryLength
with maxHistoryLength.context(10):
state = irclib.IrcState()
for msg in msgs:
try:
state.addMsg(self.irc, msg)
except Exception:
pass
self.assertFalse(len(state.history) > maxHistoryLength())
self.assertEqual(len(state.history), maxHistoryLength())
self.assertEqual(list(state.history),
msgs[len(msgs) - maxHistoryLength():])
2005-01-19 14:14:38 +01:00
def testWasteland005(self):
state = irclib.IrcState()
# Here we're testing if PREFIX works without the (ov) there.
state.addMsg(self.irc, ircmsgs.IrcMsg(':desolate.wasteland.org 005 jemfinch NOQUIT WATCH=128 SAFELIST MODES=6 MAXCHANNELS=10 MAXBANS=100 NICKLEN=30 TOPICLEN=307 KICKLEN=307 CHANTYPES=&# PREFIX=@+ NETWORK=DALnet SILENCE=10 :are available on this server'))
self.assertEqual(state.supported['prefix']['o'], '@')
self.assertEqual(state.supported['prefix']['v'], '+')
def testIRCNet005(self):
state = irclib.IrcState()
# Testing IRCNet's misuse of MAXBANS
state.addMsg(self.irc, ircmsgs.IrcMsg(':irc.inet.tele.dk 005 adkwbot WALLCHOPS KNOCK EXCEPTS INVEX MODES=4 MAXCHANNELS=20 MAXBANS=beI:100 MAXTARGETS=4 NICKLEN=9 TOPICLEN=120 KICKLEN=90 :are supported by this server'))
self.assertEqual(state.supported['maxbans'], 100)
def testSupportedUmodes(self):
state = irclib.IrcState()
state.addMsg(self.irc, ircmsgs.IrcMsg(':coulomb.oftc.net 004 testnick coulomb.oftc.net hybrid-7.2.2+oftc1.6.8 CDGPRSabcdfgiklnorsuwxyz biklmnopstveI bkloveI'))
2014-08-04 21:52:31 +02:00
self.assertEqual(state.supported['umodes'],
frozenset('CDGPRSabcdfgiklnorsuwxyz'))
self.assertEqual(state.supported['chanmodes'],
2014-08-04 22:16:34 +02:00
frozenset('biklmnopstveI'))
def testClientTagDenied(self):
state = irclib.IrcState()
# By default, every tag is assumed allowed
self.assertEqual(state.getClientTagDenied('foo'), False)
self.assertEqual(state.getClientTagDenied('bar'), False)
# Blacklist
state.addMsg(self.irc, ircmsgs.IrcMsg(
':example.org 005 mybot CLIENTTAGDENY=foo :are supported by this server'))
self.assertEqual(state.getClientTagDenied('foo'), True)
self.assertEqual(state.getClientTagDenied('bar'), False)
self.assertEqual(state.getClientTagDenied('+foo'), True)
self.assertEqual(state.getClientTagDenied('+bar'), False)
# Whitelist
state.addMsg(self.irc, ircmsgs.IrcMsg(
':example.org 005 mybot CLIENTTAGDENY=*,-foo :are supported by this server'))
self.assertEqual(state.getClientTagDenied('foo'), False)
self.assertEqual(state.getClientTagDenied('bar'), True)
self.assertEqual(state.getClientTagDenied('+foo'), False)
self.assertEqual(state.getClientTagDenied('+bar'), True)
def testShort004(self):
state = irclib.IrcState()
state.addMsg(self.irc, ircmsgs.IrcMsg(':coulomb.oftc.net 004 testnick coulomb.oftc.net hybrid-7.2.2+oftc1.6.8'))
self.assertNotIn('umodes', state.supported)
self.assertNotIn('chanmodes', state.supported)
2005-01-19 14:14:38 +01:00
def testEmptyTopic(self):
state = irclib.IrcState()
state.addMsg(self.irc, ircmsgs.topic('#foo'))
def testPickleCopy(self):
state = irclib.IrcState()
self.assertEqual(state, pickle.loads(pickle.dumps(state)))
for msg in msgs:
try:
state.addMsg(self.irc, msg)
except Exception:
pass
self.assertEqual(state, pickle.loads(pickle.dumps(state)))
def testCopy(self):
state = irclib.IrcState()
self.assertEqual(state, state.copy())
for msg in msgs:
try:
state.addMsg(self.irc, msg)
except Exception:
pass
self.assertEqual(state, state.copy())
def testCopyCopiesChannels(self):
state = irclib.IrcState()
stateCopy = state.copy()
state.channels['#foo'] = None
self.assertNotIn('#foo', stateCopy.channels)
2005-01-19 14:14:38 +01:00
def testJoin(self):
st = irclib.IrcState()
2022-11-20 20:08:04 +01:00
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.join('#foo', prefix=self.irc.prefix))
self.assertIn('#foo', st.channels)
self.assertIn(self.irc.nick, st.channels['#foo'].users)
2022-11-20 20:08:04 +01:00
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.join('#foo', prefix='foo!bar@baz'))
self.assertIn('foo', st.channels['#foo'].users)
2022-11-20 20:08:04 +01:00
2005-01-19 14:14:38 +01:00
st2 = st.copy()
2022-11-20 20:08:04 +01:00
st2.addMsg(self.irc, ircmsgs.quit(prefix='foo!bar@baz'))
self.assertNotIn('foo', st2.channels['#foo'].users)
self.assertIn('foo', st.channels['#foo'].users)
def testNickToHostmask(self):
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.join('#foo', prefix='foo!bar@baz'))
st.addMsg(self.irc, ircmsgs.join('#foo', prefix='bar!baz@qux'))
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
# QUIT erases the entry
with self.subTest("QUIT"):
st2 = st.copy()
st2.addMsg(self.irc, ircmsgs.quit(prefix='foo!bar@baz'))
with self.assertRaises(KeyError):
st2.nickToHostmask('foo')
self.assertEqual(st2.nickToHostmask('bar'), 'bar!baz@qux')
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
# NICK moves the entry
with self.subTest("NICK"):
st2 = st.copy()
st2.addMsg(self.irc, ircmsgs.IrcMsg(prefix='foo!bar@baz',
command='NICK', args=['foo2']))
with self.assertRaises(KeyError):
st2.nickToHostmask('foo')
self.assertEqual(st2.nickToHostmask('foo2'), 'foo2!bar@baz')
self.assertEqual(st2.nickToHostmask('bar'), 'bar!baz@qux')
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
# NICK moves the entry (and overwrites if needed)
with self.subTest("NICK with overwrite"):
st2 = st.copy()
st2.addMsg(self.irc, ircmsgs.IrcMsg(prefix='foo!bar@baz',
command='NICK', args=['bar']))
with self.assertRaises(KeyError):
st2.nickToHostmask('foo')
self.assertEqual(st2.nickToHostmask('bar'), 'bar!bar@baz')
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
with self.subTest("PRIVMSG"):
st2 = st.copy()
st2.addMsg(self.irc, ircmsgs.IrcMsg(prefix='foo!bar2@baz2',
command='PRIVMSG',
args=['#chan', 'foo']))
self.assertEqual(st2.nickToHostmask('foo'), 'foo!bar2@baz2')
self.assertEqual(st2.nickToHostmask('bar'), 'bar!baz@qux')
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
with self.subTest("PRIVMSG with no host is ignored"):
st2 = st.copy()
st2.addMsg(self.irc, ircmsgs.IrcMsg(prefix='foo',
command='PRIVMSG',
args=['#chan', 'foo']))
self.assertEqual(st2.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st2.nickToHostmask('bar'), 'bar!baz@qux')
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
self.assertEqual(st.nickToHostmask('bar'), 'bar!baz@qux')
def testNickToHostmaskWho(self):
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.IrcMsg(command='352', # RPL_WHOREPLY
args=[self.irc.nick, '#chan', 'bar', 'baz', 'server.example',
'foo', 'H', '0 real name']))
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
def testNickToHostmaskWhox(self):
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.IrcMsg(command='354', # RPL_WHOSPCRPL
args=[self.irc.nick, '1', 'bar', '127.0.0.1', 'baz',
'foo', 'H', '0', 'real name']))
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar@baz')
def testChghost(self):
st = irclib.IrcState()
2005-01-19 14:14:38 +01:00
2022-11-20 20:08:04 +01:00
st.addMsg(self.irc, ircmsgs.IrcMsg(prefix='foo!bar@baz',
command='CHGHOST', args=['bar2', 'baz2']))
self.assertEqual(st.nickToHostmask('foo'), 'foo!bar2@baz2')
2005-01-19 14:14:38 +01:00
def testEq(self):
state1 = irclib.IrcState()
state2 = irclib.IrcState()
self.assertEqual(state1, state2)
for msg in msgs:
try:
state1.addMsg(self.irc, msg)
state2.addMsg(self.irc, msg)
self.assertEqual(state1, state2)
except Exception:
pass
def testHandlesModes(self):
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.join('#foo', prefix=self.irc.prefix))
self.assertNotIn('bar', st.channels['#foo'].ops)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.op('#foo', 'bar'))
self.assertIn('bar', st.channels['#foo'].ops)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.deop('#foo', 'bar'))
self.assertNotIn('bar', st.channels['#foo'].ops)
2005-01-19 14:14:38 +01:00
self.assertNotIn('bar', st.channels['#foo'].voices)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.voice('#foo', 'bar'))
self.assertIn('bar', st.channels['#foo'].voices)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.devoice('#foo', 'bar'))
self.assertNotIn('bar', st.channels['#foo'].voices)
2005-01-19 14:14:38 +01:00
self.assertNotIn('bar', st.channels['#foo'].halfops)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.halfop('#foo', 'bar'))
self.assertIn('bar', st.channels['#foo'].halfops)
2005-01-19 14:14:38 +01:00
st.addMsg(self.irc, ircmsgs.dehalfop('#foo', 'bar'))
self.assertNotIn('bar', st.channels['#foo'].halfops)
2005-01-19 14:14:38 +01:00
def testDoModeOnlyChannels(self):
st = irclib.IrcState()
self.assertTrue(st.addMsg(self.irc, ircmsgs.IrcMsg('MODE foo +i')) or 1)
2005-01-19 14:14:38 +01:00
def testNamreply(self):
"""RPL_NAMREPLY / reply to NAMES"""
# Just nicks (à la RFC 1459 + some common prefix chars)
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.IrcMsg(command='353',
args=('*', '=', '#chan', 'nick1 @nick2 ~@nick3')))
chan_st = st.channels['#chan']
self.assertEqual(chan_st.users, ircutils.IrcSet(['nick1', 'nick2', 'nick3']))
self.assertEqual(chan_st.ops, ircutils.IrcSet(['nick2', 'nick3']))
self.assertEqual(st.nicksToHostmasks, ircutils.IrcDict({}))
# with userhost-in-names
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.IrcMsg(command='353',
args=('*', '=', '#chan', 'nick1!u1@h1 @nick2!u2@h2 ~@nick3!u3@h3')))
chan_st = st.channels['#chan']
self.assertEqual(chan_st.users, ircutils.IrcSet(['nick1', 'nick2', 'nick3']))
self.assertEqual(chan_st.ops, ircutils.IrcSet(['nick2', 'nick3']))
self.assertEqual(st.nicksToHostmasks['nick1'], 'nick1!u1@h1')
self.assertEqual(st.nicksToHostmasks['nick2'], 'nick2!u2@h2')
self.assertEqual(st.nicksToHostmasks['nick3'], 'nick3!u3@h3')
# Prefixed with chars not in ISUPPORT PREFIX
st = irclib.IrcState()
st.addMsg(self.irc, ircmsgs.IrcMsg(command='005',
args=('*', 'PREFIX=(ov)@+', 'are supported')))
st.addMsg(self.irc, ircmsgs.IrcMsg(command='353',
args=('*', '=', '#chan', 'nick1!u1@h1 @nick2!u2@h2 ~@nick3!u3@h3')))
chan_st = st.channels['#chan']
self.assertEqual(chan_st.users, ircutils.IrcSet(['nick1', 'nick2', '~@nick3']))
self.assertEqual(chan_st.ops, ircutils.IrcSet(['nick2']))
self.assertEqual(st.nicksToHostmasks['nick1'], 'nick1!u1@h1')
self.assertEqual(st.nicksToHostmasks['nick2'], 'nick2!u2@h2')
self.assertEqual(st.nicksToHostmasks['~@nick3'], '~@nick3!u3@h3')
class IrcCapsTestCase(SupyTestCase, CapNegMixin):
def testReqLineLength(self):
self.irc = irclib.Irc('test')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
self.irc.REQUEST_CAPABILITIES = set(['a'*400, 'b'*400])
caps = ' '.join(self.irc.REQUEST_CAPABILITIES)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', '*', 'a'*400)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'b'*400)))
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'a'*400)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'b'*400)
def testNoEchomessageWithoutLabeledresponse(self):
self.irc = irclib.Irc('test')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'account-notify echo-message')))
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'account-notify')
m = self.irc.takeMsg()
self.assertIsNone(m)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'ACK', 'account-notify')))
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('END',), m)
def testEchomessageLabeledresponseGrouped(self):
self.irc = irclib.Irc('test')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
self.irc.REQUEST_CAPABILITIES = set([
'account-notify', 'a'*490, 'echo-message', 'labeled-response'])
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP', args=(
'*', 'LS',
'account-notify ' + 'a'*490 + ' echo-message labeled-response')))
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'echo-message labeled-response')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'a'*490)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'account-notify')
m = self.irc.takeMsg()
self.assertIsNone(m)
def testCapNew(self):
self.irc = irclib.Irc('test')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.assertEqual(self.irc.sasl_next_mechanisms, [])
self.startCapNegociation(caps='')
self.endCapNegociation()
while self.irc.takeMsg():
pass
self.irc.feedMsg(ircmsgs.IrcMsg(command='422')) # ERR_NOMOTD
m = self.irc.takeMsg()
self.assertIsNone(m)
self.irc.feedMsg(ircmsgs.IrcMsg(
command='CAP', args=['*', 'NEW', 'account-notify']))
m = self.irc.takeMsg()
self.assertEqual(m,
ircmsgs.IrcMsg(command='CAP', args=['REQ', 'account-notify']))
self.irc.feedMsg(ircmsgs.IrcMsg(
command='CAP', args=['*', 'ACK', 'account-notify']))
self.assertIn('account-notify', self.irc.state.capabilities_ack)
def testCapNewEchomessageLabeledResponse(self):
self.irc = irclib.Irc('test')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.assertEqual(self.irc.sasl_next_mechanisms, [])
self.startCapNegociation(caps='')
self.endCapNegociation()
while self.irc.takeMsg():
pass
self.irc.feedMsg(ircmsgs.IrcMsg(command='422')) # ERR_NOMOTD
m = self.irc.takeMsg()
self.assertIsNone(m)
self.irc.feedMsg(ircmsgs.IrcMsg(
command='CAP', args=['*', 'NEW', 'echo-message']))
m = self.irc.takeMsg()
self.assertIsNone(m)
self.irc.feedMsg(ircmsgs.IrcMsg(
command='CAP', args=['*', 'NEW', 'labeled-response']))
m = self.irc.takeMsg()
self.assertEqual(m,
ircmsgs.IrcMsg(
command='CAP', args=['REQ', 'echo-message labeled-response']))
self.irc.feedMsg(ircmsgs.IrcMsg(
command='CAP', args=['*', 'ACK', 'echo-message labeled-response']))
self.assertIn('echo-message', self.irc.state.capabilities_ack)
self.assertIn('labeled-response', self.irc.state.capabilities_ack)
class StsTestCase(SupyTestCase):
def setUp(self):
self.irc = irclib.Irc('test')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
self.irc.driver = unittest.mock.Mock()
def tearDown(self):
ircdb.networks.networks = {}
def _testStsInSecureConnection(self, cap_value):
self.irc.driver.anyCertValidationEnabled.return_value = True
self.irc.driver.ssl = True
self.irc.driver.currentServer = drivers.Server('irc.test', 6697, None, False)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'sts=' + cap_value)))
self.assertEqual(ircdb.networks.getNetwork('test').stsPolicies, {
'irc.test': (6697, cap_value)})
self.irc.driver.reconnect.assert_not_called()
def testStsInSecureConnectionWithPort(self):
self._testStsInSecureConnection('duration=42,port=12345')
def testStsInSecureConnectionWithoutPort(self):
self._testStsInSecureConnection('duration=42')
def testStsInSecureConnectionMissingDuration(self):
# "A persistence policy, expressed via the duration key. REQUIRED on a
# secure connection"
self.irc.driver.anyCertValidationEnabled.return_value = True
self.irc.driver.ssl = True
self.irc.driver.currentServer = drivers.Server('irc.test', 6697, None, False)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'sts=port=12345')))
self.assertEqual(ircdb.networks.getNetwork('test').stsPolicies, {})
self.irc.driver.reconnect.assert_not_called()
def _testStsInInsecureTlsConnection(self, cap_value):
self.irc.driver.anyCertValidationEnabled.return_value = False
self.irc.driver.ssl = True
self.irc.driver.currentServer = drivers.Server('irc.test', 6697, None, False)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'sts=' + cap_value)))
self.assertEqual(ircdb.networks.getNetwork('test').stsPolicies, {})
self.irc.driver.reconnect.assert_called_once_with(
server=drivers.Server('irc.test', 6697, None, True),
2019-12-08 21:25:59 +01:00
wait=True)
def testStsInInsecureTlsConnectionWithPort(self):
self._testStsInInsecureTlsConnection('duration=42,port=6697')
def testStsInInsecureTlsConnectionWithoutPort(self):
self._testStsInInsecureTlsConnection('duration=42')
def _testStsInCleartextConnection(self, cap_value):
self.irc.driver.anyCertValidationEnabled.return_value = False
self.irc.driver.ssl = False
self.irc.driver.currentServer = drivers.Server('irc.test', 6667, None, False)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'sts=' + cap_value)))
self.assertEqual(ircdb.networks.getNetwork('test').stsPolicies, {})
self.irc.driver.reconnect.assert_called_once_with(
server=drivers.Server('irc.test', 6697, None, True),
2019-12-08 21:25:59 +01:00
wait=True)
def testStsInCleartextConnectionWithDuration(self):
self._testStsInCleartextConnection('duration=42,port=6697')
def testStsInCleartextConnectionWithoutDuration(self):
self._testStsInCleartextConnection('port=6697')
def testStsInCleartextConnectionInvalidDuration(self):
# "Servers MAY send this key to all clients, but insecurely
# connected clients MUST ignore it."
self._testStsInCleartextConnection('duration=foo,port=6697')
def testStsInCleartextConnectionMissingPort(self):
self.irc.driver.anyCertValidationEnabled.return_value = False
self.irc.driver.ssl = False
self.irc.driver.currentServer = drivers.Server('irc.test', 6667, None, False)
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'sts=duration=42')))
self.assertEqual(ircdb.networks.getNetwork('test').stsPolicies, {})
self.irc.driver.reconnect.assert_not_called()
2005-01-19 14:14:38 +01:00
class IrcTestCase(SupyTestCase):
def setUp(self):
self.irc = irclib.Irc('test')
2015-06-12 14:30:50 +02:00
#m = self.irc.takeMsg()
#self.assertTrue(m.command == 'PASS', 'Expected PASS, got %r.' % m)
2015-06-12 14:30:50 +02:00
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args, ('LS', '302'), 'Expected CAP LS 302, got %r.' % m)
2015-06-12 14:30:50 +02:00
m = self.irc.takeMsg()
self.assertEqual(m.command, 'NICK', 'Expected NICK, got %r.' % m)
2015-06-12 14:30:50 +02:00
m = self.irc.takeMsg()
self.assertEqual(m.command, 'USER', 'Expected USER, got %r.' % m)
2015-06-12 14:30:50 +02:00
2015-05-24 12:25:42 +02:00
# TODO
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', '*', 'account-tag multi-prefix')))
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'LS', 'extended-join')))
2015-06-12 14:30:50 +02:00
2014-08-05 11:22:56 +02:00
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
2015-05-24 12:44:16 +02:00
self.assertEqual(m.args[0], 'REQ', m)
2015-06-12 14:30:50 +02:00
# NOTE: Capabilities are requested in alphabetic order, because
# sets are unordered, and their "order" is nondeterministic.
self.assertEqual(m.args[1], 'account-tag extended-join multi-prefix')
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'ACK', 'account-tag multi-prefix extended-join')))
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
2015-05-24 12:25:42 +02:00
self.assertEqual(m.args, ('END',), m)
2015-06-12 14:30:50 +02:00
m = self.irc.takeMsg()
self.assertIsNone(m, m)
2005-01-19 14:14:38 +01:00
def testPingResponse(self):
self.irc.feedMsg(ircmsgs.ping('123'))
self.assertEqual(ircmsgs.pong('123'), self.irc.takeMsg())
def test433Response(self):
# This is necessary; it won't change nick if irc.originalName==irc.nick
self.irc.nick = 'somethingElse'
self.irc.feedMsg(ircmsgs.IrcMsg('433 * %s :Nickname already in use.' %\
self.irc.nick))
msg = self.irc.takeMsg()
self.assertTrue(msg.command == 'NICK' and msg.args[0] != self.irc.nick)
2005-01-19 14:14:38 +01:00
self.irc.feedMsg(ircmsgs.IrcMsg('433 * %s :Nickname already in use.' %\
self.irc.nick))
msg = self.irc.takeMsg()
self.assertTrue(msg.command == 'NICK' and msg.args[0] != self.irc.nick)
2005-01-19 14:14:38 +01:00
def testSendBeforeQueue(self):
while self.irc.takeMsg() is not None:
self.irc.takeMsg()
self.irc.queueMsg(ircmsgs.IrcMsg('NOTICE #foo bar'))
self.irc.sendMsg(ircmsgs.IrcMsg('PRIVMSG #foo yeah!'))
msg = self.irc.takeMsg()
self.assertEqual(msg.command, 'PRIVMSG')
2005-01-19 14:14:38 +01:00
msg = self.irc.takeMsg()
self.assertEqual(msg.command, 'NOTICE')
2005-01-19 14:14:38 +01:00
def testNoMsgLongerThan512(self):
self.irc.queueMsg(ircmsgs.privmsg('whocares', 'x'*1000))
msg = self.irc.takeMsg()
self.assertEqual(
len(msg), 512, 'len(msg) was %s (msg=%r)' % (len(msg), msg))
# Server tags don't influence the size limit of the rest of the
# message.
self.irc.queueMsg(ircmsgs.IrcMsg(
command='PRIVMSG', args=['whocares', 'x'*1000],
server_tags={'y': 'z'*500}))
msg2 = self.irc.takeMsg()
self.assertEqual(
len(msg2), 512+504, 'len(msg2) was %s (msg2=%r)' % (len(msg2), msg2))
self.assertEqual(msg.args, msg2.args)
2005-01-19 14:14:38 +01:00
def testReset(self):
for msg in msgs:
try:
self.irc.feedMsg(msg)
except:
pass
self.irc.reset()
self.assertFalse(self.irc.state.history)
self.assertFalse(self.irc.state.channels)
self.assertFalse(self.irc.outstandingPing)
2005-01-19 14:14:38 +01:00
def testHistory(self):
self.irc.reset()
msg1 = ircmsgs.IrcMsg('PRIVMSG #linux :foo bar baz!')
self.irc.feedMsg(msg1)
self.assertEqual(self.irc.state.history[0], msg1)
msg2 = ircmsgs.IrcMsg('JOIN #sourcereview')
self.irc.feedMsg(msg2)
self.assertEqual(list(self.irc.state.history), [msg1, msg2])
def testMultipleMotd(self):
self.irc.reset()
self.irc.feedMsg(ircmsgs.IrcMsg(command='422'))
self.irc.feedMsg(ircmsgs.IrcMsg(command='422'))
self.irc.feedMsg(ircmsgs.IrcMsg(command='375', args=['nick']))
self.irc.feedMsg(ircmsgs.IrcMsg(command='372', args=['nick', 'some message']))
self.irc.feedMsg(ircmsgs.IrcMsg(command='376', args=['nick']))
def testSetUmodes(self):
def assertSentModes(modes):
self.assertEqual(
self.irc.takeMsg(),
ircmsgs.IrcMsg(command='MODE', args=['test', modes]),
)
self.irc.reset()
while self.irc.takeMsg():
pass
self.irc.state.supported["BOT"] = "" # invalid
self.irc._setUmodes()
self.assertIsNone(self.irc.takeMsg())
self.irc.state.supported["BOT"] = "bB" # invalid too
self.irc._setUmodes()
self.assertIsNone(self.irc.takeMsg())
del self.irc.state.supported["BOT"]
self.irc._setUmodes()
self.assertIsNone(self.irc.takeMsg())
self.irc.state.supported["BOT"] = "B"
self.irc._setUmodes()
assertSentModes("+B")
self.irc.state.supported["BOT"] = "b"
self.irc._setUmodes()
assertSentModes("+b")
# merge with configured umodes
with conf.supybot.protocols.irc.umodes.context("+B"):
self.irc._setUmodes()
assertSentModes("+B+b")
# no duplicate if char is the same
with conf.supybot.protocols.irc.umodes.context("+b"):
self.irc._setUmodes()
assertSentModes("+b")
# no duplicate if explicitly disabled
with conf.supybot.protocols.irc.umodes.context("-b"):
self.irc._setUmodes()
assertSentModes("-b")
def testMsgChannel(self):
self.irc.reset()
self.irc.state.supported['statusmsg'] = '@'
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG #linux :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux')
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG @#linux2 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux2')
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG +#linux3 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, None)
self.irc.state.supported['statusmsg'] = '+@'
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG #linux :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux')
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG @#linux2 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux2')
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG +#linux3 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux3')
del self.irc.state.supported['statusmsg']
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG #linux :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux')
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG @#linux2 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, None)
self.irc.feedMsg(ircmsgs.IrcMsg('PRIVMSG +#linux3 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, None)
# Test msg.channel is set only for PRIVMSG and NOTICE
self.irc.state.supported['statusmsg'] = '+@'
self.irc.feedMsg(ircmsgs.IrcMsg('NOTICE @#linux :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux')
self.irc.feedMsg(ircmsgs.IrcMsg('NOTICE @#linux2 :foo bar baz!'))
self.assertEqual(self.irc.state.history[-1].channel, '#linux2')
self.irc.feedMsg(ircmsgs.IrcMsg('MODE @#linux3 +v foo'))
self.assertEqual(self.irc.state.history[-1].channel, None)
def testFilterErrors(self):
self.irc.reset()
while self.irc.takeMsg() is not None:
pass
class BuggyCallback(irclib.IrcCallback):
infilter_called = False
outfilter_called = False
def name(self):
return 'buggycallback'
def inFilter(self, irc, msg):
self.infilter_called = True
raise Exception('test exception')
def outFilter(self, irc, msg):
self.outfilter_called = True
raise Exception('test exception')
class Callback(irclib.IrcCallback):
channels_set = None
def name(self):
return 'testcallback'
def doCommand(self, irc, msg):
irc.sendMsg(ircmsgs.privmsg('#foo', 'bar'))
def inFilter(self, irc, msg):
self.infilter_called = True
raise Exception('test exception')
def outFilter(self, irc, msg):
self.outfilter_called = True
raise Exception('test exception')
bc = BuggyCallback()
self.irc.addCallback(bc)
c = Callback()
self.irc.addCallback(c)
self.irc.feedMsg(ircmsgs.IrcMsg('COMMAND blah'))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.privmsg('#foo', 'bar'))
self.assertTrue(bc.infilter_called)
self.assertTrue(bc.outfilter_called)
self.assertTrue(c.infilter_called)
self.assertTrue(c.outfilter_called)
def testQuit(self):
self.irc.reset()
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser JOIN #foo'))
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser JOIN #bar'))
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser2 JOIN #bar2'))
class Callback(irclib.IrcCallback):
channels_set = None
def name(self):
return 'testcallback'
def doQuit(self2, irc, msg):
self2.channels_set = msg.tagged('channels')
c = Callback()
self.irc.addCallback(c)
try:
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser QUIT'))
finally:
self.irc.removeCallback(c.name())
2015-12-04 01:37:23 +01:00
self.assertEqual(c.channels_set, ircutils.IrcSet(['#foo', '#bar']))
def testNick(self):
self.irc.reset()
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser JOIN #foo'))
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser JOIN #bar'))
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser2 JOIN #bar2'))
class Callback(irclib.IrcCallback):
channels_set = None
def name(self):
return 'testcallback'
def doNick(self2, irc, msg):
self2.channels_set = msg.tagged('channels')
c = Callback()
self.irc.addCallback(c)
try:
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser NICK newuser'))
finally:
self.irc.removeCallback(c.name())
self.assertEqual(c.channels_set, ircutils.IrcSet(['#foo', '#bar']))
2015-12-04 01:37:23 +01:00
def testBatch(self):
self.irc.reset()
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser1 JOIN #foo'))
m1 = ircmsgs.IrcMsg(':host BATCH +name netjoin')
2015-12-04 01:37:23 +01:00
self.irc.feedMsg(m1)
m2 = ircmsgs.IrcMsg('@batch=name :someuser2 JOIN #foo')
2015-12-04 01:37:23 +01:00
self.irc.feedMsg(m2)
self.irc.feedMsg(ircmsgs.IrcMsg(':someuser3 JOIN #foo'))
m3 = ircmsgs.IrcMsg('@batch=name :someuser4 JOIN #foo')
self.irc.feedMsg(m3)
2015-12-04 01:37:23 +01:00
class Callback(irclib.IrcCallback):
batch = None
def name(self):
return 'testcallback'
def doBatch(self2, irc, msg):
self2.batch = msg.tagged('batch')
c = Callback()
self.irc.addCallback(c)
try:
m4 = ircmsgs.IrcMsg(':host BATCH -name')
self.irc.feedMsg(m4)
2015-12-04 01:37:23 +01:00
finally:
self.irc.removeCallback(c.name())
2021-03-03 23:32:00 +01:00
self.assertEqual(
c.batch,
irclib.Batch('name', 'netjoin', (), [m1, m2, m3, m4], None),
repr(c.batch)
)
def testBatchNested(self):
self.irc.reset()
logs = textwrap.dedent('''
:irc.host BATCH +outer example.com/foo
@batch=outer :irc.host BATCH +inner example.com/bar
@batch=inner :nick!user@host PRIVMSG #channel :Hi
@batch=outer :irc.host BATCH -inner
:irc.host BATCH -outer
''')
msgs = [ircmsgs.IrcMsg(s) for s in logs.split('\n') if s]
# Feed 'BATCH +outer', it should be added in state
self.irc.feedMsg(msgs[0])
outer = irclib.Batch('outer', 'example.com/foo', (), msgs[0:1], None)
self.assertEqual(self.irc.state.batches, {'outer': outer})
msg1 = self.irc.state.history[-1]
self.assertEqual(msg1.tagged('batch'), outer)
self.assertEqual(self.irc.state.getParentBatches(msg1), [outer])
# Feed 'BATCH +inner', it should be added in state
self.irc.feedMsg(msgs[1])
outer = irclib.Batch('outer', 'example.com/foo', (), msgs[0:2], None)
inner = irclib.Batch('inner', 'example.com/bar', (), msgs[1:2], outer)
self.assertIs(self.irc.state.batches['inner'].parent_batch,
self.irc.state.batches['outer'])
self.assertEqual(dict(self.irc.state.batches),
{'outer': outer, 'inner': inner})
msg2 = self.irc.state.history[-1]
self.assertEqual(msg2.tagged('batch'), inner)
self.assertEqual(self.irc.state.getParentBatches(msg2), [inner, outer])
# Feed 'PRIVMSG'
self.irc.feedMsg(msgs[2])
outer = irclib.Batch('outer', 'example.com/foo', (), msgs[0:3], None)
inner = irclib.Batch('inner', 'example.com/bar', (), msgs[1:3], outer)
self.assertIs(self.irc.state.batches['inner'].parent_batch,
self.irc.state.batches['outer'])
self.assertEqual(self.irc.state.batches,
{'outer': outer, 'inner': inner})
msg3 = self.irc.state.history[-1]
self.assertEqual(msg3.tagged('batch'), None)
self.assertEqual(self.irc.state.getParentBatches(msg3), [inner, outer])
# Feed 'BATCH -inner', it should be remove from state
self.irc.feedMsg(msgs[3])
outer = irclib.Batch('outer', 'example.com/foo', (), msgs[0:4], None)
inner = irclib.Batch('inner', 'example.com/bar', (), msgs[1:4], outer)
self.assertEqual(self.irc.state.batches, {'outer': outer})
self.assertIs(self.irc.state.history[-1].tagged('batch').parent_batch,
self.irc.state.batches['outer'])
msg4 = self.irc.state.history[-1]
self.assertEqual(msg4.tagged('batch'), inner)
self.assertEqual(self.irc.state.getParentBatches(msg4), [inner, outer])
# Feed 'BATCH -outer', it should be remove from state
self.irc.feedMsg(msgs[4])
outer = irclib.Batch('outer', 'example.com/foo', (), msgs[0:5], None)
inner = irclib.Batch('inner', 'example.com/bar', (), msgs[1:4], outer)
self.assertEqual(self.irc.state.batches, {})
msg5 = self.irc.state.history[-1]
self.assertEqual(msg5.tagged('batch'), outer)
self.assertEqual(self.irc.state.getParentBatches(msg5), [outer])
def testBatchError(self):
# Checks getting an ERROR message in a batch does not cause issues
# due to deinitializing the connection at the same time.
self.irc.reset()
m1 = ircmsgs.IrcMsg(':host BATCH +name batchtype')
self.irc.feedMsg(m1)
m2 = ircmsgs.IrcMsg('@batch=name :someuser2 NOTICE * :oh no')
self.irc.feedMsg(m2)
m3 = ircmsgs.IrcMsg('@batch=name ERROR :bye')
self.irc.feedMsg(m3)
class Callback(irclib.IrcCallback):
batch = None
def __call__(self, *args, **kwargs):
return super().__call__(*args, **kwargs)
def name(self):
return 'testcallback'
def doBatch(self2, irc, msg):
self2.batch = msg.tagged('batch')
# would usually be called by the driver upon reconnect() trigged
# by the ERROR:
self.irc.reset()
c = Callback()
self.irc.addCallback(c)
try:
m4 = ircmsgs.IrcMsg(':host BATCH -name')
self.irc.feedMsg(m4)
finally:
self.irc.removeCallback(c.name())
self.assertEqual(
c.batch,
irclib.Batch('name', 'batchtype', (), [m1, m2, m3, m4], None),
repr(c.batch)
)
def testTruncate(self):
self.irc = irclib.Irc('test')
while self.irc.takeMsg():
pass
# over 512 bytes
msg = ircmsgs.IrcMsg(command='PRIVMSG', args=('#test2', 'é'*256))
self.irc.sendMsg(msg)
m = self.irc.takeMsg()
remaining_payload = 'é' * ((512 - len('PRIVMSG #test2 :\r\n'))//2)
self.assertEqual(
str(m), 'PRIVMSG #test2 :%s\r\n' % remaining_payload)
# over 512 bytes, make sure it doesn't truncate in the middle of
# a character
msg = ircmsgs.IrcMsg(command='PRIVMSG', args=('#test', 'é'*256))
self.irc.sendMsg(msg)
m = self.irc.takeMsg()
remaining_payload = 'é' * ((512 - len('PRIVMSG #test :\r\n'))//2)
self.assertEqual(
str(m), 'PRIVMSG #test :%s\r\n' % remaining_payload)
2015-12-04 01:37:23 +01:00
2021-03-13 13:03:26 +01:00
class BatchTestCase(SupyTestCase):
def setUp(self):
self.irc = irclib.Irc('test')
conf.supybot.protocols.irc.experimentalExtensions.setValue(True)
while self.irc.takeMsg() is not None:
self.irc.takeMsg()
def tearDown(self):
conf.supybot.protocols.irc.experimentalExtensions.setValue(False)
def testQueueBatch(self):
"""Basic operation of queueBatch"""
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :there'),
ircmsgs.IrcMsg('BATCH -label'),
]
self.irc.queueBatch(copy.deepcopy(msgs))
for msg in msgs:
self.assertEqual(msg, self.irc.takeMsg())
def testQueueBatchStartMinus(self):
msgs = [
ircmsgs.IrcMsg('BATCH -label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label'),
]
with self.assertRaises(ValueError):
self.irc.queueBatch(msgs)
self.assertIsNone(self.irc.takeMsg())
def testQueueBatchEndPlus(self):
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH +label'),
]
with self.assertRaises(ValueError):
self.irc.queueBatch(msgs)
self.assertIsNone(self.irc.takeMsg())
def testQueueBatchMismatchStartEnd(self):
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label2'),
]
with self.assertRaises(ValueError):
self.irc.queueBatch(msgs)
self.assertIsNone(self.irc.takeMsg())
def testQueueBatchMismatchInner(self):
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label2 PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label'),
]
with self.assertRaises(ValueError):
self.irc.queueBatch(msgs)
self.assertIsNone(self.irc.takeMsg())
def testQueueBatchTwice(self):
"""Basic operation of queueBatch"""
all_msgs = []
for label in ('label1', 'label2'):
msgs = [
ircmsgs.IrcMsg('BATCH +%s batchtype' % label),
ircmsgs.IrcMsg('@batch=%s PRIVMSG #channel :hello' % label),
ircmsgs.IrcMsg('@batch=%s PRIVMSG #channel :there' % label),
ircmsgs.IrcMsg('BATCH -%s' % label),
]
all_msgs.extend(msgs)
self.irc.queueBatch(copy.deepcopy(msgs))
for msg in all_msgs:
self.assertEqual(msg, self.irc.takeMsg())
def testQueueBatchDuplicate(self):
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label'),
]
self.irc.queueBatch(copy.deepcopy(msgs))
with self.assertRaises(ValueError):
self.irc.queueBatch(copy.deepcopy(msgs))
for msg in msgs:
self.assertEqual(msg, self.irc.takeMsg())
self.assertIsNone(self.irc.takeMsg())
def testQueueBatchReuse(self):
"""We can reuse the same label after the batch is closed."""
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label'),
]
self.irc.queueBatch(copy.deepcopy(msgs))
for msg in msgs:
self.assertEqual(msg, self.irc.takeMsg())
self.irc.queueBatch(copy.deepcopy(msgs))
for msg in msgs:
self.assertEqual(msg, self.irc.takeMsg())
def testBatchInterleaved(self):
"""Make sure it's not possible for an unrelated message to be sent
while a batch is open"""
msgs = [
ircmsgs.IrcMsg('BATCH +label batchtype'),
ircmsgs.IrcMsg('@batch=label PRIVMSG #channel :hello'),
ircmsgs.IrcMsg('BATCH -label'),
]
msg = ircmsgs.IrcMsg('PRIVMSG #channel :unrelated message')
with self.subTest('sendMsg called before "BATCH +" is dequeued'):
self.irc.queueBatch(copy.deepcopy(msgs))
self.irc.sendMsg(msg)
self.assertEqual(msg, self.irc.takeMsg())
self.assertEqual(msgs[0], self.irc.takeMsg())
self.assertEqual(msgs[1], self.irc.takeMsg())
self.assertEqual(msgs[2], self.irc.takeMsg())
self.assertIsNone(self.irc.takeMsg())
with self.subTest('sendMsg called after "BATCH +" is dequeued'):
self.irc.queueBatch(copy.deepcopy(msgs))
self.assertEqual(msgs[0], self.irc.takeMsg())
self.irc.sendMsg(msg)
self.assertEqual(msgs[1], self.irc.takeMsg())
self.assertEqual(msgs[2], self.irc.takeMsg())
self.assertEqual(msg, self.irc.takeMsg())
self.assertIsNone(self.irc.takeMsg())
class SaslTestCase(SupyTestCase, CapNegMixin):
def setUp(self):
pass
def testPlain(self):
try:
conf.supybot.networks.test.sasl.username.setValue('jilles')
conf.supybot.networks.test.sasl.password.setValue('sesame')
self.irc = irclib.Irc('test')
finally:
conf.supybot.networks.test.sasl.username.setValue('')
conf.supybot.networks.test.sasl.password.setValue('')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.irc.sasl_next_mechanisms = ['scram-sha-256', 'plain']
self.startCapNegociation()
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('SCRAM-SHA-256',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='904',
args=('mechanism not available',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('PLAIN',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='AUTHENTICATE', args=('+',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('amlsbGVzAGppbGxlcwBzZXNhbWU=',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='900', args=('jilles',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='903', args=('jilles',)))
self.endCapNegociation()
def testExternalFallbackToPlain(self):
try:
conf.supybot.networks.test.sasl.username.setValue('jilles')
conf.supybot.networks.test.sasl.password.setValue('sesame')
conf.supybot.networks.test.certfile.setValue('foo')
self.irc = irclib.Irc('test')
finally:
conf.supybot.networks.test.sasl.username.setValue('')
conf.supybot.networks.test.sasl.password.setValue('')
conf.supybot.networks.test.certfile.setValue('')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.irc.sasl_next_mechanisms = ['external', 'plain']
self.startCapNegociation()
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('EXTERNAL',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='904',
args=('mechanism not available',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('PLAIN',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='AUTHENTICATE', args=('+',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('amlsbGVzAGppbGxlcwBzZXNhbWU=',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='900', args=('jilles',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='903', args=('jilles',)))
self.endCapNegociation()
def testFilter(self):
try:
conf.supybot.networks.test.sasl.username.setValue('jilles')
conf.supybot.networks.test.sasl.password.setValue('sesame')
conf.supybot.networks.test.certfile.setValue('foo')
self.irc = irclib.Irc('test')
finally:
conf.supybot.networks.test.sasl.username.setValue('')
conf.supybot.networks.test.sasl.password.setValue('')
conf.supybot.networks.test.certfile.setValue('')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.irc.sasl_next_mechanisms = ['external', 'plain']
self.startCapNegociation(caps='sasl=foo,plain,bar')
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('PLAIN',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='AUTHENTICATE', args=('+',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('amlsbGVzAGppbGxlcwBzZXNhbWU=',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='900', args=('jilles',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='903', args=('jilles',)))
self.endCapNegociation()
def testReauthenticate(self):
try:
conf.supybot.networks.test.sasl.username.setValue('jilles')
conf.supybot.networks.test.sasl.password.setValue('sesame')
self.irc = irclib.Irc('test')
finally:
conf.supybot.networks.test.sasl.username.setValue('')
conf.supybot.networks.test.sasl.password.setValue('')
self.assertEqual(self.irc.sasl_current_mechanism, None)
self.irc.sasl_next_mechanisms = ['plain']
self.startCapNegociation(caps='')
self.endCapNegociation()
while self.irc.takeMsg():
pass
self.irc.feedMsg(ircmsgs.IrcMsg(command='422')) # ERR_NOMOTD
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'NEW', 'sasl=EXTERNAL')))
self.irc.takeMsg() # None. But even if it was CAP REQ sasl, it would be ok
self.assertEqual(self.irc.takeMsg(), None)
try:
conf.supybot.networks.test.sasl.username.setValue('jilles')
conf.supybot.networks.test.sasl.password.setValue('sesame')
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'DEL', 'sasl')))
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'NEW', 'sasl=PLAIN')))
finally:
conf.supybot.networks.test.sasl.username.setValue('')
conf.supybot.networks.test.sasl.password.setValue('')
m = self.irc.takeMsg()
self.assertEqual(m.command, 'CAP', 'Expected CAP, got %r.' % m)
self.assertEqual(m.args[0], 'REQ', m)
self.assertEqual(m.args[1], 'sasl')
self.irc.feedMsg(ircmsgs.IrcMsg(command='CAP',
args=('*', 'ACK', 'sasl')))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('PLAIN',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='AUTHENTICATE', args=('+',)))
m = self.irc.takeMsg()
self.assertEqual(m, ircmsgs.IrcMsg(command='AUTHENTICATE',
args=('amlsbGVzAGppbGxlcwBzZXNhbWU=',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='900', args=('jilles',)))
self.irc.feedMsg(ircmsgs.IrcMsg(command='903', args=('jilles',)))
2005-01-19 14:14:38 +01:00
class IrcCallbackTestCase(SupyTestCase):
class FakeIrc:
pass
irc = FakeIrc()
def testName(self):
class UnnamedIrcCallback(irclib.IrcCallback):
pass
unnamed = UnnamedIrcCallback()
class NamedIrcCallback(irclib.IrcCallback):
myName = 'foobar'
def name(self):
return self.myName
named = NamedIrcCallback()
self.assertEqual(unnamed.name(), unnamed.__class__.__name__)
self.assertEqual(named.name(), named.myName)
def testDoCommand(self):
def makeCommand(msg):
return 'do' + msg.command.capitalize()
class DoCommandCatcher(irclib.IrcCallback):
def __init__(self):
self.L = []
def __getattr__(self, attr):
self.L.append(attr)
return lambda *args: None
doCommandCatcher = DoCommandCatcher()
for msg in msgs:
doCommandCatcher(self.irc, msg)
commands = list(map(makeCommand, msgs))
2005-01-19 14:14:38 +01:00
self.assertEqual(doCommandCatcher.L, commands)
def testFirstCommands(self):
try:
originalNick = conf.supybot.nick()
originalUser = conf.supybot.user()
originalPassword = conf.supybot.networks.test.password()
nick = 'nick'
conf.supybot.nick.setValue(nick)
user = 'user any user'
conf.supybot.user.setValue(user)
2015-01-19 18:08:15 +01:00
expected = [
2015-06-12 14:30:50 +02:00
ircmsgs.IrcMsg(command='CAP', args=('LS', '302')),
2015-01-19 18:08:15 +01:00
ircmsgs.nick(nick),
2015-05-17 12:31:14 +02:00
ircmsgs.user('limnoria', user),
2015-01-19 18:08:15 +01:00
]
2005-01-19 14:14:38 +01:00
irc = irclib.Irc('test')
msgs = [irc.takeMsg()]
2015-05-24 12:25:42 +02:00
while msgs[-1] is not None:
2005-01-19 14:14:38 +01:00
msgs.append(irc.takeMsg())
msgs.pop()
self.assertEqual(msgs, expected)
password = 'password'
conf.supybot.networks.test.password.setValue(password)
irc = irclib.Irc('test')
msgs = [irc.takeMsg()]
2015-05-24 12:25:42 +02:00
while msgs[-1] is not None:
2005-01-19 14:14:38 +01:00
msgs.append(irc.takeMsg())
msgs.pop()
2015-06-12 14:30:50 +02:00
expected.insert(1, ircmsgs.password(password))
2005-01-19 14:14:38 +01:00
self.assertEqual(msgs, expected)
finally:
conf.supybot.nick.setValue(originalNick)
conf.supybot.user.setValue(originalUser)
conf.supybot.networks.test.password.setValue(originalPassword)
2005-01-19 14:14:38 +01:00
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
2005-01-19 14:14:38 +01:00