[Zope-Checkins] CVS: Zope/lib/python/Products/Sessions/tests - testBrowserIdManager.py:1.9 testSessionDataManager.py:1.13

Chris McDonough chrism@zope.com
Fri, 19 Jul 2002 00:44:35 -0400


Update of /cvs-repository/Zope/lib/python/Products/Sessions/tests
In directory cvs.zope.org:/tmp/cvs-serv21038/tests

Modified Files:
	testBrowserIdManager.py testSessionDataManager.py 
Log Message:
Fixed bug in SessionDataManager's "hasSessionData" method in which
a call to it would create a session data object -- the hasSessionData
call now does not create a session data object inadvertently as a result
of its usage.

Also updated tests.


=== Zope/lib/python/Products/Sessions/tests/testBrowserIdManager.py 1.8 => 1.9 ===
 
     def testSetBrowserIdName(self):
         self.m.setBrowserIdName('foo')
-        assert self.m.getBrowserIdName()== 'foo'
+        self.failUnless(self.m.getBrowserIdName()== 'foo')
 
     def testSetBadBrowserIdName(self):
-        try:
-            self.m.setBrowserIdName('')
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
-        try:
-            self.m.setBrowserIdName(1)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
-            
+        self.assertRaises(BrowserIdManagerErr,
+                          lambda self=self: self.m.setBrowserIdName(''))
+        self.assertRaises(BrowserIdManagerErr,
+                          lambda self=self: self.m.setBrowserIdName(1))
+
     def testSetBadNamespaces(self):
         d = {1:'gummy', 2:'froopy'}
-        try:
-            self.m.setBrowserIdNamespaces(d)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
-            
+        self.assertRaises(BrowserIdManagerErr,
+                          lambda self=self,d=d:
+                          self.m.setBrowserIdNamespaces(d))
+
     def testSetGoodNamespaces(self):
         d = {1:'cookies', 2:'form'}
         self.m.setBrowserIdNamespaces(d)
-        assert self.m.getBrowserIdNamespaces() == d
+        self.failUnless(self.m.getBrowserIdNamespaces() == d)
 
     def testSetNamespacesByLocation(self):
         self.m.setBrowserIdLocation('cookiesonly')
-        assert self.m.getBrowserIdNamespaces() == {1:'cookies'}
-        assert self.m.getBrowserIdLocation() == 'cookiesonly'
+        self.failUnless(self.m.getBrowserIdNamespaces() == {1:'cookies'})
+        self.failUnless(self.m.getBrowserIdLocation() == 'cookiesonly')
         self.m.setBrowserIdLocation('cookiesthenform')
-        assert self.m.getBrowserIdNamespaces() == {1:'cookies', 2:'form'}
-        assert self.m.getBrowserIdLocation() == 'cookiesthenform'
+        self.failUnless(self.m.getBrowserIdNamespaces()=={1:'cookies',2:'form'})
+        self.failUnless(self.m.getBrowserIdLocation() == 'cookiesthenform')
         self.m.setBrowserIdLocation('formonly')
-        assert self.m.getBrowserIdNamespaces() == {1:'form'}
-        assert self.m.getBrowserIdLocation() == 'formonly'
+        self.failUnless(self.m.getBrowserIdNamespaces() == {1:'form'})
+        self.failUnless(self.m.getBrowserIdLocation() == 'formonly')
         self.m.setBrowserIdLocation('formthencookies')
-        assert self.m.getBrowserIdNamespaces() == {1:'form', 2:'cookies'}
-        assert self.m.getBrowserIdLocation() == 'formthencookies'
+        self.failUnless(self.m.getBrowserIdNamespaces()=={1:'form',2:'cookies'})
+        self.failUnless(self.m.getBrowserIdLocation() == 'formthencookies')
 
     def testSetBadCookiePath(self):
         path = '/;'
-        try:
-            self.m.setCookiePath(path)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
+        self.assertRaises(BrowserIdManagerErr,
+                        lambda self=self, path=path:self.m.setCookiePath(path))
 
     def testSetGoodCookiePath(self):
         self.m.setCookiePath('/foo')
-        assert self.m.getCookiePath() == '/foo'
+        self.failUnless(self.m.getCookiePath() == '/foo')
 
     def testSetBadCookieLifeDays(self):
-        life = ''
-        try:
-            self.m.setCookieLifeDays('')
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
+        self.assertRaises(BrowserIdManagerErr,
+                          lambda self=self: self.m.setCookieLifeDays(''))
 
     def testSetGoodCookieLifeDays(self):
         self.m.setCookieLifeDays(1)
-        assert self.m.getCookieLifeDays() == 1
+        self.failUnless(self.m.getCookieLifeDays() == 1)
 
     def testSetBadCookieDomain(self):
-        life = ''
-        try:
-            self.m.setCookieDomain('gubble')
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
+        self.assertRaises(BrowserIdManagerErr,
+                          lambda self=self: self.m.setCookieDomain('gubble'))
 
     def testSetGoodCookieLifeDays(self):
         self.m.setCookieLifeDays(1)
-        assert self.m.getCookieLifeDays() == 1
+        self.failUnless(self.m.getCookieLifeDays() == 1)
 
     def testSetNoCookieDomain(self):
         domain = ''
         self.m.setCookieDomain(domain)
         setdomain = self.m.getCookieDomain()
-        assert setdomain == domain, "%s" % setdomain
+        self.failUnless(setdomain == domain)
 
     def testSetBadCookieDomain(self):
-        domain = 'zope.org' # not enough dots
-        try:
-            self.m.setCookieDomain(domain)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
-
-        domain = {1:1} # must be stringtype
-        try:
-            self.m.setCookieDomain(domain)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
-            
-        domain = '.zope.org;' # semicolon follows
-        try:
-            self.m.setCookieDomain(domain)
-        except BrowserIdManagerErr:
-            pass
-        else:
-            assert 1 == 2
+        # not enough dots, must be stringtype, semicolon follows respectively
+        for domain in ('zope.org', {1:1}, '.zope.org;'):
+            self.assertRaises(BrowserIdManagerErr,
+               lambda self=self, domain=domain: self.m.setCookieDomain(domain))
 
     def testSetGoodCookieDomain(self):
         self.m.setCookieDomain('.zope.org')
         setdomain = self.m.getCookieDomain()
-        assert setdomain == '.zope.org', "%s" % setdomain
+        self.failUnless( setdomain == '.zope.org', "%s" % setdomain )
         
     def testSetCookieSecure(self):
         self.m.setCookieSecure(1)
-        assert self.m.getCookieSecure() == 1
+        self.failUnless( self.m.getCookieSecure() == 1 )
 
     def testGetBrowserIdCookie(self):
         token = self.m.getBrowserId()
@@ -170,27 +126,27 @@
         tokenkey = self.m.getBrowserIdName()
         self.m.REQUEST.cookies[tokenkey] = token
         a = self.m.getBrowserId()
-        assert a == token, repr(a)
-        assert self.m.isBrowserIdFromCookie()
+        self.failUnless( a == token, repr(a) )
+        self.failUnless( self.m.isBrowserIdFromCookie() )
 
     def testSetBrowserIdDontCreate(self):
         a = self.m.getBrowserId(0)
-        assert a == None
+        self.failUnless( a == None )
 
     def testSetBrowserIdCreate(self):
         a = self.m.getBrowserId(1)
         tokenkey = self.m.getBrowserIdName()
         b = self.m.REQUEST.RESPONSE.cookies[tokenkey]
-        assert a == b['value'], (a, b)
+        self.failUnless( a == b['value'] )
 
     def testHasBrowserId(self):
-        assert not self.m.hasBrowserId()
+        self.failUnless( not self.m.hasBrowserId() )
         a = self.m.getBrowserId()
-        assert self.m.hasBrowserId()
+        self.failUnless( self.m.hasBrowserId() )
         
     def testBrowserIdIsNew(self):
         a = self.m.getBrowserId()
-        assert self.m.isBrowserIdNew()
+        self.failUnless( self.m.isBrowserIdNew() )
 
     def testIsBrowserIdFromCookieFirst(self):
         token = self.m.getBrowserId()
@@ -200,7 +156,7 @@
         self.m.REQUEST.cookies[tokenkey] = token
         self.m.setBrowserIdNamespaces({1:'cookies', 2:'form'})
         a = self.m.getBrowserId()
-        assert self.m.isBrowserIdFromCookie()
+        self.failUnless( self.m.isBrowserIdFromCookie() )
 
     def testIsBrowserIdFromFormFirst(self):
         token = self.m.getBrowserId()
@@ -210,7 +166,7 @@
         self.m.REQUEST.form[tokenkey] = token
         self.m.setBrowserIdNamespaces({1:'form', 2:'cookies'})
         a = self.m.getBrowserId()
-        assert self.m.isBrowserIdFromForm()
+        self.failUnless( self.m.isBrowserIdFromForm() )
 
     def testIsBrowserIdFromCookieOnly(self):
         token = self.m.getBrowserId()
@@ -220,8 +176,8 @@
         self.m.REQUEST.form[tokenkey] = token
         self.m.setBrowserIdNamespaces({1:'cookies'})
         a = self.m.getBrowserId()
-        assert self.m.isBrowserIdFromCookie()
-        assert not self.m.isBrowserIdFromForm()
+        self.failUnless( self.m.isBrowserIdFromCookie() )
+        self.failUnless( not self.m.isBrowserIdFromForm() )
  
     def testIsBrowserIdFromFormOnly(self):
         token = self.m.getBrowserId()
@@ -231,8 +187,8 @@
         self.m.REQUEST.form[tokenkey] = token
         self.m.setBrowserIdNamespaces({1:'form'})
         a = self.m.getBrowserId()
-        assert not self.m.isBrowserIdFromCookie()
-        assert self.m.isBrowserIdFromForm()
+        self.failUnless( not self.m.isBrowserIdFromCookie() )
+        self.failUnless( self.m.isBrowserIdFromForm() )
 
     def testFlushBrowserIdCookie(self):
         token = self.m.getBrowserId()
@@ -241,11 +197,11 @@
         tokenkey = self.m.getBrowserIdName()
         self.m.REQUEST.cookies[tokenkey] = token
         a = self.m.getBrowserId()
-        assert a == token, repr(a)
-        assert self.m.isBrowserIdFromCookie()
+        self.failUnless( a == token, repr(a) )
+        self.failUnless( self.m.isBrowserIdFromCookie() )
         self.m.flushBrowserIdCookie()
         c = self.m.REQUEST.RESPONSE.cookies[tokenkey]
-        assert c['value'] == 'deleted', c
+        self.failUnless( c['value'] == 'deleted' )
         
     def testSetBrowserIdCookieByForce(self):
         token = self.m.getBrowserId()
@@ -254,22 +210,22 @@
         tokenkey = self.m.getBrowserIdName()
         self.m.REQUEST.cookies[tokenkey] = token
         a = self.m.getBrowserId()
-        assert a == token, repr(a)
-        assert self.m.isBrowserIdFromCookie()
+        self.failUnless( a == token )
+        self.failUnless( self.m.isBrowserIdFromCookie() )
         token = 'abcdefghijk'
         self.m.setBrowserIdCookieByForce(token)
         c = self.m.REQUEST.RESPONSE.cookies[tokenkey]
-        assert c['value'] == token, c
+        self.failUnless( c['value'] == token )
 
     def testEncodeUrl(self):
         keystring = self.m.getBrowserIdName()
         key = self.m.getBrowserId()
         u = '/home/chrism/foo'
         r = self.m.encodeUrl(u)
-        assert r == '%s?%s=%s' % (u, keystring, key)
+        self.failUnless( r == '%s?%s=%s' % (u, keystring, key) )
         u = 'http://www.zope.org/Members/mcdonc?foo=bar&spam=eggs'
         r = self.m.encodeUrl(u)
-        assert r == '%s&%s=%s' % (u, keystring, key)
+        self.failUnless( r == '%s&%s=%s' % (u, keystring, key) )
 
 def test_suite():
     testsuite = makeSuite(TestBrowserIdManager, 'test')


=== Zope/lib/python/Products/Sessions/tests/testSessionDataManager.py 1.12 => 1.13 ===
 tf_name = 'temp_folder'
 idmgr_name = 'browser_id_manager'
 toc_name = 'temp_transient_container'
+sdm_name = 'session_data_manager'
 
 stuff = {}
 
@@ -66,7 +67,7 @@
     tf = MountedTemporaryFolder(tf_name, title="Temporary Folder")
     toc = TransientObjectContainer(toc_name, title='Temporary '
         'Transient Object Container', timeout_mins=20)
-    session_data_manager=SessionDataManager(id='session_data_manager',
+    session_data_manager=SessionDataManager(id=sdm_name,
         path='/'+tf_name+'/'+toc_name, title='Session Data Manager',
         requestName='TESTOFSESSION')
 
@@ -76,7 +77,7 @@
     try: app._delObject(tf_name)
     except AttributeError: pass
 
-    try: app._delObject('session_data_manager')
+    try: app._delObject(sdm_name)
     except AttributeError: pass
 
     try: app._delObject('index_html')
@@ -84,7 +85,7 @@
 
     app._setObject(idmgr_name, bidmgr)
 
-    app._setObject('session_data_manager', session_data_manager)
+    app._setObject(sdm_name, session_data_manager)
 
     app._setObject(tf_name, tf)
     get_transaction().commit()
@@ -110,48 +111,53 @@
 
 class TestSessionManager(TestBase):
     def testHasId(self):
-        assert self.app.session_data_manager.id == 'session_data_manager'
+        self.failUnless(self.app.session_data_manager.id == \
+                        sdm_name)
 
     def testHasTitle(self):
-        assert self.app.session_data_manager.title == 'Session Data Manager'
+        self.failUnless(self.app.session_data_manager.title \
+                        == 'Session Data Manager')
 
     def testGetSessionDataNoCreate(self):
         sd = self.app.session_data_manager.getSessionData(0)
-        assert sd is None, repr(sd)
+        self.failUnless(sd is None)
 
     def testGetSessionDataCreate(self):
         sd = self.app.session_data_manager.getSessionData(1)
-        assert sd.__class__ is TransientObject, repr(sd)
+        self.failUnless(sd.__class__ is TransientObject)
 
     def testHasSessionData(self):
         sd = self.app.session_data_manager.getSessionData()
-        assert self.app.session_data_manager.hasSessionData()
+        self.failUnless(self.app.session_data_manager.hasSessionData())
+
+    def testNotHasSessionData(self):
+        self.failUnless(not self.app.session_data_manager.hasSessionData())
 
     def testSessionDataWrappedInSDMandTOC(self):
         sd = self.app.session_data_manager.getSessionData(1)
-        assert aq_base(sd.aq_parent) is \
-               aq_base(getattr(self.app, 'session_data_manager')), sd.aq_parent
-        assert aq_base(sd.aq_parent.aq_parent) is \
-               aq_base(getattr(self.app.temp_folder, toc_name)), \
-               sd.aq_parent.aq_parent
+        sdm = aq_base(getattr(self.app, sdm_name))
+        toc = aq_base(getattr(self.app.temp_folder, toc_name))
+        
+        self.failUnless(aq_base(sd.aq_parent) is sdm)
+        self.failUnless(aq_base(sd.aq_parent.aq_parent) is toc)
 
     def testNewSessionDataObjectIsValid(self):
         sdType = type(TransientObject(1))
         sd = self.app.session_data_manager.getSessionData()
-        assert type(getattr(sd, 'aq_base', sd)) is sdType
-        assert not hasattr(sd, '_invalid')
+        self.failUnless(type(aq_base(sd)) is sdType)
+        self.failUnless(not hasattr(sd, '_invalid'))
 
     def testBrowserIdIsSet(self):
         sd = self.app.session_data_manager.getSessionData()
         mgr = getattr(self.app, idmgr_name)
-        assert mgr.hasBrowserId()
+        self.failUnless(mgr.hasBrowserId())
 
     def testGetSessionDataByKey(self):
         sd = self.app.session_data_manager.getSessionData()
         mgr = getattr(self.app, idmgr_name)
         token = mgr.getBrowserId()
         bykeysd = self.app.session_data_manager.getSessionDataByKey(token)
-        assert sd == bykeysd, (sd, bykeysd, token)
+        self.failUnless(sd == bykeysd)
 
     def testBadExternalSDCPath(self):
         sdm = self.app.session_data_manager
@@ -168,7 +174,7 @@
         sd = sdm.getSessionData()
         sd['test'] = 'Its alive!  Alive!'
         sd.invalidate()
-        assert not sdm.getSessionData().has_key('test')
+        self.failUnless(not sdm.getSessionData().has_key('test'))
 
     def testGhostUnghostSessionManager(self):
         sdm = self.app.session_data_manager
@@ -177,12 +183,12 @@
         sd.set('foo', 'bar')
         sdm._p_changed = None
         get_transaction().commit()
-        assert sdm.getSessionData().get('foo') == 'bar'
+        self.failUnless(sdm.getSessionData().get('foo') == 'bar')
 
     def testSubcommit(self):
         sd = self.app.session_data_manager.getSessionData()
         sd.set('foo', 'bar')
-        assert get_transaction().commit(1) == None
+        self.failUnless(get_transaction().commit(1) == None)
 
     def testForeignObject(self):
         self.assertRaises(InvalidObjectReference, self._foreignAdd)
@@ -205,7 +211,7 @@
         self.app.REQUEST['PARENTS'] = [self.app]
         self.app.REQUEST['URL'] = 'a'
         self.app.REQUEST.traverse('/')
-        assert self.app.REQUEST.has_key('TESTOFSESSION')
+        self.failUnless(self.app.REQUEST.has_key('TESTOFSESSION'))
 
     def testUnlazifyAutoPopulated(self):
         self.app.REQUEST['PARENTS'] = [self.app]
@@ -213,7 +219,7 @@
         self.app.REQUEST.traverse('/')
         sess = self.app.REQUEST['TESTOFSESSION']
         sdType = type(TransientObject(1))
-        assert type(aq_base(sess)) is sdType, type(aq_base(sess))
+        self.failUnless(type(aq_base(sess)) is sdType)
 
 def test_suite():
     test_datamgr = makeSuite(TestSessionManager, 'test')