def test__fire_always_consumes_all_hooks(self): dhooks = DeferredHooks() d1, d2 = Deferred(), Deferred() d1.addCallback(lambda _: 0 / 0) # d1 will fail. dhooks.add(d1) dhooks.add(d2) self.assertRaises(ZeroDivisionError, dhooks.fire) self.assertThat(dhooks.hooks, HasLength(0)) self.assertThat(d1, IsFiredDeferred()) self.assertThat(d2, IsFiredDeferred())
def test_handleRequest_builds_handler(self): protocol, factory = self.make_protocol() protocol.user = sentinel.user handler_class = MagicMock() handler_name = maas_factory.make_name("handler") handler_class._meta.handler_name = handler_name handler = handler_class.return_value handler.execute.return_value = succeed(None) # Inject mock handler into the factory. factory.handlers[handler_name] = handler_class d = protocol.handleRequest({ "type": MSG_TYPE.REQUEST, "request_id": random.randint(1, 999999), "method": "%s.get" % handler_name, }) self.assertThat(d, IsFiredDeferred()) self.assertThat(handler_class, MockCalledOnceWith( protocol.user, protocol.cache[handler_name])) # The cache passed into the handler constructor *is* the one found in # the protocol's cache; they're not merely equal. self.assertIs( protocol.cache[handler_name], handler_class.call_args[0][1])
def test__fire_calls_hooks_in_reactor(self): def validate_in_reactor(_): self.assertTrue(isInIOThread()) dhooks = DeferredHooks() d = Deferred() d.addCallback(validate_in_reactor) dhooks.add(d) dhooks.fire() self.assertThat(d, IsFiredDeferred())
def test__reset_cancels_in_reactor(self): def validate_in_reactor(_): self.assertTrue(isInIOThread()) dhooks = DeferredHooks() d = Deferred() d.addBoth(validate_in_reactor) dhooks.add(d) dhooks.reset() self.assertThat(dhooks.hooks, HasLength(0)) self.assertThat(d, IsFiredDeferred())
def test__starts_and_stops_process(self): service = SleepProcessProtocolService() with TwistedLoggerFixture() as logger: service.startService() self.assertThat(service._protocol.done, Not(IsFiredDeferred())) yield service.stopService() result = yield service._protocol.done self.assertThat(result, Is(None)) self.assertThat( logger.output, DocTestMatches("SleepProcessProtocolService started.\n" "-...-\n" "SleepProcessProtocolService ...")) with ExpectedException(ProcessExitedAlready): service._process.signalProcess("INT")
def test__restarts_process_after_finishing(self): ifname = factory.make_name("eth") service = BeaconingService(ifname, Mock()) mock_process_params = self.patch(service, "getProcessParameters") mock_process_params.return_value = [b"/bin/echo", b"{}"] service.clock = Clock() service.startService() # Wait for the protocol to finish service.clock.advance(0.0) yield service._protocol.done # Advance the clock (should start the service again) interval = service.step service.clock.advance(interval) # The Deferred should have been recreated. self.assertThat(service._protocol.done, Not(IsFiredDeferred())) yield service._protocol.done service.stopService()
def test__logs_failures_from_cancelled_hooks(self): logger = self.useFixture(TwistedLoggerFixture()) error = factory.make_exception() dhooks = DeferredHooks() d = Deferred() d.addBoth(lambda _: Failure(error)) dhooks.add(d) dhooks.reset() self.assertThat(dhooks.hooks, HasLength(0)) self.assertThat(d, IsFiredDeferred()) self.assertDocTestMatches( dedent("""\ Failure when cancelling hook. Traceback (most recent call last): ... maastesting.factory.TestException#... """), logger.output)
def test__logs_failures_from_cancellers_when_hook_already_fired(self): logger = self.useFixture(TwistedLoggerFixture()) def canceller(d): d.callback(None) raise factory.make_exception() dhooks = DeferredHooks() d = Deferred(canceller) dhooks.add(d) dhooks.reset() self.assertThat(dhooks.hooks, HasLength(0)) self.assertThat(d, IsFiredDeferred()) self.assertDocTestMatches( dedent("""\ Failure when cancelling hook. Traceback (most recent call last): ... maastesting.factory.TestException#... """), logger.output)
def test_onConnectionLost_fires_when_connection_is_lost(self): protocol = common.RPCProtocol() protocol.makeConnection(StringTransport()) protocol.connectionLost(connectionDone) self.assertThat(protocol.onConnectionLost, IsFiredDeferred())
def test_onConnectionMade_fires_when_connection_is_made(self): protocol = common.RPCProtocol() protocol.connectionMade() self.assertThat(protocol.onConnectionMade, IsFiredDeferred())
def test__does_not_match_non_deferred(self): self.assertMismatch(IsFiredDeferred().match(object()), " is not a Deferred")
def test__does_not_match_unfired_deferred(self): d = defer.Deferred() self.assertMismatch(IsFiredDeferred().match(d), " has not been called")
def test__matches_fired_deferred(self): d = defer.Deferred() d.callback(None) self.assertThat(d, IsFiredDeferred())