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