[Zodb-checkins] CVS: ZODB4/src/zodb/zeo/tests - test_options.py:1.2 test_mon.py:1.2 test_auth.py:1.2 invalid.py:1.2 basethread.py:1.2 auth_plaintext.py:1.2 zeoserver.py:1.9 test_zeo.py:1.13 test_conn.py:1.6 test_cache.py:1.4 forker.py:1.6 connection.py:1.9 commitlock.py:1.8 thread.py:NONE

Jeremy Hylton jeremy at zope.com
Thu Jun 19 18:41:39 EDT 2003


Update of /cvs-repository/ZODB4/src/zodb/zeo/tests
In directory cvs.zope.org:/tmp/cvs-serv15960/src/zodb/zeo/tests

Modified Files:
	zeoserver.py test_zeo.py test_conn.py test_cache.py forker.py 
	connection.py commitlock.py 
Added Files:
	test_options.py test_mon.py test_auth.py invalid.py 
	basethread.py auth_plaintext.py 
Removed Files:
	thread.py 
Log Message:
Merge ZODB3-2-merge branch to the head.

This completes the porting of bug fixes and random improvements from
ZODB 3.2 to ZODB 4.


=== ZODB4/src/zodb/zeo/tests/test_options.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/test_options.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,107 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+"""Test suite for ZEO.runzeo.ZEOOptions."""
+
+import os
+import sys
+import tempfile
+import unittest
+from StringIO import StringIO
+
+import zodb.config
+
+from zodb.zeo.runzeo import ZEOOptions
+from zdaemon.tests.testzdoptions import TestZDOptions
+
+class TestZEOOptions(TestZDOptions):
+
+    OptionsClass = ZEOOptions
+
+    input_args = ["-f", "Data.fs", "-a", "5555"]
+    output_opts = [("-f", "Data.fs"), ("-a", "5555")]
+    output_args = []
+
+    configdata = """
+        <zeo>
+          address 5555
+        </zeo>
+        <filestorage fs>
+          path Data.fs
+        </filestorage>
+        """
+
+    def setUp(self):
+        self.tempfilename = tempfile.mktemp()
+        f = open(self.tempfilename, "w")
+        f.write(self.configdata)
+        f.close()
+
+    def tearDown(self):
+        try:
+            os.remove(self.tempfilename)
+        except os.error:
+            pass
+
+    def test_configure(self):
+        # Hide the base class test_configure
+        pass
+
+    def test_defaults_with_schema(self):
+        options = self.OptionsClass()
+        options.realize(["-C", self.tempfilename])
+        self.assertEqual(options.address, ("", 5555))
+        self.assertEqual(len(options.storages), 1)
+        opener = options.storages[0]
+        self.assertEqual(opener.name, "fs")
+        self.assertEqual(opener.__class__, zodb.config.FileStorage)
+        self.assertEqual(options.read_only, 0)
+        self.assertEqual(options.transaction_timeout, None)
+        self.assertEqual(options.invalidation_queue_size, 100)
+
+    def test_defaults_without_schema(self):
+        options = self.OptionsClass()
+        options.realize(["-a", "5555", "-f", "Data.fs"])
+        self.assertEqual(options.address, ("", 5555))
+        self.assertEqual(len(options.storages), 1)
+        opener = options.storages[0]
+        self.assertEqual(opener.name, "1")
+        self.assertEqual(opener.__class__, zodb.config.FileStorage)
+        self.assertEqual(opener.config.path, "Data.fs")
+        self.assertEqual(options.read_only, 0)
+        self.assertEqual(options.transaction_timeout, None)
+        self.assertEqual(options.invalidation_queue_size, 100)
+
+    def test_commandline_overrides(self):
+        options = self.OptionsClass()
+        options.realize(["-C", self.tempfilename,
+                         "-a", "6666", "-f", "Wisdom.fs"])
+        self.assertEqual(options.address, ("", 6666))
+        self.assertEqual(len(options.storages), 1)
+        opener = options.storages[0]
+        self.assertEqual(opener.__class__, zodb.config.FileStorage)
+        self.assertEqual(opener.config.path, "Wisdom.fs")
+        self.assertEqual(options.read_only, 0)
+        self.assertEqual(options.transaction_timeout, None)
+        self.assertEqual(options.invalidation_queue_size, 100)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    for cls in [TestZEOOptions]:
+        suite.addTest(unittest.makeSuite(cls))
+    return suite
+
+if __name__ == "__main__":
+    unittest.main(defaultTest='test_suite')


=== ZODB4/src/zodb/zeo/tests/test_mon.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/test_mon.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,90 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Test that the monitor produce sensible results.
+
+$Id$
+"""
+
+import socket
+import time
+import unittest
+
+from zodb.zeo.tests.connection import CommonSetupTearDown
+from zodb.zeo.monitor import StorageStats
+
+class MonitorTests(CommonSetupTearDown):
+
+    monitor = 1
+
+    def get_monitor_output(self):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.connect(('localhost', 42000))
+        L = []
+        while 1:
+            buf = s.recv(8192)
+            if buf:
+                L.append(buf)
+            else:
+                break
+        s.close()
+        return "".join(L)
+
+    def parse(self, s):
+        # Return a list of StorageStats, one for each storage.
+        lines = s.split("\n")
+        self.assert_(lines[0].startswith("ZEO monitor server"))
+        # lines[1] is a date
+
+        # Break up rest of lines into sections starting with Storage:
+        # and ending with a blank line.
+        sections = []
+        cur = None
+        for line in lines[2:]:
+            if line.startswith("Storage:"):
+                cur = [line]
+            elif line:
+                cur.append(line)
+            else:
+                if cur is not None:
+                    sections.append(cur)
+                    cur = None
+        assert cur is None # bug in the test code if this fails
+
+        d = {}
+        for sect in sections:
+            hdr = sect[0]
+            key, value = hdr.split(":")
+            storage = int(value)
+            s = d[storage] = StorageStats()
+            s.parse("\n".join(sect[1:]))
+
+        return d
+        
+    def getConfig(self, path, create, read_only):
+        return """<mappingstorage 1/>"""
+
+    def testMonitor(self):
+        # just open a client to know that the server is up and running
+        # XXX should put this in setUp
+        self.storage = self.openClientStorage()
+        s = self.get_monitor_output()
+        self.storage.close()
+        self.assert_(s.find("monitor") != -1)
+        d = self.parse(s)
+        stats = d[1]
+        self.assertEqual(stats.clients, 1)
+        self.assertEqual(stats.commits, 0)
+
+def test_suite():
+    return unittest.makeSuite(MonitorTests)


=== ZODB4/src/zodb/zeo/tests/test_auth.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/test_auth.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,109 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Test suite for AuthZEO."""
+
+import os
+import tempfile
+import time
+import unittest
+
+from zodb.zeo.client import ClientStorage
+from zodb.zeo.server import StorageServer
+from zodb.zeo.tests.connection import CommonSetupTearDown
+
+from zodb.storage.file import FileStorage
+
+class AuthTest(CommonSetupTearDown):
+    __super_getServerConfig = CommonSetupTearDown.getServerConfig
+    __super_setUp = CommonSetupTearDown.setUp
+    __super_tearDown = CommonSetupTearDown.tearDown
+    
+    realm = None
+
+    def setUp(self):
+        self.pwfile = tempfile.mktemp()
+        if self.realm:
+            self.pwdb = self.dbclass(self.pwfile, self.realm)
+        else:
+            self.pwdb = self.dbclass(self.pwfile)
+        self.pwdb.add_user("foo", "bar")
+        self.pwdb.save()
+        self.__super_setUp()
+
+    def tearDown(self):
+        self.__super_tearDown()
+        os.remove(self.pwfile)
+
+    def getConfig(self, path, create, read_only):
+        return "<mappingstorage 1/>"
+
+    def getServerConfig(self, addr, ro_svr):
+        zconf = self.__super_getServerConfig(addr, ro_svr)
+        zconf.authentication_protocol = self.protocol
+        zconf.authentication_database = self.pwfile
+        zconf.authentication_realm = self.realm
+        return zconf
+
+    def wait(self):
+        for i in range(25):
+            if self._storage.test_connection:
+                return
+            time.sleep(0.1)
+        self.fail("Timed out waiting for client to authenticate")
+
+    def testOK(self):
+        # Sleep for 0.2 seconds to give the server some time to start up
+        # seems to be needed before and after creating the storage
+        self._storage = self.openClientStorage(wait=0, username="foo",
+                                              password="bar", realm=self.realm)
+        self.wait()
+
+        self.assert_(self._storage._connection)
+        self._storage._connection.poll()
+        self.assert_(self._storage.is_connected())
+    
+    def testNOK(self):
+        self._storage = self.openClientStorage(wait=0, username="foo",
+                                              password="noogie",
+                                              realm=self.realm)
+        self.wait()
+        # If the test established a connection, then it failed.
+        self.failIf(self._storage._connection)
+
+class PlainTextAuth(AuthTest):
+    import zodb.zeo.tests.auth_plaintext
+    protocol = "plaintext"
+    database = "authdb.sha"
+    dbclass = zodb.zeo.tests.auth_plaintext.Database
+    realm = "Plaintext Realm"
+
+class DigestAuth(AuthTest):
+    import zodb.zeo.auth.auth_digest
+    protocol = "digest"
+    database = "authdb.digest"
+    dbclass = zodb.zeo.auth.auth_digest.DigestDatabase
+    realm = "Digest Realm"
+
+test_classes = [PlainTextAuth, DigestAuth]
+
+def test_suite():
+    suite = unittest.TestSuite()
+    for klass in test_classes:
+        sub = unittest.makeSuite(klass)
+        suite.addTest(sub)
+    return suite
+
+if __name__ == "__main__":
+    unittest.main(defaultTest='test_suite')
+


=== ZODB4/src/zodb/zeo/tests/invalid.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/invalid.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,319 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+from thread import get_ident
+import threading
+import time
+
+from zodb.btrees.check import check, display
+from zodb.btrees.OOBTree import OOBTree
+from zodb.db import DB
+from zodb.interfaces import ReadConflictError, ConflictError, VersionLockError
+
+from zodb.zeo.tests.basethread import TestThread
+from zodb.zeo.tests.connection import CommonSetupTearDown
+
+from transaction import get_transaction
+
+import logging
+
+# XXX stopped porting here
+
+# The tests here let several threads have a go at one or more database
+# instances simultaneously.  Each thread appends a disjoint (from the
+# other threads) sequence of increasing integers to an OOBTree, one at
+# at time (per thread).  This provokes lots of conflicts, and BTrees
+# work hard at conflict resolution too.  An OOBTree is used because
+# that flavor has the smallest maximum bucket size, and so splits buckets
+# more often than other BTree flavors.
+#
+# When these tests were first written, they provoked an amazing number
+# of obscure timing-related bugs in cache consistency logic, revealed
+# by failure of the BTree to pass internal consistency checks at the end,
+# and/or by failure of the BTree to contain all the keys the threads
+# thought they added (i.e., the keys for which get_transaction().commit()
+# did not raise any exception).
+
+class StressThread(TestThread):
+
+    # Append integers startnum, startnum + step, startnum + 2*step, ...
+    # to 'tree' until Event stop is set.  If sleep is given, sleep
+    # that long after each append.  At the end, instance var .added_keys
+    # is a list of the ints the thread believes it added successfully.
+    def __init__(self, testcase, db, stop, threadnum, startnum,
+                 step=2, sleep=None):
+        TestThread.__init__(self, testcase)
+        self.db = db
+        self.stop = stop
+        self.threadnum = threadnum
+        self.startnum = startnum
+        self.step = step
+        self.sleep = sleep
+        self.added_keys = []
+
+    def testrun(self):
+        cn = self.db.open()
+        while not self.stop.isSet():
+            try:
+                tree = cn.root()["tree"]
+                break
+            except (ConflictError, KeyError):
+                get_transaction().abort()
+                cn.sync()
+        key = self.startnum
+        while not self.stop.isSet():
+            try:
+                tree[key] = self.threadnum
+                get_transaction().note("add key %s" % key)
+                get_transaction().commit()
+                if self.sleep:
+                    time.sleep(self.sleep)
+            except (ReadConflictError, ConflictError), msg:
+                get_transaction().abort()
+                # sync() is necessary here to process invalidations
+                # if we get a read conflict.  In the read conflict case,
+                # no objects were modified so cn never got registered
+                # with the transaction.
+                cn.sync()
+            else:
+                self.added_keys.append(key)
+            key += self.step
+        cn.close()
+
+class VersionStressThread(TestThread):
+
+    def __init__(self, testcase, db, stop, threadnum, startnum,
+                 step=2, sleep=None):
+        TestThread.__init__(self, testcase)
+        self.db = db
+        self.stop = stop
+        self.threadnum = threadnum
+        self.startnum = startnum
+        self.step = step
+        self.sleep = sleep
+        self.added_keys = []
+        self.log = logging.getLogger("thread:%s" % get_ident()).info
+
+    def testrun(self):
+        self.log("thread begin")
+        commit = 0
+        key = self.startnum
+        while not self.stop.isSet():
+            version = "%s:%s" % (self.threadnum, key)
+            commit = not commit
+            self.log("attempt to add key=%s version=%s commit=%d" %
+                     (key, version, commit))
+            if self.oneupdate(version, key, commit):
+                self.added_keys.append(key)
+            key += self.step
+
+    def oneupdate(self, version, key, commit=1):
+        # The mess of sleeps below were added to reduce the number
+        # of VersionLockErrors, based on empirical observation.
+        # It looks like the threads don't switch enough without
+        # the sleeps.
+
+        cn = self.db.open(version)
+        while not self.stop.isSet():
+            try:
+                tree = cn.root()["tree"]
+                break
+            except (ConflictError, KeyError), msg:
+                cn.sync()
+        while not self.stop.isSet():
+            try:
+                tree[key] = self.threadnum
+                get_transaction().note("add key %d" % key)
+                get_transaction().commit()
+                if self.sleep:
+                    time.sleep(self.sleep)
+                break
+            except (VersionLockError, ReadConflictError, ConflictError), msg:
+                self.log(msg)
+                get_transaction().abort()
+                # sync() is necessary here to process invalidations
+                # if we get a read conflict.  In the read conflict case,
+                # no objects were modified so cn never got registered
+                # with the transaction.
+                cn.sync()
+                if self.sleep:
+                    time.sleep(self.sleep)
+        try:
+            while not self.stop.isSet():
+                try:
+                    if commit:
+                        self.db.commitVersion(version)
+                        get_transaction().note("commit version %s" % version)
+                    else:
+                        self.db.abortVersion(version)
+                        get_transaction().note("abort version %s" % version)
+                    get_transaction().commit()
+                    if self.sleep:
+                        time.sleep(self.sleep)
+                    return commit
+                except ConflictError, msg:
+                    self.log(msg)
+                    get_transaction().abort()
+                    cn.sync()
+        finally:
+            cn.close()
+        return 0
+
+class InvalidationTests(CommonSetupTearDown):
+
+    level = 2
+    DELAY = 15  # number of seconds the main thread lets the workers run
+
+    def _check_tree(self, cn, tree):
+        # Make sure the BTree is sane and that all the updates persisted.
+        retries = 3
+        while retries:
+            retries -= 1
+            try:
+                check(tree)
+                tree._check()
+            except ReadConflictError:
+                if retries:
+                    get_transaction().abort()
+                    cn.sync()
+                else:
+                    raise
+            except:
+                display(tree)
+                raise
+
+    def _check_threads(self, tree, *threads):
+        # Make sure the thread's view of the world is consistent with
+        # the actual database state.
+        all_keys = []
+        for t in threads:
+            # If the test didn't add any keys, it didn't do what we expected.
+            self.assert_(t.added_keys)
+            for key in t.added_keys:
+                self.assert_(tree.has_key(key), key)
+            all_keys.extend(t.added_keys)
+        all_keys.sort()
+        self.assertEqual(all_keys, list(tree.keys()))
+
+    def go(self, stop, *threads):
+        # Run the threads
+        for t in threads:
+            t.start()
+        time.sleep(self.DELAY)
+        stop.set()
+        for t in threads:
+            t.cleanup()
+
+    def testConcurrentUpdates2Storages(self):
+        self._storage = storage1 = self.openClientStorage()
+        storage2 = self.openClientStorage(cache="2")
+        db1 = DB(storage1)
+        stop = threading.Event()
+
+        cn = db1.open()
+        tree = cn.root()["tree"] = OOBTree()
+        get_transaction().commit()
+
+        db2 = DB(storage2)
+        # Run two threads that update the BTree
+        t1 = StressThread(self, db1, stop, 1, 1)
+        t2 = StressThread(self, db2, stop, 2, 2)
+        self.go(stop, t1, t2)
+
+        cn.sync()
+        self._check_tree(cn, tree)
+        self._check_threads(tree, t1, t2)
+
+        cn.close()
+        db1.close()
+        db2.close()
+
+    def testConcurrentUpdates1Storage(self):
+        self._storage = storage1 = self.openClientStorage()
+        db1 = DB(storage1)
+        stop = threading.Event()
+
+        cn = db1.open()
+        tree = cn.root()["tree"] = OOBTree()
+        get_transaction().commit()
+
+        # Run two threads that update the BTree
+        t1 = StressThread(self, db1, stop, 1, 1, sleep=0.001)
+        t2 = StressThread(self, db1, stop, 2, 2, sleep=0.001)
+        self.go(stop, t1, t2)
+
+        cn.sync()
+        self._check_tree(cn, tree)
+        self._check_threads(tree, t1, t2)
+
+        cn.close()
+        db1.close()
+
+    def testConcurrentUpdates2StoragesMT(self):
+        self._storage = storage1 = self.openClientStorage()
+        db1 = DB(storage1)
+        stop = threading.Event()
+
+        cn = db1.open()
+        tree = cn.root()["tree"] = OOBTree()
+        get_transaction().commit()
+
+        db2 = DB(self.openClientStorage(cache="2"))
+        # Run three threads that update the BTree.
+        # Two of the threads share a single storage so that it
+        # is possible for both threads to read the same object
+        # at the same time.
+
+        t1 = StressThread(self, db1, stop, 1, 1, 3)
+        t2 = StressThread(self, db2, stop, 2, 2, 3, 0.001)
+        t3 = StressThread(self, db2, stop, 3, 3, 3, 0.001)
+        self.go(stop, t1, t2, t3)
+
+        cn.sync()
+        self._check_tree(cn, tree)
+        self._check_threads(tree, t1, t2, t3)
+
+        cn.close()
+        db1.close()
+        db2.close()
+
+    def testConcurrentUpdatesInVersions(self):
+        self._storage = storage1 = self.openClientStorage()
+        db1 = DB(storage1)
+        stop = threading.Event()
+
+        cn = db1.open()
+        tree = cn.root()["tree"] = OOBTree()
+        get_transaction().commit()
+        cn.close()
+
+        db2 = DB(self.openClientStorage(cache="2"))
+        # Run three threads that update the BTree.
+        # Two of the threads share a single storage so that it
+        # is possible for both threads to read the same object
+        # at the same time.
+
+        t1 = VersionStressThread(self, db1, stop, 1, 1, 3)
+        t2 = VersionStressThread(self, db2, stop, 2, 2, 3, 0.001)
+        t3 = VersionStressThread(self, db2, stop, 3, 3, 3, 0.001)
+        self.go(stop, t1, t2, t3)
+
+        cn = db1.open()
+        self._check_tree(cn, tree)
+        self._check_threads(tree, t1, t2, t3)
+
+        cn.close()
+        db1.close()
+        db2.close()
+


=== ZODB4/src/zodb/zeo/tests/basethread.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/basethread.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,42 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""A Thread base class for use with unittest."""
+
+from cStringIO import StringIO
+import threading
+import traceback
+
+class TestThread(threading.Thread):
+    __super_init = threading.Thread.__init__
+    __super_run = threading.Thread.run
+
+    def __init__(self, testcase, group=None, target=None, name=None,
+                 args=(), kwargs={}, verbose=None):
+        self.__super_init(group, target, name, args, kwargs, verbose)
+        self.setDaemon(1)
+        self._testcase = testcase
+
+    def run(self):
+        try:
+            self.testrun()
+        except Exception:
+            s = StringIO()
+            traceback.print_exc(file=s)
+            self._testcase.fail("Exception in thread %s:\n%s\n" %
+                                (self, s.getvalue()))
+
+    def cleanup(self, timeout=15):
+        self.join(timeout)
+        if self.isAlive():
+            self._testcase.fail("Thread did not finish: %s" % self)


=== ZODB4/src/zodb/zeo/tests/auth_plaintext.py 1.1 => 1.2 ===
--- /dev/null	Thu Jun 19 17:41:38 2003
+++ ZODB4/src/zodb/zeo/tests/auth_plaintext.py	Thu Jun 19 17:41:07 2003
@@ -0,0 +1,44 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Implements plaintext password authentication. The password is stored in
+an SHA hash in the Database. The client sends over the plaintext
+password, and the SHA hashing is done on the server side. 
+ 
+This mechanism offers *no network security at all*; the only security
+is provided by not storing plaintext passwords on disk.  (See the
+auth_srp module for a secure mechanism)"""
+
+import sha
+
+from zodb.zeo.server import ZEOStorage
+from zodb.zeo.auth import register_module
+from zodb.zeo.auth.base import Client, Database
+
+class StorageClass(ZEOStorage):
+    def auth(self, username, password):
+        try:
+            dbpw = self.database.get_password(username)
+        except LookupError:
+            return 0
+        
+        password = sha.new(password).hexdigest()
+        return self.finish_auth(dbpw == password)
+    
+class PlaintextClient(Client):
+    extensions = ["auth"]
+
+    def start(self, username, realm, password):
+        return self.stub.auth(username, password)
+
+register_module("plaintext", StorageClass, PlaintextClient, Database)


=== ZODB4/src/zodb/zeo/tests/zeoserver.py 1.8 => 1.9 ===
--- ZODB4/src/zodb/zeo/tests/zeoserver.py:1.8	Tue Feb 25 13:55:05 2003
+++ ZODB4/src/zodb/zeo/tests/zeoserver.py	Thu Jun 19 17:41:07 2003
@@ -28,12 +28,8 @@
 from zodb import config
 import zodb.zeo.server
 from zodb.zeo import threadedasync
-
-def load_storage(fp):
-    context = ZConfig.Context.Context()
-    rootconf = context.loadFile(fp)
-    storageconf = rootconf.getSection('Storage')
-    return config.createStorage(storageconf)
+from zodb.zeo.runzeo import ZEOOptions
+from zodb.zeo.server import StorageServer
 
 class ZEOTestServer(asyncore.dispatcher):
     """A server for killing the whole process at the end of a test.
@@ -123,56 +119,58 @@
 
     # We don't do much sanity checking of the arguments, since if we get it
     # wrong, it's a bug in the test suite.
-    ro_svr = False
-    keep = False
+    keep = 0
     configfile = None
-    invalidation_queue_size = 100
-    transaction_timeout = None
-    monitor_address = None
     # Parse the arguments and let getopt.error percolate
-    opts, args = getopt.getopt(sys.argv[1:], 'rkC:Q:T:m:')
+    opts, args = getopt.getopt(sys.argv[1:], 'kC:')
     for opt, arg in opts:
-        if opt == '-r':
-            ro_svr = True
-        elif opt == '-k':
-            keep = True
+        if opt == '-k':
+            keep = 1
         elif opt == '-C':
             configfile = arg
-        elif opt == '-Q':
-            invalidation_queue_size = int(arg)
-        elif opt == '-T':
-            transaction_timeout = int(arg)
-        elif opt == '-m':
-            monitor_address = '', int(arg)
+
+    zo = ZEOOptions()
+    zo.realize(["-C", configfile])
+    zeo_port = int(zo.address[1])
+            
+    # XXX a hack
+    if zo.auth_protocol == "plaintext":
+        import zodb.zeo.tests.auth_plaintext
+        
     # Open the config file and let ZConfig parse the data there.  Then remove
     # the config file, otherwise we'll leave turds.
-    fp = open(configfile, 'r')
-    storage = load_storage(fp)
-    fp.close()
-    os.remove(configfile)
     # The rest of the args are hostname, portnum
-    zeo_port = int(args[0])
     test_port = zeo_port + 1
-    test_addr = ('', test_port)
-    addr = ('', zeo_port)
-    serv = zodb.zeo.server.StorageServer(
-        addr, {'1': storage}, ro_svr,
-        invalidation_queue_size=invalidation_queue_size,
-        transaction_timeout=transaction_timeout,
-        monitor_address=monitor_address)
+    test_addr = ('localhost', test_port)
+    addr = ('localhost', zeo_port)
+    logger.info('creating the storage server')
+    storage = zo.storages[0].open()
+    mon_addr = None
+    if zo.monitor_address:
+        mon_addr = zo.monitor_address.address
+    server = StorageServer(
+        zo.address,
+        {"1": storage},
+        read_only=zo.read_only,
+        invalidation_queue_size=zo.invalidation_queue_size,
+        transaction_timeout=zo.transaction_timeout,
+        monitor_address=mon_addr,
+        auth_protocol=zo.auth_protocol,
+        auth_filename=zo.auth_database,
+        auth_realm=zo.auth_realm)
+
     try:
-        logger.info('creating the test server, ro: %s, keep: %s',
-                    ro_svr, keep)
-        t = ZEOTestServer(test_addr, serv, keep)
+        logger.info('creating the test server, keep: %s', keep)
+        t = ZEOTestServer(test_addr, server, keep)
     except socket.error, e:
         if e[0] <> errno.EADDRINUSE: raise
         logger.info('addr in use, closing and exiting')
         storage.close()
         storage.cleanup()
         sys.exit(2)
-    addr = ('', zeo_port)
+        
     logger.info('creating the storage server')
-    t.register_socket(serv.dispatcher)
+    t.register_socket(server.dispatcher)
     # Loop for socket events
     logger.info('entering threadedasync loop')
     threadedasync.loop()


=== ZODB4/src/zodb/zeo/tests/test_zeo.py 1.12 => 1.13 ===
--- ZODB4/src/zodb/zeo/tests/test_zeo.py:1.12	Fri May 16 18:53:47 2003
+++ ZODB4/src/zodb/zeo/tests/test_zeo.py	Thu Jun 19 17:41:07 2003
@@ -19,6 +19,7 @@
 import time
 import errno
 import socket
+import random
 import logging
 import asyncore
 import tempfile
@@ -40,6 +41,27 @@
 from zodb.zeo.tests import commitlock, threadtests
 from zodb.zeo.tests.common import TestClientStorage, DummyDB
 
+def get_port():
+    """Return a port that is not in use.
+
+    Checks if a port is in use by trying to connect to it.  Assumes it
+    is not in use if connect raises an exception.
+
+    Raises RuntimeError after 10 tries.
+    """
+    for i in range(10):
+        port = random.randrange(20000, 30000)
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            try:
+                s.connect(('localhost', port))
+            except socket.error:
+                # XXX check value of error?
+                return port
+        finally:
+            s.close()
+    raise RuntimeError, "Can't find port"
+
 class DummyDB:
     def invalidate(self, *args):
         pass
@@ -102,8 +124,11 @@
         logging.info("testZEO: setUp() %s", self.id())
         config = self.getConfig()
         for i in range(10):
+            port = get_port()
+            zconf = forker.ZEOConfig(('', port))
             try:
-                zeoport, adminaddr, pid = forker.start_zeo_server(config)
+                zport, adminaddr, pid, path = \
+                       forker.start_zeo_server(config, zconf, port)
             except socket.error, e:
                 if e[0] not in (errno.ECONNREFUSED, errno.ECONNRESET):
                     raise
@@ -113,14 +138,16 @@
             raise
         self._pids = [pid]
         self._servers = [adminaddr]
-        self._storage = TestClientStorage(zeoport, '1', cache_size=20000000,
-                                          min_disconnect_poll=0.5, wait=1)
+        self._conf_path = path
+        self._storage = ClientStorage(zport, '1', cache_size=20000000,
+                                      min_disconnect_poll=0.5, wait=1)
         self._storage.registerDB(DummyDB())
 
     def tearDown(self):
         # Clean up any transaction that might be left hanging around
         get_transaction().abort()
         self._storage.close()
+        os.remove(self._conf_path)
         for server in self._servers:
             forker.shutdown_zeo_server(server)
         if hasattr(os, 'waitpid'):
@@ -162,7 +189,7 @@
 
     def testTransactionalUndoIterator(self):
         pass
-    
+
     def _iterate(self):
         pass
 
@@ -174,11 +201,9 @@
     def getConfig(self):
         filename = self.__fs_base = tempfile.mktemp()
         return """\
-        <Storage>
-            type FileStorage
-            file_name %s
-            create yes
-        </Storage>
+        <filestorage 1>
+        path %s
+        </filestorage>
         """ % filename
 
 class BDBTests(UndoVersionStorageTests):
@@ -189,10 +214,9 @@
     def getConfig(self):
         self._envdir = tempfile.mktemp()
         return """\
-        <Storage>
-            type BDBFullStorage
-            name %s
-        </Storage>
+        <fullstorage 1>
+        name %s
+        </fullstorage>
         """ % self._envdir
 
     # XXX These test seems to have massive failures when I run them.
@@ -207,13 +231,7 @@
 class MappingStorageTests(StorageTests):
 
     def getConfig(self):
-        self._envdir = tempfile.mktemp()
-        return """\
-        <Storage>
-            type MappingStorage
-            name %s
-        </Storage>
-        """ % self._envdir
+        return """<mappingstorage 1/>"""
 
 test_classes = [FileStorageTests, MappingStorageTests]
 


=== ZODB4/src/zodb/zeo/tests/test_conn.py 1.5 => 1.6 ===
--- ZODB4/src/zodb/zeo/tests/test_conn.py:1.5	Fri May 16 17:49:36 2003
+++ ZODB4/src/zodb/zeo/tests/test_conn.py	Thu Jun 19 17:41:07 2003
@@ -1,6 +1,6 @@
 ##############################################################################
 #
-# Copyright (c) 2001 Zope Corporation and Contributors.
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
 # All Rights Reserved.
 #
 # This software is subject to the provisions of the Zope Public License,
@@ -19,59 +19,117 @@
 
 import unittest
 
-from zodb.zeo.tests.connection import ConnectionTests, ReconnectionTests
+from zodb.zeo.tests.connection \
+     import ConnectionTests, ReconnectionTests, TimeoutTests
+from zodb.zeo.tests.invalid import InvalidationTests
 from zodb.storage.base import berkeley_is_available
 
 class FileStorageConfig:
     def getConfig(self, path, create, read_only):
         return """\
-        <Storage>
-            type FileStorage
-            file_name %s
-            create %s
-            read_only %s
-        </Storage>""" % (path,
-                         create and 'yes' or 'no',
-                         read_only and 'yes' or 'no')
+        <filestorage 1>
+        path %s
+        create %s
+        read-only %s
+        </filestorage>""" % (path,
+                             create and 'yes' or 'no',
+                             read_only and 'yes' or 'no')
 
 class BerkeleyStorageConfig:
     def getConfig(self, path, create, read_only):
-        # Full always creates and doesn't have a read_only flag
         return """\
-        <Storage>
-            type BDBFullStorage
-            name %s
-            read_only %s
-        </Storage>""" % (path,
-                         read_only and 'yes' or 'no')
+        <fullstorage 1>
+        name %s
+        read-only %s
+        </fullstorage>""" % (path, read_only and "yes" or "no")
 
 class MappingStorageConfig:
     def getConfig(self, path, create, read_only):
-        return """\
-        <Storage>
-            type MappingStorage
-            name %s
-        </Storage>""" % path
-
-tests = [
-    (MappingStorageConfig, ConnectionTests, 1),
-    (FileStorageConfig, ReconnectionTests, 1),
-    (FileStorageConfig, ConnectionTests, 2),
-    ]
-         
+        return """<mappingstorage 1/>"""
+
+
+class FileStorageConnectionTests(
+    FileStorageConfig,
+    ConnectionTests,
+    InvalidationTests
+    ):
+    """FileStorage-specific connection tests."""
+    level = 2
+
+class FileStorageReconnectionTests(
+    FileStorageConfig,
+    ReconnectionTests
+    ):
+    """FileStorage-specific re-connection tests."""
+    # Run this at level 1 because MappingStorage can't do reconnection tests
+    level = 1
+
+class FileStorageTimeoutTests(
+    FileStorageConfig,
+    TimeoutTests
+    ):
+    level = 2
+
+
+class BDBConnectionTests(
+    BerkeleyStorageConfig,
+    ConnectionTests,
+    InvalidationTests
+    ):
+    """Berkeley storage connection tests."""
+    level = 2
+
+class BDBReconnectionTests(
+    BerkeleyStorageConfig,
+    ReconnectionTests
+    ):
+    """Berkeley storage re-connection tests."""
+    level = 2
+
+class BDBTimeoutTests(
+    BerkeleyStorageConfig,
+    TimeoutTests
+    ):
+    level = 2
+
+
+class MappingStorageConnectionTests(
+    MappingStorageConfig,
+    ConnectionTests
+    ):
+    """Mapping storage connection tests."""
+    level = 1
+
+# The ReconnectionTests can't work with MappingStorage because it's only an
+# in-memory storage and has no persistent state.
+
+class MappingStorageTimeoutTests(
+    MappingStorageConfig,
+    TimeoutTests
+    ):
+    level = 1
+
+
+
+test_classes = [FileStorageConnectionTests,
+                FileStorageReconnectionTests,
+                FileStorageTimeoutTests,
+                MappingStorageConnectionTests,
+                MappingStorageTimeoutTests]
+
 if berkeley_is_available:
-    tests += [
-        (BerkeleyStorageConfig, ConnectionTests, 2),
-        (BerkeleyStorageConfig, ReconnectionTests, 2),
-        ]
+    test_classes.append(BDBConnectionTests)
+    test_classes.append(BDBReconnectionTests)
+    test_classes.append(BDBTimeoutTests)
+
 
 def test_suite():
     suite = unittest.TestSuite()
-    for testclass, configclass, level in tests:
-        # synthesize a concrete class combining tests and configuration
-        name = "%s:%s" % (testclass.__name__, configclass.__name__)
-        aclass = type.__new__(type, name, (configclass, testclass, object), {})
-        aclass.level = level
-        sub = unittest.makeSuite(aclass)
+    for klass in test_classes:
+        sub = unittest.makeSuite(klass)
         suite.addTest(sub)
     return suite
+
+
+if __name__ == "__main__":
+    unittest.main(defaultTest='test_suite')


=== ZODB4/src/zodb/zeo/tests/test_cache.py 1.3 => 1.4 ===
--- ZODB4/src/zodb/zeo/tests/test_cache.py:1.3	Tue Feb 25 13:55:05 2003
+++ ZODB4/src/zodb/zeo/tests/test_cache.py	Thu Jun 19 17:41:07 2003
@@ -26,6 +26,10 @@
 
 class ClientCacheTests(unittest.TestCase):
 
+    _oid  = 'abcdefgh'
+    _oid2 = 'bcdefghi'
+    _oid3 = 'cdefghij'
+
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.cachesize = 10*1000*1000
@@ -41,94 +45,87 @@
 
     def testStoreLoad(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, '', '', '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
 
     def testMissingLoad(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
+        cache.store(self._oid, data, serial, '', '', '')
         loaded = cache.load('garbage1', '')
         self.assertEqual(loaded, None)
 
     def testInvalidate(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, '', '', '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
-        cache.invalidate(oid, '')
-        loaded = cache.load(oid, '')
+        cache.invalidate(self._oid, '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, None)
 
     def testVersion(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
         vname = 'myversion'
         vdata = '5678'*200
         vserial = 'IJKLMNOP'
-        cache.store(oid, data, serial, vname, vdata, vserial)
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, vname, vdata, vserial)
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
-        vloaded = cache.load(oid, vname)
+        vloaded = cache.load(self._oid, vname)
         self.assertEqual(vloaded, (vdata, vserial))
 
     def testVersionOnly(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = ''
         serial = ''
         vname = 'myversion'
         vdata = '5678'*200
         vserial = 'IJKLMNOP'
-        cache.store(oid, data, serial, vname, vdata, vserial)
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, vname, vdata, vserial)
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, None)
-        vloaded = cache.load(oid, vname)
+        vloaded = cache.load(self._oid, vname)
         self.assertEqual(vloaded, (vdata, vserial))
 
     def testInvalidateNonVersion(self):
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
         vname = 'myversion'
         vdata = '5678'*200
         vserial = 'IJKLMNOP'
-        cache.store(oid, data, serial, vname, vdata, vserial)
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, vname, vdata, vserial)
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
-        vloaded = cache.load(oid, vname)
+        vloaded = cache.load(self._oid, vname)
         self.assertEqual(vloaded, (vdata, vserial))
-        cache.invalidate(oid, '')
-        loaded = cache.load(oid, '')
+        cache.invalidate(self._oid, '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, None)
         # The version data is also invalidated at this point
-        vloaded = cache.load(oid, vname)
+        vloaded = cache.load(self._oid, vname)
         self.assertEqual(vloaded, None)
 
     def testInvalidateVersion(self):
         # Invalidating a version should not invalidate the non-version data.
         # (This tests for the same bug as testInvalidatePersists below.)
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, '', '', '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
-        cache.invalidate(oid, 'bogus')
-        loaded = cache.load(oid, '')
+        cache.invalidate(self._oid, 'bogus')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
 
     def testVerify(self):
@@ -138,30 +135,27 @@
             results.append((oid, serial, vserial))
         cache.verify(verifier)
         self.assertEqual(results, [])
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
+        cache.store(self._oid, data, serial, '', '', '')
         results = []
         cache.verify(verifier)
-        self.assertEqual(results, [(oid, serial, None)])
+        self.assertEqual(results, [(self._oid, serial, None)])
 
     def testCheckSize(self):
         # Make sure that cache._index[oid] is erased for oids that are
         # stored in the cache file that's rewritten after a flip.
         cache = self.cache
-        oid = 'abcdefgh'
         data = '1234'*100
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
+        cache.store(self._oid, data, serial, '', '', '')
         cache.checkSize(10*self.cachesize) # Force a file flip
-        oid2 = 'abcdefgz'
         data2 = '1234'*10
         serial2 = 'ABCDEFGZ'
-        cache.store(oid2, data2, serial2, '', '', '')
+        cache.store(self._oid2, data2, serial2, '', '', '')
         cache.checkSize(10*self.cachesize) # Force another file flip
-        self.assertNotEqual(cache._index.get(oid2), None)
-        self.assertEqual(cache._index.get(oid), None)
+        self.assertNotEqual(cache._index.get(self._oid2), None)
+        self.assertEqual(cache._index.get(self._oid), None)
 
     def testCopyToCurrent(self):
         # - write some objects to cache file 0
@@ -177,91 +171,105 @@
         cache = self.cache
 
         # Create some objects
-        oid1 = 'abcdefgh'
         data1 = '1234' * 100
         serial1 = 'ABCDEFGH'
-        oid2 = 'bcdefghi'
         data2 = '2345' * 200
         serial2 = 'BCDEFGHI'
         version2 = 'myversion'
         nonversion = 'nada'
         vdata2 = '5432' * 250
         vserial2 = 'IHGFEDCB'
-        oid3 = 'cdefghij'
         data3 = '3456' * 300
         serial3 = 'CDEFGHIJ'
 
         # Store them in the cache
-        cache.store(oid1, data1, serial1, '', '', '')
-        cache.store(oid2, data2, serial2, version2, vdata2, vserial2)
-        cache.store(oid3, data3, serial3, '', '', '')
+        cache.store(self._oid, data1, serial1, '', '', '')
+        cache.store(self._oid2, data2, serial2, version2, vdata2, vserial2)
+        cache.store(self._oid3, data3, serial3, '', '', '')
 
         # Verify that they are in file 0
-        self.assert_(None is not cache._index.get(oid1) > 0)
-        self.assert_(None is not cache._index.get(oid2) > 0)
-        self.assert_(None is not cache._index.get(oid3) > 0)
+        self.assert_(None is not cache._index.get(self._oid) > 0)
+        self.assert_(None is not cache._index.get(self._oid2) > 0)
+        self.assert_(None is not cache._index.get(self._oid3) > 0)
 
         # Load them and verify that the loads return correct data
-        self.assertEqual(cache.load(oid1, ''), (data1, serial1))
-        self.assertEqual(cache.load(oid2, ''), (data2, serial2))
-        self.assertEqual(cache.load(oid2, nonversion), (data2, serial2))
-        self.assertEqual(cache.load(oid2, version2), (vdata2, vserial2))
-        self.assertEqual(cache.load(oid3, ''), (data3, serial3))
+        self.assertEqual(cache.load(self._oid, ''), (data1, serial1))
+        self.assertEqual(cache.load(self._oid2, ''), (data2, serial2))
+        self.assertEqual(cache.load(self._oid2, nonversion), (data2, serial2))
+        self.assertEqual(cache.load(self._oid2, version2), (vdata2, vserial2))
+        self.assertEqual(cache.load(self._oid3, ''), (data3, serial3))
 
         # Verify that they are still in file 0
-        self.assert_(None is not cache._index.get(oid1) > 0)
-        self.assert_(None is not cache._index.get(oid2) > 0)
-        self.assert_(None is not cache._index.get(oid3) > 0)
+        self.assert_(None is not cache._index.get(self._oid) > 0)
+        self.assert_(None is not cache._index.get(self._oid2) > 0)
+        self.assert_(None is not cache._index.get(self._oid3) > 0)
 
         # Cause a cache flip
         cache.checkSize(10*self.cachesize)
 
         # Load o1, o2, o4 again and verify that the loads return correct data
-        self.assertEqual(cache.load(oid1, ''), (data1, serial1))
-        self.assertEqual(cache.load(oid2, version2), (vdata2, vserial2))
-        self.assertEqual(cache.load(oid2, nonversion), (data2, serial2))
-        self.assertEqual(cache.load(oid2, ''), (data2, serial2))
+        self.assertEqual(cache.load(self._oid, ''), (data1, serial1))
+        self.assertEqual(cache.load(self._oid2, version2), (vdata2, vserial2))
+        self.assertEqual(cache.load(self._oid2, nonversion), (data2, serial2))
+        self.assertEqual(cache.load(self._oid2, ''), (data2, serial2))
 
         # Verify that o1, o2, 04 are now in file 1, o3 still in file 0
-        self.assert_(None is not cache._index.get(oid1) < 0)
-        self.assert_(None is not cache._index.get(oid2) < 0)
-        self.assert_(None is not cache._index.get(oid3) > 0)
+        self.assert_(None is not cache._index.get(self._oid) < 0)
+        self.assert_(None is not cache._index.get(self._oid2) < 0)
+        self.assert_(None is not cache._index.get(self._oid3) > 0)
 
         # Cause another cache flip
         cache.checkSize(10*self.cachesize)
 
         # Load o1 and o2 again and verify that the loads return correct data
-        self.assertEqual(cache.load(oid1, ''), (data1, serial1))
-        self.assertEqual(cache.load(oid2, nonversion), (data2, serial2))
-        self.assertEqual(cache.load(oid2, version2), (vdata2, vserial2))
-        self.assertEqual(cache.load(oid2, ''), (data2, serial2))
+        self.assertEqual(cache.load(self._oid, ''), (data1, serial1))
+        self.assertEqual(cache.load(self._oid2, nonversion), (data2, serial2))
+        self.assertEqual(cache.load(self._oid2, version2), (vdata2, vserial2))
+        self.assertEqual(cache.load(self._oid2, ''), (data2, serial2))
 
         # Verify that o1 and o2 are now back in file 0, o3 is lost
-        self.assert_(None is not cache._index.get(oid1) > 0)
-        self.assert_(None is not cache._index.get(oid2) > 0)
-        self.assert_(None is cache._index.get(oid3))
+        self.assert_(None is not cache._index.get(self._oid) > 0)
+        self.assert_(None is not cache._index.get(self._oid2) > 0)
+        self.assert_(None is cache._index.get(self._oid3))
 
         # Invalidate version data for o2
-        cache.invalidate(oid2, nonversion)
-        self.assertEqual(cache.load(oid2, ''), (data2, serial2))
-        self.assertEqual(cache.load(oid2, nonversion), None)
-        self.assertEqual(cache.load(oid2, version2), None)
+        cache.invalidate(self._oid2, nonversion)
+        self.assertEqual(cache.load(self._oid2, ''), (data2, serial2))
+        self.assertEqual(cache.load(self._oid2, nonversion), None)
+        self.assertEqual(cache.load(self._oid2, version2), None)
 
         # Cause another cache flip
         cache.checkSize(10*self.cachesize)
 
         # Load o1 and o2 again and verify that the loads return correct data
-        self.assertEqual(cache.load(oid1, ''), (data1, serial1))
-        self.assertEqual(cache.load(oid2, version2), None)
-        self.assertEqual(cache.load(oid2, nonversion), None)
-        self.assertEqual(cache.load(oid2, ''), (data2, serial2))
+        self.assertEqual(cache.load(self._oid, ''), (data1, serial1))
+        self.assertEqual(cache.load(self._oid2, version2), None)
+        self.assertEqual(cache.load(self._oid2, nonversion), None)
+        self.assertEqual(cache.load(self._oid2, ''), (data2, serial2))
 
         # Verify that o1 and o2 are now in file 1
-        self.assert_(None is not cache._index.get(oid1) < 0)
-        self.assert_(None is not cache._index.get(oid2) < 0)
+        self.assert_(None is not cache._index.get(self._oid) < 0)
+        self.assert_(None is not cache._index.get(self._oid2) < 0)
+
+    def testLastTid(self):
+        cache = self.cache
+        self.failUnless(cache.getLastTid() is None)
+        ltid = 'pqrstuvw'
+        cache.setLastTid(ltid)
+        self.assertEqual(cache.getLastTid(), ltid)
+        cache.checkSize(10*self.cachesize) # Force a file flip
+        self.assertEqual(cache.getLastTid(), ltid)
+        cache.setLastTid(None)
+        self.failUnless(cache.getLastTid() is None)
+        cache.checkSize(10*self.cachesize) # Force a file flip
+        self.failUnless(cache.getLastTid() is None)
 
 class PersistentClientCacheTests(unittest.TestCase):
 
+    _oid  = 'abcdefgh'
+    _oid2 = 'bcdefghi'
+    _oid3 = 'cdefghij'
+
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.vardir = os.getcwd() # Don't use /tmp, it's a security risk
@@ -309,18 +317,18 @@
         # 'current' file when a persistent cache was opened.
         cache = self.cache
         self.assertEqual(cache._current, 0) # Check that file 0 is current
-        oid = 'abcdefgh'
         data = '1234'
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
+        cache.store(self._oid, data, serial, '', '', '')
+        cache.setLastTid(serial)
         cache.checkSize(10*self.cachesize) # Force a file flip
         self.assertEqual(cache._current, 1) # Check that the flip worked
-        oid = 'abcdefgh'
         data = '123'
         serial = 'ABCDEFGZ'
-        cache.store(oid, data, serial, '', '', '')
+        cache.store(self._oid, data, serial, '', '', '')
+        cache.setLastTid(serial)
         cache = self.reopenCache()
-        loaded = cache.load(oid, '')
+        loaded = cache.load(self._oid, '')
         # Check that we got the most recent data:
         self.assertEqual(loaded, (data, serial))
         self.assertEqual(cache._current, 1) # Double check that 1 is current
@@ -334,23 +342,50 @@
         cache = self.cache
         magicsize = (ord('i') + 1) << 16
         cache = self.cache
-        oid = 'abcdefgh'
         data = '!'*magicsize
         serial = 'ABCDEFGH'
-        cache.store(oid, data, serial, '', '', '')
-        loaded = cache.load(oid, '')
+        cache.store(self._oid, data, serial, '', '', '')
+        loaded = cache.load(self._oid, '')
         self.assertEqual(loaded, (data, serial))
-        cache.invalidate(oid, '')
+        cache.invalidate(self._oid, '')
         cache = self.reopenCache()
-        loaded = cache.load(oid, '')
+        loaded = cache.load(self._oid, '')
         if loaded != None:
             self.fail("invalidated data resurrected, size %d, was %d" %
                       (len(loaded[0]), len(data)))
 
+    def testPersistentLastTid(self):
+        cache = self.cache
+        self.failUnless(cache.getLastTid() is None)
+        ltid = 'pqrstuvw'
+        cache.setLastTid(ltid)
+        self.assertEqual(cache.getLastTid(), ltid)
+        data = '1234'
+        serial = 'ABCDEFGH'
+        cache.store(self._oid, data, serial, '', '', '')
+        self.assertEqual(cache.getLastTid(), ltid)
+        cache.checkSize(10*self.cachesize) # Force a file flip
+        self.assertEqual(cache.getLastTid(), ltid)
+        cache = self.reopenCache()
+        self.assertEqual(cache.getLastTid(), ltid)
+        cache.setLastTid(None)
+        self.failUnless(cache.getLastTid() is None)
+        cache.checkSize(10*self.cachesize) # Force a file flip
+        self.failUnless(cache.getLastTid() is None)
+        
+class ClientCacheLongOIDTests(ClientCacheTests):
+    _oid  = 'abcdefghijklmnop' * 2
+    _oid2 = 'bcdefghijklmnopq' * 2
+    _oid3 = 'cdefghijklmnopqr' * 2
+
+class PersistentClientCacheLongOIDTests(PersistentClientCacheTests):
+    _oid = 'abcdefghijklmnop' * 2
+    
 def test_suite():
     suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(ClientCacheTests))
-    suite.addTest(unittest.makeSuite(PersistentClientCacheTests))
+    for klass in (ClientCacheTests, PersistentClientCacheTests,
+                  ClientCacheLongOIDTests, PersistentClientCacheLongOIDTests):
+        suite.addTest(unittest.makeSuite(klass))
     return suite
 
 if __name__ == '__main__':


=== ZODB4/src/zodb/zeo/tests/forker.py 1.5 => 1.6 ===
--- ZODB4/src/zodb/zeo/tests/forker.py:1.5	Tue Feb 25 13:55:05 2003
+++ ZODB4/src/zodb/zeo/tests/forker.py	Thu Jun 19 17:41:07 2003
@@ -16,104 +16,103 @@
 import os
 import sys
 import time
+import logging
 import errno
 import random
 import socket
+import StringIO
 import tempfile
-import traceback
-import logging
-
-# Change value of PROFILE to enable server-side profiling
-PROFILE = False
-if PROFILE:
-    import hotshot
-
-
-def get_port():
-    """Return a port that is not in use.
 
-    Checks if a port is in use by trying to connect to it.  Assumes it
-    is not in use if connect raises an exception.
-
-    Raises RuntimeError after 10 tries.
-    """
-    for i in range(10):
-        port = random.randrange(20000, 30000)
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        try:
-            try:
-                s.connect(('localhost', port))
-            except socket.error:
-                # XXX check value of error?
-                return port
-        finally:
-            s.close()
-    raise RuntimeError, "Can't find port"
+class ZEOConfig:
+    """Class to generate ZEO configuration file. """
 
+    def __init__(self, addr):
+        self.address = addr
+        self.read_only = None
+        self.invalidation_queue_size = None
+        self.monitor_address = None
+        self.transaction_timeout = None
+        self.authentication_protocol = None
+        self.authentication_database = None
+        self.authentication_realm = None
+
+    def dump(self, f):
+        print >> f, "<zeo>"
+        print >> f, "address %s:%s" % self.address
+        if self.read_only is not None:
+            print >> f, "read-only", self.read_only and "true" or "false"
+        if self.invalidation_queue_size is not None:
+            print >> f, "invalidation-queue-size", self.invalidation_queue_size
+        if self.monitor_address is not None:
+            print >> f, "monitor-address %s:%s" % self.monitor_address
+        if self.transaction_timeout is not None:
+            print >> f, "transaction-timeout", self.transaction_timeout
+        if self.authentication_protocol is not None:
+            print >> f, "authentication-protocol", self.authentication_protocol
+        if self.authentication_database is not None:
+            print >> f, "authentication-database", self.authentication_database
+        if self.authentication_realm is not None:
+            print >> f, "authentication-realm", self.authentication_realm
+        print >> f, "</zeo>"
+
+    def __str__(self):
+        f = StringIO.StringIO()
+        self.dump(f)
+        return f.getvalue()
 
-def start_zeo_server(conf, addr=None, ro_svr=False, monitor=False, keep=False,
-                     invq=None, timeout=None):
+def start_zeo_server(storage_conf, zeo_conf, port, keep=0):
     """Start a ZEO server in a separate process.
 
-    Returns the ZEO port, the test server port, and the pid.
+    Takes two positional arguments a string containing the storage conf
+    and a ZEOConfig object.
+
+    Returns the ZEO port, the test server port, the pid, and the path
+    to the config file.
     """
+    
     # Store the config info in a temp file.
-    tmpfile = tempfile.mktemp()
+    tmpfile = tempfile.mktemp(".conf")
     fp = open(tmpfile, 'w')
-    fp.write(conf)
+    zeo_conf.dump(fp)
+    fp.write(storage_conf)
     fp.close()
-    # Create the server
+    
+    # Find the zeoserver script
     import zodb.zeo.tests.zeoserver
-    if addr is None:
-        port = get_port()
-    else:
-        port = addr[1]
     script = zodb.zeo.tests.zeoserver.__file__
     if script.endswith('.pyc'):
         script = script[:-1]
+        
     # Create a list of arguments, which we'll tuplify below
     qa = _quote_arg
     args = [qa(sys.executable), qa(script), '-C', qa(tmpfile)]
-    if ro_svr:
-        args.append('-r')
     if keep:
-        args.append('-k')
-    if invq:
-        args += ['-Q', str(invq)]
-    if timeout:
-        args += ['-T', str(timeout)]
-    if monitor:
-        # XXX Is it safe to reuse the port?
-        args += ['-m', '42000']
-    args.append(str(port))
+        args.append("-k")
     d = os.environ.copy()
     d['PYTHONPATH'] = os.pathsep.join(sys.path)
     pid = os.spawnve(os.P_NOWAIT, sys.executable, tuple(args), d)
-    adminaddr = ('localhost', port+1)
-    # We need to wait until the server starts, but not forever.
-    # Always do a sleep as the first thing, since we don't expect
-    # the spawned process to get started right away.
-    delay = 0.25
-    for i in range(10):
-        time.sleep(delay)
-        logging.debug('forker: connect %s', i)
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    adminaddr = ('localhost', port + 1)
+    logger = logging.getLogger("forker")
+    # We need to wait until the server starts, but not forever
+    for i in range(20):
+        time.sleep(0.25)
         try:
+            logger.debug("connect %s", i)
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             s.connect(adminaddr)
             ack = s.recv(1024)
+            s.close()
+            logger.debug("acked: %s", ack)
+            break
         except socket.error, e:
             if e[0] not in (errno.ECONNREFUSED, errno.ECONNRESET):
                 raise
-            logging.debug('forker: failed %s' % i)
             s.close()
-        else:
-            logging.debug('forker: acked: %s', ack)
-            s.close()
-            break
     else:
-        logging.debug('forker: boo hoo')
+        logger.debug("boo foo")
         raise
-    return ('localhost', port), adminaddr, pid
+    return ('localhost', port), adminaddr, pid, tmpfile
+
 
 if sys.platform[:3].lower() == "win":
     def _quote_arg(s):
@@ -122,6 +121,7 @@
     def _quote_arg(s):
         return s
 
+
 def shutdown_zeo_server(adminaddr):
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.connect(adminaddr)
@@ -130,5 +130,5 @@
     except socket.error, e:
         if e[0] <> errno.ECONNRESET: raise
         ack = 'no ack received'
-    logging.debug('shutdownServer: acked: %s', ack)
+    logging.getLogger("forker").debug("shutdown server acked: %s", ack)
     s.close()


=== ZODB4/src/zodb/zeo/tests/connection.py 1.8 => 1.9 ===
--- ZODB4/src/zodb/zeo/tests/connection.py:1.8	Thu Mar 13 16:32:30 2003
+++ ZODB4/src/zodb/zeo/tests/connection.py	Thu Jun 19 17:41:07 2003
@@ -30,6 +30,7 @@
 from zodb.zeo.tests.common import TestClientStorage, DummyDB
 
 from transaction import get_transaction
+from zodb.db import DB
 from zodb.ztransaction import Transaction
 from zodb.storage.interfaces import ReadOnlyError
 from zodb.storage.tests.base import StorageTestBase
@@ -37,6 +38,28 @@
 from zodb.storage.tests.base import zodb_pickle, zodb_unpickle
 from zodb.storage.tests.base import handle_all_serials, ZERO
 
+class TestClientStorage(ClientStorage):
+
+    test_connection = 0
+
+    def verify_cache(self, stub):
+        self.end_verify = threading.Event()
+        self.verify_result = ClientStorage.verify_cache(self, stub)
+
+    def endVerify(self):
+        ClientStorage.endVerify(self)
+        self.end_verify.set()
+
+    def testConnection(self, conn):
+        try:
+            return ClientStorage.testConnection(self, conn)
+        finally:
+            self.test_connection = 1
+
+class DummyDB:
+    def invalidate(self, *args, **kwargs):
+        pass
+
 class CommonSetupTearDown(StorageTestBase):
     """Common boilerplate"""
 
@@ -47,6 +70,7 @@
     invq = None
     timeout = None
     monitor = 0
+    db_class = DummyDB
 
     def setUp(self):
         """Test setup for connection tests.
@@ -62,12 +86,16 @@
         self.addr = []
         self._pids = []
         self._servers = []
+        self._conf_paths = []
+        self._caches = []
         self._newAddr()
         self.startServer()
 
     def tearDown(self):
         """Try to cause the tests to halt"""
         self.logger.warn("tearDown() %s", self.id())
+        for p in self._conf_paths:
+            os.remove(p)
         if getattr(self, '_storage', None) is not None:
             self._storage.close()
             if hasattr(self._storage, 'cleanup'):
@@ -79,13 +107,27 @@
             # Not in Windows Python until 2.3
             for pid in self._pids:
                 os.waitpid(pid, 0)
-        for i in 0, 1:
-            path = "c1-test-%d.zec" % i
-            if os.path.exists(path):
-                try:
-                    os.unlink(path)
-                except os.error:
-                    pass
+        for c in self._caches:
+            for i in 0, 1:
+                path = "c1-%s-%d.zec" % (c, i)
+                # On Windows before 2.3, we don't have a way to wait for
+                # the spawned server(s) to close, and they inherited
+                # file descriptors for our open files.  So long as those
+                # processes are alive, we can't delete the files.  Try
+                # a few times then give up.
+                need_to_delete = 0
+                if os.path.exists(path):
+                    need_to_delete = 1
+                    for dummy in range(5):
+                        try:
+                            os.unlink(path)
+                        except:
+                            time.sleep(0.5)
+                        else:
+                            need_to_delete = 0
+                            break
+                if need_to_delete:
+                    os.unlink(path)  # sometimes this is just gonna fail
         self.__super_tearDown()
 
     def _newAddr(self):
@@ -95,38 +137,51 @@
         # port+1 is also used, so only draw even port numbers
         return 'localhost', random.randrange(25000, 30000, 2)
 
+    def getConfig(self, path, create, read_only):
+        raise NotImplementedError
+
     def openClientStorage(self, cache='', cache_size=200000, wait=True,
                           read_only=False, read_only_fallback=False,
-                          addr=None):
-        if addr is None:
-            addr = self.addr
-        storage = TestClientStorage(addr,
+                          username=None, password=None, realm=None):
+        self._caches.append(cache)
+        storage = TestClientStorage(self.addr,
                                     client=cache,
                                     cache_size=cache_size,
                                     wait=wait,
                                     min_disconnect_poll=0.1,
                                     read_only=read_only,
-                                    read_only_fallback=read_only_fallback)
+                                    read_only_fallback=read_only_fallback,
+                                    username=username,
+                                    password=password,
+                                    realm=realm)
         storage.registerDB(DummyDB())
         return storage
 
-    # The start_zeo_server() function attempts to connect to the new
-    # server process once a second.  After forker_admin_retries attempts,
-    # it fails with an error.
-    forker_admin_retries = 10
-
-    # Concrete test classes must provide a getConfig() method
+    def getServerConfig(self, addr, ro_svr):
+        zconf = forker.ZEOConfig(addr)
+        if ro_svr:
+            zconf.read_only = 1
+        if self.monitor:
+             zconf.monitor_address = ("", 42000)
+        if self.invq:
+            zconf.invalidation_queue_size = self.invq
+        if self.timeout:
+            zconf.transaction_timeout = self.timeout
+        return zconf
 
     def startServer(self, create=True, index=0, read_only=False, ro_svr=False,
-                    keep=False):
+                    keep=None):
         addr = self.addr[index]
         self.logger.warn("startServer(create=%d, index=%d, read_only=%d) @ %s",
                          create, index, read_only, addr)
         path = "%s.%d" % (self.file, index)
-        conf = self.getConfig(path, create, read_only)
-        zeoport, adminaddr, pid = forker.start_zeo_server(
-            conf, addr, ro_svr,
-            self.monitor, self.keep, self.invq, self.timeout)
+        sconf = self.getConfig(path, create, read_only)
+        zconf = self.getServerConfig(addr, ro_svr)
+        if keep is None:
+            keep = self.keep
+        zeoport, adminaddr, pid, path = forker.start_zeo_server(
+            sconf, zconf, addr[1], keep)
+        self._conf_paths.append(path)
         self._pids.append(pid)
         self._servers.append(adminaddr)
 
@@ -168,7 +223,7 @@
     start and stop a ZEO storage server.
     """
 
-    def checkMultipleAddresses(self):
+    def testMultipleAddresses(self):
         for i in range(4):
             self._newAddr()
         self._storage = self.openClientStorage('test', 100000)
@@ -177,7 +232,7 @@
         self._dostore(oid, data=obj)
         self._storage.close()
 
-    def checkMultipleServers(self):
+    def testMultipleServers(self):
         # XXX crude test at first -- just start two servers and do a
         # commit at each one.
 
@@ -191,15 +246,18 @@
         # If we can still store after shutting down one of the
         # servers, we must be reconnecting to the other server.
 
+        did_a_store = False
         for i in range(10):
             try:
                 self._dostore()
+                did_a_store = True
                 break
             except ClientDisconnected:
                 time.sleep(0.5)
                 self._storage.sync()
+        self.assert_(did_a_store)
 
-    def checkReadOnlyClient(self):
+    def testReadOnlyClient(self):
         # Open a read-only client to a read-write server; stores fail
 
         # Start a read-only client for a read-write server
@@ -207,7 +265,7 @@
         # Stores should fail here
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReadOnlyServer(self):
+    def testReadOnlyServer(self):
         # Open a read-only client to a read-only *server*; stores fail
 
         # We don't want the read-write server created by setUp()
@@ -220,7 +278,7 @@
         # Stores should fail here
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReadOnlyFallbackWritable(self):
+    def testReadOnlyFallbackWritable(self):
         # Open a fallback client to a read-write server; stores succeed
 
         # Start a read-only-fallback client for a read-write server
@@ -228,7 +286,7 @@
         # Stores should succeed here
         self._dostore()
 
-    def checkReadOnlyFallbackReadOnlyServer(self):
+    def testReadOnlyFallbackReadOnlyServer(self):
         # Open a fallback client to a read-only *server*; stores fail
 
         # We don't want the read-write server created by setUp()
@@ -245,7 +303,7 @@
     # further down.  Is the code here hopelessly naive, or is
     # checkReconnection() overwrought?
 
-    def checkReconnectWritable(self):
+    def testReconnectWritable(self):
         # A read-write client reconnects to a read-write server
 
         # Start a client
@@ -268,7 +326,7 @@
         # Stores should succeed here
         self._dostore()
 
-    def checkDisconnectionError(self):
+    def testDisconnectionError(self):
         # Make sure we get a ClientDisconnected when we try to read an
         # object when we're not connected to a storage server and the
         # object is not in the cache.
@@ -277,7 +335,7 @@
         self.assertRaises(ClientDisconnected,
                           self._storage.load, 'fredwash', '')
 
-    def checkDisconnectedAbort(self):
+    def testDisconnectedAbort(self):
         self._storage = self.openClientStorage()
         self._dostore()
         oids = [self._storage.newObjectId() for i in range(5)]
@@ -293,7 +351,7 @@
         self._storage._wait()
         self._dostore()
 
-    def checkBasicPersistence(self):
+    def testBasicPersistence(self):
         # Verify cached data persists across client storage instances.
 
         # To verify that the cache is being used, the test closes the
@@ -312,7 +370,7 @@
         self.assertEqual(revid1, revid2)
         self._storage.close()
 
-    def checkRollover(self):
+    def testRollover(self):
         # Check that the cache works when the files are swapped.
 
         # In this case, only one object fits in a cache file.  When the
@@ -331,7 +389,7 @@
         self._storage.load(oid1, '')
         self._storage.load(oid2, '')
 
-    def checkReconnection(self):
+    def testReconnection(self):
         # Check that the client reconnects when a server restarts.
 
         # XXX Seem to get occasional errors that look like this:
@@ -365,11 +423,11 @@
             self.fail("Could not reconnect to server")
         self.logger.warn("checkReconnection: finished")
 
-    def checkBadMessage1(self):
+    def testBadMessage1(self):
         # not even close to a real message
         self._bad_message("salty")
 
-    def checkBadMessage2(self):
+    def testBadMessage2(self):
         # just like a real message, but with an unpicklable argument
         global Hack
         class Hack:
@@ -403,49 +461,44 @@
         self._storage = self.openClientStorage()
         self._dostore()
 
-    # Test case for multiple storages participating in a single
-    # transaction.  This is not really a connection test, but it needs
-    # about the same infrastructure (several storage servers).
-
-    # XXX WARNING: with the current ZEO code, this occasionally fails.
-    # That's the point of this test. :-)
-
-    def NOcheckMultiStorageTransaction(self):
-        # Configuration parameters (larger values mean more likely deadlocks)
-        N = 2
-        # These don't *have* to be all the same, but it's convenient this way
-        self.nservers = N
-        self.nthreads = N
-        self.ntrans = N
-        self.nobj = N
+    def testCrossDBInvalidations(self):
+        db1 = DB(self.openClientStorage())
+        c1 = db1.open()
+        r1 = c1.root()
 
-        # Start extra servers
-        for i in range(1, self.nservers):
-            self._newAddr()
-            self.startServer(index=i)
+        r1["a"] = MinPO("a")
+        get_transaction().commit()
 
-        # Spawn threads that each do some transactions on all storages
-        threads = []
-        try:
-            for i in range(self.nthreads):
-                t = MSTThread(self, "T%d" % i)
-                threads.append(t)
-                t.start()
-            # Wait for all threads to finish
-            for t in threads:
-                t.join(60)
-                self.failIf(t.isAlive(), "%s didn't die" % t.getName())
-        finally:
-            for t in threads:
-                t.closeclients()
+        db2 = DB(self.openClientStorage())
+        r2 = db2.open().root()
+
+        self.assertEqual(r2["a"].value, "a")
+
+        r2["b"] = MinPO("b")
+        get_transaction().commit()
+
+        # make sure the invalidation is received in the other client
+        for i in range(10):
+            c1._storage.sync()
+            if r1._p_oid in c1._invalidated:
+                break
+            time.sleep(0.1)
+        self.assert_(r1._p_oid in c1._invalidated)
 
+        # force the invalidations to be applied...
+        c1.sync()
+        r1.keys() # unghostify
+        self.assertEqual(r1._p_serial, r2._p_serial)
+
+        db2.close()
+        db1.close()
 
 class ReconnectionTests(CommonSetupTearDown):
     keep = True
     forker_admin_retries = 20
     invq = 2
 
-    def checkReadOnlyStorage(self):
+    def testReadOnlyStorage(self):
         # Open a read-only client to a read-only *storage*; stores fail
 
         # We don't want the read-write server created by setUp()
@@ -458,7 +511,7 @@
         # Stores should fail here
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReadOnlyFallbackReadOnlyStorage(self):
+    def testReadOnlyFallbackReadOnlyStorage(self):
         # Open a fallback client to a read-only *storage*; stores fail
 
         # We don't want the read-write server created by setUp()
@@ -471,7 +524,7 @@
         # Stores should fail here
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReconnectReadOnly(self):
+    def testReconnectReadOnly(self):
         # A read-only client reconnects from a read-write to a
         # read-only server
 
@@ -495,7 +548,7 @@
         # Stores should still fail
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReconnectFallback(self):
+    def testReconnectFallback(self):
         # A fallback client reconnects from a read-write to a
         # read-only server
 
@@ -519,7 +572,7 @@
         # Stores should fail here
         self.assertRaises(ReadOnlyError, self._dostore)
 
-    def checkReconnectUpgrade(self):
+    def testReconnectUpgrade(self):
         # A fallback client reconnects from a read-only to a
         # read-write server
 
@@ -548,7 +601,7 @@
         # Stores should now succeed
         self._dostore()
 
-    def checkReconnectSwitch(self):
+    def testReconnectSwitch(self):
         # A fallback client initially connects to a read-only server,
         # then discovers a read-write server and switches to that
 
@@ -577,7 +630,7 @@
         else:
             self.fail("Couldn't store after starting a read-write server")
 
-    def checkNoVerificationOnServerRestart(self):
+    def testNoVerificationOnServerRestart(self):
         self._storage = self.openClientStorage()
         # When we create a new storage, it should always do a full
         # verification
@@ -592,7 +645,7 @@
         # should be needed.
         self.assertEqual(self._storage.verify_result, "no verification")
 
-    def checkNoVerificationOnServerRestartWith2Clients(self):
+    def testNoVerificationOnServerRestartWith2Clients(self):
         perstorage = self.openClientStorage(cache="test")
         self.assertEqual(perstorage.verify_result, "full verification")
 
@@ -622,7 +675,7 @@
         self.assertEqual(perstorage.verify_result, "no verification")
         perstorage.close()
 
-    def checkQuickVerificationWith2Clients(self):
+    def testQuickVerificationWith2Clients(self):
         perstorage = self.openClientStorage(cache="test")
         self.assertEqual(perstorage.verify_result, "full verification")
 
@@ -646,10 +699,9 @@
 
         self.assertEqual(perstorage.load(oid, ''),
                          self._storage.load(oid, ''))
+        perstorage.close()
 
-
-
-    def checkVerificationWith2ClientsInvqOverflow(self):
+    def testVerificationWith2ClientsInvqOverflow(self):
         perstorage = self.openClientStorage(cache="test")
         self.assertEqual(perstorage.verify_result, "full verification")
 
@@ -681,13 +733,12 @@
         self.assertEqual(self._storage.load(oid, '')[1], revid)
         self.assertEqual(perstorage.load(oid, ''),
                          self._storage.load(oid, ''))
-
         perstorage.close()
 
 class TimeoutTests(CommonSetupTearDown):
     timeout = 1
 
-    def checkTimeout(self):
+    def testTimeout(self):
         storage = self.openClientStorage()
         txn = Transaction()
         storage.tpcBegin(txn)
@@ -695,14 +746,14 @@
         time.sleep(2)
         self.assertRaises(ClientDisconnected, storage.tpcFinish, txn)
 
-    def checkTimeoutOnAbort(self):
+    def testTimeoutOnAbort(self):
         storage = self.openClientStorage()
         txn = Transaction()
         storage.tpcBegin(txn)
         storage.tpcVote(txn)
         storage.tpcAbort(txn)
 
-    def checkTimeoutOnAbortNoLock(self):
+    def testTimeoutOnAbortNoLock(self):
         storage = self.openClientStorage()
         txn = Transaction()
         storage.tpcBegin(txn)


=== ZODB4/src/zodb/zeo/tests/commitlock.py 1.7 => 1.8 ===
--- ZODB4/src/zodb/zeo/tests/commitlock.py:1.7	Fri May 16 17:49:36 2003
+++ ZODB4/src/zodb/zeo/tests/commitlock.py	Thu Jun 19 17:41:07 2003
@@ -23,7 +23,7 @@
 
 from zodb.zeo.client import ClientStorage
 from zodb.zeo.interfaces import ClientDisconnected
-from zodb.zeo.tests.thread import TestThread
+from zodb.zeo.tests.basethread import TestThread
 from zodb.zeo.tests.common import DummyDB
 
 
@@ -179,7 +179,7 @@
 
     def _get_timestamp(self):
         t = time.time()
-        t = apply(TimeStamp,(time.gmtime(t)[:5]+(t%60,)))
+        t = TimeStamp(*time.gmtime(t)[:5]+(t%60,))
         return `t`
 
 class CommitLockUndoTests(CommitLockTests):

=== Removed File ZODB4/src/zodb/zeo/tests/thread.py ===




More information about the Zodb-checkins mailing list