Removed lots of version support. More version support, especially in

ZEO, still needs to be removed.

src/ZEO/tests/Cache.py

@@ -52,51 +52,3 @@ class TransUndoStorageWithCache:
         data, revid = self._storage.load(oid, '')
         obj = zodb_unpickle(data)
         assert obj == MinPO(24)
-
-class StorageWithCache:
-
-    def checkAbortVersionInvalidation(self):
-        oid = self._storage.new_oid()
-        revid = self._dostore(oid, data=MinPO(1))
-        revid = self._dostore(oid, revid=revid, data=MinPO(2))
-        revid = self._dostore(oid, revid=revid, data=MinPO(3), version="foo")
-        revid = self._dostore(oid, revid=revid, data=MinPO(4), version="foo")
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.abortVersion("foo", t)
-        self._storage.load(oid, "foo")
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        data, revid = self._storage.load(oid, "foo")
-        obj = zodb_unpickle(data)
-        assert obj == MinPO(2), obj
-
-    def checkCommitEmptyVersionInvalidation(self):
-        oid = self._storage.new_oid()
-        revid = self._dostore(oid, data=MinPO(1))
-        revid = self._dostore(oid, revid=revid, data=MinPO(2))
-        revid = self._dostore(oid, revid=revid, data=MinPO(3), version="foo")
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion("foo", "", t)
-        self._storage.load(oid, "")
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        data, revid = self._storage.load(oid, "")
-        obj = zodb_unpickle(data)
-        assert obj == MinPO(3), obj
-
-    def checkCommitVersionInvalidation(self):
-        oid = self._storage.new_oid()
-        revid = self._dostore(oid, data=MinPO(1))
-        revid = self._dostore(oid, revid=revid, data=MinPO(2))
-        revid = self._dostore(oid, revid=revid, data=MinPO(3), version="foo")
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion("foo", "bar", t)
-        self._storage.load(oid, "")
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        data, revid = self._storage.load(oid, "bar")
-        obj = zodb_unpickle(data)
-        assert obj == MinPO(3), obj

src/ZEO/tests/InvalidationTests.py

@@ -234,74 +234,6 @@ class LargeUpdatesThread(FailableThread):
         self.added_keys = keys_added.keys()
         cn.close()
 
-class VersionStressThread(FailableThread):
-
-    def __init__(self, db, stop, threadnum, commitdict, startnum,
-                 step=2, sleep=None):
-        TestThread.__init__(self)
-        self.db = db
-        self.stop = stop
-        self.threadnum = threadnum
-        self.startnum = startnum
-        self.step = step
-        self.sleep = sleep
-        self.added_keys = []
-        self.commitdict = commitdict
-
-    def _testrun(self):
-        commit = 0
-        key = self.startnum
-        while not self.stop.isSet():
-            version = "%s:%s" % (self.threadnum, key)
-            commit = not commit
-            if self.oneupdate(version, key, commit):
-                self.added_keys.append(key)
-                self.commitdict[self] = 1
-            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):
-                transaction.abort()
-        while not self.stop.isSet():
-            try:
-                tree[key] = self.threadnum
-                transaction.commit()
-                if self.sleep:
-                    time.sleep(self.sleep)
-                break
-            except (VersionLockError, ReadConflictError, ConflictError), msg:
-                transaction.abort()
-                if self.sleep:
-                    time.sleep(self.sleep)
-        try:
-            while not self.stop.isSet():
-                try:
-                    if commit:
-                        self.db.commitVersion(version)
-                        transaction.get().note("commit version %s" % version)
-                    else:
-                        self.db.abortVersion(version)
-                        transaction.get().note("abort version %s" % version)
-                    transaction.commit()
-                    if self.sleep:
-                        time.sleep(self.sleep)
-                    return commit
-                except ConflictError, msg:
-                    transaction.abort()
-        finally:
-            cn.close()
-        return 0
-
 class InvalidationTests:
 
     level = 2

src/ZEO/tests/testAuth.py

@@ -82,7 +82,7 @@ class AuthTest(CommonSetupTearDown):
         self._storage._connection.poll()
         self.assert_(self._storage.is_connected())
         # Make a call to make sure the mechanism is working
-        self._storage.versions()
+        self._storage.undoInfo()
 
     def testNOK(self):
         self._storage = self.openClientStorage(wait=0, username="foo",
@@ -101,11 +101,11 @@ class AuthTest(CommonSetupTearDown):
         # 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.wait()
-        self._storage.versions()
+        self._storage.undoInfo()
         # Manually clear the state of the hmac connection
         self._storage._connection._SizedMessageAsyncConnection__hmac_send = None
         # Once the client stops using the hmac, it should be disconnected.
-        self.assertRaises(ClientDisconnected, self._storage.versions)
+        self.assertRaises(ClientDisconnected, self._storage.undoInfo)
 
 
 class PlainTextAuth(AuthTest):

src/ZEO/tests/testConversionSupport.py

@@ -17,10 +17,9 @@ from zope.testing import doctest
 class FakeStorageBase:
 
     def __getattr__(self, name):
-        if name in ('versionEmpty', 'versions', 'getTid',
-                    'history', 'load', 'loadSerial', 'modifiedInVersion',
+        if name in ('getTid', 'history', 'load', 'loadSerial',
                     'lastTransaction', 'getSize', 'getName', 'supportsUndo',
-                    'supportsVersions', 'tpc_transaction'):
+                    'tpc_transaction'):
            return lambda *a, **k: None
         raise AttributeError(name)
 

src/ZEO/tests/testZEO.py

@@ -38,8 +38,8 @@ import persistent
 import transaction
 
 # ZODB test mixin classes
-from ZODB.tests import StorageTestBase, BasicStorage, VersionStorage, \
-     TransactionalUndoStorage, TransactionalUndoVersionStorage, \
+from ZODB.tests import StorageTestBase, BasicStorage,  \
+     TransactionalUndoStorage,  \
      PackableStorage, Synchronization, ConflictResolution, RevisionStorage, \
      MTStorage, ReadOnlyStorage
 
@@ -223,7 +223,6 @@ class GenericTests(
 
 class FullGenericTests(
     GenericTests,
-    Cache.StorageWithCache,
     Cache.TransUndoStorageWithCache,
     CommitLockTests.CommitLockUndoTests,
     ConflictResolution.ConflictResolvingStorage,
@@ -231,8 +230,6 @@ class FullGenericTests(
     PackableStorage.PackableUndoStorage,
     RevisionStorage.RevisionStorage,
     TransactionalUndoStorage.TransactionalUndoStorage,
-    TransactionalUndoVersionStorage.TransactionalUndoVersionStorage,
-    VersionStorage.VersionStorage,
     ):
     """Extend GenericTests with tests that MappingStorage can't pass."""
 
@@ -256,8 +253,6 @@ class MappingStorageTests(GenericTests):
 
 class DemoStorageTests(
     GenericTests,
-    Cache.StorageWithCache,
-    VersionStorage.VersionStorage,
     ):
 
     def getConfig(self):
@@ -269,21 +264,6 @@ class DemoStorageTests(
         </demostorage>
         """ % tempfile.mktemp()
 
-    def checkLoadBeforeVersion(self):
-        # Doesn't implement loadBefore, except as a kind of place holder.
-        pass
-    
-    # the next three pack tests depend on undo
-
-    def checkPackVersionReachable(self):
-        pass
-
-    def checkPackVersions(self):
-        pass
-
-    def checkPackVersionsInPast(self):
-        pass
-
 class HeartbeatTests(ZEO.tests.ConnectionTests.CommonSetupTearDown):
     """Make sure a heartbeat is being sent and that it does no harm
 

src/ZEO/tests/test_cache.py

@@ -11,7 +11,7 @@
 # FOR A PARTICULAR PURPOSE.
 #
 ##############################################################################
-"""Basic unit tests for a multi-version client cache."""
+"""Basic unit tests for a client cache."""
 
 import os
 import random

src/ZODB/BaseStorage.py

@@ -338,7 +338,7 @@ def copy(source, dest, verbose=0):
             if verbose:
                 print oid_repr(oid), r.version, len(r.data)
             if restoring:
-                dest.restore(oid, r.tid, r.data, r.version,
+                dest.restore(oid, r.tid, r.data, '',
                              r.data_txn, transaction)
             else:
                 pre = preget(oid, None)

src/ZODB/FileStorage/format.py

@@ -64,19 +64,10 @@
 #
 #   - 8-byte beginning of transaction record file position.
 #
-#   - 2-byte version length
+#   - 2-bytes with zero values. (Was version length.)
 #
 #   - 8-byte data length
 #
-#   ? 8-byte position of non-version data record
-#     (if version length > 0)
-#
-#   ? 8-byte position of previous record in this version
-#     (if version length > 0)
-#
-#   ? version string
-#     (if version length > 0)
-#
 #   ? data
 #     (data length > 0)
 #
@@ -87,41 +78,10 @@
 # Also, the object ids time stamps are big-endian, so comparisons
 # are meaningful.
 #
-# Version handling
-#
-#   There isn't a separate store for versions.  Each record has a
-#   version field, indicating what version it is in.  The records in a
-#   version form a linked list.  Each record that has a non-empty
-#   version string has a pointer to the previous record in the version.
-#   Version back pointers are retained *even* when versions are
-#   committed or aborted or when transactions are undone.
-#
-#   There is a notion of "current" version records, which are the
-#   records in a version that are the current records for their
-#   respective objects.  When a version is comitted, the current records
-#   are committed to the destination version.  When a version is
-#   aborted, the current records are aborted.
-#
-#   When committing or aborting, we search backward through the linked
-#   list until we find a record for an object that does not have a
-#   current record in the version.  If we find a record for which the
-#   non-version pointer is the same as the previous pointer, then we
-#   forget that the corresponding object had a current record in the
-#   version. This strategy allows us to avoid searching backward through
-#   previously committed or aborted version records.
-#
-#   Of course, we ignore records in undone transactions when committing
-#   or aborting.
-#
 # Backpointers
 #
-#   When we commit or abort a version, we don't copy (or delete)
-#   and data.  Instead, we write records with back pointers.
-#
-#   A version record *never* has a back pointer to a non-version
-#   record, because we never abort to a version.  A non-version record
-#   may have a back pointer to a version record or to a non-version
-#   record.
+#   When we undo a record, we don't copy (or delete)
+#   data.  Instead, we write records with back pointers.
 
 import struct
 import logging
@@ -156,7 +116,6 @@ DATA_HDR = ">8s8sQQHQ"
 # constants to support various header sizes
 TRANS_HDR_LEN = 23
 DATA_HDR_LEN = 42
-DATA_VERSION_HDR_LEN = 58
 assert struct.calcsize(TRANS_HDR) == TRANS_HDR_LEN
 assert struct.calcsize(DATA_HDR) == DATA_HDR_LEN
 
@@ -180,9 +139,6 @@ class FileStorageFormatter(object):
 
         If ois is not None, raise CorruptedDataError if oid passed
         does not match oid in file.
-
-        If there is version data, reads the version part of the header.
-        If there is no pickle data, reads the back pointer.
         """
         self._file.seek(pos)
         s = self._file.read(DATA_HDR_LEN)
@@ -191,17 +147,10 @@ class FileStorageFormatter(object):
         h = DataHeaderFromString(s)
         if oid is not None and oid != h.oid:
             raise CorruptedDataError(oid, s, pos)
-        if h.vlen:
-            s = self._file.read(16 + h.vlen)
-            h.parseVersion(s)
         if not h.plen:
             h.back = u64(self._file.read(8))
         return h
 
-    def _write_version_header(self, file, pnv, vprev, version):
-        s = struct.pack(">8s8s", pnv, vprev)
-        file.write(s + version)
-
     def _read_txn_header(self, pos, tid=None):
         self._file.seek(pos)
         s = self._file.read(TRANS_HDR_LEN)
@@ -284,47 +233,26 @@ def DataHeaderFromString(s):
 class DataHeader(object):
     """Header for a data record."""
 
-    __slots__ = (
-        "oid", "tid", "prev", "tloc", "vlen", "plen", "back",
-        # These three attributes are only defined when vlen > 0
-        "pnv", "vprev", "version")
+    __slots__ = ("oid", "tid", "prev", "tloc", "plen", "back")
 
     def __init__(self, oid, tid, prev, tloc, vlen, plen):
-        self.back = 0 # default
-        self.version = "" # default
+        if vlen:
+            raise ValueError(
+                "Non-zero version length. Versions aren't supported.")
+        
         self.oid = oid
         self.tid = tid
         self.prev = prev
         self.tloc = tloc
-        self.vlen = vlen
         self.plen = plen
+        self.back = 0 # default
 
     def asString(self):
-        s = struct.pack(DATA_HDR, self.oid, self.tid, self.prev,
-                        self.tloc, self.vlen, self.plen)
-        if self.version:
-            v = struct.pack(">QQ", self.pnv, self.vprev)
-            return s + v + self.version
-        else:
-            return s
-
-    def setVersion(self, version, pnv, vprev):
-        self.version = version
-        self.vlen = len(version)
-        self.pnv = pnv
-        self.vprev = vprev
-
-    def parseVersion(self, buf):
-        pnv, vprev = struct.unpack(">QQ", buf[:16])
-        self.pnv = pnv
-        self.vprev = vprev
-        self.version = buf[16:]
+        return struct.pack(DATA_HDR, self.oid, self.tid, self.prev,
+                           self.tloc, 0, self.plen)
 
     def recordlen(self):
-        rlen = DATA_HDR_LEN + (self.plen or 8)
-        if self.version:
-            rlen += 16 + self.vlen
-        return rlen
+        return DATA_HDR_LEN + (self.plen or 8)
 
 def TxnHeaderFromString(s):
     return TxnHeader(*struct.unpack(TRANS_HDR, s))

src/ZODB/FileStorage/fsdump.py

@@ -14,8 +14,8 @@
 import struct
 
 from ZODB.FileStorage import FileIterator
-from ZODB.FileStorage.format import TRANS_HDR, TRANS_HDR_LEN, DATA_HDR, DATA_HDR_LEN
-from ZODB.FileStorage.format import DATA_HDR_LEN
+from ZODB.FileStorage.format import TRANS_HDR, TRANS_HDR_LEN
+from ZODB.FileStorage.format import DATA_HDR, DATA_HDR_LEN
 from ZODB.TimeStamp import TimeStamp
 from ZODB.utils import u64, get_pickle_metadata
 from ZODB.tests.StorageTestBase import zodb_unpickle
@@ -41,11 +41,6 @@ def fsdump(path, file=None, with_offset=1):
                 size = " size=%d" % len(rec.data)
                 fullclass = "%s.%s" % (modname, classname)
 
-            if rec.version:
-                version = " version=%r" % rec.version
-            else:
-                version = ""
-
             if rec.data_txn:
                 # It would be nice to print the transaction number
                 # (i) but it would be expensive to keep track of.
@@ -53,8 +48,8 @@ def fsdump(path, file=None, with_offset=1):
             else:
                 bp = ""
 
-            print >> file, ("  data #%05d oid=%016x%s%s class=%s%s" %
-                  (j, u64(rec.oid), version, size, fullclass, bp))
+            print >> file, ("  data #%05d oid=%016x%s class=%s%s" %
+                  (j, u64(rec.oid), size, fullclass, bp))
     iter.close()
 
 def fmt(p64):
@@ -117,14 +112,7 @@ class Dumper:
         print >> self.dest, "revid: %s" % fmt(revid)
         print >> self.dest, "previous record offset: %d" % prev
         print >> self.dest, "transaction offset: %d" % tloc
-        if vlen:
-            pnv = self.file.read(8)
-            sprevdata = self.file.read(8)
-            version = self.file.read(vlen)
-            print >> self.dest, "version: %r" % version
-            print >> self.dest, "non-version data offset: %d" % u64(pnv)
-            print >> self.dest, ("previous version data offset: %d" %
-                                 u64(sprevdata))
+        assert not vlen
         print >> self.dest, "len(data): %d" % dlen
         self.file.read(dlen)
         if not dlen:

src/ZODB/FileStorage/fsoids.py

@@ -148,7 +148,7 @@ class Tracer(object):
                                       txn._tpos)
 
     def _save_references(self, drec):
-        # drec has members oid, tid, version, data, data_txn
+        # drec has members oid, tid, data, data_txn
         tid, oid, pick, pos = drec.tid, drec.oid, drec.data, drec.pos
         if pick:
             if oid in self.oids:
@@ -159,13 +159,12 @@ class Tracer(object):
             self._records_map[oid] = drec
             self._records.append(drec)
         elif oid in self.oids:
-            # Or maybe it's a version abort.
             self._msg(oid, tid, "creation undo at", pos)
 
     # Process next data record.  If a message is produced, self._produced_msg
     # will be set True.
     def _check_drec(self, drec):
-        # drec has members oid, tid, version, data, data_txn
+        # drec has members oid, tid, data, data_txn
         tid, oid, pick, pos = drec.tid, drec.oid, drec.data, drec.pos
         ref2name = self._ref2name
         ref2name_get = ref2name.get

src/ZODB/fsrecover.py

@@ -338,8 +338,8 @@ def recover(inp, outp, verbose=0, partial=False, force=False, pack=None):
                     else:
                         l = len(r.data)
 
-                    print "%7d %s %s" % (u64(r.oid), l, r.version)
-                ofs.restore(r.oid, r.tid, r.data, r.version, r.data_txn,
+                    print "%7d %s %s" % (u64(r.oid), l)
+                ofs.restore(r.oid, r.tid, r.data, '', r.data_txn,
                             txn)
                 nrec += 1
         except (KeyboardInterrupt, SystemExit):

src/ZODB/fstools.py

@@ -22,7 +22,7 @@ import cPickle
 import struct
 
 from ZODB.FileStorage.format import TRANS_HDR, DATA_HDR, TRANS_HDR_LEN
-from ZODB.FileStorage.format import DATA_HDR_LEN, DATA_VERSION_HDR_LEN
+from ZODB.FileStorage.format import DATA_HDR_LEN
 from ZODB.utils import u64
 from persistent.TimeStamp import TimeStamp
 
@@ -103,12 +103,9 @@ class DataHeader:
     serial              8-16    object serial numver
     prev_rec_pos       16-24    position of previous data record for object
     txn_pos            24-32    position of txn header
-    version_len        32-34    length of version
+    version_len        32-34    length of version (always 0)
     data_len           34-42    length of data
-    nonversion_pos     42-50*   position of nonversion data record
-    prev_version_pos   50-58*   pos of previous version data record
     
-    * these attributes are only present if version_len != 0.
     """
 
     def __init__(self, file, pos):
@@ -118,27 +115,18 @@ class DataHeader:
 
     def _read_header(self):
         self._file.seek(self._pos)
-        self._hdr = self._file.read(DATA_VERSION_HDR_LEN)
+        self._hdr = self._file.read(DATA_HDR_LEN)
         # always read the longer header, just in case
-        (self.oid, self.serial, prev_rec_pos, txn_pos, self.version_len,
-         data_len) = struct.unpack(DATA_HDR, self._hdr[:DATA_HDR_LEN])
+        (self.oid, self.serial, prev_rec_pos, txn_pos, vlen, data_len
+         ) = struct.unpack(DATA_HDR, self._hdr[:DATA_HDR_LEN])
+        assert not vlen
         self.prev_rec_pos = u64(prev_rec_pos)
         self.txn_pos = u64(txn_pos)
         self.data_len = u64(data_len)
-        if self.version_len:
-            s = self._hdr[DATA_HDR_LEN:]
-            self.nonversion_pos = u64(s[:8])
-            self.prev_version_pos = u64(s[8:])
-        else:
-            self.nonversion_pos = None
-            self.prev_version_pos = None
         
     def next_offset(self):
         """Return offset of next record."""
         off = self._pos + self.data_len
-        if self.version_len:
-            off += self.version_len + DATA_VERSION_HDR_LEN
-        else:
         off += DATA_HDR_LEN
         if self.data_len == 0:
             off += 8 # backpointer

src/ZODB/tests/BasicStorage.py

@@ -44,40 +44,12 @@ class BasicStorage:
             self._storage.store,
             0, 0, 0, 0, transaction.Transaction())
 
-        if self.__supportsVersions():
-            try:
-                self._storage.abortVersion(
-                    'dummy', transaction.Transaction())
-            except (POSException.StorageTransactionError,
-                    POSException.VersionCommitError):
-                pass # test passed ;)
-            else:
-                assert 0, "Should have failed, invalid transaction."
-
-            try:
-                self._storage.commitVersion('dummy', 'dummer',
-                                            transaction.Transaction())
-            except (POSException.StorageTransactionError,
-                    POSException.VersionCommitError):
-                pass # test passed ;)
-            else:
-                assert 0, "Should have failed, invalid transaction."
-
         self.assertRaises(
             POSException.StorageTransactionError,
             self._storage.store,
             0, 1, 2, 3, transaction.Transaction())
         self._storage.tpc_abort(t)
 
-    def __supportsVersions(self):
-        storage = self._storage
-        try:
-            supportsVersions = storage.supportsVersions
-        except AttributeError:
-            return False
-        else:
-            return supportsVersions()
-
     def checkSerialIsNoneForInitialRevision(self):
         eq = self.assertEqual
         oid = self._storage.new_oid()
@@ -95,13 +67,13 @@ class BasicStorage:
         eq(value, MinPO(11))
         eq(revid, newrevid)
 
-    def checkNonVersionStore(self):
+    def checkStore(self):
         revid = ZERO
         newrevid = self._dostore(revid=None)
         # Finish the transaction.
         self.assertNotEqual(newrevid, revid)
 
-    def checkNonVersionStoreAndLoad(self):
+    def checkStoreAndLoad(self):
         eq = self.assertEqual
         oid = self._storage.new_oid()
         self._dostore(oid=oid, data=MinPO(7))
@@ -115,12 +87,6 @@ class BasicStorage:
         data, revid = self._storage.load(oid, '')
         eq(zodb_unpickle(data), MinPO(21))
 
-    def checkNonVersionModifiedInVersion(self):
-        if self.__supportsVersions():
-            oid = self._storage.new_oid()
-            self._dostore(oid=oid)
-            self.assertEqual(self._storage.modifiedInVersion(oid), '')
-
     def checkConflicts(self):
         oid = self._storage.new_oid()
         revid1 = self._dostore(oid, data=MinPO(11))

src/ZODB/tests/HistoryStorage.py

@@ -23,7 +23,7 @@ from transaction import Transaction
 class HistoryStorage:
     def checkSimpleHistory(self):
         eq = self.assertEqual
-        # Store a couple of non-version revisions of the object
+        # Store a couple of revisions of the object
         oid = self._storage.new_oid()
         self.assertRaises(KeyError,self._storage.history,oid)
         revid1 = self._dostore(oid, data=MinPO(11))
@@ -34,197 +34,29 @@ class HistoryStorage:
         eq(len(h), 1)
         d = h[0]
         eq(d['tid'], revid3)
-        eq(d['version'], '')
         # Try to get 2 historical revisions
         h = self._storage.history(oid, size=2)
         eq(len(h), 2)
         d = h[0]
         eq(d['tid'], revid3)
-        eq(d['version'], '')
         d = h[1]
         eq(d['tid'], revid2)
-        eq(d['version'], '')
         # Try to get all 3 historical revisions
         h = self._storage.history(oid, size=3)
         eq(len(h), 3)
         d = h[0]
         eq(d['tid'], revid3)
-        eq(d['version'], '')
         d = h[1]
         eq(d['tid'], revid2)
-        eq(d['version'], '')
         d = h[2]
         eq(d['tid'], revid1)
-        eq(d['version'], '')
         # There should be no more than 3 revisions
         h = self._storage.history(oid, size=4)
         eq(len(h), 3)
         d = h[0]
         eq(d['tid'], revid3)
-        eq(d['version'], '')
         d = h[1]
         eq(d['tid'], revid2)
-        eq(d['version'], '')
         d = h[2]
         eq(d['tid'], revid1)
-        eq(d['version'], '')
         
-    def checkVersionHistory(self):
-        if not self._storage.supportsVersions():
-            return
-        eq = self.assertEqual
-        # Store a couple of non-version revisions
-        oid = self._storage.new_oid()
-        revid1 = self._dostore(oid, data=MinPO(11))
-        revid2 = self._dostore(oid, revid=revid1, data=MinPO(12))
-        revid3 = self._dostore(oid, revid=revid2, data=MinPO(13))
-        # Now store some new revisions in a version
-        version = 'test-version'
-        revid4 = self._dostore(oid, revid=revid3, data=MinPO(14),
-                               version=version)
-        revid5 = self._dostore(oid, revid=revid4, data=MinPO(15),
-                               version=version)
-        revid6 = self._dostore(oid, revid=revid5, data=MinPO(16),
-                               version=version)
-        # Now, try to get the six historical revisions (first three are in
-        # 'test-version', followed by the non-version revisions).
-        h = self._storage.history(oid, version, 100)
-        eq(len(h), 6)
-        d = h[0]
-        eq(d['tid'], revid6)
-        eq(d['version'], version)
-        d = h[1]
-        eq(d['tid'], revid5)
-        eq(d['version'], version)
-        d = h[2]
-        eq(d['tid'], revid4)
-        eq(d['version'], version)
-        d = h[3]
-        eq(d['tid'], revid3)
-        eq(d['version'], '')
-        d = h[4]
-        eq(d['tid'], revid2)
-        eq(d['version'], '')
-        d = h[5]
-        eq(d['tid'], revid1)
-        eq(d['version'], '')
-
-    def checkHistoryAfterVersionCommit(self):
-        if not self._storage.supportsVersions():
-            return
-        eq = self.assertEqual
-        # Store a couple of non-version revisions
-        oid = self._storage.new_oid()
-        revid1 = self._dostore(oid, data=MinPO(11))
-        revid2 = self._dostore(oid, revid=revid1, data=MinPO(12))
-        revid3 = self._dostore(oid, revid=revid2, data=MinPO(13))
-        # Now store some new revisions in a version
-        version = 'test-version'
-        revid4 = self._dostore(oid, revid=revid3, data=MinPO(14),
-                               version=version)
-        revid5 = self._dostore(oid, revid=revid4, data=MinPO(15),
-                               version=version)
-        revid6 = self._dostore(oid, revid=revid5, data=MinPO(16),
-                               version=version)
-        # Now commit the version
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion(version, '', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        # After consultation with Jim, we agreed that the semantics of
-        # revision id's after a version commit is that the committed object
-        # gets a new serial number (a.k.a. revision id).  Note that
-        # FileStorage is broken here; the serial number in the post-commit
-        # non-version revision will be the same as the serial number of the
-        # previous in-version revision.
-        #
-        # BAW: Using load() is the only way to get the serial number of the
-        # current revision of the object.  But at least this works for both
-        # broken and working storages.
-        ign, revid7 = self._storage.load(oid, '')
-        # Now, try to get the six historical revisions (first three are in
-        # 'test-version', followed by the non-version revisions).
-        h = self._storage.history(oid, version, 100)
-        eq(len(h), 7)
-        d = h[0]
-        eq(d['tid'], revid7)
-        eq(d['version'], '')
-        d = h[1]
-        eq(d['tid'], revid6)
-        eq(d['version'], version)
-        d = h[2]
-        eq(d['tid'], revid5)
-        eq(d['version'], version)
-        d = h[3]
-        eq(d['tid'], revid4)
-        eq(d['version'], version)
-        d = h[4]
-        eq(d['tid'], revid3)
-        eq(d['version'], '')
-        d = h[5]
-        eq(d['tid'], revid2)
-        eq(d['version'], '')
-        d = h[6]
-        eq(d['tid'], revid1)
-        eq(d['version'], '')
-
-    def checkHistoryAfterVersionAbort(self):
-        if not self._storage.supportsVersions():
-            return
-        eq = self.assertEqual
-        # Store a couple of non-version revisions
-        oid = self._storage.new_oid()
-        revid1 = self._dostore(oid, data=MinPO(11))
-        revid2 = self._dostore(oid, revid=revid1, data=MinPO(12))
-        revid3 = self._dostore(oid, revid=revid2, data=MinPO(13))
-        # Now store some new revisions in a version
-        version = 'test-version'
-        revid4 = self._dostore(oid, revid=revid3, data=MinPO(14),
-                               version=version)
-        revid5 = self._dostore(oid, revid=revid4, data=MinPO(15),
-                               version=version)
-        revid6 = self._dostore(oid, revid=revid5, data=MinPO(16),
-                               version=version)
-        # Now commit the version
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.abortVersion(version, t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        # After consultation with Jim, we agreed that the semantics of
-        # revision id's after a version commit is that the committed object
-        # gets a new serial number (a.k.a. revision id).  Note that
-        # FileStorage is broken here; the serial number in the post-commit
-        # non-version revision will be the same as the serial number of the
-        # previous in-version revision.
-        #
-        # BAW: Using load() is the only way to get the serial number of the
-        # current revision of the object.  But at least this works for both
-        # broken and working storages.
-        ign, revid7 = self._storage.load(oid, '')
-        # Now, try to get the six historical revisions (first three are in
-        # 'test-version', followed by the non-version revisions).
-        h = self._storage.history(oid, version, 100)
-        eq(len(h), 7)
-        d = h[0]
-        eq(d['tid'], revid7)
-        eq(d['version'], '')
-        d = h[1]
-        eq(d['tid'], revid6)
-        eq(d['version'], version)
-        d = h[2]
-        eq(d['tid'], revid5)
-        eq(d['version'], version)
-        d = h[3]
-        eq(d['tid'], revid4)
-        eq(d['version'], version)
-        d = h[4]
-        eq(d['tid'], revid3)
-        eq(d['version'], '')
-        d = h[5]
-        eq(d['tid'], revid2)
-        eq(d['version'], '')
-        d = h[6]
-        eq(d['tid'], revid1)
-        eq(d['version'], '')

src/ZODB/tests/IteratorStorage.py

@@ -34,7 +34,6 @@ class IteratorCompare:
             for rec in reciter:
                 eq(rec.oid, oid)
                 eq(rec.tid, revid)
-                eq(rec.version, '')
                 eq(zodb_unpickle(rec.data), MinPO(val))
                 val = val + 1
         eq(val, val0 + len(revids))
@@ -59,34 +58,7 @@ class IteratorStorage(IteratorCompare):
         txniter.close()
         self.assertRaises(IOError, txniter.__getitem__, 0)
 
-    def checkVersionIterator(self):
-        if not self._storage.supportsVersions():
-            return
-        self._dostore()
-        self._dostore(version='abort')
-        self._dostore()
-        self._dostore(version='abort')
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.abortVersion('abort', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-
-        self._dostore(version='commit')
-        self._dostore()
-        self._dostore(version='commit')
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion('commit', '', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-
-        txniter = self._storage.iterator()
-        for trans in txniter:
-            for data in trans:
-                pass
-
-    def checkUndoZombieNonVersion(self):
+    def checkUndoZombie(self):
         oid = self._storage.new_oid()
         revid = self._dostore(oid, data=MinPO(94))
         # Get the undo information
@@ -215,7 +187,6 @@ class IteratorDeepCompare:
             for rec1, rec2 in zip(txn1, txn2):
                 eq(rec1.oid,     rec2.oid)
                 eq(rec1.tid,  rec2.tid)
-                eq(rec1.version, rec2.version)
                 eq(rec1.data,    rec2.data)
             # Make sure there are no more records left in rec1 and rec2,
             # meaning they were the same length.

src/ZODB/tests/MTStorage.py

@@ -165,13 +165,6 @@ class ExtStorageClientThread(StorageClientThread):
         names = ["do_load"]
 
         storage = self.storage
-        try:
-            supportsVersions = storage.supportsVersions
-        except AttributeError:
-            pass
-        else:
-            if supportsVersions():
-                names.append("do_modifiedInVersion")
 
         try:
             supportsUndo = storage.supportsUndo
@@ -203,10 +196,6 @@ class ExtStorageClientThread(StorageClientThread):
         oid = self.pick_oid()
         self.storage.loadSerial(oid, self.oids[oid])
 
-    def do_modifiedInVersion(self):
-        oid = self.pick_oid()
-        self.storage.modifiedInVersion(oid)
-
     def do_undoLog(self):
         self.storage.undoLog(0, -20)
 

src/ZODB/tests/PersistentStorage.py

@@ -28,8 +28,6 @@ class PersistentStorage:
         self._dostore()
         oid = self._storage.new_oid()
         revid = self._dostore(oid)
-        if self._storage.supportsVersions():
-            self._dostore(oid, revid, data=8, version='b')
         oid = self._storage.new_oid()
         revid = self._dostore(oid, data=1)
         revid = self._dostore(oid, revid, data=2)
@@ -40,10 +38,6 @@ class PersistentStorage:
         for oid in oids:
             p, s = self._storage.load(oid, '')
             objects.append((oid, '', p, s))
-            ver = self._storage.modifiedInVersion(oid)
-            if ver:
-                p, s = self._storage.load(oid, ver)
-                objects.append((oid, ver, p, s))
 
         self._storage.close()
         self.open()

src/ZODB/tests/ReadOnlyStorage.py

@@ -36,7 +36,6 @@ class ReadOnlyStorage:
         for oid in self.oids.keys():
             data, revid = self._storage.load(oid, '')
             self.assertEqual(revid, self.oids[oid])
-            self.assert_(not self._storage.modifiedInVersion(oid))
             # Storages without revisions may not have loadSerial().
             try:
                 _data = self._storage.loadSerial(oid, revid)
@@ -50,12 +49,6 @@ class ReadOnlyStorage:
         t = transaction.Transaction()
         self.assertRaises(ReadOnlyError, self._storage.tpc_begin, t)
 
-        if self._storage.supportsVersions():
-            self.assertRaises(ReadOnlyError, self._storage.abortVersion,
-                              '', t)
-            self.assertRaises(ReadOnlyError, self._storage.commitVersion,
-                              '', '', t)
-
         self.assertRaises(ReadOnlyError, self._storage.store,
                           '\000' * 8, None, '', '', t)
 

src/ZODB/tests/RecoveryStorage.py

@@ -32,104 +32,6 @@ class RecoveryStorage(IteratorDeepCompare):
         self._dst.copyTransactionsFrom(self._storage)
         self.compare(self._storage, self._dst)
 
-    def checkRecoveryAcrossVersions(self):
-        oid = self._storage.new_oid()
-        revid = self._dostore(oid, data=21)
-        revid = self._dostore(oid, revid=revid, data=22)
-        revid = self._dostore(oid, revid=revid, data=23, version='one')
-        revid = self._dostore(oid, revid=revid, data=34, version='one')
-        # Now commit the version
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion('one', '', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        self._dst.copyTransactionsFrom(self._storage)
-        self.compare(self._storage, self._dst)
-
-    def checkRecoverAbortVersion(self):
-        oid = self._storage.new_oid()
-        revid = self._dostore(oid, data=21, version="one")
-        revid = self._dostore(oid, revid=revid, data=23, version='one')
-        revid = self._dostore(oid, revid=revid, data=34, version='one')
-        # Now abort the version and the creation
-        t = Transaction()
-        self._storage.tpc_begin(t)
-        tid, oids = self._storage.abortVersion('one', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        self.assertEqual(oids, [oid])
-        self._dst.copyTransactionsFrom(self._storage)
-        self.compare(self._storage, self._dst)
-        # Also make sure the the last transaction has a data record
-        # with None for its data attribute, because we've undone the
-        # object.
-        for s in self._storage, self._dst:
-            iter = s.iterator()
-            for trans in iter:
-                pass # iterate until we get the last one
-            data = trans[0]
-            self.assertRaises(IndexError, lambda i, t=trans: t[i], 1)
-            self.assertEqual(data.oid, oid)
-            self.assertEqual(data.data, None)
-
-    def checkRecoverUndoInVersion(self):
-        oid = self._storage.new_oid()
-        version = "aVersion"
-        revid_a = self._dostore(oid, data=MinPO(91))
-        revid_b = self._dostore(oid, revid=revid_a, version=version,
-                                data=MinPO(92))
-        revid_c = self._dostore(oid, revid=revid_b, version=version,
-                                data=MinPO(93))
-        self._undo(self._storage.undoInfo()[0]['id'], [oid])
-        self._commitVersion(version, '')
-        self._undo(self._storage.undoInfo()[0]['id'], [oid])
-
-        # now copy the records to a new storage
-        self._dst.copyTransactionsFrom(self._storage)
-        self.compare(self._storage, self._dst)
-
-        # The last two transactions were applied directly rather than
-        # copied.  So we can't use compare() to verify that they new
-        # transactions are applied correctly.  (The new transactions
-        # will have different timestamps for each storage.)
-
-        self._abortVersion(version)
-        self.assert_(self._storage.versionEmpty(version))
-        self._undo(self._storage.undoInfo()[0]['id'], [oid])
-        self.assert_(not self._storage.versionEmpty(version))
-
-        # check the data is what we expect it to be
-        data, revid = self._storage.load(oid, version)
-        self.assertEqual(zodb_unpickle(data), MinPO(92))
-        data, revid = self._storage.load(oid, '')
-        self.assertEqual(zodb_unpickle(data), MinPO(91))
-
-        # and swap the storages
-        tmp = self._storage
-        self._storage = self._dst
-        self._abortVersion(version)
-        self.assert_(self._storage.versionEmpty(version))
-        self._undo(self._storage.undoInfo()[0]['id'], [oid])
-        self.assert_(not self._storage.versionEmpty(version))
-
-        # check the data is what we expect it to be
-        data, revid = self._storage.load(oid, version)
-        self.assertEqual(zodb_unpickle(data), MinPO(92))
-        data, revid = self._storage.load(oid, '')
-        self.assertEqual(zodb_unpickle(data), MinPO(91))
-
-        # swap them back
-        self._storage = tmp
-
-        # Now remove _dst and copy all the transactions a second time.
-        # This time we will be able to confirm via compare().
-        self._dst.close()
-        self._dst.cleanup()
-        self._dst = self.new_dest()
-        self._dst.copyTransactionsFrom(self._storage)
-        self.compare(self._storage, self._dst)
-
     def checkRestoreAcrossPack(self):
         db = DB(self._storage)
         c = db.open()
@@ -150,7 +52,7 @@ class RecoveryStorage(IteratorDeepCompare):
         final = list(it)[-1]
         self._dst.tpc_begin(final, final.tid, final.status)
         for r in final:
-            self._dst.restore(r.oid, r.tid, r.data, r.version, r.data_txn,
+            self._dst.restore(r.oid, r.tid, r.data, '', r.data_txn,
                               final)
         it.close()
         self._dst.tpc_vote(final)

src/ZODB/tests/StorageTestBase.py

@@ -160,14 +160,13 @@ class StorageTestBase(unittest.TestCase):
     def tearDown(self):
         self._close()
 
-    def _dostore(self, oid=None, revid=None, data=None, version=None,
+    def _dostore(self, oid=None, revid=None, data=None,
                  already_pickled=0, user=None, description=None):
         """Do a complete storage transaction.  The defaults are:
 
          - oid=None, ask the storage for a new oid
          - revid=None, use a revid of ZERO
          - data=None, pickle up some arbitrary data (the integer 7)
-         - version=None, use the empty string version
 
         Returns the object's new revision id.
         """
@@ -181,8 +180,6 @@ class StorageTestBase(unittest.TestCase):
             data = MinPO(data)
         if not already_pickled:
             data = zodb_pickle(data)
-        if version is None:
-            version = ''
         # Begin the transaction
         t = transaction.Transaction()
         if user is not None:
@@ -192,7 +189,7 @@ class StorageTestBase(unittest.TestCase):
         try:
             self._storage.tpc_begin(t)
             # Store an object
-            r1 = self._storage.store(oid, revid, data, version, t)
+            r1 = self._storage.store(oid, revid, data, '', t)
             # Finish the transaction
             r2 = self._storage.tpc_vote(t)
             revid = handle_serials(oid, r1, r2)
@@ -202,9 +199,9 @@ class StorageTestBase(unittest.TestCase):
             raise
         return revid
 
-    def _dostoreNP(self, oid=None, revid=None, data=None, version=None,
+    def _dostoreNP(self, oid=None, revid=None, data=None,
                    user=None, description=None):
-        return self._dostore(oid, revid, data, version, 1, user, description)
+        return self._dostore(oid, revid, data, 1, user, description)
 
     # The following methods depend on optional storage features.
 
@@ -222,21 +219,3 @@ class StorageTestBase(unittest.TestCase):
             for oid in expected_oids:
                 self.assert_(oid in oids)
         return self._storage.lastTransaction()
-
-    def _commitVersion(self, src, dst):
-        t = transaction.Transaction()
-        t.note("commit %r to %r" % (src, dst))
-        self._storage.tpc_begin(t)
-        tid, oids = self._storage.commitVersion(src, dst, t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        return oids
-
-    def _abortVersion(self, ver):
-        t = transaction.Transaction()
-        t.note("abort %r" % ver)
-        self._storage.tpc_begin(t)
-        tid, oids = self._storage.abortVersion(ver, t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-        return oids

src/ZODB/tests/Synchronization.py

@@ -45,7 +45,7 @@ undo(): how's that handled?
 
 Methods that have nothing to do with committing/non-committing:
 load(), loadSerial(), getName(), getSize(), __len__(), history(),
-undoLog(), modifiedInVersion(), versionEmpty(), versions(), pack().
+undoLog(), pack().
 
 Specific questions:
 
@@ -65,7 +65,6 @@ tested?  Is it a general restriction?
 from transaction import Transaction
 from ZODB.POSException import StorageTransactionError
 
-VERSION = "testversion"
 OID = "\000" * 8
 SERIALNO = "\000" * 8
 TID = "\000" * 8
@@ -84,35 +83,6 @@ class SynchronizedStorage:
         self.assertRaises(StorageTransactionError, callable, *args)
         self._storage.tpc_abort(t)
 
-    def __supportsVersions(self):
-        storage = self._storage
-        try:
-            supportsVersions = storage.supportsVersions
-        except AttributeError:
-            return False
-        return supportsVersions()
-
-    def checkAbortVersionNotCommitting(self):
-        if self.__supportsVersions():
-            self.verifyNotCommitting(self._storage.abortVersion,
-                                     VERSION, Transaction())
-
-    def checkAbortVersionWrongTrans(self):
-        if self.__supportsVersions():
-            self.verifyWrongTrans(self._storage.abortVersion,
-                                  VERSION, Transaction())
-
-    def checkCommitVersionNotCommitting(self):
-        if self.__supportsVersions():
-            self.verifyNotCommitting(self._storage.commitVersion,
-                                     VERSION, "", Transaction())
-
-    def checkCommitVersionWrongTrans(self):
-        if self.__supportsVersions():
-            self.verifyWrongTrans(self._storage.commitVersion,
-                                  VERSION, "", Transaction())
-
-
     def checkStoreNotCommitting(self):
         self.verifyNotCommitting(self._storage.store,
                                  OID, SERIALNO, "", "", Transaction())

src/ZODB/tests/TransactionalUndoVersionStorage.py

-##############################################################################
-#
-# 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.1 (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.
-#
-##############################################################################
-# Check interactions between undo() and versions.  Any storage that
-# supports both undo() and versions must pass these tests.
-
-import time
-
-import transaction
-
-from ZODB.serialize import referencesf
-from ZODB.tests.MinPO import MinPO
-from ZODB.tests.StorageTestBase import zodb_unpickle
-
-from ZODB.tests.VersionStorage import loadEx
-
-class TransactionalUndoVersionStorage:
-
-    # `hook` is a callable used by the ZRS tests.
-    def checkUndoInVersion(self, hook=None):
-        eq = self.assertEqual
-        unless = self.failUnless
-
-        def check_objects(nonversiondata, versiondata):
-            data, revid = self._storage.load(oid, version)
-            self.assertEqual(zodb_unpickle(data), MinPO(versiondata))
-            data, revid = self._storage.load(oid, '')
-            self.assertEqual(zodb_unpickle(data), MinPO(nonversiondata))
-
-        oid = self._storage.new_oid()
-        version = 'one'
-        revid_a = self._dostore(oid, data=MinPO(91))
-        revid_b = self._dostore(oid, revid=revid_a, data=MinPO(92),
-                                version=version)
-        revid_c = self._dostore(oid, revid=revid_b, data=MinPO(93),
-                                version=version)
-
-        info = self._storage.undoInfo()
-        self._undo(info[0]['id'], [oid])
-
-        data, revid = self._storage.load(oid, '')
-        # load() always returns the tid of the most recent reversion in 3.4,
-        # so this old test of revid can't work anymore.
-        ##eq(revid, revid_a)
-
-        # But the data should be correct for the non-version revision.
-        eq(zodb_unpickle(data), MinPO(91))
-        data, revid = self._storage.load(oid, version)
-        unless(revid > revid_b and revid > revid_c)
-        eq(zodb_unpickle(data), MinPO(92))
-
-        # Now commit the version...
-        oids = self._commitVersion(version, "")
-        eq(len(oids), 1)
-        eq(oids[0], oid)
-
-        check_objects(92, 92)
-
-        # ...and undo the commit
-        info = self._storage.undoInfo()
-        self._undo(info[0]['id'], [oid])
-
-        check_objects(91, 92)
-
-        if hook:
-            # ZRS passes a hook that arranges to start a secondary at this
-            # point in the test.
-            hook()
-
-        # Now abort the version.
-        oids = self._abortVersion(version)
-        assert len(oids) == 1
-        assert oids[0] == oid
-
-        check_objects(91, 91)
-
-        # Now undo the abort.
-        info=self._storage.undoInfo()
-        self._undo(info[0]['id'], [oid])
-
-        # And the object should be back in versions 'one' and ''.
-        check_objects(91, 92)
-
-    def checkUndoCommitVersion(self):
-        def load_value(oid, version=''):
-            data, revid = self._storage.load(oid, version)
-            return zodb_unpickle(data).value
-
-        # create a bunch of packable transactions
-        oid = self._storage.new_oid()
-        revid = '\000' * 8
-        for i in range(4):
-            revid = self._dostore(oid, revid, description='packable%d' % i)
-        pt = time.time()
-        time.sleep(1)
-
-        oid1 = self._storage.new_oid()
-        version = 'version'
-        revid1 = self._dostore(oid1, data=MinPO(0), description='create1')
-        revid2 = self._dostore(oid1, data=MinPO(1), revid=revid1,
-                               version=version, description='version1')
-        self._dostore(oid1, data=MinPO(2), revid=revid2,
-                      version=version, description='version2')
-        self._dostore(description='create2')
-
-        t = transaction.Transaction()
-        t.description = 'commit version'
-        self._storage.tpc_begin(t)
-        self._storage.commitVersion(version, '', t)
-        self._storage.tpc_vote(t)
-        self._storage.tpc_finish(t)
-
-        info = self._storage.undoInfo()
-        t_id = info[0]['id']
-
-        self.assertEqual(load_value(oid1), 2)
-        self.assertEqual(load_value(oid1, version), 2)
-
-        self._storage.pack(pt, referencesf)
-
-        self._undo(t_id, note="undo commit version")
-
-        self.assertEqual(load_value(oid1), 0)
-        self.assertEqual(load_value(oid1, version), 2)
-
-        data, tid = self._storage.load(oid1, "")
-        # After undoing the version commit, the non-version data
-        # once again becomes the non-version data from 'create1'.
-        self.assertEqual(tid, self._storage.lastTransaction())
-
-        # The current version data comes from an undo record, which
-        # means that it gets data via the backpointer but tid from the
-        # current txn.
-        data, tid, ver = loadEx(self._storage, oid1, version)
-        self.assertEqual(ver, version)
-        self.assertEqual(tid, self._storage.lastTransaction())
-
-    def checkUndoAbortVersion(self):
-        def load_value(oid, version=''):
-            data, revid = self._storage.load(oid, version)
-            return zodb_unpickle(data).value
-
-        # create a bunch of packable transactions
-        oid = self._storage.new_oid()
-        revid = '\000' * 8
-        for i in range(3):
-            revid = self._dostore(oid, revid, description='packable%d' % i)
-        pt = time.time()
-        time.sleep(1)
-
-        oid1 = self._storage.new_oid()
-        version = 'version'
-        revid1 = self._dostore(oid1, data=MinPO(0), description='create1')
-        revid2 = self._dostore(oid1, data=MinPO(1), revid=revid1,
-                               version=version, description='version1')
-        self._dostore(oid1, data=MinPO(2), revid=revid2,
-                      version=version, description='version2')
-        self._dostore(description='create2')
-
-        self._abortVersion(version)
-
-        info = self._storage.undoInfo()
-        t_id = info[0]['id']
-
-        self.assertEqual(load_value(oid1), 0)
-        # after abort, we should see non-version data
-        self.assertEqual(load_value(oid1, version), 0)
-
-        self._undo(t_id, note="undo abort version")
-
-        self.assertEqual(load_value(oid1), 0)
-        # t undo will re-create the version
-        self.assertEqual(load_value(oid1, version), 2)
-
-        info = self._storage.undoInfo()
-        t_id = info[0]['id']
-
-        self._storage.pack(pt, referencesf)
-
-        self._undo(t_id, note="undo undo")
-
-        # undo of undo will put as back where we started
-        self.assertEqual(load_value(oid1), 0)
-        # after abort, we should see non-version data
-        self.assertEqual(load_value(oid1, version), 0)

src/ZODB/tests/testConnection.py

@@ -145,9 +145,6 @@ class UserMethodTests(unittest.TestCase):
     # add isn't tested here, because there are a bunch of traditional
     # unit tests for it.
 
-    # The version tests would require a storage that supports versions
-    # which is a bit more work.
-
     def test_root(self):
         r"""doctest of root() method
 
@@ -547,7 +544,6 @@ class StubStorage:
 
     Only one concurrent transaction is supported.
     Voting is not supported.
-    Versions are not supported.
 
     Inspect self._stored and self._finished to see how the storage has been
     used during a unit test. Whenever an object is stored in the store()
@@ -607,7 +603,7 @@ class StubStorage:
         self._transdata.clear()
         self._transstored = []
 
-    def load(self, oid, version):
+    def load(self, oid, version=''):
         if version != '':
             raise TypeError('StubStorage does not support versions.')
         return self._data[oid]

src/ZODB/tests/testDemoStorage.py

@@ -17,12 +17,11 @@ import transaction
 from ZODB.DB import DB
 import ZODB.utils
 import ZODB.DemoStorage
-from ZODB.tests import StorageTestBase, BasicStorage, VersionStorage
+from ZODB.tests import StorageTestBase, BasicStorage
 from ZODB.tests import Synchronization
 
 class DemoStorageTests(StorageTestBase.StorageTestBase,
                        BasicStorage.BasicStorage,
-                       VersionStorage.VersionStorage,
                        Synchronization.SynchronizedStorage,
                        ):
 
@@ -38,25 +37,6 @@ class DemoStorageTests(StorageTestBase.StorageTestBase,
         # have this limit, so we inhibit this test here.
         pass
 
-    def checkAbortVersionNonCurrent(self):
-        # TODO:  Need to implement a real loadBefore for DemoStorage?
-        pass
-
-    def checkLoadBeforeVersion(self):
-        # TODO:  Need to implement a real loadBefore for DemoStorage?
-        pass
-
-    # the next three pack tests depend on undo
-
-    def checkPackVersionReachable(self):
-        pass
-
-    def checkPackVersions(self):
-        pass
-
-    def checkPackVersionsInPast(self):
-        pass
-
     def checkLoadDelegation(self):
         # Minimal test of loadEX w/o version -- ironically
         db = DB(self._storage) # creates object 0. :)

src/ZODB/tests/testFileStorage.py

@@ -19,7 +19,6 @@ from ZODB import POSException
 from ZODB import DB
 
 from ZODB.tests import StorageTestBase, BasicStorage, TransactionalUndoStorage
-from ZODB.tests import VersionStorage, TransactionalUndoVersionStorage
 from ZODB.tests import PackableStorage, Synchronization, ConflictResolution
 from ZODB.tests import HistoryStorage, IteratorStorage, Corruption
 from ZODB.tests import RevisionStorage, PersistentStorage, MTStorage
@@ -44,8 +43,6 @@ class FileStorageTests(
     BasicStorage.BasicStorage,
     TransactionalUndoStorage.TransactionalUndoStorage,
     RevisionStorage.RevisionStorage,
-    VersionStorage.VersionStorage,
-    TransactionalUndoVersionStorage.TransactionalUndoVersionStorage,
     PackableStorage.PackableStorage,
     PackableStorage.PackableUndoStorage,
     Synchronization.SynchronizedStorage,
@@ -182,45 +179,6 @@ class FileStorageTests(
         self.open()
         self.assertEqual(self._storage._saved, 1)
 
-    def check_index_oid_ignored(self):
-        # Prior to ZODB 3.2.6, the 'oid' value stored in the .index file
-        # was believed.  But there were cases where adding larger oids
-        # didn't update the FileStorage ._oid attribute -- the restore()
-        # method in particular didn't update it, and that's about the only
-        # method copyTransactionsFrom() uses.  A database copy created that
-        # way then stored an 'oid' of z64 in the .index file.  This created
-        # torturous problems, as when that file was opened, "new" oids got
-        # generated starting over from 0 again.
-        # Now the cached 'oid' value is ignored:  verify that this is so.
-        import cPickle as pickle
-        from ZODB.utils import z64
-
-        # Create some data.
-        db = DB(self._storage)
-        conn = db.open()
-        conn.root()['xyz'] = 1
-        transaction.commit()
-        true_max_oid = self._storage._oid
-
-        # Save away the index, and poke in a bad 'oid' value by hand.
-        db.close()
-        f = open('FileStorageTests.fs.index', 'r+b')
-        p = pickle.Unpickler(f)
-        data = p.load()
-        saved_oid = data['oid']
-        self.assertEqual(true_max_oid, saved_oid)
-        data['oid'] = z64
-        f.seek(0)
-        f.truncate()
-        p = pickle.Pickler(f, 1)
-        p.dump(data)
-        f.close()
-
-        # Verify that we get the correct oid again when we reopen, despite
-        # that we stored nonsense in the .index file's 'oid'.
-        self.open()
-        self.assertEqual(self._storage._oid, true_max_oid)
-
     # This would make the unit tests too slow
     # check_save_after_load_that_worked_hard(self)
 

src/ZODB/tests/testZODB.py

@@ -25,11 +25,6 @@ from persistent import Persistent
 from persistent.mapping import PersistentMapping
 import transaction
 
-# deprecated39  remove when versions go away
-warnings.filterwarnings("ignore",
-                        "Versions are deprecated",
-                        DeprecationWarning, __name__)
-
 class P(Persistent):
     pass