def test_module_update(self):
Temp = namedtuple.namedtuple("Temp", "foo")
assert Temp.__module__ == self.__module__
with patch.object(namedtuple, "_sys") as mock_sys:
mock_sys.wraps = sys
mock_sys._getframe.side_effect = AttributeError()
Temp = namedtuple.namedtuple("Temp", "foo")
assert Temp.__module__ == "namedtuple_Temp"
def test_invalid_names(self):
self.assertRaises(ValueError, namedtuple.namedtuple, "Temp", "foo!")
self.assertRaises(ValueError, namedtuple.namedtuple, "Temp!", "foo")
self.assertRaises(ValueError, namedtuple.namedtuple, "Temp", "def")
self.assertRaises(ValueError, namedtuple.namedtuple, "def", "foo")
self.assertRaises(ValueError, namedtuple.namedtuple, "Temp", "0foo")
self.assertRaises(ValueError, namedtuple.namedtuple, "0Temp", "foo")
self.assertRaises(ValueError, namedtuple.namedtuple, "Temp", "_foo")
namedtuple.namedtuple("_Temp", "foo")
def test_verbose(self):
with patch.object(sys, "stdout", spec_set=True) as mock_stdout:
Temp = namedtuple.namedtuple("Temp", "foo", verbose=True)
call_args_list = mock_stdout.write.call_args_list
assert len(call_args_list) == 2
output = [call_args[0][0] for call_args in call_args_list]
assert output == [
"""class Temp(tuple):
'Temp(foo,)' \n
__slots__ = () \n
_fields = ('foo',) \n
def __new__(_cls, foo,):
return _tuple.__new__(_cls, (foo,)) \n
@classmethod
def _make(cls, iterable, new=tuple.__new__, len=len):
'Make a new Temp object from a sequence or iterable'
result = new(cls, iterable)
if len(result) != 1:
raise TypeError('Expected 1 arguments, got %d' % len(result))
return result \n
def __repr__(self):
return 'Temp(foo=%r)' % self \n
def _asdict(self):
'Return a new dict which maps field names to their values'
return dict(zip(self._fields, self)) \n
def _replace(_self, **kwds):
'Return a new Temp object replacing specified fields with new values'
result = _self._make(map(kwds.pop, ('foo',), _self))
if kwds:
raise ValueError('Got unexpected field names: %r' % kwds.keys())
return result \n
def __getnewargs__(self):
return tuple(self) \n
foo = _property(_itemgetter(0))\n""",
"\n",
]
from baiocas.lib.namedtuple import namedtuple
Listener = namedtuple('Listener', 'id function extra_args extra_kwargs')
# those gets converted and the class is private to Tornado.
def _add_timeout(deadline, callback):
timeout = IOLoop.add_timeout(self.io_loop, deadline, callback)
timeouts.append(Timeout(
callback=callback,
deadline=deadline,
reference=timeout
))
return timeout
def _remove_timeout(reference):
IOLoop.remove_timeout(self.io_loop, reference)
for index, timeout in enumerate(timeouts):
if timeout.reference == reference:
del timeouts[index]
break
# Grab all calls to add_timeout/remove_timeout
with nested(
patch.object(self.io_loop, 'add_timeout'),
patch.object(self.io_loop, 'remove_timeout', mocksignature=True)
) as (mock_add_timeout, mock_remove_timeout):
mock_add_timeout.side_effect = _add_timeout
mock_remove_timeout.side_effect = _remove_timeout
yield timeouts
# Class for timeouts scheduled with the I/O event loop. We don't use Tornado's
# instance directly since the deadline is converted to a timestamp and, more
# importantly, the class itself is marked as a private implementation detail.
Timeout = namedtuple('Timeout', 'callback, deadline, reference')
def test_rename(self):
fields = ("foo0", "_foo1", "foo2!", "foo0", "4foo", "foo5")
Temp = namedtuple.namedtuple("Temp", fields, rename=True)
assert Temp._fields == ("foo0", "_1", "_2", "_3", "_4", "foo5")
def setUpClass(cls):
cls._mask = ModuleMask("collections")
reload(namedtuple)
assert namedtuple.namedtuple.__module__ == "baiocas.lib.namedtuple"
module = sys.modules[cls.__module__]
setattr(module, "Point", namedtuple.namedtuple("Point", "x y"))
