def test_addProgramToGroup_raises_bad_name_when_process_already_exists(self): pconfig = DummyPConfig(None, 'process_that_exists', '/bin/foo') gconfig = DummyPGroupConfig(None, pconfigs=[pconfig]) pgroup = DummyProcessGroup(gconfig) supervisord = DummySupervisor(process_groups = {'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) poptions = {'command': '/usr/bin/find /'} self.assertRPCError(SupervisorFaults.BAD_NAME, interface.addProgramToGroup, 'group_name', 'process_that_exists', poptions)
def test_addProgramToGroup_raises_incorrect_params_when_poptions_is_not_dict(self): pconfig = DummyPConfig(None, 'foo', '/bin/foo') gconfig = DummyPGroupConfig(None, pconfigs=[pconfig]) pgroup = DummyProcessGroup(gconfig) supervisord = DummySupervisor(process_groups = {'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) bad_poptions = 42 self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS, interface.addProgramToGroup, 'group_name', 'new_process', bad_poptions)
def test_addProgramToGroup_raises_incorrect_params_when_poptions_is_not_dict( self): pconfig = DummyPConfig(None, 'foo', '/bin/foo') gconfig = DummyPGroupConfig(None, pconfigs=[pconfig]) pgroup = DummyProcessGroup(gconfig) supervisord = DummySupervisor(process_groups={'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) bad_poptions = 42 self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS, interface.addProgramToGroup, 'group_name', 'new_process', bad_poptions)
def test_addProgramToGroup_raises_bad_name_when_process_already_exists( self): pconfig = DummyPConfig(None, 'process_that_exists', '/bin/foo') gconfig = DummyPGroupConfig(None, pconfigs=[pconfig]) pgroup = DummyProcessGroup(gconfig) supervisord = DummySupervisor(process_groups={'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) poptions = {'command': '/usr/bin/find /'} self.assertRPCError(SupervisorFaults.BAD_NAME, interface.addProgramToGroup, 'group_name', 'process_that_exists', poptions)
def test_fetch(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {'the-key': 'its-value'} self.assertEqual('its-value', interface.fetch('the-key')) self.assertEqual(interface.update_text, 'fetch')
def test_fetch_raises_bad_name_when_key_does_not_exist(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {} self.assertRPCError(Faults.BAD_NAME, interface.fetch, 'nonexistant-key')
def test_getKeys_returns_list_of_keys_for_items_in_cache(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {'foo': None, 'bar': None} self.assertEqual(interface.getKeys(), ['bar','foo']) self.assertEqual(interface.update_text, 'getKeys')
def test_store(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.store('the-key', 'its-value') self.assertEqual(interface.cache['the-key'], 'its-value') self.assertEqual(interface.update_text, 'store')
def test_continue_request_nosuchmethod(self): supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) import xmlrpc.client data = xmlrpc.client.dumps(('a', 'b'), 'supervisor.noSuchMethod') request = DummyRequest('/what/ever', None, None, None) handler.continue_request(data, request) logdata = supervisor.options.logger.data from supervisor.xmlrpc_lib import loads if loads: expected = 2 else: expected = 3 self.assertEqual(len(logdata), expected) self.assertEqual(logdata[-2], 'XML-RPC method called: supervisor.noSuchMethod()') self.assertEqual( logdata[-1], ('XML-RPC method supervisor.noSuchMethod() returned fault: ' '[1] UNKNOWN_METHOD')) self.assertEqual(len(request.producers), 1) xml_response = request.producers[0] self.assertRaises(xmlrpc.client.Fault, xmlrpc.client.loads, xml_response)
def test_log_raises_incorrect_parameters_when_level_is_bad(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) for bad_level in ['bad_level', 9999, None]: self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS, interface.log, 'hello', bad_level)
def test_removeProcessFromGroup_can_be_disabled(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord, whitelist='foo,bar') self.assertRPCError(TwiddlerFaults.NOT_IN_WHITELIST, interface.removeProcessFromGroup, 'group', 'process')
def test_continue_request_methodsuccess(self): supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) import xmlrpclib data = xmlrpclib.dumps((), 'supervisor.getAPIVersion') request = DummyRequest('/what/ever', None, None, None) handler.continue_request(data, request) logdata = supervisor.options.logger.data from supervisor.xmlrpc import loads if loads: expected = 2 else: expected = 3 self.assertEqual(len(logdata), expected) self.assertEqual(logdata[-2], u'XML-RPC method called: supervisor.getAPIVersion()') self.assertEqual(logdata[-1], u'XML-RPC method supervisor.getAPIVersion() returned successfully') self.assertEqual(len(request.producers), 1) xml_response = request.producers[0] response = xmlrpclib.loads(xml_response) self.assertEqual(response[0][0], '3.0') self.assertEqual(request._done, True) self.assertEqual(request.headers['Content-Type'], 'text/xml') self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_store_raises_incorrect_parameters_when_data_is_not_string(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) not_a_string = 42 self.assertRPCError(Faults.INCORRECT_PARAMETERS, interface.store, 'key', not_a_string)
def test_ctor(self): supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) self.assertEqual(handler.supervisord, supervisor) from supervisor.xmlrpc import RootRPCInterface self.assertEqual(handler.rpcinterface.__class__, RootRPCInterface)
def test_updater_raises_shutdown_error_if_supervisord_in_shutdown_state( self): supervisord = DummySupervisor(state=SupervisorStates.SHUTDOWN) interface = self.makeOne(supervisord) self.assertRPCError(SupervisorFaults.SHUTDOWN_STATE, interface.getAPIVersion)
def test_handle_request_stdout_logfile_missing(self): supervisor = DummySupervisor() supervisor.options.logfile = '/not/there' request = DummyRequest('/mainlogtail', None, None, None) handler = self._makeOne(supervisor) handler.handle_request(request) self.assertEqual(request._error, 410)
def test_getGroupNames_returns_empty_array_when_no_groups(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) names = interface.getGroupNames() self.assertTrue(isinstance(names, list)) self.assertEqual(0, len(names))
def test_store_raises_bad_name_when_key_is_not_a_string(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) not_a_string = 42 self.assertRPCError(Faults.BAD_NAME, interface.store, not_a_string, 'data')
def test_fetch_none(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {'the-key': None} self.assertEqual(None, interface.fetch('the-key')) self.assertEqual(interface.update_text, 'fetch')
def test_continue_request_no_params_in_request(self): supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) data = '<?xml version="1.0" encoding="UTF-8"?>' \ '<methodCall>' \ '<methodName>supervisor.getAPIVersion</methodName>' \ '</methodCall>' request = DummyRequest('/what/ever', None, None, None) handler.continue_request(data, request) logdata = supervisor.options.logger.data from supervisor.xmlrpc import loads if loads: expected = 2 else: expected = 3 self.assertEqual(len(logdata), expected) self.assertEqual(logdata[-2], u'XML-RPC method called: supervisor.getAPIVersion()') self.assertEqual(logdata[-1], u'XML-RPC method supervisor.getAPIVersion() returned successfully') self.assertEqual(len(request.producers), 1) xml_response = request.producers[0] import xmlrpclib response = xmlrpclib.loads(xml_response) from supervisor.rpcinterface import API_VERSION self.assertEqual(response[0][0], API_VERSION) self.assertEqual(request._done, True) self.assertEqual(request.headers['Content-Type'], 'text/xml') self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_continue_request_500_if_xmlrpc_dumps_raises(self): supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) import xmlrpclib data = xmlrpclib.dumps((), 'supervisor.getXmlRpcUnmarshallable') request = DummyRequest('/what/ever', None, None, None) handler.continue_request(data, request) logdata = supervisor.options.logger.data from supervisor.xmlrpc import loads if loads: expected = 3 else: expected = 4 self.assertEqual(len(logdata), expected) self.assertEqual(logdata[-3], 'XML-RPC method called: supervisor.getXmlRpcUnmarshallable()') self.assertEqual(logdata[-2], 'XML-RPC method supervisor.getXmlRpcUnmarshallable() ' 'returned successfully') self.assertTrue("unexpected exception" in logdata[-1]) self.assertTrue(repr(data) in logdata[-1]) self.assertTrue("Traceback" in logdata[-1]) self.assertTrue("TypeError: cannot marshal" in logdata[-1]) self.assertEqual(request._error, 500)
def test_addGroup_adds_new_group(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) self.assertTrue(interface.addGroup("group", 999)) self.assertEqual(1, len(interface.supervisord.process_groups)) self.assertTrue("group" in interface.supervisord.process_groups)
def test_match(self): class DummyRequest: def __init__(self, uri): self.uri = uri supervisor = DummySupervisor() handler = self._makeOne(supervisor) self.assertEqual(handler.match(DummyRequest(handler.path)), True)
def test_make_callback_noaction(self): context = DummyContext() context.supervisord = DummySupervisor() context.template = 'ui/status.html' context.form = {} view = self._makeOne(context) self.assertRaises(ValueError, view.make_callback, 'process', None)
def test_getKeys_returns_empty_list_when_no_items_cache(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {} self.assertEqual(interface.getKeys(), []) self.assertEqual(interface.update_text, 'getKeys')
def test_delete_removes_data_from_cache_by_key(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {'delete-me': 'foo', 'keep-me': 'bar'} self.assertTrue(interface.delete('delete-me')) self.assertEqual(None, interface.cache.get('delete-me')) self.assertEqual({'keep-me': 'bar'}, interface.cache)
def test_store_allows_nonstring_values(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) not_a_string = [1, 2, 3] interface.store('the-key', not_a_string) self.assertEqual(interface.cache['the-key'], not_a_string) self.assertEqual(interface.update_text, 'store')
def test_clear(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) interface.cache = {'foo': 'bar'} interface.clear() self.assertEqual({}, interface.cache) self.assertEqual(interface.update_text, 'clear')
def test_addProgramToGroup_adds_new_process_config_to_group(self): pconfig = DummyPConfig(None, 'foo', '/bin/foo') gconfig = DummyPGroupConfig(None, pconfigs=[pconfig]) pgroup = DummyProcessGroup(gconfig) pgroup.processes = {} supervisord = DummySupervisor(process_groups = {'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) poptions = {'command': '/usr/bin/find /'} self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions)) self.assertEqual('addProgramToGroup', interface.update_text) config = pgroup.config.process_configs[1] self.assertEqual('new_process', config.name) self.assertTrue(isinstance(config, supervisor.options.ProcessConfig))
def test_handle_request_stdout_logfile_missing(self): supervisor = DummySupervisor() options = DummyOptions() pconfig = DummyPConfig(options, 'foo', 'foo', 'it/is/missing') supervisord = PopulatedDummySupervisor(options, 'foo', pconfig) handler = self._makeOne(supervisord) request = DummyRequest('/logtail/foo', None, None, None) handler.handle_request(request) self.assertEqual(request._error, 410)
def test_addProgramToGroup_adds_all_processes_resulting_from_program_options(self): gconfig = DummyPGroupConfig(None, pconfigs=[]) pgroup = DummyProcessGroup(gconfig) pgroup.processes = {} supervisord = DummySupervisor(process_groups = {'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) poptions = {'command': '/usr/bin/find /', 'process_name': 'find_%(process_num)d', 'numprocs': 3} self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions)) self.assertEqual('addProgramToGroup', interface.update_text) self.assertEqual(3, len(pgroup.config.process_configs)) self.assertEqual(3, len(pgroup.processes))
def test_make_cache_rpcinterface_factory(self): from supervisor_cache import rpcinterface supervisord = DummySupervisor() interface = rpcinterface.make_cache_rpcinterface(supervisord) self.assertTrue(isinstance(interface, rpcinterface.CacheNamespaceRPCInterface)) self.assertEqual(supervisord, interface.supervisord)
def test_match(self): class DummyRequest2: def __init__(self, uri): self.uri = uri supervisor = DummySupervisor() subinterfaces = [('supervisor', DummySupervisorRPCNamespace())] handler = self._makeOne(supervisor, subinterfaces) self.assertEqual(handler.match(DummyRequest2('/RPC2')), True) self.assertEqual(handler.match(DummyRequest2('/nope')), False)
def test_getAPIVersion_returns_api_version(self): supervisord = DummySupervisor() interface = self.makeOne(supervisord) version = interface.getAPIVersion() self.assertEqual('getAPIVersion', interface.update_text) from supervisor_cache.rpcinterface import API_VERSION self.assertEqual(version, API_VERSION)
def test_addProgramToGroup_uses_process_name_from_options(self): gconfig = DummyPGroupConfig(None, pconfigs=[]) pgroup = DummyProcessGroup(gconfig) pgroup.processes = {} supervisord = DummySupervisor(process_groups = {'group_name': pgroup}) supervisord.options = supervisor.options.ServerOptions() interface = self.makeOne(supervisord) poptions = {'process_name': 'renamed', 'command': '/usr/bin/find /'} self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions)) self.assertEqual('addProgramToGroup', interface.update_text) config = pgroup.config.process_configs[0] self.assertEqual('renamed', config.name) self.assertTrue(pgroup.processes.get('new_process') is None) self.assertTrue(isinstance(pgroup.processes.get('renamed'), supervisor.process.Subprocess))