Source Code for Module repoze.who.plugins.tests.test_sql

  1  import unittest 
  2   
  3 -class TestSQLAuthenticatorPlugin(unittest.TestCase): 
  4   
  5 -    def _getTargetClass(self): 
  6          from repoze.who.plugins.sql import SQLAuthenticatorPlugin 
  7          return SQLAuthenticatorPlugin 
  8   
  9 -    def _makeOne(self, *arg, **kw): 
 10          plugin = self._getTargetClass()(*arg, **kw) 
 11          return plugin 
 12   
 13 -    def _makeEnviron(self, kw=None): 
 14          environ = {} 
 15          environ['wsgi.version'] = (1,0) 
 16          if kw is not None: 
 17              environ.update(kw) 
 18          return environ 
 19   
 20 -    def test_implements(self): 
 21          from zope.interface.verify import verifyClass 
 22          from repoze.who.interfaces import IAuthenticator 
 23          klass = self._getTargetClass() 
 24          verifyClass(IAuthenticator, klass, tentative=True) 
 25   
 26 -    def test_authenticate_noresults(self): 
 27          dummy_factory = DummyConnectionFactory([]) 
 28          plugin = self._makeOne('select foo from bar', dummy_factory, 
 29                                 compare_succeed) 
 30          environ = self._makeEnviron() 
 31          identity = {'login':'foo', 'password':'bar'} 
 32          result = plugin.authenticate(environ, identity) 
 33          self.assertEqual(result, None) 
 34          self.assertEqual(dummy_factory.query, 'select foo from bar') 
 35          self.assertEqual(dummy_factory.closed, True) 
 36   
 37 -    def test_authenticate_comparefail(self): 
 38          dummy_factory = DummyConnectionFactory([ ['userid', 'password'] ]) 
 39          plugin = self._makeOne('select foo from bar', dummy_factory, 
 40                                 compare_fail) 
 41          environ = self._makeEnviron() 
 42          identity = {'login':'fred', 'password':'bar'} 
 43          result = plugin.authenticate(environ, identity) 
 44          self.assertEqual(result, None) 
 45          self.assertEqual(dummy_factory.query, 'select foo from bar') 
 46          self.assertEqual(dummy_factory.closed, True) 
 47   
 48 -    def test_authenticate_comparesuccess(self): 
 49          dummy_factory = DummyConnectionFactory([ ['userid', 'password'] ]) 
 50          plugin = self._makeOne('select foo from bar', dummy_factory, 
 51                                 compare_succeed) 
 52          environ = self._makeEnviron() 
 53          identity = {'login':'fred', 'password':'bar'} 
 54          result = plugin.authenticate(environ, identity) 
 55          self.assertEqual(result, 'userid') 
 56          self.assertEqual(dummy_factory.query, 'select foo from bar') 
 57          self.assertEqual(dummy_factory.closed, True) 
 58   
 59 -    def test_authenticate_nologin(self): 
 60          dummy_factory = DummyConnectionFactory([ ['userid', 'password'] ]) 
 61          plugin = self._makeOne('select foo from bar', dummy_factory, 
 62                                 compare_succeed) 
 63          environ = self._makeEnviron() 
 64          identity = {} 
 65          result = plugin.authenticate(environ, identity) 
 66          self.assertEqual(result, None) 
 67          self.assertEqual(dummy_factory.query, None) 
 68          self.assertEqual(dummy_factory.closed, False) 
 69   
 70 -class TestDefaultPasswordCompare(unittest.TestCase): 
 71   
 72 -    def _getFUT(self): 
 73          from repoze.who.plugins.sql import default_password_compare 
 74          return default_password_compare 
 75   
 76 -    def _get_sha_hex_digest(self, clear='password'): 
 77          try: 
 78              from hashlib import sha1 
 79          except ImportError: 
 80              from sha import new as sha1 
 81          return sha1(clear).hexdigest() 
 82   
 83 -    def test_shaprefix_success(self): 
 84          stored = '{SHA}' +  self._get_sha_hex_digest() 
 85          compare = self._getFUT() 
 86          result = compare('password', stored) 
 87          self.assertEqual(result, True) 
 88   
 89 -    def test_shaprefix_fail(self): 
 90          stored = '{SHA}' + self._get_sha_hex_digest() 
 91          compare = self._getFUT() 
 92          result = compare('notpassword', stored) 
 93          self.assertEqual(result, False) 
 94   
 95 -    def test_noprefix_success(self): 
 96          stored = 'password' 
 97          compare = self._getFUT() 
 98          result = compare('password', stored) 
 99          self.assertEqual(result, True) 
100   
101 -    def test_noprefix_fail(self): 
102          stored = 'password' 
103          compare = self._getFUT() 
104          result = compare('notpassword', stored) 
105          self.assertEqual(result, False) 
106   
107 -class TestSQLMetadataProviderPlugin(unittest.TestCase): 
108   
109 -    def _getTargetClass(self): 
110          from repoze.who.plugins.sql import SQLMetadataProviderPlugin 
111          return SQLMetadataProviderPlugin 
112   
113 -    def _makeOne(self, *arg, **kw): 
114          klass = self._getTargetClass() 
115          return klass(*arg, **kw) 
116   
117 -    def test_implements(self): 
118          from zope.interface.verify import verifyClass 
119          from repoze.who.interfaces import IMetadataProvider 
120          klass = self._getTargetClass() 
121          verifyClass(IMetadataProvider, klass, tentative=True) 
122   
123 -    def test_add_metadata(self): 
124          dummy_factory = DummyConnectionFactory([ [1, 2, 3] ]) 
125          def dummy_filter(results): 
126              return results 
127          plugin = self._makeOne('md', 'select foo from bar', dummy_factory, 
128                                 dummy_filter) 
129          environ = {} 
130          identity = {'repoze.who.userid':1} 
131          plugin.add_metadata(environ, identity) 
132          self.assertEqual(dummy_factory.closed, True) 
133          self.assertEqual(identity['md'], [ [1,2,3] ]) 
134          self.assertEqual(dummy_factory.query, 'select foo from bar') 
135          self.failIf(identity.has_key('__userid')) 
136   
137 -class TestMakeSQLAuthenticatorPlugin(unittest.TestCase): 
138   
139 -    def _getFUT(self): 
140          from repoze.who.plugins.sql import make_authenticator_plugin 
141          return make_authenticator_plugin 
142   
143 -    def test_noquery(self): 
144          f = self._getFUT() 
145          self.assertRaises(ValueError, f, None, 'conn', 'compare') 
146   
147 -    def test_no_connfactory(self): 
148          f = self._getFUT() 
149          self.assertRaises(ValueError, f, 'statement', None, 'compare') 
150   
151 -    def test_bad_connfactory(self): 
152          f = self._getFUT() 
153          self.assertRaises(ValueError, f, 'statement', 'does.not:exist', None) 
154   
155 -    def test_connfactory_specd(self): 
156          f = self._getFUT() 
157          plugin = f('statement', 
158                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory', 
159                     None) 
160          self.assertEqual(plugin.query, 'statement') 
161          self.assertEqual(plugin.conn_factory, DummyConnFactory) 
162          from repoze.who.plugins.sql import default_password_compare 
163          self.assertEqual(plugin.compare_fn, default_password_compare) 
164   
165 -    def test_comparefunc_specd(self): 
166          f = self._getFUT() 
167          plugin = f('statement', 
168                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory', 
169                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory') 
170          self.assertEqual(plugin.query, 'statement') 
171          self.assertEqual(plugin.conn_factory, DummyConnFactory) 
172          self.assertEqual(plugin.compare_fn, make_dummy_connfactory) 
173   
174 -class TestMakeSQLMetadataProviderPlugin(unittest.TestCase): 
175   
176 -    def _getFUT(self): 
177          from repoze.who.plugins.sql import make_metadata_plugin 
178          return make_metadata_plugin 
179   
180 -    def test_no_name(self): 
181          f = self._getFUT() 
182          self.assertRaises(ValueError, f) 
183   
184 -    def test_no_query(self): 
185          f = self._getFUT() 
186          self.assertRaises(ValueError, f, 'name', None, None) 
187   
188 -    def test_no_connfactory(self): 
189          f = self._getFUT() 
190          self.assertRaises(ValueError, f, 'name', 'statement', None) 
191   
192 -    def test_bad_connfactory(self): 
193          f = self._getFUT() 
194          self.assertRaises(ValueError, f, 'name', 'statement', 
195                            'does.not:exist', None) 
196   
197 -    def test_connfactory_specd(self): 
198          f = self._getFUT() 
199          plugin = f('name', 'statement', 
200                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory', 
201                     None) 
202          self.assertEqual(plugin.name, 'name') 
203          self.assertEqual(plugin.query, 'statement') 
204          self.assertEqual(plugin.conn_factory, DummyConnFactory) 
205          self.assertEqual(plugin.filter, None) 
206   
207 -    def test_comparefn_specd(self): 
208          f = self._getFUT() 
209          plugin = f('name', 'statement', 
210                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory', 
211                     'repoze.who.plugins.tests.test_sql:make_dummy_connfactory') 
212          self.assertEqual(plugin.name, 'name') 
213          self.assertEqual(plugin.query, 'statement') 
214          self.assertEqual(plugin.conn_factory, DummyConnFactory) 
215          self.assertEqual(plugin.filter, make_dummy_connfactory) 
216   
217   
218 -class DummyConnectionFactory: 
219      # acts as all of: a factory, a connection, and a cursor 
220      closed = False 
221      query = None 
222 -    def __init__(self, results): 
223          self.results = results 
224   
225 -    def __call__(self): 
226          return self 
227   
228 -    def cursor(self): 
229          return self 
230   
231 -    def execute(self, query, *arg): 
232          self.query = query 
233          self.bindargs = arg 
234   
235 -    def fetchall(self): 
236          return self.results 
237   
238 -    def fetchone(self): 
239          if self.results: 
240              return self.results[0] 
241          return [] 
242   
243 -    def close(self): 
244          self.closed = True 
245   
246 -def compare_fail(cleartext, stored): 
247      return False 
248   
249 -def compare_succeed(cleartext, stored): 
250      return True 
251   
252 -class _DummyConnFactory: 
253      pass 
254   
255  DummyConnFactory = _DummyConnFactory() 
256   
257 -def make_dummy_connfactory(**kw): 
258      return DummyConnFactory 
259