mò
Sã¸Ec @ s– d Z d k l Z d k Z d k Z d k l Z d k Z d k l Z d k
l Z l Z d k
l Z d k l Z e i d d e e ƒ d
e i f d „ ƒ YZ d e i f d
„ ƒ YZ d e i f d „ ƒ YZ d „ Z d e f d „ ƒ YZ d f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d f d „ ƒ YZ d e i f d „ ƒ YZ d f d „ ƒ YZ! d! „ Z" d S(" s$ Unit tests for the Connection class.( s doctestN( s
Persistent( s databaseFromString( s p64s u64( s WarningsHook( s verifyObjectt ignores! .*
subtransactions are deprecatedt ConnectionDotAddc B sY t Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z
RS(
Nc C sH d k l } t ƒ | _ | | i ƒ | _ | i i ƒ t ƒ | _ d S( N( s
Connection( t ZODB.Connectiont
Connectiont StubDatabaset selft dbt datamgrt opent StubTransactiont transaction( R R ( ( t8 /data/zmath/zope/lib/python/ZODB/tests/testConnection.pyt setUp# s
c C s t i ƒ d S( N( R
t abort( R ( ( R t tearDown* s c C s d k l } t ƒ } | i | i d j ƒ | i | i d j ƒ | i i
| ƒ | i | i d j ƒ | i | i | i j ƒ | i | i i | i ƒ | j ƒ | i t
| i i
t ƒ ƒ | i } | i i
| ƒ | i | i | ƒ t ƒ } t ƒ | _ | i | | i i
| ƒ d S( N( s InvalidObjectReference( t ZODB.POSExceptiont InvalidObjectReferencet
StubObjectt objR t assert_t _p_oidt Nonet _p_jarR t addt gett assertRaisest TypeErrort objectt oidt assertEqualt obj2( R R R R R ( ( R t check_add- s
" c C s~ t ƒ } | i i | ƒ | i } | i i | i ƒ | i | i d j ƒ | i | i d j ƒ | i t
| i i | ƒ d S( N( R R R R R R R R
R
R R R R t KeyErrorR ( R R R ( ( R t checkResetOnAbortE s c C s‘ t ƒ } | i i | ƒ | i } | i i | i ƒ | i i | i ƒ | i
| i d j ƒ | i
| i d j ƒ | i
t | i i | ƒ d S( N( R R R R R R R t tpc_beginR
t tpc_abortR R R R R R ( R R R ( ( R t checkResetOnTpcAbortP s c C sÀ t ƒ } | i i | ƒ | i } | i i | i ƒ | i i | i ƒ | i i
| i ƒ | i | i d j ƒ | i | i
d j ƒ | i t | i i | ƒ | i | i i i | g ƒ d S( N( R R R R R R R R" R
t commitR# R R R R R R t assertEqualsR t _storaget _stored( R R R ( ( R t checkTpcAbortAfterCommit_ s c C sÆ t ƒ } | i i | ƒ | i } | i i | i ƒ | i i | i ƒ | i i
| i ƒ | i | i | j ƒ | i | i | i j ƒ | i
| i i i | g ƒ | i
| i i i | g ƒ d S( N( R R R R R R R R" R
R% t
tpc_finishR R R& R R' R( t _finished( R R R ( ( R t checkCommitl s c C sí t ƒ } t ƒ } | | _ t | ƒ } | i i | ƒ | i i | i ƒ | i i
| i ƒ | i i | i ƒ | i i
} | i | i | i j d ƒ | i | i | i j d ƒ | i | i | i j d ƒ | i | i i d j ƒ d S( Ns object was not storeds subobject was not storeds member was not stored( R t membert subobjt ModifyOnGetStateObjectR R R R R" R
R% R* R R' t storageR R R( t _added_during_commitR ( R R R0 R- R. ( ( R t checkModifyOnGetstate| s c C sb t ƒ } | i i | ƒ | i i | i ƒ | i i | i ƒ | i | i | i i
i j ƒ d S( N( R R R R R R" R
R* R R R' R( ( R R ( ( R t checkUnusedAddWorksΠs
( t __name__t
__module__R R R R! R$ R) R, R2 R3 ( ( ( R R ! s
t UserMethodTestsc B sP t Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z RS( Nc C s d S( s doctest of root() method
The root() method is simple, and the tests are pretty minimal.
Ensure that a new database has a root and that it is a
PersistentMapping.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> root = cn.root()
>>> type(root).__name__
'PersistentMapping'
>>> root._p_oid
'\x00\x00\x00\x00\x00\x00\x00\x00'
>>> root._p_jar is cn
True
>>> db.close()
N( ( R ( ( R t test_root s c C s d S( sØ doctest of get() method
The get() method return the persistent object corresponding to
an oid.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> obj = cn.get(p64(0))
>>> obj._p_oid
'\x00\x00\x00\x00\x00\x00\x00\x00'
The object is a ghost.
>>> obj._p_state
-1
And multiple calls with the same oid, return the same object.
>>> obj2 = cn.get(p64(0))
>>> obj is obj2
True
If all references to the object are released, then a new
object will be returned. The cache doesn't keep unreferenced
ghosts alive. (The next object returned my still have the
same id, because Python may re-use the same memory.)
>>> del obj, obj2
>>> cn._cache.get(p64(0), None)
If the object is unghosted, then it will stay in the cache
after the last reference is released. (This is true only if
there is room in the cache and the object is recently used.)
>>> obj = cn.get(p64(0))
>>> obj._p_activate()
>>> y = id(obj)
>>> del obj
>>> obj = cn.get(p64(0))
>>> id(obj) == y
True
>>> obj._p_state
0
A request for an object that doesn't exist will raise a KeyError.
>>> cn.get(p64(1))
Traceback (most recent call last):
...
KeyError: '\x00\x00\x00\x00\x00\x00\x00\x01'
N( ( R ( ( R t test_get° s 3c C s d S( sG doctest of close() method
This is a minimal test, because most of the interesting
effects on closing a connection involve its interaction with the
database and the transaction.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
It's safe to close a connection multiple times.
>>> cn.close()
>>> cn.close()
>>> cn.close()
It's not possible to load or store objects once the storage is closed.
>>> cn.get(p64(0))
Traceback (most recent call last):
...
ConnectionStateError: The database connection is closed
>>> p = Persistent()
>>> cn.add(p)
Traceback (most recent call last):
...
ConnectionStateError: The database connection is closed
N( ( R ( ( R t
test_closeå s c C s d S( s doctest to ensure close() w/ pending changes complains
>>> import transaction
Just opening and closing is fine.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> cn.close()
Opening, making a change, committing, and closing is fine.
>>> cn = db.open()
>>> cn.root()['a'] = 1
>>> transaction.commit()
>>> cn.close()
Opening, making a change, and aborting is fine.
>>> cn = db.open()
>>> cn.root()['a'] = 1
>>> transaction.abort()
>>> cn.close()
But trying to close with a change pending complains.
>>> cn = db.open()
>>> cn.root()['a'] = 10
>>> cn.close()
Traceback (most recent call last):
...
ConnectionStateError: Cannot close a connection joined to a transaction
This leaves the connection as it was, so we can still commit
the change.
>>> transaction.commit()
>>> cn2 = db.open()
>>> cn2.root()['a']
10
>>> cn.close(); cn2.close()
Bug: We weren't catching the case where the only changes pending
were in a subtransaction.
>>> cn = db.open()
>>> cn.root()['a'] = 100
>>> transaction.commit(True)
>>> cn.close() # this was succeeding
Traceback (most recent call last):
...
ConnectionStateError: Cannot close a connection joined to a transaction
Again this leaves the connection as it was.
>>> transaction.commit()
>>> cn2 = db.open()
>>> cn2.root()['a']
100
>>> cn.close(); cn2.close()
Make sure we can still close a connection after aborting a pending
subtransaction.
>>> cn = db.open()
>>> cn.root()['a'] = 1000
>>> transaction.commit(True)
>>> cn.root()['a']
1000
>>> transaction.abort()
>>> cn.root()['a']
100
>>> cn.close()
>>> db.close()
N( ( R ( ( R t test_close_with_pending_changes s Dc C s d S( s+ doctest of onCloseCallback() method
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
Every function registered is called, even if it raises an
exception. They are only called once.
>>> L = []
>>> def f():
... L.append("f")
>>> def g():
... L.append("g")
... return 1 / 0
>>> cn.onCloseCallback(g)
>>> cn.onCloseCallback(f)
>>> cn.close()
>>> L
['g', 'f']
>>> del L[:]
>>> cn.close()
>>> L
[]
The implementation keeps a list of callbacks that is reset
to a class variable (which is bound to None) after the connection
is closed.
>>> cn._Connection__onCloseCallbacks
N( ( R ( ( R t test_onCloseCallbacksG s c C s d S( sê doctest of db() method
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> cn.db() is db
True
>>> cn.close()
>>> cn.db() is db
True
N( ( R ( ( R t test_dbg s
c C s d S( s doctest of isReadOnly() method
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> cn.isReadOnly()
False
>>> cn.close()
>>> cn.isReadOnly()
Traceback (most recent call last):
...
ConnectionStateError: The database connection is closed
An expedient way to create a read-only storage:
>>> db._storage._is_read_only = True
>>> cn = db.open()
>>> cn.isReadOnly()
True
N( ( R ( ( R t test_isReadOnlys s c C s d S( s0 doctest of cacheMinimize().
Thus test us minimal, just verifying that the method can be called
and has some effect. We need other tests that verify the cache works
as intended.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> r = cn.root()
>>> cn.cacheMinimize()
>>> r._p_state
-1
>>> r._p_activate()
>>> r._p_state # up to date
0
>>> cn.cacheMinimize()
>>> r._p_state # ghost again
-1
N( ( R ( ( R t
test_cacheˆ s (
R4 R5 R7 R8 R9 R: R; R< R= R> ( ( ( R R6 • s 5 F t InvalidationTestsc B s t Z d „ Z RS( Nc C s d S( s
This test initializes the database with several persistent
objects, then manually delivers invalidations and verifies that
they have the expected effect.
>>> db = databaseFromString("\n\n")
>>> cn = db.open()
>>> p1 = Persistent()
>>> p2 = Persistent()
>>> p3 = Persistent()
>>> r = cn.root()
>>> r.update(dict(p1=p1, p2=p2, p3=p3))
>>> transaction.commit()
Transaction ids are 8-byte strings, just like oids; p64() will
create one from an int.
>>> cn.invalidate(p64(1), {p1._p_oid: 1})
>>> cn._txn_time
'\x00\x00\x00\x00\x00\x00\x00\x01'
>>> p1._p_oid in cn._invalidated
True
>>> p2._p_oid in cn._invalidated
False
>>> cn.invalidate(p64(10), {p2._p_oid: 1, p64(76): 1})
>>> cn._txn_time
'\x00\x00\x00\x00\x00\x00\x00\x01'
>>> p1._p_oid in cn._invalidated
True
>>> p2._p_oid in cn._invalidated
True
Calling invalidate() doesn't affect the object state until
a transaction boundary.
>>> p1._p_state
0
>>> p2._p_state
0
>>> p3._p_state
0
The sync() method will abort the current transaction and
process any pending invalidations.
>>> cn.sync()
>>> p1._p_state
-1
>>> p2._p_state
-1
>>> p3._p_state
0
>>> cn._invalidated
{}
N( ( R ( ( R t test_invalidate¥ s :( R4 R5 R@ ( ( ( R R? ž s c C s d S( sS
The invalidateCache method invalidates a connection's cache. It also
prevents reads until the end of a transaction.
>>> from ZODB.tests.util import DB
>>> import transaction
>>> db = DB()
>>> tm = transaction.TransactionManager()
>>> connection = db.open(transaction_manager=tm)
>>> connection.root()['a'] = StubObject()
>>> connection.root()['a'].x = 1
>>> connection.root()['b'] = StubObject()
>>> connection.root()['b'].x = 1
>>> connection.root()['c'] = StubObject()
>>> connection.root()['c'].x = 1
>>> tm.commit()
>>> connection.root()['b']._p_deactivate()
>>> connection.root()['c'].x = 2
So we have a connection and an active transaction with some
modifications. Lets call invalidateCache:
>>> connection.invalidateCache()
Now, if we try to load an object, we'll get a read conflict:
>>> connection.root()['b'].x
Traceback (most recent call last):
...
ReadConflictError: database read conflict error
If we try to commit the transaction, we'll get a conflict error:
>>> tm.commit()
Traceback (most recent call last):
...
ConflictError: database conflict error
and the cache will have been cleared:
>>> print connection.root()['a']._p_changed
None
>>> print connection.root()['b']._p_changed
None
>>> print connection.root()['c']._p_changed
None
But we'll be able to access data again:
>>> connection.root()['b'].x
1
Aborting a transaction after a read conflict also lets us read data
and go on about our business:
>>> connection.invalidateCache()
>>> connection.root()['c'].x
Traceback (most recent call last):
...
ReadConflictError: database read conflict error
>>> tm.abort()
>>> connection.root()['c'].x
1
>>> connection.root()['c'].x = 2
>>> tm.commit()
>>> db.close()
N( ( ( ( R t test_invalidateCacheá s HR c B s t Z RS( N( R4 R5 ( ( ( R R - s R c B s t Z RS( N( R4 R5 ( ( ( R R 0 s t ErrorOnGetstateExceptionc B s t Z RS( N( R4 R5 ( ( ( R RB 3 s t ErrorOnGetstateObjectc B s t Z d „ Z RS( Nc C s
t ‚ d S( N( RB ( R ( ( R t __getstate__8 s ( R4 R5 RD ( ( ( R RC 6 s R/ c B s t Z d „ Z d „ Z RS( Nc C s
| | _ d S( N( t pR t _v_p( R RE ( ( R t __init__= s c C s, | i i | i ƒ | i | _ t i | ƒ S( N( R R R RF RE t
PersistentRD ( R ( ( R RD @ s ( R4 R5 RG RD ( ( ( R R/ ; s t StubStoragec B sb t Z d Z d Z e Z d „ Z d „ Z d „ Z d „ Z d „ Z
d „ Z d „ Z d „ Z
RS(
s Very simple in-memory storage that does *just* enough to support tests.
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()
method, its oid is appended to self._stored. When a transaction is
finished, the oids that have been stored during the transaction are
appended to self._finished.
i c C s1 g | _ g | _ h | _ h | _ g | _ d S( N( R R( R+ t _datat
_transdatat _transstored( R ( ( R RG X s
c C s" t | i ƒ } | i d 7_ | S( Ni ( t strR t _oidR ( R R ( ( R t new_oid` s c C s d S( Ns StubStorage sortKey( ( R ( ( R t sortKeye s c C s^ | d j o t d ƒ ‚ n> | i d j o
| | _ n! | i | j o t d ƒ ‚ n d S( Ns transaction may not be Nones/ StubStorage uses only one transaction at a time( R
R R R t _transactiont RuntimeError( R R
( ( R R" h s
c C sT | d j o t d ƒ ‚ n! | i | j o t d ƒ ‚ n | ` | i i ƒ d S( Ns transaction may not be Nones/ StubStorage uses only one transaction at a time( R
R R R RQ RR RK t clear( R R
( ( R R# q s
c C s | d j o t d ƒ ‚ n! | i | j o t d ƒ ‚ n | i i | i ƒ | i i
| i ƒ | | ƒ | ` | i i
ƒ g | _ d S( Ns transaction may not be Nones/ StubStorage uses only one transaction at a time( R
R R R RQ RR R+ t extendRL RJ t updateRK t callbackRS ( R R
RV ( ( R R* z s
c C s( | d j o t d ƒ ‚ n | i | S( Nt s& StubStorage does not support versions.( t versionR R RJ R ( R R RX ( ( R t load‡ s
c C s‘ | d j o t d ƒ ‚ n | d j o t d ƒ ‚ n! | i | j o t d ƒ ‚ n | i i | ƒ | i
i | ƒ | | f | i
|
( t ZODB.interfacest IConnectiont databaseFromStringR R t cnt verifyObject( R R` Rb R ( ( R t test_connection_interfacež s
( R4 R5 Rd ( ( ( R R^ œ s R c B s5 t Z d „ Z d Z d Z h d e