[Repoze-dev] Repoze CVS: test_publisher.py

[Tres Seaver]

Update of /home/repoze/cvs/repoze.obob/repoze/obob/tests
In directory laguna.palladion.com:/tmp/cvs-serv16102/repoze/obob/tests

Modified Files:
	test_publisher.py 
Log Message:
 - Turn private methods into defaults with override via Paste config.

Index: test_publisher.py
===================================================================
RCS file: /home/repoze/cvs/repoze.obob/repoze/obob/tests/test_publisher.py,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- test_publisher.py	11 Sep 2007 01:19:51 -0000	1.1
+++ test_publisher.py	12 Sep 2007 15:19:09 -0000	1.2
@@ -26,42 +26,96 @@
         self.failUnless(obob.before_invoke is None)
 
         klass = self._getTargetClass()
-        self.failUnless(obob.traverse.im_func is klass.traverse.im_func)
+        for defaulted in ('request_factory',
+                          'traverse',
+                          'invoke',
+                          'map_result',
+                         ):
+            from_instance = getattr(obob, defaulted).im_func
+            from_class = getattr(klass, defaulted).im_func
+
+            self.failUnless(from_instance is from_class)
 
     def test_ctor_root_and_others(self):
 
         def _root(request): pass
+        def _rf(environ): pass
         def _bt(current, name, request): pass
         def _t(current, name): pass
         def _bi(published, request): pass
+        def _i(published, request): pass
+        def _mr(request, result): pass
 
         obob = self._makeOne(root=_root,
+                             request_factory=_rf,
                              before_traverse=_bt,
                              traverse =_t,
                              before_invoke=_bi,
+                             invoke=_i,
+                             map_result=_mr,
                             )
 
         self.failUnless(obob.root is _root)
+        self.failUnless(obob.request_factory is _rf)
         self.failUnless(obob.before_traverse is _bt)
         self.failUnless(obob.traverse is _t)
         self.failUnless(obob.before_invoke is _bi)
+        self.failUnless(obob.invoke is _i)
+        self.failUnless(obob.map_result is _mr)
 
     def test_ctor_before_traverse_not_callable_raises(self):
-        self.assertRaises(ValueError, self._makeOne, lambda *r: object(),
+        self.assertRaises(ValueError, self._makeOne, root=lambda *r: object(),
                                       before_traverse=object())
 
     def test_ctor_traverse_not_callable_raises(self):
-        self.assertRaises(ValueError, self._makeOne, lambda *r: object(),
+        self.assertRaises(ValueError, self._makeOne, root=lambda *r: object(),
                                       traverse=object())
 
     def test_ctor_before_traverse_not_callable_raises(self):
-        self.assertRaises(ValueError, self._makeOne, lambda *r: object(),
+        self.assertRaises(ValueError, self._makeOne, root=lambda *r: object(),
                                       before_invoke=object())
 
+    def test_ctor_invoke_not_callable_raises(self):
+        self.assertRaises(ValueError, self._makeOne, root=lambda *r: object(),
+                                      invoke=object())
+
+    def test_ctor_map_result_not_callable_raises(self):
+        self.assertRaises(ValueError, self._makeOne, root=lambda *r: object(),
+                                      map_result=object())
+
+    def test_request_factory_default(self):
+        obob = self._makeOne(root=lambda *request: object())
+        environ = object()
+        self.failUnless(obob.request_factory(environ) is environ)
+
     def test_traverse_default(self):
-        obob = self._makeOne(lambda *request: object())
+        obob = self._makeOne(root=lambda *request: object())
         d = {'key': 'value'}
         self.assertEqual(obob.traverse(d, 'key'), 'value')
 
-    # def test_makeRequestResponse_...
-    # def test_publish_...
+    def test_invoke_default(self):
+        obob = self._makeOne(root=lambda *request: object())
+        called_with = []
+        request = object()
+        RESULT = object()
+        def _published(*args, **kw):
+            called_with.append((args, kw))
+            return RESULT
+
+        result = obob.invoke(_published, request)
+
+        self.assertEqual(len(called_with), 1)
+        self.assertEqual(called_with[0][0], (request,))
+        self.assertEqual(called_with[0][1], {})
+        self.failUnless(result is RESULT)
+
+    def test_map_result_default(self):
+        obob = self._makeOne(root=lambda *request: object())
+        request = object()
+        result = object()
+
+        status, headers, body_iter = obob.map_result(request, result)
+
+        self.assertEqual(status, 200)
+        self.assertEqual(headers, {})
+        self.assertEqual(body_iter, [result])

_______________________________________________
Repoze-dev mailing list
Repoze-dev at lists.repoze.org
http://lists.repoze.org/mailman/listinfo/repoze-dev