def test__handle_uncaught_exception_logs_other_failure(self): handler = views.WebApplicationHandler() request = make_request() request.path = factory.make_name("path") # Capture an exc_info tuple with traceback. exc_type = factory.make_exception_type() exc_msg = factory.make_name("message") try: raise exc_type(exc_msg) except exc_type: exc_info = sys.exc_info() with FakeLogger(views.__name__, logging.ERROR) as logger: handler.handle_uncaught_exception(request=request, resolver=get_resolver(None), exc_info=exc_info) self.assertThat( logger.output, DocTestMatches("""\ 500 Internal Server Error @ %s Traceback (most recent call last): ... maastesting.factory.TestException#...: %s """ % (request.path, exc_msg)))
def test_does_not_validate_wrong_key(self): # Validation fails if normalise_openssh_public_key crashes. norm = self.patch(sshkey, "normalise_openssh_public_key") norm.side_effect = factory.make_exception_type() self.assertRaises( ValidationError, validate_ssh_public_key, factory.make_name("key") )
def test_connectionMade_drops_connections_if_authentication_errors(self): logger = self.useFixture(TwistedLoggerFixture()) service = RegionService(sentinel.ipcWorker) service.running = True # Pretend it's running. service.factory.protocol = HandshakingRegionServer protocol = service.factory.buildProtocol(addr=None) # addr is unused. protocol.transport = MagicMock() exception_type = factory.make_exception_type() self.patch_authenticate_for_error(protocol, exception_type()) self.assertDictEqual({}, service.connections) connectionMade = wait_for_reactor(protocol.connectionMade) connectionMade() # The protocol is not added to the connection set. self.assertDictEqual({}, service.connections) # The transport is instructed to lose the connection. self.assertThat(protocol.transport.loseConnection, MockCalledOnceWith()) # The log was written to. self.assertDocTestMatches( """\ Rack controller '...' could not be authenticated; dropping connection. Check that /var/lib/maas/secret...""", logger.dump(), )
def test_raises_unknown_exception(self): exc_type = factory.make_exception_type() self.assertRaises( exc_type, get_best_discovered_result, ({}, {factory.make_name("system_id"): exc_type()}), )
def test_tryConnection_logs_error(self): listener = PostgresListenerService() exception_type = factory.make_exception_type() exception_message = factory.make_name("message") startConnection = self.patch(listener, "startConnection") startConnection.side_effect = exception_type(exception_message) with TwistedLoggerFixture() as logger: with ExpectedException(exception_type): yield listener.tryConnection() self.assertThat(logger.events, HasLength(1)) self.assertThat( logger.events[0], ContainsDict({ "log_format": Equals("Unable to connect to database: {error}"), "log_level": Equals(LogLevel.error), "error": Equals(exception_message), }), )
def test__raises_same_exception(self): pod = factory.make_Pod() node = factory.make_Node() token = NodeKey.objects.get_token_for_node(node) metadata_url = factory.make_url() client = Mock() exception_type = factory.make_exception_type() exception_msg = factory.make_name("error") client.return_value = fail(exception_type(exception_msg)) error = self.assertRaises( exception_type, wait_for_reactor(send_pod_commissioning_results), client, pod.id, pod.name, pod.power_type, node.system_id, pod.power_parameters, token.consumer.key, token.key, token.secret, metadata_url, ) self.assertEqual(exception_msg, str(error))
def test_maybe_make_stats_request_does_not_error(self): service = stats.PrometheusService() deferToDatabase = self.patch(stats, "deferToDatabase") exception_type = factory.make_exception_type() deferToDatabase.return_value = fail(exception_type()) d = service.maybe_push_prometheus_stats() self.assertIsNone(extract_result(d))
def test_raises_UnknownPodType_over_unknown(self): exc_type = factory.make_exception_type() self.assertRaises( UnknownPodType, get_best_discovered_result, ({}, { factory.make_name("system_id"): exc_type(), factory.make_name("system_id"): UnknownPodType("unknown"), }))
def test_authenticateCluster_propagates_errors(self): server = self.make_running_server() exception_type = factory.make_exception_type() callRemote = self.patch_autospec(server, "callRemote") callRemote.return_value = fail(exception_type()) d = server.authenticateCluster() self.assertRaises(exception_type, extract_result, d)
def test__does_not_suppress_exceptions_from_connectivity_checks(self): middleware = ExternalComponentsMiddleware() error_type = factory.make_exception_type() check_rack_controller_connectivity = self.patch( middleware, "_check_rack_controller_connectivity") check_rack_controller_connectivity.side_effect = error_type self.assertRaises(error_type, middleware.process_request, None) self.assertThat(check_rack_controller_connectivity, MockCalledOnceWith())
def test_raises_NotImplemended_over_UnknownPodType(self): exc_type = factory.make_exception_type() self.assertRaises( NotImplementedError, get_best_discovered_result, ({}, { factory.make_name("system_id"): exc_type(), factory.make_name("system_id"): UnknownPodType("unknown"), factory.make_name("system_id"): NotImplementedError(), }))
def test_tryConnection_closes_connection_on_failure(self): listener = PostgresListenerService() exc_type = factory.make_exception_type() startReading = self.patch(listener, "startReading") startReading.side_effect = exc_type("no reason") with ExpectedException(exc_type): yield listener.tryConnection() self.assertThat(listener.connection, Is(None))
def test__raises_same_exception(self): pod = factory.make_Pod() client = Mock() exception_type = factory.make_exception_type() exception_msg = factory.make_name('error') client.return_value = fail(exception_type(exception_msg)) error = self.assertRaises(exception_type, wait_for_reactor(decompose_machine), client, pod.power_type, pod.power_parameters, pod.id, pod.name) self.assertEqual(exception_msg, str(error))
def test_start_up_logs_failure_if_all_endpoint_options_fail(self): service = RegionService(sentinel.ipcWorker) error_1 = factory.make_exception_type() error_2 = factory.make_exception_type() endpoint_1 = Mock() endpoint_1.listen.return_value = fail(error_1()) endpoint_2 = Mock() endpoint_2.listen.return_value = fail(error_2()) service.endpoints = [[endpoint_1, endpoint_2]] with TwistedLoggerFixture() as logger: yield service.startService() self.assertDocTestMatches( """\ RegionServer endpoint failed to listen. Traceback (most recent call last): ... %s: """ % fullyQualifiedName(error_2), logger.output)
def test__tryConnection_calls_registerChannels_after_startConnection(self): listener = PostgresListenerService() exception_type = factory.make_exception_type() self.patch(listener, "startConnection") mock_registerChannels = self.patch(listener, "registerChannels") mock_registerChannels.side_effect = exception_type with ExpectedException(exception_type): yield listener.tryConnection() self.assertThat(mock_registerChannels, MockCalledOnceWith())
def test__handle_uncaught_exception_does_not_note_other_failure(self): handler = views.WebApplicationHandler() request = make_request() request.path = factory.make_name("path") failure_type = factory.make_exception_type() failure = failure_type, failure_type(), None response = handler.handle_uncaught_exception( request=request, resolver=get_resolver(None), exc_info=failure) # HTTP 500 is returned... self.expectThat(response.status_code, Equals(http.client.INTERNAL_SERVER_ERROR)) # ... but the response is NOT recorded as needing a retry. self.expectThat(handler._WebApplicationHandler__retry, Not(Contains(response)))
def test_tryConnection_will_not_retry_if_autoReconnect_not_set(self): listener = PostgresListenerService() listener.autoReconnect = False exception_type = factory.make_exception_type() exception_message = factory.make_name("message") startConnection = self.patch(listener, "startConnection") startConnection.side_effect = exception_type(exception_message) deferLater = self.patch(listener_module, "deferLater") deferLater.return_value = sentinel.retry with ExpectedException(exception_type): yield listener.tryConnection() self.assertThat(deferLater, MockNotCalled())
def test__caches_hash(self): # Fake the API description. api_description = factory.make_string() api_description_hasher = hash_canonical(api_description) # The description can only be fetched once before crashing. self.patch(doc_module, "describe_api").side_effect = [ api_description, factory.make_exception_type(), ] # The hash is generated and cached. self.assertThat(get_api_description_hash(), Equals(api_description_hasher.hexdigest())) self.assertThat(get_api_description_hash(), Equals(api_description_hasher.hexdigest())) # Calling `describe_api` a second time would have failed. self.assertRaises(Exception, doc_module.describe_api)
def test_regionRefresh_refreshes_a_region(self): region = factory.make_RegionController() self.patch(region, "refresh").return_value = Deferred() d = start_up.refreshRegion(region) self.assertThat(d, IsInstance(Deferred)) exception = factory.make_exception_type() with TwistedLoggerFixture() as logger: d.errback(exception("boom")) # The exception is suppressed ... self.assertThat(extract_result(d), Is(None)) # ... but it has been logged. self.assertThat( logger.output, DocTestMatches(""" Failure when refreshing region. Traceback (most recent call last):... Failure: maastesting.factory.TestException#...: boom """))