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())
