def test__deferDHCPRequests(self): clock = Clock() monitor = DHCPRequestMonitor('lo', clock) mock_addErrback = mock.MagicMock() mock_deferredListResult = mock.MagicMock() mock_deferLater = self.patch(detect_module, 'deferLater') mock_deferLater.return_value = mock.MagicMock() mock_deferLater.return_value.addErrback = mock_addErrback mock_DeferredList = self.patch(detect_module, 'DeferredList') mock_DeferredList.return_value = mock_deferredListResult mock_deferredListResult.addErrback = mock_addErrback expected_calls = [ call( clock, seconds + 0.1, send_dhcp_request_packet, DHCPDiscoverPacket(transaction_id=monitor.transaction_id, seconds=seconds), 'lo') for seconds in DHCP_REQUEST_TIMING ] monitor.deferDHCPRequests() self.assertThat(mock_deferLater, MockCallsMatch(*expected_calls)) self.assertThat( mock_DeferredList, MockCallsMatch( call(monitor.deferredDHCPRequests, fireOnOneErrback=True, consumeErrors=True))) # Expect addErrback to be called both on each individual Deferred, plus # one more time on the DeferredList. expected_errback_calls = [ call(monitor.deferredDHCPRequestErrback) for _ in range(len(DHCP_REQUEST_TIMING) + 1) ] self.assertThat(mock_addErrback, MockCallsMatch(*expected_errback_calls))
def test__deferredDHCPRequestErrback_logs_known_exceptions(self): logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor("lo") error = factory.make_string() monitor.deferredDHCPRequestErrback( make_Failure(DHCPProbeException, error)) self.assertThat(logger.output, DocTestMatches("DHCP probe failed. %s" % error))
def test__deferredDHCPRequestErrback_logs_unknown_exceptions(self): logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor('lo') error = factory.make_string() monitor.deferredDHCPRequestErrback(make_Failure(IOError, error)) self.assertThat( logger.output, DocTestMatches("...unknown error...Traceback...%s" % error))
def test__run_skips_logging_if_no_servers_found(self): logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor("lo") mock_send_and_await = self.patch(monitor, "send_requests_and_await_replies") mock_send_and_await.return_value = {} yield monitor.run() self.assertThat(mock_send_and_await, MockCallsMatch(call())) self.assertThat(logger.output, DocTestMatches(""))
def test__cancelAll(self): self.errbacks_called = 0 def mock_errback(result: Failure): self.assertTrue(result.check(CancelledError)) self.errbacks_called += 1 a = deferLater(reactor, 6, lambda: "a") b = deferLater(reactor, 6, lambda: "b") a.addBoth(mock_errback) b.addBoth(mock_errback) deferreds = [a, b] DHCPRequestMonitor.cancelAll(deferreds) deferredList = DeferredList(deferreds) yield deferredList self.assertThat(self.errbacks_called, Equals(2))
def test__deferredDHCPRequestErrback_cancels_all_on_FirstError(self): mock_cancelAll = self.patch(DHCPRequestMonitor, 'cancelAll') def raise_ioerror(): raise IOError() a = deferLater(reactor, 0.0, raise_ioerror) b = deferLater(reactor, 6, lambda: 'b') monitor = DHCPRequestMonitor('lo') monitor.deferredDHCPRequests = [a, b] deferredList = DeferredList(monitor.deferredDHCPRequests, consumeErrors=True, fireOnOneErrback=True) deferredList.addErrback(monitor.deferredDHCPRequestErrback) yield deferredList # Still have one call left in the reactor, since we mocked cancelAll(). b.cancel() self.assertThat(mock_cancelAll, MockCallsMatch(call([a, b])))
def test__run_logs_result_and_makes_properties_available(self): logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor('lo') mock_send_and_await = self.patch(monitor, 'send_requests_and_await_replies') mock_send_and_await.return_value = { DHCPServer('127.0.0.1', '127.0.0.1'), DHCPServer('127.1.1.1', '127.2.2.2'), } yield monitor.run() self.assertThat(mock_send_and_await, MockCallsMatch(call())) self.assertThat( logger.output, DocTestMatches( "External DHCP server(s) discovered on interface 'lo': 127.0.0.1, " "127.1.1.1 (via 127.2.2.2)")) self.assertThat(monitor.dhcp_servers, Equals({"127.0.0.1", "127.1.1.1"})) self.assertThat(monitor.dhcp_addresses, Equals({"127.0.0.1", "127.2.2.2"}))
def test__deferredDHCPRequestErrback_ignores_cancelled(self): logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor("lo") error = factory.make_string() monitor.deferredDHCPRequestErrback(make_Failure(CancelledError, error)) self.assertThat(logger.output, DocTestMatches(""))
def test__send_requests_and_await_replies(self): # This test is a bit large because it covers the entire functionality # of the `send_requests_and_await_replies()` method. (It could be # split apart into multiple tests, but the large amount of setup work # and interdependencies makes that a maintenance burden.) mock_socket = patch_socket(self) mock_socket.bind = mock.MagicMock() mock_socket.recvfrom = mock.MagicMock() mock_socket.setsockopt = mock.MagicMock() mock_socket.settimeout = mock.MagicMock() # Pretend we were successful at deferring the DHCP requests. self.patch_autospec(detect_module, "blockingCallFromThread") # This method normally blocks for ~10 seconds, so take control of the # monotonic clock and make sure the last call to `recvfrom()` happens # just as we hit the reply timeout. mock_time_monotonic = self.patch(detect_module.time.monotonic) mock_time_monotonic.side_effect = ( # Start time (before loop starts). 10, # First reply (truncated packet). 11, # Second reply (not a match to our transaction). 12, # Third reply (Matching reply with server identifier option). 13, # First socket timeout (need to make sure the loop continues). 14, # Second socket timeout (hey, we're done!). 10 + detect_module.REPLY_TIMEOUT, ) mock_xid = factory.make_bytes(4) valid_dhcp_reply = factory.make_dhcp_packet( transaction_id=mock_xid, include_server_identifier=True, server_ip="127.1.1.1", ) mock_get_xid = self.patch(detect_module.make_dhcp_transaction_id) mock_get_xid.return_value = mock_xid # Valid DHCP packet, but not a match because it doesn't have a # Server Identifier option. valid_non_match = DHCPDiscoverPacket(mac="01:02:03:04:05:06", transaction_id=mock_xid).packet mock_socket.recvfrom.side_effect = ( # Truncated packet, to test logging. (b"", ("127.0.0.1", BOOTP_SERVER_PORT)), (valid_non_match, ("127.0.0.2", BOOTP_SERVER_PORT)), (valid_dhcp_reply, ("127.0.0.3", BOOTP_SERVER_PORT)), socket.timeout, socket.timeout, ) logger = self.useFixture(TwistedLoggerFixture()) monitor = DHCPRequestMonitor("lo", Clock()) result = monitor.send_requests_and_await_replies() self.assertThat( mock_socket.setsockopt, MockCallsMatch( call(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1), call(socket.SOL_SOCKET, socket.SO_BROADCAST, 1), ), ) self.assertThat(mock_socket.bind, MockCallsMatch(call(("", 68)))) self.assertThat( mock_socket.settimeout, MockCallsMatch(call(detect_module.SOCKET_TIMEOUT)), ) self.assertThat( mock_socket.recvfrom, MockCallsMatch(call(2048), call(2048), call(2048), call(2048), call(2048)), ) # One of the response packets was truncated. self.assertThat( logger.output, DocTestMatches("Invalid DHCP response...Truncated..."), ) self.assertThat(result, HasLength(1)) # Ensure we record the fact that the reply packet came from a different # IP address than the server claimed to be. self.assertThat(result, Contains(DHCPServer("127.1.1.1", "127.0.0.3")))