284 lines
8.3 KiB
Python
284 lines
8.3 KiB
Python
# Copyright (c) Twisted Matrix Laboratories.
|
|
# See LICENSE for details.
|
|
|
|
|
|
import sys, os
|
|
import types
|
|
|
|
from twisted.trial import unittest
|
|
from twisted.python import rebuild
|
|
from twisted.python.compat import _PY3
|
|
|
|
from . import crash_test_dummy
|
|
f = crash_test_dummy.foo
|
|
|
|
class Foo: pass
|
|
class Bar(Foo): pass
|
|
class Baz(object): pass
|
|
class Buz(Bar, Baz): pass
|
|
|
|
class HashRaisesRuntimeError:
|
|
"""
|
|
Things that don't hash (raise an Exception) should be ignored by the
|
|
rebuilder.
|
|
|
|
@ivar hashCalled: C{bool} set to True when __hash__ is called.
|
|
"""
|
|
def __init__(self):
|
|
self.hashCalled = False
|
|
|
|
|
|
def __hash__(self):
|
|
self.hashCalled = True
|
|
raise RuntimeError('not a TypeError!')
|
|
|
|
|
|
|
|
# Set in test_hashException
|
|
unhashableObject = None
|
|
|
|
|
|
|
|
class RebuildTests(unittest.TestCase):
|
|
"""
|
|
Simple testcase for rebuilding, to at least exercise the code.
|
|
"""
|
|
def setUp(self):
|
|
self.libPath = self.mktemp()
|
|
os.mkdir(self.libPath)
|
|
self.fakelibPath = os.path.join(self.libPath,
|
|
'twisted_rebuild_fakelib')
|
|
os.mkdir(self.fakelibPath)
|
|
open(os.path.join(self.fakelibPath, '__init__.py'), 'w').close()
|
|
sys.path.insert(0, self.libPath)
|
|
|
|
|
|
def tearDown(self):
|
|
sys.path.remove(self.libPath)
|
|
|
|
|
|
def test_FileRebuild(self):
|
|
from twisted.python.util import sibpath
|
|
import shutil, time
|
|
shutil.copyfile(sibpath(__file__, "myrebuilder1.py"),
|
|
os.path.join(self.fakelibPath, "myrebuilder.py"))
|
|
from twisted_rebuild_fakelib import myrebuilder
|
|
a = myrebuilder.A()
|
|
b = myrebuilder.B()
|
|
i = myrebuilder.Inherit()
|
|
self.assertEqual(a.a(), 'a')
|
|
# Necessary because the file has not "changed" if a second has not gone
|
|
# by in unix. This sucks, but it's not often that you'll be doing more
|
|
# than one reload per second.
|
|
time.sleep(1.1)
|
|
shutil.copyfile(sibpath(__file__, "myrebuilder2.py"),
|
|
os.path.join(self.fakelibPath, "myrebuilder.py"))
|
|
rebuild.rebuild(myrebuilder)
|
|
b2 = myrebuilder.B()
|
|
self.assertEqual(b2.b(), 'c')
|
|
self.assertEqual(b.b(), 'c')
|
|
self.assertEqual(i.a(), 'd')
|
|
self.assertEqual(a.a(), 'b')
|
|
|
|
|
|
def test_Rebuild(self):
|
|
"""
|
|
Rebuilding an unchanged module.
|
|
"""
|
|
# This test would actually pass if rebuild was a no-op, but it
|
|
# ensures rebuild doesn't break stuff while being a less
|
|
# complex test than testFileRebuild.
|
|
|
|
x = crash_test_dummy.X('a')
|
|
|
|
rebuild.rebuild(crash_test_dummy, doLog=False)
|
|
# Instance rebuilding is triggered by attribute access.
|
|
x.do()
|
|
self.assertEqual(x.__class__, crash_test_dummy.X)
|
|
|
|
self.assertEqual(f, crash_test_dummy.foo)
|
|
|
|
|
|
def test_ComponentInteraction(self):
|
|
x = crash_test_dummy.XComponent()
|
|
x.setAdapter(crash_test_dummy.IX, crash_test_dummy.XA)
|
|
x.getComponent(crash_test_dummy.IX)
|
|
rebuild.rebuild(crash_test_dummy, 0)
|
|
newComponent = x.getComponent(crash_test_dummy.IX)
|
|
|
|
newComponent.method()
|
|
|
|
self.assertEqual(newComponent.__class__, crash_test_dummy.XA)
|
|
|
|
# Test that a duplicate registerAdapter is not allowed
|
|
from twisted.python import components
|
|
self.assertRaises(ValueError, components.registerAdapter,
|
|
crash_test_dummy.XA, crash_test_dummy.X,
|
|
crash_test_dummy.IX)
|
|
|
|
|
|
def test_UpdateInstance(self):
|
|
global Foo, Buz
|
|
|
|
b = Buz()
|
|
|
|
class Foo:
|
|
def foo(self):
|
|
"""
|
|
Dummy method
|
|
"""
|
|
|
|
class Buz(Bar, Baz):
|
|
x = 10
|
|
|
|
rebuild.updateInstance(b)
|
|
assert hasattr(b, 'foo'), "Missing method on rebuilt instance"
|
|
assert hasattr(b, 'x'), "Missing class attribute on rebuilt instance"
|
|
|
|
|
|
def test_BananaInteraction(self):
|
|
from twisted.python import rebuild
|
|
from twisted.spread import banana
|
|
rebuild.latestClass(banana.Banana)
|
|
|
|
|
|
def test_hashException(self):
|
|
"""
|
|
Rebuilding something that has a __hash__ that raises a non-TypeError
|
|
shouldn't cause rebuild to die.
|
|
"""
|
|
global unhashableObject
|
|
unhashableObject = HashRaisesRuntimeError()
|
|
def _cleanup():
|
|
global unhashableObject
|
|
unhashableObject = None
|
|
self.addCleanup(_cleanup)
|
|
rebuild.rebuild(rebuild)
|
|
self.assertTrue(unhashableObject.hashCalled)
|
|
|
|
|
|
def test_Sensitive(self):
|
|
"""
|
|
L{twisted.python.rebuild.Sensitive}
|
|
"""
|
|
from twisted.python import rebuild
|
|
from twisted.python.rebuild import Sensitive
|
|
|
|
class TestSensitive(Sensitive):
|
|
def test_method(self):
|
|
"""
|
|
Dummy method
|
|
"""
|
|
|
|
testSensitive = TestSensitive()
|
|
testSensitive.rebuildUpToDate()
|
|
self.assertFalse(testSensitive.needRebuildUpdate())
|
|
|
|
# Test rebuilding a builtin class
|
|
newException = rebuild.latestClass(Exception)
|
|
if _PY3:
|
|
self.assertEqual(repr(Exception), repr(newException))
|
|
else:
|
|
self.assertIn('twisted.python.rebuild.Exception', repr(newException))
|
|
self.assertEqual(newException, testSensitive.latestVersionOf(newException))
|
|
|
|
# Test types.MethodType on method in class
|
|
self.assertEqual(TestSensitive.test_method,
|
|
testSensitive.latestVersionOf(TestSensitive.test_method))
|
|
# Test types.MethodType on method in instance of class
|
|
self.assertEqual(testSensitive.test_method,
|
|
testSensitive.latestVersionOf(testSensitive.test_method))
|
|
# Test a class
|
|
self.assertEqual(TestSensitive,
|
|
testSensitive.latestVersionOf(TestSensitive))
|
|
|
|
class Foo:
|
|
"""
|
|
Dummy class
|
|
"""
|
|
|
|
foo = Foo()
|
|
|
|
# Test types.InstanceType
|
|
self.assertEqual(foo, testSensitive.latestVersionOf(foo))
|
|
|
|
def myFunction():
|
|
"""
|
|
Dummy method
|
|
"""
|
|
|
|
# Test types.FunctionType
|
|
self.assertEqual(myFunction, testSensitive.latestVersionOf(myFunction))
|
|
|
|
|
|
|
|
class NewStyleTests(unittest.TestCase):
|
|
"""
|
|
Tests for rebuilding new-style classes of various sorts.
|
|
"""
|
|
def setUp(self):
|
|
self.m = types.ModuleType('whipping')
|
|
sys.modules['whipping'] = self.m
|
|
|
|
|
|
def tearDown(self):
|
|
del sys.modules['whipping']
|
|
del self.m
|
|
|
|
|
|
def test_slots(self):
|
|
"""
|
|
Try to rebuild a new style class with slots defined.
|
|
"""
|
|
classDefinition = (
|
|
"class SlottedClass(object):\n"
|
|
" __slots__ = ['a']\n")
|
|
|
|
exec(classDefinition, self.m.__dict__)
|
|
inst = self.m.SlottedClass()
|
|
inst.a = 7
|
|
exec(classDefinition, self.m.__dict__)
|
|
rebuild.updateInstance(inst)
|
|
self.assertEqual(inst.a, 7)
|
|
self.assertIs(type(inst), self.m.SlottedClass)
|
|
|
|
|
|
def test_typeSubclass(self):
|
|
"""
|
|
Try to rebuild a base type subclass.
|
|
"""
|
|
classDefinition = (
|
|
"class ListSubclass(list):\n"
|
|
" pass\n")
|
|
|
|
exec(classDefinition, self.m.__dict__)
|
|
inst = self.m.ListSubclass()
|
|
inst.append(2)
|
|
exec(classDefinition, self.m.__dict__)
|
|
rebuild.updateInstance(inst)
|
|
self.assertEqual(inst[0], 2)
|
|
self.assertIs(type(inst), self.m.ListSubclass)
|
|
|
|
|
|
def test_instanceSlots(self):
|
|
"""
|
|
Test that when rebuilding an instance with a __slots__ attribute, it
|
|
fails accurately instead of giving a L{rebuild.RebuildError}.
|
|
"""
|
|
classDefinition = (
|
|
"class NotSlottedClass(object):\n"
|
|
" pass\n")
|
|
|
|
exec(classDefinition, self.m.__dict__)
|
|
inst = self.m.NotSlottedClass()
|
|
inst.__slots__ = ['a']
|
|
classDefinition = (
|
|
"class NotSlottedClass:\n"
|
|
" pass\n")
|
|
exec(classDefinition, self.m.__dict__)
|
|
# Moving from new-style class to old-style should fail.
|
|
self.assertRaises(TypeError, rebuild.updateInstance, inst)
|
|
|
|
if getattr(types, 'ClassType', None) is None:
|
|
test_instanceSlots.skip = "Old-style classes not supported on Python 3"
|