def buildProtocol(self, addr): router = Router() proto = self.protocol(router) proto.factory = self default = router.bindRoute(proto, None) default.connectTo(None) return proto
def setUp(self): """ Create sender, router, receiver, and route objects. """ self.sender = CollectingSender() self.router = Router() self.router.startReceivingBoxes(self.sender) self.receiver = SomeReceiver() self.route = self.router.bindRoute(self.receiver) self.route.connectTo("foo")
def indirect(self, interface): """ Create a L{Router} to handle AMP boxes received over an AMP connection. """ if interface is IBoxReceiver: router = Router() connector = self.connectorFactory(router) router.bindRoute(connector, None).connectTo(None) return router raise NotImplementedError()
def setUp(self): """ Create a route attached to a stub sender. """ self.receiver = SomeReceiver() self.sender = CollectingSender() self.localName = "foo" self.remoteName = "bar" self.router = Router() self.router.startReceivingBoxes(self.sender) self.route = self.router.bindRoute(self.receiver, self.localName)
def main(reactor, username, password): startLogging(stdout) router = Router() proto = AMP(router) router.bindRoute(proto, None).connectTo(None) cc = ClientCreator(reactor, lambda: proto) d = cc.connectTCP(username.split('@')[1], 7805) d.addCallback(login, UsernamePassword(username, password)) d.addCallback(connectRoute, router, BoxPrinter(), u'http://divmod.org/ns/echo') d.addCallback(sendBox) return d
def main(reactor, username, password): startLogging(stdout) router = Router() proto = AMP(router) router.bindRoute(proto, None).connectTo(None) cc = ClientCreator(reactor, lambda: proto) d = cc.connectTCP(username.split('@')[1], 7805) d.addCallback(login, UsernamePassword(username, password)) d.addCallback( connectRoute, router, BoxPrinter(), u'http://divmod.org/ns/echo') d.addCallback(sendBox) return d
def test_bindBeforeStartFinishAfterStart(self): """ If a L{Route} is created with L{Router.connect} before the L{Router} is started with L{Router.startReceivingBoxes} but the Deferred returned by the connect thunk does not fire until after the router is started, the L{IBoxReceiver} associated with the route is not started until that Deferred fires and the route is associated with a remote route name. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertFalse(receiver.started) route.connectTo(u"remoteName") self.assertTrue(receiver.started) receiver.sender.sendBox({'foo': 'bar'}) self.assertEqual(sender.boxes, [{_ROUTE: 'remoteName', 'foo': 'bar'}])
def test_bindBeforeStartFinishAfterStart(self): """ If a L{Route} is created with L{Router.connect} before the L{Router} is started with L{Router.startReceivingBoxes} but the Deferred returned by the connect thunk does not fire until after the router is started, the L{IBoxReceiver} associated with the route is not started until that Deferred fires and the route is associated with a remote route name. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertFalse(receiver.started) route.connectTo("remoteName") self.assertTrue(receiver.started) receiver.sender.sendBox({'foo': 'bar'}) self.assertEqual(sender.boxes, [{_ROUTE: 'remoteName', 'foo': 'bar'}])
def setUp(self): """ Create sender, router, receiver, and route objects. """ self.sender = CollectingSender() self.router = Router() self.router.startReceivingBoxes(self.sender) self.receiver = SomeReceiver() self.route = self.router.bindRoute(self.receiver) self.route.connectTo(u"foo")
def test_ampBoxReceivedDefaultRoute(self): """ L{Router.ampBoxReceived} delivers boxes with no route to the default box receiver. """ sender = CollectingSender() receiver = SomeReceiver() router = Router() router.startReceivingBoxes(sender) router.bindRoute(receiver, None).start() router.ampBoxReceived({'foo': 'bar'}) self.assertEqual(receiver.boxes, [{'foo': 'bar'}])
def setUp(self): """ Create a route attached to a stub sender. """ self.receiver = SomeReceiver() self.sender = CollectingSender() self.localName = u"foo" self.remoteName = u"bar" self.router = Router() self.router.startReceivingBoxes(self.sender) self.route = self.router.bindRoute(self.receiver, self.localName)
def test_stopReceivingBoxes(self): """ L{Router.stopReceivingBoxes} calls the C{stop} method of each connected route. """ sender = CollectingSender() router = Router() router.startReceivingBoxes(sender) receiver = SomeReceiver() router.bindRoute(receiver) class DummyException(Exception): pass self.assertFalse(receiver.stopped) router.stopReceivingBoxes(Failure(DummyException())) self.assertTrue(receiver.stopped) receiver.reason.trap(DummyException)
def test_bindBeforeStart(self): """ If a L{Route} is created with L{Router.bind} before the L{Router} is started with L{Router.startReceivingBoxes}, the L{Route} is created unstarted and only started when the L{Router} is started. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) route.connectTo('quux') self.assertFalse(receiver.started) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertTrue(receiver.started) route.sendBox({'foo': 'bar'}) self.assertEqual( sender.boxes, [{_ROUTE: route.remoteRouteName, 'foo': 'bar'}]) router.ampBoxReceived({_ROUTE: route.localRouteName, 'baz': 'quux'}) self.assertEqual(receiver.boxes, [{'baz': 'quux'}])
def test_bindBeforeStart(self): """ If a L{Route} is created with L{Router.bind} before the L{Router} is started with L{Router.startReceivingBoxes}, the L{Route} is created unstarted and only started when the L{Router} is started. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) route.connectTo(u'quux') self.assertFalse(receiver.started) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertTrue(receiver.started) route.sendBox({'foo': 'bar'}) self.assertEqual( sender.boxes, [{_ROUTE: route.remoteRouteName, 'foo': 'bar'}]) router.ampBoxReceived({_ROUTE: route.localRouteName, 'baz': 'quux'}) self.assertEqual(receiver.boxes, [{'baz': 'quux'}])
class RouterTests(TestCase): """ Tests for L{Router}, the L{IBoxReceiver} which directs routed AMP boxes to the right object. """ def setUp(self): """ Create sender, router, receiver, and route objects. """ self.sender = CollectingSender() self.router = Router() self.router.startReceivingBoxes(self.sender) self.receiver = SomeReceiver() self.route = self.router.bindRoute(self.receiver) self.route.connectTo("foo") def test_interfaces(self): """ L{Router} instances provide L{IBoxReceiver}. """ self.assertTrue(verifyObject(IBoxReceiver, self.router)) def test_uniqueRoutes(self): """ L{Router.createRouteIdentifier} returns a new, different route identifier on each call. """ identifiers = [self.router.createRouteIdentifier() for x in range(10)] self.assertEqual(len(set(identifiers)), len(identifiers)) def test_bind(self): """ L{Router.bind} returns a new L{Route} instance which will send boxes to the L{Route}'s L{IBoxSender} after adding a C{_ROUTE} key to them. """ self.route.sendBox({'foo': 'bar'}) self.assertEqual( self.sender.boxes, [{_ROUTE: self.route.remoteRouteName, 'foo': 'bar'}]) self.route.unhandledError(Failure(Exception("some test exception"))) self.assertEqual( self.sender.errors, ["some test exception"]) def test_bindBeforeStart(self): """ If a L{Route} is created with L{Router.bind} before the L{Router} is started with L{Router.startReceivingBoxes}, the L{Route} is created unstarted and only started when the L{Router} is started. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) route.connectTo('quux') self.assertFalse(receiver.started) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertTrue(receiver.started) route.sendBox({'foo': 'bar'}) self.assertEqual( sender.boxes, [{_ROUTE: route.remoteRouteName, 'foo': 'bar'}]) router.ampBoxReceived({_ROUTE: route.localRouteName, 'baz': 'quux'}) self.assertEqual(receiver.boxes, [{'baz': 'quux'}]) def test_bindBeforeStartFinishAfterStart(self): """ If a L{Route} is created with L{Router.connect} before the L{Router} is started with L{Router.startReceivingBoxes} but the Deferred returned by the connect thunk does not fire until after the router is started, the L{IBoxReceiver} associated with the route is not started until that Deferred fires and the route is associated with a remote route name. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertFalse(receiver.started) route.connectTo("remoteName") self.assertTrue(receiver.started) receiver.sender.sendBox({'foo': 'bar'}) self.assertEqual(sender.boxes, [{_ROUTE: 'remoteName', 'foo': 'bar'}]) def test_ampBoxReceived(self): """ L{Router.ampBoxReceived} passes on AMP boxes to the L{IBoxReceiver} identified by the route key in the box. """ firstReceiver = SomeReceiver() firstRoute = self.router.bindRoute(firstReceiver) firstRoute.start() secondReceiver = SomeReceiver() secondRoute = self.router.bindRoute(secondReceiver) secondRoute.start() self.router.ampBoxReceived( {_ROUTE: firstRoute.localRouteName, 'foo': 'bar'}) self.router.ampBoxReceived( {_ROUTE: secondRoute.localRouteName, 'baz': 'quux'}) self.assertEqual(firstReceiver.boxes, [{'foo': 'bar'}]) self.assertEqual(secondReceiver.boxes, [{'baz': 'quux'}]) def test_ampBoxReceivedDefaultRoute(self): """ L{Router.ampBoxReceived} delivers boxes with no route to the default box receiver. """ sender = CollectingSender() receiver = SomeReceiver() router = Router() router.startReceivingBoxes(sender) router.bindRoute(receiver, None).start() router.ampBoxReceived({'foo': 'bar'}) self.assertEqual(receiver.boxes, [{'foo': 'bar'}]) def test_stopReceivingBoxes(self): """ L{Router.stopReceivingBoxes} calls the C{stop} method of each connected route. """ sender = CollectingSender() router = Router() router.startReceivingBoxes(sender) receiver = SomeReceiver() router.bindRoute(receiver) class DummyException(Exception): pass self.assertFalse(receiver.stopped) router.stopReceivingBoxes(Failure(DummyException())) self.assertTrue(receiver.stopped) receiver.reason.trap(DummyException)
def main(reactor): router = Router() cc = ClientCreator(reactor, AMP, router) d = cc.connectTCP('localhost', 7805) d.addCallback(makeRoutes, router) return d
class RouteTests(TestCase): """ Tests for L{Route}, the L{IBoxSender} which handles adding routing information to outgoing boxes. """ def setUp(self): """ Create a route attached to a stub sender. """ self.receiver = SomeReceiver() self.sender = CollectingSender() self.localName = "foo" self.remoteName = "bar" self.router = Router() self.router.startReceivingBoxes(self.sender) self.route = self.router.bindRoute(self.receiver, self.localName) def test_interfaces(self): """ L{Route} instances provide L{IBoxSender}. """ self.assertTrue(verifyObject(IBoxSender, self.route)) def test_start(self): """ L{Route.start} starts its L{IBoxReceiver}. """ self.assertFalse(self.receiver.started) self.route.start() self.assertTrue(self.receiver.started) self.assertIdentical(self.receiver.sender, self.route) def test_stop(self): """ L{Route.stop} stops its L{IBoxReceiver}. """ self.route.start() self.assertFalse(self.receiver.stopped) self.route.stop(Failure(RuntimeError("foo"))) self.assertTrue(self.receiver.stopped) self.receiver.reason.trap(RuntimeError) def test_sendBox(self): """ L{Route.sendBox} adds the route name to the box before passing it on to the underlying sender. """ self.route.connectTo(self.remoteName) self.route.sendBox({"foo": "bar"}) self.assertEqual( self.sender.boxes, [{_ROUTE: self.remoteName, "foo": "bar"}]) def test_sendUnroutedBox(self): """ If C{Route.connectTo} is called with C{None}, no route name is added to the outgoing box. """ self.route.connectTo(None) self.route.sendBox({"foo": "bar"}) self.assertEqual( self.sender.boxes, [{"foo": "bar"}]) def test_sendBoxWithoutConnection(self): """ L{Route.sendBox} raises L{RouteNotConnected} if called before the L{Route} is connected to a remote route name. """ self.assertRaises( RouteNotConnected, self.route.sendBox, {'foo': 'bar'}) def test_unbind(self): """ L{Route.unbind} removes the route from its router. """ self.route.unbind() self.assertRaises( KeyError, self.router.ampBoxReceived, {_ROUTE: self.localName})
class RouterTests(TestCase): """ Tests for L{Router}, the L{IBoxReceiver} which directs routed AMP boxes to the right object. """ def setUp(self): """ Create sender, router, receiver, and route objects. """ self.sender = CollectingSender() self.router = Router() self.router.startReceivingBoxes(self.sender) self.receiver = SomeReceiver() self.route = self.router.bindRoute(self.receiver) self.route.connectTo(u"foo") def test_interfaces(self): """ L{Router} instances provide L{IBoxReceiver}. """ self.assertTrue(verifyObject(IBoxReceiver, self.router)) def test_uniqueRoutes(self): """ L{Router.createRouteIdentifier} returns a new, different route identifier on each call. """ identifiers = [self.router.createRouteIdentifier() for x in range(10)] self.assertEqual(len(set(identifiers)), len(identifiers)) def test_bind(self): """ L{Router.bind} returns a new L{Route} instance which will send boxes to the L{Route}'s L{IBoxSender} after adding a C{_ROUTE} key to them. """ self.route.sendBox({'foo': 'bar'}) self.assertEqual( self.sender.boxes, [{_ROUTE: self.route.remoteRouteName, 'foo': 'bar'}]) self.route.unhandledError(Failure(Exception("some test exception"))) self.assertEqual( self.sender.errors, ["some test exception"]) def test_bindBeforeStart(self): """ If a L{Route} is created with L{Router.bind} before the L{Router} is started with L{Router.startReceivingBoxes}, the L{Route} is created unstarted and only started when the L{Router} is started. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) route.connectTo(u'quux') self.assertFalse(receiver.started) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertTrue(receiver.started) route.sendBox({'foo': 'bar'}) self.assertEqual( sender.boxes, [{_ROUTE: route.remoteRouteName, 'foo': 'bar'}]) router.ampBoxReceived({_ROUTE: route.localRouteName, 'baz': 'quux'}) self.assertEqual(receiver.boxes, [{'baz': 'quux'}]) def test_bindBeforeStartFinishAfterStart(self): """ If a L{Route} is created with L{Router.connect} before the L{Router} is started with L{Router.startReceivingBoxes} but the Deferred returned by the connect thunk does not fire until after the router is started, the L{IBoxReceiver} associated with the route is not started until that Deferred fires and the route is associated with a remote route name. """ router = Router() receiver = SomeReceiver() route = router.bindRoute(receiver) sender = CollectingSender() router.startReceivingBoxes(sender) self.assertFalse(receiver.started) route.connectTo(u"remoteName") self.assertTrue(receiver.started) receiver.sender.sendBox({'foo': 'bar'}) self.assertEqual(sender.boxes, [{_ROUTE: 'remoteName', 'foo': 'bar'}]) def test_ampBoxReceived(self): """ L{Router.ampBoxReceived} passes on AMP boxes to the L{IBoxReceiver} identified by the route key in the box. """ firstReceiver = SomeReceiver() firstRoute = self.router.bindRoute(firstReceiver) firstRoute.start() secondReceiver = SomeReceiver() secondRoute = self.router.bindRoute(secondReceiver) secondRoute.start() self.router.ampBoxReceived( {_ROUTE: firstRoute.localRouteName, 'foo': 'bar'}) self.router.ampBoxReceived( {_ROUTE: secondRoute.localRouteName, 'baz': 'quux'}) self.assertEqual(firstReceiver.boxes, [{'foo': 'bar'}]) self.assertEqual(secondReceiver.boxes, [{'baz': 'quux'}]) def test_ampBoxReceivedDefaultRoute(self): """ L{Router.ampBoxReceived} delivers boxes with no route to the default box receiver. """ sender = CollectingSender() receiver = SomeReceiver() router = Router() router.startReceivingBoxes(sender) router.bindRoute(receiver, None).start() router.ampBoxReceived({'foo': 'bar'}) self.assertEqual(receiver.boxes, [{'foo': 'bar'}]) def test_stopReceivingBoxes(self): """ L{Router.stopReceivingBoxes} calls the C{stop} method of each connected route. """ sender = CollectingSender() router = Router() router.startReceivingBoxes(sender) receiver = SomeReceiver() router.bindRoute(receiver) class DummyException(Exception): pass self.assertFalse(receiver.stopped) router.stopReceivingBoxes(Failure(DummyException())) self.assertTrue(receiver.stopped) receiver.reason.trap(DummyException)
class RouteTests(TestCase): """ Tests for L{Route}, the L{IBoxSender} which handles adding routing information to outgoing boxes. """ def setUp(self): """ Create a route attached to a stub sender. """ self.receiver = SomeReceiver() self.sender = CollectingSender() self.localName = u"foo" self.remoteName = u"bar" self.router = Router() self.router.startReceivingBoxes(self.sender) self.route = self.router.bindRoute(self.receiver, self.localName) def test_interfaces(self): """ L{Route} instances provide L{IBoxSender}. """ self.assertTrue(verifyObject(IBoxSender, self.route)) def test_start(self): """ L{Route.start} starts its L{IBoxReceiver}. """ self.assertFalse(self.receiver.started) self.route.start() self.assertTrue(self.receiver.started) self.assertIdentical(self.receiver.sender, self.route) def test_stop(self): """ L{Route.stop} stops its L{IBoxReceiver}. """ self.route.start() self.assertFalse(self.receiver.stopped) self.route.stop(Failure(RuntimeError("foo"))) self.assertTrue(self.receiver.stopped) self.receiver.reason.trap(RuntimeError) def test_sendBox(self): """ L{Route.sendBox} adds the route name to the box before passing it on to the underlying sender. """ self.route.connectTo(self.remoteName) self.route.sendBox({"foo": "bar"}) self.assertEqual( self.sender.boxes, [{_ROUTE: self.remoteName, "foo": "bar"}]) def test_sendUnroutedBox(self): """ If C{Route.connectTo} is called with C{None}, no route name is added to the outgoing box. """ self.route.connectTo(None) self.route.sendBox({"foo": "bar"}) self.assertEqual( self.sender.boxes, [{"foo": "bar"}]) def test_sendBoxWithoutConnection(self): """ L{Route.sendBox} raises L{RouteNotConnected} if called before the L{Route} is connected to a remote route name. """ self.assertRaises( RouteNotConnected, self.route.sendBox, {'foo': 'bar'}) def test_unbind(self): """ L{Route.unbind} removes the route from its router. """ self.route.unbind() self.assertRaises( KeyError, self.router.ampBoxReceived, {_ROUTE: self.localName})