def testModules(self):
self.registry.newModule("foo", foo_src)
# quux has a copy of foo.x
self.registry.newModule("quux", quux_src)
# bar has a reference to foo
self.registry.newModule("bar", "import foo")
# baz has reference to f and copy of x,
# remember the the global x in f is looked up in foo
self.registry.newModule("baz", "from foo import *")
import foo, bar, baz, quux
self.assert_(foo._p_oid is None)
transaction.commit()
self.assert_(foo._p_oid)
self.assert_(bar._p_oid)
self.assert_(baz._p_oid)
self.assert_(quux._p_oid)
self.assertEqual(foo.f(4), 5)
self.assertEqual(bar.foo.f(4), 5)
self.assertEqual(baz.f(4), 5)
self.assertEqual(quux.f(4), 5)
self.assert_(foo.f is bar.foo.f)
self.assert_(foo.f is baz.f)
foo.x = 42
self.assertEqual(quux.f(4), 5)
transaction.commit()
self.assertEqual(quux.f(4), 5)
foo._p_deactivate()
# foo is deactivated, which means its dict is empty when f()
# is activated, how do we guarantee that foo is also
# activated?
self.assertEqual(baz.f(4), 46)
self.assertEqual(bar.foo.f(4), 46)
self.assertEqual(foo.f(4), 46)
self.useNewConnection()
def testClassReload(self):
self.registry.newModule("foo", src)
transaction.commit()
import foo
obj = foo.Foo()
obj.m()
self.root["d"] = d = PersistentDict()
d["m"] = obj
transaction.commit()
self.close()
foo._p_deactivate()
self.open()
del foo
import foo
def testClass(self):
self.registry.newModule("foo", src)
transaction.commit()
import foo
obj = foo.Foo()
obj.m()
self.root["m"] = obj
transaction.commit()
foo._p_deactivate()
o = foo.Foo()
i = o.m()
j = o.m()
self.assertEqual(i + 1, j)
self.useNewConnection()
