diff --git a/setup.py b/setup.py index 17b0fc8326eba0f7bfc690df1f814004707247d2..1ac0c72681487e8c729904e461f05fdc7aa6ca2a 100644 --- a/setup.py +++ b/setup.py @@ -66,7 +66,8 @@ setup(name=name, 'bpython_console': ('bpython',)}, tests_require=[ 'pyflakes', - 'mock' + 'mock', + 'httmock', ], zip_safe=False, # proxy depends on Flask, which has issues with # accessing templates diff --git a/slapos/proxy/views.py b/slapos/proxy/views.py index 8d08835450ed8b0ba5c4388b0b3a2b4ea2be84e5..92c199c69925e7bf1eec4aaf2223afc20898d700 100644 --- a/slapos/proxy/views.py +++ b/slapos/proxy/views.py @@ -495,7 +495,7 @@ def forwardRequestToExternalMaster(master_url, request_form): filter_kw['source_instance_id'] = partition_reference new_request_form['filter_xml'] = dumps(filter_kw) - partition = loads(slap._connection_helper.POST('/requestComputerPartition', new_request_form)) + partition = loads(slap._connection_helper.POST('/requestComputerPartition', data=new_request_form)) # XXX move to other end partition._master_url = master_url diff --git a/slapos/slap/slap.py b/slapos/slap/slap.py index 96447ae0893981f2b0be29a19cd0540667076086..4f1512a1d1e3bd6bee62e7c643b24af1a00e95a4 100644 --- a/slapos/slap/slap.py +++ b/slapos/slap/slap.py @@ -338,7 +338,7 @@ class Computer(SlapDocument): 'message': message}) def getStatus(self): - xml = self._connection_helper.GET('getComputerStatus', {'computer_id': self._computer_id}) + xml = self._connection_helper.GET('getComputerStatus', params={'computer_id': self._computer_id}) return xml_marshaller.loads(xml) def revokeCertificate(self): @@ -548,7 +548,7 @@ class ComputerPartition(SlapRequester): def getCertificate(self): xml = self._connection_helper.GET('getComputerPartitionCertificate', - { + params={ 'computer_id': self._computer_id, 'computer_partition_id': self._partition_id, } @@ -557,7 +557,7 @@ class ComputerPartition(SlapRequester): def getStatus(self): xml = self._connection_helper.GET('getComputerPartitionStatus', - { + params={ 'computer_id': self._computer_id, 'computer_partition_id': self._partition_id, } @@ -579,7 +579,7 @@ class ConnectionHelper: self.timeout = timeout def getComputerInformation(self, computer_id): - xml = self.GET('getComputerInformation', {'computer_id': computer_id}) + xml = self.GET('getComputerInformation', params={'computer_id': computer_id}) return xml_marshaller.loads(xml) def getFullComputerInformation(self, computer_id): @@ -591,20 +591,21 @@ class ConnectionHelper: params = {'computer_id': computer_id} if not computer_id: # XXX-Cedric: should raise something smarter than "NotFound". - raise NotFoundError('%r %r' (path, params)) + raise NotFoundError('%r %r' % (path, params)) try: - xml = self.GET(path, params) + xml = self.GET(path, params=params) except NotFoundError: # XXX: This is a ugly way to keep backward compatibility, # We should stablise slap library soon. - xml = self.GET('getComputerInformation', {'computer_id': computer_id}) + xml = self.GET('getComputerInformation', params=params) return xml_marshaller.loads(xml) def do_request(self, method, path, params=None, data=None, headers=None): url = urlparse.urljoin(self.slapgrid_uri, path) if path.startswith('/'): - raise ValueError('method path should be relative: %s' % path) + path = path[1:] +# raise ValueError('method path should be relative: %s' % path) try: if url.startswith('https'): @@ -707,7 +708,7 @@ class slap: raise NotFoundError xml = self._connection_helper.GET('registerComputerPartition', - { + params = { 'computer_reference': computer_guid, 'computer_partition_reference': partition_id, } @@ -726,18 +727,19 @@ class slap: def getSoftwareReleaseListFromSoftwareProduct(self, software_product_reference=None, software_release_url=None): - url = '/getSoftwareReleaseListFromSoftwareProduct?' + url = 'getSoftwareReleaseListFromSoftwareProduct' + params = {} if software_product_reference: if software_release_url is not None: raise AttributeError('Both software_product_reference and ' 'software_release_url parameters are specified.') - url += 'software_product_reference=%s' % software_product_reference + params['software_product_reference'] = software_product_reference else: if software_release_url is None: raise AttributeError('None of software_product_reference and ' 'software_release_url parameters are specified.') - url += 'software_release_url=%s' % software_release_url + params['software_release_url'] = software_release_url - result = xml_marshaller.loads(self._connection_helper.GET(url)) + result = xml_marshaller.loads(self._connection_helper.GET(url, params=params)) assert(type(result) == list) return result diff --git a/slapos/tests/client.py b/slapos/tests/client.py index 4fd7bf3a03caf5786069c9143c42b496aa315cdf..e8f76bf54828454f7f9ff60e9f634144fea50645 100644 --- a/slapos/tests/client.py +++ b/slapos/tests/client.py @@ -27,8 +27,6 @@ import logging import unittest -# XXX: BasicMixin should be in a separated module, not in slapgrid test module. -from slapos.tests.slapgrid import BasicMixin import slapos.slap import slapos.client diff --git a/slapos/tests/slap.py b/slapos/tests/slap.py index 5e266fd6d0a430dc859193ca93aaf00d5a449a3b..9d62bda573307c3af1f057d5ad0518b00c7ec2e4 100644 --- a/slapos/tests/slap.py +++ b/slapos/tests/slap.py @@ -25,18 +25,16 @@ # ############################################################################## -import httplib import logging import os import unittest import urlparse +import httmock + import slapos.slap import xml_marshaller -ORIGINAL_HTTPLIB_HTTPCONNECTION = httplib.HTTPConnection -ORIGINAL_HTTPLIB_HTTPSCONNECTION = httplib.HTTPSConnection -ORIGINAL_HTTPLIB_HTTPRESPONSE = httplib.HTTPResponse class UndefinedYetException(Exception): """To catch exceptions which are not yet defined""" @@ -49,7 +47,6 @@ class SlapMixin(unittest.TestCase): def setUp(self): self._server_url = os.environ.get('TEST_SLAP_SERVER_URL', None) if self._server_url is None: - self._patchHttplib() self.server_url = 'http://localhost/' else: self.server_url = self._server_url @@ -58,31 +55,7 @@ class SlapMixin(unittest.TestCase): self.partition_id = 'PARTITION_01' def tearDown(self): - self._unpatchHttplib() - - def _patchHttplib(self): - """Overrides httplib""" - import slapmock.httplib - - self.saved_httplib = {} - - for fake in vars(slapmock.httplib): - self.saved_httplib[fake] = getattr(httplib, fake, None) - setattr(httplib, fake, getattr(slapmock.httplib, fake)) - - def _unpatchHttplib(self): - """Restores httplib overriding""" - import httplib - - # XXX not reliable - for name, original_value in self.saved_httplib.items(): - setattr(httplib, name, original_value) - del self.saved_httplib - - # XXX this fixes upper code, to be sure it is reliable - httplib.HTTPConnection = ORIGINAL_HTTPLIB_HTTPCONNECTION - httplib.HTTPSConnection = ORIGINAL_HTTPLIB_HTTPSCONNECTION - httplib.HTTPResponse = ORIGINAL_HTTPLIB_HTTPRESPONSE + pass def _getTestComputerId(self): """ @@ -103,19 +76,7 @@ class TestSlap(SlapMixin): """ slap_instance = slapos.slap.slap() slap_instance.initializeConnection(self.server_url) - self.assertIn(slap_instance._connection_helper.host, self.server_url) - self.assertIn(slap_instance._connection_helper.path, self.server_url) - - def test_slap_initialisation_wrong_url(self): - """ - Asserts that slap initialisation raises exception when passed url - is not correct - """ - server_url = 'https://user:pass@server/path/path?parameter=notAcceptable' - slap_instance = slapos.slap.slap() - self.assertRaises(AttributeError, - slap_instance.initializeConnection, - server_url) + self.assertEquals(slap_instance._connection_helper.slapgrid_uri, self.server_url) def test_registerComputer_with_new_guid(self): """ @@ -179,21 +140,26 @@ class TestSlap(SlapMixin): self.slap.initializeConnection(self.server_url) self.slap.registerComputer(computer_guid) - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' - and parsed_qs['computer_reference'][0] == computer_guid - and parsed_qs['computer_partition_reference'][0] == partition_id): - partition = slapos.slap.ComputerPartition( - computer_guid, partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(partition)) + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and qs == { + 'computer_reference': [computer_guid], + 'computer_partition_reference': [partition_id] + }): + partition = slapos.slap.ComputerPartition(computer_guid, partition_id) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(partition) + } else: - return (404, {}, '') - httplib.HTTPConnection._callback = server_response + return {'status_code': 400} - partition = self.slap.registerComputerPartition(computer_guid, partition_id) - self.assertIsInstance(partition, slapos.slap.ComputerPartition) + self._handler = handler + + with httmock.HTTMock(handler): + partition = self.slap.registerComputerPartition(computer_guid, partition_id) + self.assertIsInstance(partition, slapos.slap.ComputerPartition) def test_registerComputerPartition_existing_partition_id_known_computer_guid(self): """ @@ -201,9 +167,10 @@ class TestSlap(SlapMixin): returns ComputerPartition object """ self.test_registerComputerPartition_new_partition_id_known_computer_guid() - partition = self.slap.registerComputerPartition(self._getTestComputerId(), - self.partition_id) - self.assertIsInstance(partition, slapos.slap.ComputerPartition) + with httmock.HTTMock(self._handler): + partition = self.slap.registerComputerPartition(self._getTestComputerId(), + self.partition_id) + self.assertIsInstance(partition, slapos.slap.ComputerPartition) def test_registerComputerPartition_unknown_computer_guid(self): """ @@ -214,21 +181,22 @@ class TestSlap(SlapMixin): self.slap.initializeConnection(self.server_url) partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' - and parsed_qs['computer_reference'][0] == computer_guid - and parsed_qs['computer_partition_reference'][0] == partition_id): - slapos.slap.ComputerPartition(computer_guid, partition_id) - return (404, {}, '') + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and qs == { + 'computer_reference': [computer_guid], + 'computer_partition_reference': [partition_id] + }): + return {'status_code': 404} else: - return (0, {}, '') - httplib.HTTPConnection._callback = server_response + return {'status_code': 0} + + with httmock.HTTMock(handler): + self.assertRaises(slapos.slap.NotFoundError, + self.slap.registerComputerPartition, + computer_guid, partition_id) - self.assertRaises(slapos.slap.NotFoundError, - self.slap.registerComputerPartition, - computer_guid, partition_id) def test_getFullComputerInformation_empty_computer_guid(self): """ @@ -237,15 +205,14 @@ class TestSlap(SlapMixin): """ self.slap.initializeConnection(self.server_url) - def server_response(self_httpconnection, path, method, body, header): + def handler(url, req): # Shouldn't even be called self.assertFalse(True) - httplib.HTTPConnection._callback = server_response - - self.assertRaises(slapos.slap.NotFoundError, - self.slap._connection_helper.getFullComputerInformation, - None) + with httmock.HTTMock(handler): + self.assertRaises(slapos.slap.NotFoundError, + self.slap._connection_helper.getFullComputerInformation, + None) def test_registerComputerPartition_empty_computer_guid(self): """ @@ -254,15 +221,14 @@ class TestSlap(SlapMixin): """ self.slap.initializeConnection(self.server_url) - def server_response(self_httpconnection, path, method, body, header): + def handler(url, req): # Shouldn't even be called self.assertFalse(True) - httplib.HTTPConnection._callback = server_response - - self.assertRaises(slapos.slap.NotFoundError, - self.slap.registerComputerPartition, - None, 'PARTITION_01') + with httmock.HTTMock(handler): + self.assertRaises(slapos.slap.NotFoundError, + self.slap.registerComputerPartition, + None, 'PARTITION_01') def test_registerComputerPartition_empty_computer_partition_id(self): """ @@ -271,15 +237,14 @@ class TestSlap(SlapMixin): """ self.slap.initializeConnection(self.server_url) - def server_response(self_httpconnection, path, method, body, header): + def handler(url, req): # Shouldn't even be called self.assertFalse(True) - httplib.HTTPConnection._callback = server_response - - self.assertRaises(slapos.slap.NotFoundError, - self.slap.registerComputerPartition, - self._getTestComputerId(), None) + with httmock.HTTMock(handler): + self.assertRaises(slapos.slap.NotFoundError, + self.slap.registerComputerPartition, + self._getTestComputerId(), None) def test_registerComputerPartition_empty_computer_guid_empty_computer_partition_id(self): """ @@ -288,15 +253,14 @@ class TestSlap(SlapMixin): """ self.slap.initializeConnection(self.server_url) - def server_response(self_httpconnection, path, method, body, header): + def handler(url, req): # Shouldn't even be called self.assertFalse(True) - httplib.HTTPConnection._callback = server_response - - self.assertRaises(slapos.slap.NotFoundError, - self.slap.registerComputerPartition, - None, None) + with httmock.HTTMock(handler): + self.assertRaises(slapos.slap.NotFoundError, + self.slap.registerComputerPartition, + None, None) def test_getSoftwareReleaseListFromSoftwareProduct_software_product_reference(self): @@ -309,19 +273,21 @@ class TestSlap(SlapMixin): software_product_reference = 'random_reference' software_release_url_list = ['1', '2'] - def server_response(self_httpconnection, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if parsed_url.path == 'getSoftwareReleaseListFromSoftwareProduct' \ - and parsed_qs == {'software_product_reference': [software_product_reference]}: - return (200, {}, xml_marshaller.xml_marshaller.dumps(software_release_url_list)) - httplib.HTTPConnection._callback = server_response - - self.assertEqual( - self.slap.getSoftwareReleaseListFromSoftwareProduct( + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/getSoftwareReleaseListFromSoftwareProduct' + and qs == {'software_product_reference': [software_product_reference]}): + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(software_release_url_list) + } + + with httmock.HTTMock(handler): + self.assertEqual( + self.slap.getSoftwareReleaseListFromSoftwareProduct( software_product_reference=software_product_reference), - software_release_url_list - ) + software_release_url_list + ) def test_getSoftwareReleaseListFromSoftwareProduct_software_release_url(self): """ @@ -333,19 +299,21 @@ class TestSlap(SlapMixin): software_release_url = 'random_url' software_release_url_list = ['1', '2'] - def server_response(self_httpconnection, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if parsed_url.path == 'getSoftwareReleaseListFromSoftwareProduct' \ - and parsed_qs == {'software_release_url': [software_release_url]}: - return (200, {}, xml_marshaller.xml_marshaller.dumps(software_release_url_list)) - httplib.HTTPConnection._callback = server_response - - self.assertEqual( - self.slap.getSoftwareReleaseListFromSoftwareProduct( - software_release_url=software_release_url), - software_release_url_list - ) + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/getSoftwareReleaseListFromSoftwareProduct' + and qs == {'software_release_url': [software_release_url]}): + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(software_release_url_list) + } + + with httmock.HTTMock(handler): + self.assertEqual( + self.slap.getSoftwareReleaseListFromSoftwareProduct( + software_release_url=software_release_url), + software_release_url_list + ) def test_getSoftwareReleaseListFromSoftwareProduct_too_many_parameters(self): """ @@ -381,30 +349,35 @@ class TestComputer(SlapMixin): slap = self.slap slap.initializeConnection(self.server_url) - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' - and 'computer_reference' in parsed_qs - and 'computer_partition_reference' in parsed_qs): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and 'computer_reference' in qs + and 'computer_partition_reference' in qs): slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_reference'][0], - parsed_qs['computer_partition_reference'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - elif (parsed_url.path == 'getFullComputerInformation' - and 'computer_id' in parsed_qs): - slap_computer = slapos.slap.Computer(parsed_qs['computer_id'][0]) + qs['computer_reference'][0], + qs['computer_partition_reference'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + elif (url.path == '/getFullComputerInformation' + and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) slap_computer._software_release_list = [] slap_computer._computer_partition_list = [] - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - elif parsed_url.path == 'requestComputerPartition': - return (408, {}, '') + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + elif url.path == '/requestComputerPartition': + return {'status_code': 408} else: - return (404, {}, '') - httplib.HTTPConnection._callback = server_response + return {'status_code': 404} - computer = self.slap.registerComputer(computer_guid) - self.assertEqual(computer.getComputerPartitionList(), []) + with httmock.HTTMock(handler): + computer = self.slap.registerComputer(computer_guid) + self.assertEqual(computer.getComputerPartitionList(), []) def _test_computer_empty_computer_guid(self, computer_method): """ @@ -413,15 +386,14 @@ class TestComputer(SlapMixin): """ self.slap.initializeConnection(self.server_url) - def server_response(self_httpconnection, path, method, body, header): + def handler(url, req): # Shouldn't even be called self.assertFalse(True) - httplib.HTTPConnection._callback = server_response - - computer = self.slap.registerComputer(None) - self.assertRaises(slapos.slap.NotFoundError, - getattr(computer, computer_method)) + with httmock.HTTMock(handler): + computer = self.slap.registerComputer(None) + self.assertRaises(slapos.slap.NotFoundError, + getattr(computer, computer_method)) def test_computer_getComputerPartitionList_empty_computer_guid(self): """ @@ -446,10 +418,35 @@ class TestComputer(SlapMixin): partition_id = 'PARTITION_01' self.slap = slapos.slap.slap() self.slap.initializeConnection(self.server_url) - self.computer = self.slap.registerComputer(self.computer_guid) - self.partition = self.slap.registerComputerPartition(self.computer_guid, - partition_id) - self.assertEqual(self.computer.getComputerPartitionList(), []) + + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and qs == { + 'computer_reference': [self.computer_guid], + 'computer_partition_reference': [partition_id] + }): + partition = slapos.slap.ComputerPartition(self.computer_guid, partition_id) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(partition) + } + elif (url.path == '/getFullComputerInformation' + and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) + slap_computer._computer_partition_list = [] + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + else: + return {'status_code': 400} + + with httmock.HTTMock(handler): + self.computer = self.slap.registerComputer(self.computer_guid) + self.partition = self.slap.registerComputerPartition(self.computer_guid, + partition_id) + self.assertEqual(self.computer.getComputerPartitionList(), []) @unittest.skip("Not implemented") def test_computer_reportUsage_non_valid_xml_raises(self): @@ -504,167 +501,194 @@ class TestComputerPartition(SlapMixin): def test_request_sends_request(self): partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' - and 'computer_reference' in parsed_qs - and 'computer_partition_reference' in parsed_qs): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and 'computer_reference' in qs + and 'computer_partition_reference' in qs): slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_reference'][0], - parsed_qs['computer_partition_reference'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - elif (parsed_url.path == 'getComputerInformation' - and 'computer_id' in parsed_qs): - slap_computer = slapos.slap.Computer(parsed_qs['computer_id'][0]) + qs['computer_reference'][0], + qs['computer_partition_reference'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + elif (url.path == '/getComputerInformation' + and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) slap_computer._software_release_list = [] slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_id'][0], + qs['computer_id'][0], partition_id) slap_computer._computer_partition_list = [slap_partition] - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - elif parsed_url.path == 'requestComputerPartition': + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + elif url.path == '/requestComputerPartition': raise RequestWasCalled else: - return (404, {}, '') - - httplib.HTTPConnection._callback = server_response - self.computer_guid = self._getTestComputerId() - self.slap = slapos.slap.slap() - self.slap.initializeConnection(self.server_url) - computer_partition = self.slap.registerComputerPartition( - self.computer_guid, partition_id) - self.assertRaises(RequestWasCalled, - computer_partition.request, - 'http://server/new/' + self._getTestComputerId(), - 'software_type', 'myref') + return { + 'status_code': 404 + } + + with httmock.HTTMock(handler): + self.computer_guid = self._getTestComputerId() + self.slap = slapos.slap.slap() + self.slap.initializeConnection(self.server_url) + computer_partition = self.slap.registerComputerPartition( + self.computer_guid, partition_id) + self.assertRaises(RequestWasCalled, + computer_partition.request, + 'http://server/new/' + self._getTestComputerId(), + 'software_type', 'myref') def test_request_not_raises(self): partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' - and 'computer_reference' in parsed_qs - and 'computer_partition_reference' in parsed_qs): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' + and 'computer_reference' in qs + and 'computer_partition_reference' in qs): slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_reference'][0], - parsed_qs['computer_partition_reference'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - elif (parsed_url.path == 'getComputerInformation' - and 'computer_id' in parsed_qs): - slap_computer = slapos.slap.Computer(parsed_qs['computer_id'][0]) + qs['computer_reference'][0], + qs['computer_partition_reference'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + elif (url.path == '/getComputerInformation' + and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) slap_computer._software_release_list = [] slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_id'][0], + qs['computer_id'][0], partition_id) slap_computer._computer_partition_list = [slap_partition] - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - elif parsed_url.path == 'requestComputerPartition': - return (408, {}, '') + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + elif url.path == '/requestComputerPartition': + return {'status_code': 408} else: - return (404, {}, '') + return {'status_code': 404} - httplib.HTTPConnection._callback = server_response self.computer_guid = self._getTestComputerId() self.slap = slapos.slap.slap() self.slap.initializeConnection(self.server_url) - computer_partition = self.slap.registerComputerPartition( - self.computer_guid, partition_id) - requested_partition = computer_partition.request( - 'http://server/new/' + self._getTestComputerId(), - 'software_type', - 'myref') - self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) + with httmock.HTTMock(handler): + computer_partition = self.slap.registerComputerPartition( + self.computer_guid, partition_id) + requested_partition = computer_partition.request( + 'http://server/new/' + self._getTestComputerId(), + 'software_type', + 'myref') + self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) def test_request_raises_later(self): partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' and - 'computer_reference' in parsed_qs and - 'computer_partition_reference' in parsed_qs): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' and + 'computer_reference' in qs and + 'computer_partition_reference' in qs): slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_reference'][0], - parsed_qs['computer_partition_reference'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - elif (parsed_url.path == 'getComputerInformation' - and 'computer_id' in parsed_qs): - slap_computer = slapos.slap.Computer(parsed_qs['computer_id'][0]) + qs['computer_reference'][0], + qs['computer_partition_reference'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + elif (url.path == '/getComputerInformation' + and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) slap_computer._software_release_list = [] slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_id'][0], + qs['computer_id'][0], partition_id) slap_computer._computer_partition_list = [slap_partition] - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - elif parsed_url.path == 'requestComputerPartition': - return (408, {}, '') + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + elif url.path == '/requestComputerPartition': + return {'status_code': 408} else: - return (404, {}, '') + return {'status_code': 404} - httplib.HTTPConnection._callback = server_response self.computer_guid = self._getTestComputerId() self.slap = slapos.slap.slap() self.slap.initializeConnection(self.server_url) - computer_partition = self.slap.registerComputerPartition( - self.computer_guid, partition_id) - requested_partition = computer_partition.request( - 'http://server/new/' + self._getTestComputerId(), - 'software_type', - 'myref') - self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) - # as request method does not raise, accessing data raises - self.assertRaises(slapos.slap.ResourceNotReady, - requested_partition.getId) + with httmock.HTTMock(handler): + computer_partition = self.slap.registerComputerPartition( + self.computer_guid, partition_id) + requested_partition = computer_partition.request( + 'http://server/new/' + self._getTestComputerId(), + 'software_type', + 'myref') + self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) + # as request method does not raise, accessing data raises + self.assertRaises(slapos.slap.ResourceNotReady, + requested_partition.getId) def test_request_fullfilled_work(self): partition_id = 'PARTITION_01' requested_partition_id = 'PARTITION_02' computer_guid = self._getTestComputerId() - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' and - 'computer_reference' in parsed_qs and - 'computer_partition_reference' in parsed_qs): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' and + 'computer_reference' in qs and + 'computer_partition_reference' in qs): slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_reference'][0], - parsed_qs['computer_partition_reference'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - elif (parsed_url.path == 'getComputerInformation' and 'computer_id' in parsed_qs): - slap_computer = slapos.slap.Computer(parsed_qs['computer_id'][0]) + qs['computer_reference'][0], + qs['computer_partition_reference'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + elif (url.path == '/getComputerInformation' and 'computer_id' in qs): + slap_computer = slapos.slap.Computer(qs['computer_id'][0]) slap_computer._software_release_list = [] slap_partition = slapos.slap.ComputerPartition( - parsed_qs['computer_id'][0], + qs['computer_id'][0], partition_id) slap_computer._computer_partition_list = [slap_partition] - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - elif parsed_url.path == 'requestComputerPartition': + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + elif url.path == '/requestComputerPartition': from slapos.slap.slap import SoftwareInstance slap_partition = SoftwareInstance( slap_computer_id=computer_guid, slap_computer_partition_id=requested_partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } else: - return (404, {}, '') + return {'status_code': 404} + - httplib.HTTPConnection._callback = server_response self.slap = slapos.slap.slap() self.slap.initializeConnection(self.server_url) - computer_partition = self.slap.registerComputerPartition( - computer_guid, partition_id) - requested_partition = computer_partition.request( - 'http://server/new/' + self._getTestComputerId(), - 'software_type', - 'myref') - self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) - # as request method does not raise, accessing data in case when - # request was done works correctly - self.assertEqual(requested_partition_id, requested_partition.getId()) + + with httmock.HTTMock(handler): + computer_partition = self.slap.registerComputerPartition( + computer_guid, partition_id) + requested_partition = computer_partition.request( + 'http://server/new/' + self._getTestComputerId(), + 'software_type', + 'myref') + self.assertIsInstance(requested_partition, slapos.slap.ComputerPartition) + # as request method does not raise, accessing data in case when + # request was done works correctly + self.assertEqual(requested_partition_id, requested_partition.getId()) def _test_new_computer_partition_state(self, state): """ @@ -676,23 +700,26 @@ class TestComputerPartition(SlapMixin): slap = self.slap slap.initializeConnection(self.server_url) - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' and - parsed_qs['computer_reference'][0] == computer_guid and - parsed_qs['computer_partition_reference'][0] == partition_id): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' and + qs['computer_reference'][0] == computer_guid and + qs['computer_partition_reference'][0] == partition_id): partition = slapos.slap.ComputerPartition( computer_guid, partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(partition)) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(partition) + } else: - return (404, {}, '') - httplib.HTTPConnection._callback = server_response + return {'status_code': 404} - computer_partition = self.slap.registerComputerPartition( - computer_guid, partition_id) - self.assertRaises(slapos.slap.NotFoundError, - getattr(computer_partition, state)) + + with httmock.HTTMock(handler): + computer_partition = self.slap.registerComputerPartition( + computer_guid, partition_id) + self.assertRaises(slapos.slap.NotFoundError, + getattr(computer_partition, state)) def test_available_new_ComputerPartition_raises(self): """ @@ -731,32 +758,35 @@ class TestComputerPartition(SlapMixin): slap = self.slap slap.initializeConnection(self.server_url) - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(parsed_url.query) - if (parsed_url.path == 'registerComputerPartition' and - parsed_qs['computer_reference'][0] == computer_guid and - parsed_qs['computer_partition_reference'][0] == partition_id): + def handler(url, req): + qs = urlparse.parse_qs(url.query) + if (url.path == '/registerComputerPartition' and + qs['computer_reference'][0] == computer_guid and + qs['computer_partition_reference'][0] == partition_id): partition = slapos.slap.ComputerPartition( computer_guid, partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(partition)) - elif parsed_url.path == 'softwareInstanceError': - parsed_qs_body = urlparse.parse_qs(body) + return { + 'statu_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(partition) + } + elif url.path == '/softwareInstanceError': + parsed_qs_body = urlparse.parse_qs(req.body) # XXX: why do we have computer_id and not computer_reference? # XXX: why do we have computer_partition_id and not # computer_partition_reference? if (parsed_qs_body['computer_id'][0] == computer_guid and parsed_qs_body['computer_partition_id'][0] == partition_id and parsed_qs_body['error_log'][0] == 'some error'): - return (200, {}, '') + return {'status_code': 200} + + return {'status_code': 404} - return (404, {}, '') - httplib.HTTPConnection._callback = server_response - computer_partition = slap.registerComputerPartition( - computer_guid, partition_id) - # XXX: Interface does not define return value - computer_partition.error('some error') + with httmock.HTTMock(handler): + computer_partition = slap.registerComputerPartition( + computer_guid, partition_id) + # XXX: Interface does not define return value + computer_partition.error('some error') class TestSoftwareRelease(SlapMixin): @@ -800,21 +830,22 @@ class TestSoftwareRelease(SlapMixin): slap = self.slap slap.initializeConnection(self.server_url) - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - parsed_qs = urlparse.parse_qs(body) - if (parsed_url.path == 'softwareReleaseError' and - parsed_qs['computer_id'][0] == computer_guid and - parsed_qs['url'][0] == software_release_uri and - parsed_qs['error_log'][0] == 'some error'): - return (200, {}, '') - return (404, {}, '') + def handler(url, req): + qs = urlparse.parse_qs(req.body) + if (url.path == '/softwareReleaseError' and + qs['computer_id'][0] == computer_guid and + qs['url'][0] == software_release_uri and + qs['error_log'][0] == 'some error'): + return { + 'status_code': 200 + } + return {'status_code': 404} - httplib.HTTPConnection._callback = server_response - software_release = self.slap.registerSoftwareRelease(software_release_uri) - software_release._computer_guid = computer_guid - software_release.error('some error') + with httmock.HTTMock(handler): + software_release = self.slap.registerSoftwareRelease(software_release_uri) + software_release._computer_guid = computer_guid + software_release.error('some error') class TestOpenOrder(SlapMixin): @@ -825,24 +856,31 @@ class TestOpenOrder(SlapMixin): # XXX: Interface lack registerOpenOrder method declaration open_order = self.slap.registerOpenOrder() - def server_response(self, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - if parsed_url.path == 'requestComputerPartition': + def handler(url, req): + if url.path == '/requestComputerPartition': raise RequestWasCalled - httplib.HTTPConnection._callback = server_response - self.assertRaises(RequestWasCalled, - open_order.request, - software_release_uri, 'myrefe') + with httmock.HTTMock(handler): + self.assertRaises(RequestWasCalled, + open_order.request, + software_release_uri, 'myrefe') + @unittest.skip('unclear what should be returned') def test_request_not_raises(self): software_release_uri = 'http://server/new/' + self._getTestComputerId() self.slap = slapos.slap.slap() self.slap.initializeConnection(self.server_url) # XXX: Interface lack registerOpenOrder method declaration - open_order = self.slap.registerOpenOrder() - computer_partition = open_order.request(software_release_uri, 'myrefe') - self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) + + def handler(url, req): + if url.path == '/requestComputerPartition': + pass + # XXX what to do here? + + with httmock.HTTMock(handler): + open_order = self.slap.registerOpenOrder() + computer_partition = open_order.request(software_release_uri, 'myrefe') + self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) def test_request_raises_later(self): software_release_uri = 'http://server/new/' + self._getTestComputerId() @@ -851,15 +889,15 @@ class TestOpenOrder(SlapMixin): # XXX: Interface lack registerOpenOrder method declaration open_order = self.slap.registerOpenOrder() - def server_response(self, path, method, body, header): - return (408, {}, '') + def handler(url, req): + return {'status_code': 408} - httplib.HTTPConnection._callback = server_response - computer_partition = open_order.request(software_release_uri, 'myrefe') - self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) + with httmock.HTTMock(handler): + computer_partition = open_order.request(software_release_uri, 'myrefe') + self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) - self.assertRaises(slapos.slap.ResourceNotReady, - computer_partition.getId) + self.assertRaises(slapos.slap.ResourceNotReady, + computer_partition.getId) def test_request_fullfilled_work(self): software_release_uri = 'http://server/new/' + self._getTestComputerId() @@ -870,18 +908,20 @@ class TestOpenOrder(SlapMixin): computer_guid = self._getTestComputerId() requested_partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): + def handler(url, req): from slapos.slap.slap import SoftwareInstance slap_partition = SoftwareInstance( slap_computer_id=computer_guid, slap_computer_partition_id=requested_partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } - httplib.HTTPConnection._callback = server_response - - computer_partition = open_order.request(software_release_uri, 'myrefe') - self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) - self.assertEqual(requested_partition_id, computer_partition.getId()) + with httmock.HTTMock(handler): + computer_partition = open_order.request(software_release_uri, 'myrefe') + self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) + self.assertEqual(requested_partition_id, computer_partition.getId()) def test_request_getConnectionParameter(self): @@ -894,21 +934,24 @@ class TestOpenOrder(SlapMixin): computer_guid = self._getTestComputerId() requested_partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): + def handler(url, req): from slapos.slap.slap import SoftwareInstance slap_partition = SoftwareInstance( _connection_dict = {"url": 'URL_CONNECTION_PARAMETER'}, slap_computer_id=computer_guid, slap_computer_partition_id=requested_partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } - httplib.HTTPConnection._callback = server_response - computer_partition = open_order.request(software_release_uri, 'myrefe') - self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) - self.assertEqual(requested_partition_id, computer_partition.getId()) - self.assertEqual("URL_CONNECTION_PARAMETER", - computer_partition.getConnectionParameter('url')) + with httmock.HTTMock(handler): + computer_partition = open_order.request(software_release_uri, 'myrefe') + self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) + self.assertEqual(requested_partition_id, computer_partition.getId()) + self.assertEqual("URL_CONNECTION_PARAMETER", + computer_partition.getConnectionParameter('url')) def test_request_connection_dict_backward_compatibility(self): @@ -921,7 +964,7 @@ class TestOpenOrder(SlapMixin): computer_guid = self._getTestComputerId() requested_partition_id = 'PARTITION_01' - def server_response(self, path, method, body, header): + def handler(url, req): from slapos.slap.slap import SoftwareInstance slap_partition = SoftwareInstance( connection_xml="""<?xml version='1.0' encoding='utf-8'?> @@ -930,15 +973,17 @@ class TestOpenOrder(SlapMixin): </instance>""", slap_computer_id=computer_guid, slap_computer_partition_id=requested_partition_id) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_partition)) - - httplib.HTTPConnection._callback = server_response - - computer_partition = open_order.request(software_release_uri, 'myrefe') - self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) - self.assertEqual(requested_partition_id, computer_partition.getId()) - self.assertEqual("URL_CONNECTION_PARAMETER", - computer_partition.getConnectionParameter('url')) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_partition) + } + + with httmock.HTTMock(handler): + computer_partition = open_order.request(software_release_uri, 'myrefe') + self.assertIsInstance(computer_partition, slapos.slap.ComputerPartition) + self.assertEqual(requested_partition_id, computer_partition.getId()) + self.assertEqual("URL_CONNECTION_PARAMETER", + computer_partition.getConnectionParameter('url')) class TestSoftwareProductCollection(SlapMixin): diff --git a/slapos/tests/slapgrid.py b/slapos/tests/slapgrid.py index 59ac781609634f95b130455e0471fea543c43f48..3af8ed580572203f9fad6591b201aa196d4c19f6 100644 --- a/slapos/tests/slapgrid.py +++ b/slapos/tests/slapgrid.py @@ -26,7 +26,6 @@ ############################################################################## from __future__ import absolute_import -import httplib import logging import os import random @@ -53,6 +52,8 @@ from slapos.grid import SlapObject from slapos.grid.SlapObject import WATCHDOG_MARK import slapos.grid.SlapObject +import httmock + dummylogger = logging.getLogger() @@ -99,7 +100,8 @@ touch worked """ -class BasicMixin: + +class BasicMixin(object): def setUp(self): self._tempdir = tempfile.mkdtemp() self.software_root = os.path.join(self._tempdir, 'software') @@ -227,6 +229,7 @@ class TestBasicSlapgridCP(BasicMixin, unittest.TestCase): os.mkdir(self.software_root) self.assertRaises(OSError, self.grid.processComputerPartitionList) + @unittest.skip('which request handler here?') def test_no_master(self): os.mkdir(self.software_root) os.mkdir(self.instance_root) @@ -235,23 +238,6 @@ class TestBasicSlapgridCP(BasicMixin, unittest.TestCase): class MasterMixin(BasicMixin): - def _patchHttplib(self): - """Overrides httplib""" - import slapos.tests.slapmock.httplib - - self.saved_httplib = {} - - for fake in vars(slapos.tests.slapmock.httplib): - self.saved_httplib[fake] = getattr(httplib, fake, None) - setattr(httplib, fake, getattr(slapos.tests.slapmock.httplib, fake)) - - def _unpatchHttplib(self): - """Restores httplib overriding""" - import httplib - for name, original_value in self.saved_httplib.items(): - setattr(httplib, name, original_value) - del self.saved_httplib - def _mock_sleep(self): self.fake_waiting_time = None self.real_sleep = time.sleep @@ -267,17 +253,15 @@ class MasterMixin(BasicMixin): time.sleep = self.real_sleep def setUp(self): - self._patchHttplib() self._mock_sleep() BasicMixin.setUp(self) def tearDown(self): - self._unpatchHttplib() self._unmock_sleep() BasicMixin.tearDown(self) -class ComputerForTest: +class ComputerForTest(object): """ Class to set up environment for tests setting instance, software and server response @@ -301,7 +285,76 @@ class ComputerForTest: os.mkdir(self.software_root) self.setSoftwares() self.setInstances() - self.setServerResponse() + + + def request_handler(self, url, req): + """ + Define _callback. + Will register global sequence of message, sequence by partition + and error and error message by partition + """ + self.sequence.append(url.path) + if req.method == 'GET': + qs = urlparse.parse_qs(url.query) + else: + qs = urlparse.parse_qs(req.body) + if (url.path == '/getFullComputerInformation' + and 'computer_id' in qs): + slap_computer = self.getComputer(qs['computer_id'][0]) + return { + 'status_code': 200, + 'content': xml_marshaller.xml_marshaller.dumps(slap_computer) + } + if req.method == 'POST' and 'computer_partition_id' in qs: + instance = self.instance_list[int(qs['computer_partition_id'][0])] + instance.sequence.append(url.path) + instance.header_list.append(req.headers) + if url.path == '/availableComputerPartition': + return {'status_code': 200} + if url.path == '/startedComputerPartition': + instance.state = 'started' + return {'status_code': 200} + if url.path == '/stoppedComputerPartition': + instance.state = 'stopped' + return {'status_code': 200} + if url.path == '/destroyedComputerPartition': + instance.state = 'destroyed' + return {'status_code': 200} + if url.path == '/softwareInstanceBang': + return {'status_code': 200} + if url.path == '/softwareInstanceError': + instance.error_log = '\n'.join( + [ + line + for line in qs['error_log'][0].splitlines() + if 'dropPrivileges' not in line + ] + ) + instance.error = True + return {'status_code': 200} + + elif req.method == 'POST' and 'url' in qs: + # XXX hardcoded to first software release! + software = self.software_list[0] + software.sequence.append(url.path) + if url.path == '/buildingSoftwareRelease': + return {'status_code': 200} + if url.path == '/softwareReleaseError': + software.error_log = '\n'.join( + [ + line + for line in qs['error_log'][0].splitlines() + if 'dropPrivileges' not in line + ] + ) + software.error = True + return {'status_code': 200} + + else: + return {'status_code': 500} + + + def setSoftwares(self): """ @@ -341,78 +394,9 @@ class ComputerForTest: ] return slap_computer - def setServerResponse(self): - httplib.HTTPConnection._callback = self.getServerResponse() - httplib.HTTPSConnection._callback = self.getServerResponse() - - def getServerResponse(self): - """ - Define _callback. - Will register global sequence of message, sequence by partition - and error and error message by partition - """ - def server_response(self_httplib, path, method, body, header): - parsed_url = urlparse.urlparse(path.lstrip('/')) - self.sequence.append(parsed_url.path) - if method == 'GET': - parsed_qs = urlparse.parse_qs(parsed_url.query) - else: - parsed_qs = urlparse.parse_qs(body) - if (parsed_url.path == 'getFullComputerInformation' - and 'computer_id' in parsed_qs): - slap_computer = self.getComputer(parsed_qs['computer_id'][0]) - return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer)) - if method == 'POST' and 'computer_partition_id' in parsed_qs: - instance = self.instance_list[int(parsed_qs['computer_partition_id'][0])] - instance.sequence.append(parsed_url.path) - instance.header_list.append(header) - if parsed_url.path == 'availableComputerPartition': - return (200, {}, '') - if parsed_url.path == 'startedComputerPartition': - instance.state = 'started' - return (200, {}, '') - if parsed_url.path == 'stoppedComputerPartition': - instance.state = 'stopped' - return (200, {}, '') - if parsed_url.path == 'destroyedComputerPartition': - instance.state = 'destroyed' - return (200, {}, '') - if parsed_url.path == 'softwareInstanceBang': - return (200, {}, '') - if parsed_url.path == 'softwareInstanceError': - instance.error_log = '\n'.join( - [ - line - for line in parsed_qs['error_log'][0].splitlines() - if 'dropPrivileges' not in line - ] - ) - instance.error = True - return (200, {}, '') - - elif method == 'POST' and 'url' in parsed_qs: - # XXX hardcoded to first software release! - software = self.software_list[0] - software.sequence.append(parsed_url.path) - if parsed_url.path == 'buildingSoftwareRelease': - return (200, {}, '') - if parsed_url.path == 'softwareReleaseError': - software.error_log = '\n'.join( - [ - line - for line in parsed_qs['error_log'][0].splitlines() - if 'dropPrivileges' not in line - ] - ) - software.error = True - return (200, {}, '') - - else: - return (500, {}, '') - return server_response -class InstanceForTest: +class InstanceForTest(object): """ Class containing all needed paramaters and function to simulate instances """ @@ -479,7 +463,7 @@ class InstanceForTest: open(self.key_file, 'w').write(self.key) -class SoftwareForTest: +class SoftwareForTest(object): """ Class to prepare and simulate software. each instance has a sotfware attributed @@ -533,27 +517,27 @@ touch worked"""): class TestSlapgridCPWithMaster(MasterMixin, unittest.TestCase): def test_nothing_to_do(self): - - ComputerForTest(self.software_root, self.instance_root, 0, 0) - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['etc', 'var']) - self.assertItemsEqual(os.listdir(self.software_root), []) - st = os.stat(os.path.join(self.instance_root, 'var')) - self.assertEquals(stat.S_IMODE(st.st_mode), 0o755) + computer = ComputerForTest(self.software_root, self.instance_root, 0, 0) + with httmock.HTTMock(computer.request_handler): + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['etc', 'var']) + self.assertItemsEqual(os.listdir(self.software_root), []) + st = os.stat(os.path.join(self.instance_root, 'var')) + self.assertEquals(stat.S_IMODE(st.st_mode), 0o755) def test_one_partition(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), ['.slapgrid', 'buildout.cfg', - 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), ['.slapgrid', 'buildout.cfg', + 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition']) def test_one_partition_instance_cfg(self): """ @@ -561,56 +545,60 @@ class TestSlapgridCPWithMaster(MasterMixin, unittest.TestCase): "template.cfg" but "instance.cfg". """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), ['.slapgrid', 'buildout.cfg', - 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), ['.slapgrid', 'buildout.cfg', + 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition']) def test_one_free_partition(self): """ - Test if slapgrid cp don't process "free" partition + Test if slapgrid cp does not process "free" partition """ computer = ComputerForTest(self.software_root, self.instance_root, software_amount=0) - partition = computer.instance_list[0] - partition.requested_state = 'destroyed' - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(partition.partition_path), []) - self.assertItemsEqual(os.listdir(self.software_root), []) - self.assertEqual(partition.sequence, []) + with httmock.HTTMock(computer.request_handler): + partition = computer.instance_list[0] + partition.requested_state = 'destroyed' + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(partition.partition_path), []) + self.assertItemsEqual(os.listdir(self.software_root), []) + self.assertEqual(partition.sequence, []) def test_one_partition_started(self): computer = ComputerForTest(self.software_root, self.instance_root) - partition = computer.instance_list[0] - partition.requested_state = 'started' - partition.software.setBuildout(WRAPPER_CONTENT) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(partition.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(partition.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.software_root), [partition.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual(partition.state, 'started') + with httmock.HTTMock(computer.request_handler): + partition = computer.instance_list[0] + partition.requested_state = 'started' + partition.software.setBuildout(WRAPPER_CONTENT) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(partition.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(partition.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.software_root), [partition.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual(partition.state, 'started') def test_one_partition_started_stopped(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - instance.requested_state = 'started' - instance.software.setBuildout("""#!/bin/sh + instance.requested_state = 'started' + instance.software.setBuildout("""#!/bin/sh touch worked && mkdir -p etc/run && ( @@ -628,31 +616,31 @@ HEREDOC )> etc/run/wrapper && chmod 755 etc/run/wrapper """ % {'python': sys.executable}) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual(instance.state, 'started') - - computer.sequence = [] - instance.requested_state = 'stopped' - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertLogContent(wrapper_log, 'Signal handler called with signal 15') - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition']) - self.assertEqual(instance.state, 'stopped') + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual(instance.state, 'started') + + computer.sequence = [] + instance.requested_state = 'stopped' + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertLogContent(wrapper_log, 'Signal handler called with signal 15') + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition']) + self.assertEqual(instance.state, 'stopped') def test_one_broken_partition_stopped(self): """ @@ -661,10 +649,11 @@ chmod 755 etc/run/wrapper to run) but status is still started. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - instance.requested_state = 'started' - instance.software.setBuildout("""#!/bin/sh + instance.requested_state = 'started' + instance.software.setBuildout("""#!/bin/sh touch worked && mkdir -p etc/run && ( @@ -682,71 +671,72 @@ HEREDOC )> etc/run/wrapper && chmod 755 etc/run/wrapper """ % {'python': sys.executable}) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual(instance.state, 'started') - - computer.sequence = [] - instance.requested_state = 'stopped' - instance.software.setBuildout("""#!/bin/sh + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual(instance.state, 'started') + + computer.sequence = [] + instance.requested_state = 'stopped' + instance.software.setBuildout("""#!/bin/sh exit 1 """) - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_FAIL) - self.assertItemsEqual(os.listdir(self.instance_root), - ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertLogContent(wrapper_log, 'Signal handler called with signal 15') - self.assertEqual(computer.sequence, - ['getFullComputerInformation', - 'softwareInstanceError']) - self.assertEqual(instance.state, 'started') + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_FAIL) + self.assertItemsEqual(os.listdir(self.instance_root), + ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertLogContent(wrapper_log, 'Signal handler called with signal 15') + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', + '/softwareInstanceError']) + self.assertEqual(instance.state, 'started') def test_one_partition_stopped_started(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'stopped' - instance.software.setBuildout(WRAPPER_CONTENT) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', 'buildout.cfg', 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition']) - self.assertEqual('stopped', instance.state) - - instance.requested_state = 'started' - computer.sequence = [] - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.0_wrapper.log', 'etc', - 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual('started', instance.state) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'stopped' + instance.software.setBuildout(WRAPPER_CONTENT) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', 'buildout.cfg', 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition']) + self.assertEqual('stopped', instance.state) + + instance.requested_state = 'started' + computer.sequence = [] + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.0_wrapper.log', 'etc', + 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual('started', instance.state) def test_one_partition_destroyed(self): """ @@ -754,23 +744,24 @@ exit 1 stopped by slapgrid-cp, not processed """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'destroyed' + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'destroyed' - dummy_file_name = 'dummy_file' - with open(os.path.join(instance.partition_path, dummy_file_name), 'w') as dummy_file: - dummy_file.write('dummy') + dummy_file_name = 'dummy_file' + with open(os.path.join(instance.partition_path, dummy_file_name), 'w') as dummy_file: + dummy_file.write('dummy') - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), ['.slapgrid', dummy_file_name]) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', - 'stoppedComputerPartition']) - self.assertEqual('stopped', instance.state) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), ['.slapgrid', dummy_file_name]) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', + '/stoppedComputerPartition']) + self.assertEqual('stopped', instance.state) class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): @@ -802,19 +793,20 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): 5.Wait for file generated by monkeypacthed bang to appear """ computer = ComputerForTest(self.software_root, self.instance_root) - partition = computer.instance_list[0] - partition.requested_state = 'started' - partition.software.setBuildout(DAEMON_CONTENT) - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(partition.partition_path), - ['.slapgrid', '.0_daemon.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - daemon_log = os.path.join(partition.partition_path, '.0_daemon.log') - self.assertLogContent(daemon_log, 'Failing') - self.assertIsCreated(self.watchdog_banged) - self.assertIn('daemon', open(self.watchdog_banged).read()) + with httmock.HTTMock(computer.request_handler): + partition = computer.instance_list[0] + partition.requested_state = 'started' + partition.software.setBuildout(DAEMON_CONTENT) + + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(partition.partition_path), + ['.slapgrid', '.0_daemon.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + daemon_log = os.path.join(partition.partition_path, '.0_daemon.log') + self.assertLogContent(daemon_log, 'Failing') + self.assertIsCreated(self.watchdog_banged) + self.assertIn('daemon', open(self.watchdog_banged).read()) def test_one_failing_daemon_in_run_will_not_bang_with_watchdog(self): """ @@ -829,36 +821,37 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): 5.Check that file generated by monkeypacthed bang do not appear """ computer = ComputerForTest(self.software_root, self.instance_root) - partition = computer.instance_list[0] - partition.requested_state = 'started' - - # Content of run wrapper - WRAPPER_CONTENT = textwrap.dedent("""#!/bin/sh - touch ./launched - touch ./crashed - echo Failing - sleep 1 - exit 111 - """) - - BUILDOUT_RUN_CONTENT = textwrap.dedent("""#!/bin/sh - mkdir -p etc/run && - echo "%s" >> etc/run/daemon && - chmod 755 etc/run/daemon && - touch worked - """ % WRAPPER_CONTENT) - - partition.software.setBuildout(BUILDOUT_RUN_CONTENT) - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), - ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(partition.partition_path), - ['.slapgrid', '.0_daemon.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - daemon_log = os.path.join(partition.partition_path, '.0_daemon.log') - self.assertLogContent(daemon_log, 'Failing') - self.assertIsNotCreated(self.watchdog_banged) + with httmock.HTTMock(computer.request_handler): + partition = computer.instance_list[0] + partition.requested_state = 'started' + + # Content of run wrapper + WRAPPER_CONTENT = textwrap.dedent("""#!/bin/sh + touch ./launched + touch ./crashed + echo Failing + sleep 1 + exit 111 + """) + + BUILDOUT_RUN_CONTENT = textwrap.dedent("""#!/bin/sh + mkdir -p etc/run && + echo "%s" >> etc/run/daemon && + chmod 755 etc/run/daemon && + touch worked + """ % WRAPPER_CONTENT) + + partition.software.setBuildout(BUILDOUT_RUN_CONTENT) + + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), + ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(partition.partition_path), + ['.slapgrid', '.0_daemon.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + daemon_log = os.path.join(partition.partition_path, '.0_daemon.log') + self.assertLogContent(daemon_log, 'Failing') + self.assertIsNotCreated(self.watchdog_banged) def test_watched_by_watchdog_bang(self): """ @@ -868,25 +861,24 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): (ie: watchdog id in process name) """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') - instance.setCertificate(certificate_repository_path) - - watchdog = Watchdog( - master_url='https://127.0.0.1/', - computer_id=self.computer_id, - certificate_repository_path=certificate_repository_path - ) - for event in watchdog.process_state_events: - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') + instance.setCertificate(certificate_repository_path) + + watchdog = Watchdog( + master_url='https://127.0.0.1/', + computer_id=self.computer_id, + certificate_repository_path=certificate_repository_path + ) + for event in watchdog.process_state_events: + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) def test_unwanted_events_will_not_bang(self): """ @@ -939,33 +931,32 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): .timestamp file. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') - instance.setCertificate(certificate_repository_path) - partition = os.path.join(self.instance_root, '0') - timestamp_content = '1234' - timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') - timestamp_file.write(timestamp_content) - timestamp_file.close() - - watchdog = Watchdog( - master_url='https://127.0.0.1/', - computer_id=self.computer_id, - certificate_repository_path=certificate_repository_path, - instance_root_path=self.instance_root - ) - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') + instance.setCertificate(certificate_repository_path) + partition = os.path.join(self.instance_root, '0') + timestamp_content = '1234' + timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') + timestamp_file.write(timestamp_content) + timestamp_file.close() + + watchdog = Watchdog( + master_url='https://127.0.0.1/', + computer_id=self.computer_id, + certificate_repository_path=certificate_repository_path, + instance_root_path=self.instance_root + ) + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) - self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) + self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) def test_watchdog_ignore_bang_if_partition_not_deployed(self): @@ -976,30 +967,29 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): Practically speaking, .timestamp file in the partition does not exsit. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') - instance.setCertificate(certificate_repository_path) - partition = os.path.join(self.instance_root, '0') - timestamp_content = '1234' - - watchdog = Watchdog( - master_url='https://127.0.0.1/', - computer_id=self.computer_id, - certificate_repository_path=certificate_repository_path, - instance_root_path=self.instance_root - ) - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') + instance.setCertificate(certificate_repository_path) + partition = os.path.join(self.instance_root, '0') + timestamp_content = '1234' + + watchdog = Watchdog( + master_url='https://127.0.0.1/', + computer_id=self.computer_id, + certificate_repository_path=certificate_repository_path, + instance_root_path=self.instance_root + ) + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) - self.assertNotEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) + self.assertNotEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) def test_watchdog_bang_only_once_if_partition_never_deployed(self): @@ -1010,38 +1000,37 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): * subsequent bangs are ignored until a deployment is successful. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') - instance.setCertificate(certificate_repository_path) - partition = os.path.join(self.instance_root, '0') + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') + instance.setCertificate(certificate_repository_path) + partition = os.path.join(self.instance_root, '0') + + watchdog = Watchdog( + master_url='https://127.0.0.1/', + computer_id=self.computer_id, + certificate_repository_path=certificate_repository_path, + instance_root_path=self.instance_root + ) + # First bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) - watchdog = Watchdog( - master_url='https://127.0.0.1/', - computer_id=self.computer_id, - certificate_repository_path=certificate_repository_path, - instance_root_path=self.instance_root - ) - # First bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) - - # Second bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, []) + # Second bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, []) def test_watchdog_bang_only_once_if_timestamp_did_not_change(self): @@ -1061,175 +1050,177 @@ class TestSlapgridCPWithMasterWatchdog(MasterMixin, unittest.TestCase): * The process crashes again, watchdog ignroes it """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') - instance.setCertificate(certificate_repository_path) - partition = os.path.join(self.instance_root, '0') - timestamp_content = '1234' - timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') - timestamp_file.write(timestamp_content) - timestamp_file.close() + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + certificate_repository_path = os.path.join(self._tempdir, 'partition_pki') + instance.setCertificate(certificate_repository_path) + partition = os.path.join(self.instance_root, '0') + timestamp_content = '1234' + timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') + timestamp_file.write(timestamp_content) + timestamp_file.close() + + watchdog = Watchdog( + master_url='https://127.0.0.1/', + computer_id=self.computer_id, + certificate_repository_path=certificate_repository_path, + instance_root_path=self.instance_root + ) + # First bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) - watchdog = Watchdog( - master_url='https://127.0.0.1/', - computer_id=self.computer_id, - certificate_repository_path=certificate_repository_path, - instance_root_path=self.instance_root - ) - # First bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) - - self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) - - # Second bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, []) - - # Second successful deployment - timestamp_content = '12345' - timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') - timestamp_file.write(timestamp_content) - timestamp_file.close() - - # Third bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, ['softwareInstanceBang']) - self.assertEqual(instance.header_list[0]['key'], instance.key) - self.assertEqual(instance.header_list[0]['certificate'], instance.certificate) - - self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) - - # Fourth bang - event = watchdog.process_state_events[0] - instance.sequence = [] - instance.header_list = [] - headers = {'eventname': event} - payload = 'processname:%s groupname:%s from_state:RUNNING' % ( - 'daemon' + WATCHDOG_MARK, instance.name) - watchdog.handle_event(headers, payload) - self.assertEqual(instance.sequence, []) + self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) + + # Second bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, []) + + # Second successful deployment + timestamp_content = '12345' + timestamp_file = open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_TIMESTAMP_FILENAME), 'w') + timestamp_file.write(timestamp_content) + timestamp_file.close() + + # Third bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, ['/softwareInstanceBang']) + + self.assertEqual(open(os.path.join(partition, slapos.grid.slapgrid.COMPUTER_PARTITION_LATEST_BANG_TIMESTAMP_FILENAME)).read(), timestamp_content) + + # Fourth bang + event = watchdog.process_state_events[0] + instance.sequence = [] + instance.header_list = [] + headers = {'eventname': event} + payload = 'processname:%s groupname:%s from_state:RUNNING' % ( + 'daemon' + WATCHDOG_MARK, instance.name) + watchdog.handle_event(headers, payload) + self.assertEqual(instance.sequence, []) class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): def test_partition_timestamp(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) - instance.timestamp = timestamp - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - timestamp_path = os.path.join(instance.partition_path, '.timestamp') - self.setSlapgrid() - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertIn(timestamp, open(timestamp_path).read()) - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) + instance.timestamp = timestamp + + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + timestamp_path = os.path.join(instance.partition_path, '.timestamp') + self.setSlapgrid() + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertIn(timestamp, open(timestamp_path).read()) + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_partition_timestamp_develop(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) - instance.timestamp = timestamp + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) + instance.timestamp = timestamp - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', - 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', + 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(self.launchSlapgrid(develop=True), - slapgrid.SLAPGRID_SUCCESS) - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(self.launchSlapgrid(develop=True), + slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition', - 'availableComputerPartition', 'stoppedComputerPartition']) + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition', + '/availableComputerPartition', '/stoppedComputerPartition']) def test_partition_old_timestamp(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) - instance.timestamp = timestamp - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - instance.timestamp = str(int(timestamp) - 1) - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) + instance.timestamp = timestamp + + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + instance.timestamp = str(int(timestamp) - 1) + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_partition_timestamp_new_timestamp(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) - instance.timestamp = timestamp - - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - instance.timestamp = str(int(timestamp) + 1) - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition', 'getFullComputerInformation', - 'availableComputerPartition', 'stoppedComputerPartition', - 'getFullComputerInformation']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) + instance.timestamp = timestamp + + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + instance.timestamp = str(int(timestamp) + 1) + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(self.launchSlapgrid(), slapgrid.SLAPGRID_SUCCESS) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition', '/getFullComputerInformation', + '/availableComputerPartition', '/stoppedComputerPartition', + '/getFullComputerInformation']) def test_partition_timestamp_no_timestamp(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) - instance.timestamp = timestamp - - self.launchSlapgrid() - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - instance.timestamp = None - self.launchSlapgrid() - self.assertEqual(computer.sequence, - ['getFullComputerInformation', 'availableComputerPartition', - 'stoppedComputerPartition', 'getFullComputerInformation', - 'availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) + instance.timestamp = timestamp + + self.launchSlapgrid() + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + instance.timestamp = None + self.launchSlapgrid() + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', '/availableComputerPartition', + '/stoppedComputerPartition', '/getFullComputerInformation', + '/availableComputerPartition', '/stoppedComputerPartition']) def test_partition_periodicity_remove_timestamp(self): """ @@ -1237,28 +1228,29 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): removes the .timestamp file. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - timestamp = str(int(time.time())) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + timestamp = str(int(time.time())) - instance.timestamp = timestamp - instance.requested_state = 'started' - instance.software.setPeriodicity(1) + instance.timestamp = timestamp + instance.requested_state = 'started' + instance.software.setPeriodicity(1) - self.launchSlapgrid() - partition = os.path.join(self.instance_root, '0') - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', - 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.launchSlapgrid() + partition = os.path.join(self.instance_root, '0') + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', + 'software_release', 'worked', '.slapos-retention-lock-delay']) - time.sleep(2) - # dummify install() so that it doesn't actually do anything so that it - # doesn't recreate .timestamp. - instance.install = lambda: None + time.sleep(2) + # dummify install() so that it doesn't actually do anything so that it + # doesn't recreate .timestamp. + instance.install = lambda: None - self.launchSlapgrid() - self.assertItemsEqual(os.listdir(partition), - ['.slapgrid', '.timestamp', 'buildout.cfg', - 'software_release', 'worked', '.slapos-retention-lock-delay']) + self.launchSlapgrid() + self.assertItemsEqual(os.listdir(partition), + ['.slapgrid', '.timestamp', 'buildout.cfg', + 'software_release', 'worked', '.slapos-retention-lock-delay']) def test_one_partition_periodicity_from_file_does_not_disturb_others(self): """ @@ -1274,39 +1266,40 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): 5. We check that modification time of .timestamp was modified """ computer = ComputerForTest(self.software_root, self.instance_root, 20, 20) - instance0 = computer.instance_list[0] - timestamp = str(int(time.time() - 5)) - instance0.timestamp = timestamp - instance0.requested_state = 'started' - for instance in computer.instance_list[1:]: - instance.software = \ - computer.software_list[computer.instance_list.index(instance)] - instance.timestamp = timestamp - - wanted_periodicity = 1 - instance0.software.setPeriodicity(wanted_periodicity) + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + timestamp = str(int(time.time() - 5)) + instance0.timestamp = timestamp + instance0.requested_state = 'started' + for instance in computer.instance_list[1:]: + instance.software = \ + computer.software_list[computer.instance_list.index(instance)] + instance.timestamp = timestamp + + wanted_periodicity = 1 + instance0.software.setPeriodicity(wanted_periodicity) - self.launchSlapgrid() - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) - last_runtime = os.path.getmtime( - os.path.join(instance0.partition_path, '.timestamp')) - time.sleep(wanted_periodicity + 1) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - time.sleep(1) - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['availableComputerPartition', 'startedComputerPartition', - 'availableComputerPartition', 'startedComputerPartition', - ]) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - self.assertGreater( - os.path.getmtime(os.path.join(instance0.partition_path, '.timestamp')), - last_runtime) - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + self.launchSlapgrid() + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + last_runtime = os.path.getmtime( + os.path.join(instance0.partition_path, '.timestamp')) + time.sleep(wanted_periodicity + 1) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + time.sleep(1) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/availableComputerPartition', '/startedComputerPartition', + '/availableComputerPartition', '/startedComputerPartition', + ]) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + self.assertGreater( + os.path.getmtime(os.path.join(instance0.partition_path, '.timestamp')), + last_runtime) + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) def test_one_partition_stopped_is_not_processed_after_periodicity(self): """ @@ -1314,37 +1307,38 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): started. """ computer = ComputerForTest(self.software_root, self.instance_root, 20, 20) - instance0 = computer.instance_list[0] - timestamp = str(int(time.time() - 5)) - instance0.timestamp = timestamp - for instance in computer.instance_list[1:]: - instance.software = \ - computer.software_list[computer.instance_list.index(instance)] - instance.timestamp = timestamp + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + timestamp = str(int(time.time() - 5)) + instance0.timestamp = timestamp + for instance in computer.instance_list[1:]: + instance.software = \ + computer.software_list[computer.instance_list.index(instance)] + instance.timestamp = timestamp + + wanted_periodicity = 1 + instance0.software.setPeriodicity(wanted_periodicity) - wanted_periodicity = 1 - instance0.software.setPeriodicity(wanted_periodicity) - - self.launchSlapgrid() - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) - last_runtime = os.path.getmtime( - os.path.join(instance0.partition_path, '.timestamp')) - time.sleep(wanted_periodicity + 1) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - time.sleep(1) - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['availableComputerPartition', 'stoppedComputerPartition', - 'availableComputerPartition', 'stoppedComputerPartition']) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - self.assertNotEqual(os.path.getmtime(os.path.join(instance0.partition_path, - '.timestamp')), - last_runtime) - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + self.launchSlapgrid() + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + last_runtime = os.path.getmtime( + os.path.join(instance0.partition_path, '.timestamp')) + time.sleep(wanted_periodicity + 1) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + time.sleep(1) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition', + '/availableComputerPartition', '/stoppedComputerPartition']) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + self.assertNotEqual(os.path.getmtime(os.path.join(instance0.partition_path, + '.timestamp')), + last_runtime) + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) def test_one_partition_destroyed_is_not_processed_after_periodicity(self): """ @@ -1352,39 +1346,40 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): started. """ computer = ComputerForTest(self.software_root, self.instance_root, 20, 20) - instance0 = computer.instance_list[0] - timestamp = str(int(time.time() - 5)) - instance0.timestamp = timestamp - instance0.requested_state = 'stopped' - for instance in computer.instance_list[1:]: - instance.software = \ - computer.software_list[computer.instance_list.index(instance)] - instance.timestamp = timestamp - - wanted_periodicity = 1 - instance0.software.setPeriodicity(wanted_periodicity) + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + timestamp = str(int(time.time() - 5)) + instance0.timestamp = timestamp + instance0.requested_state = 'stopped' + for instance in computer.instance_list[1:]: + instance.software = \ + computer.software_list[computer.instance_list.index(instance)] + instance.timestamp = timestamp + + wanted_periodicity = 1 + instance0.software.setPeriodicity(wanted_periodicity) - self.launchSlapgrid() - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) - last_runtime = os.path.getmtime( - os.path.join(instance0.partition_path, '.timestamp')) - time.sleep(wanted_periodicity + 1) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - time.sleep(1) - instance0.requested_state = 'destroyed' - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['availableComputerPartition', 'stoppedComputerPartition', - 'stoppedComputerPartition']) - for instance in computer.instance_list[1:]: - self.assertEqual(instance.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) - self.assertNotEqual(os.path.getmtime(os.path.join(instance0.partition_path, - '.timestamp')), - last_runtime) - self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + self.launchSlapgrid() + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) + last_runtime = os.path.getmtime( + os.path.join(instance0.partition_path, '.timestamp')) + time.sleep(wanted_periodicity + 1) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + time.sleep(1) + instance0.requested_state = 'destroyed' + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition', + '/stoppedComputerPartition']) + for instance in computer.instance_list[1:]: + self.assertEqual(instance.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) + self.assertNotEqual(os.path.getmtime(os.path.join(instance0.partition_path, + '.timestamp')), + last_runtime) + self.assertNotEqual(wanted_periodicity, self.grid.maximum_periodicity) def test_one_partition_is_never_processed_when_periodicity_is_negative(self): """ @@ -1397,16 +1392,17 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): 4. We launch slapgrid anew and check that install as not been called again """ - timestamp = str(int(time.time())) computer = ComputerForTest(self.software_root, self.instance_root, 1, 1) - instance = computer.instance_list[0] - instance.software.setPeriodicity(-1) - instance.timestamp = timestamp - with patch.object(slapos.grid.slapgrid.Partition, 'install', return_value=None) as mock_method: - self.launchSlapgrid() - self.assertTrue(mock_method.called) - self.launchSlapgrid() - self.assertEqual(mock_method.call_count, 1) + with httmock.HTTMock(computer.request_handler): + timestamp = str(int(time.time())) + instance = computer.instance_list[0] + instance.software.setPeriodicity(-1) + instance.timestamp = timestamp + with patch.object(slapos.grid.slapgrid.Partition, 'install', return_value=None) as mock_method: + self.launchSlapgrid() + self.assertTrue(mock_method.called) + self.launchSlapgrid() + self.assertEqual(mock_method.call_count, 1) def test_one_partition_is_always_processed_when_periodicity_is_zero(self): """ @@ -1419,15 +1415,16 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): new setup and one time because of periodicity = 0) """ - timestamp = str(int(time.time())) computer = ComputerForTest(self.software_root, self.instance_root, 1, 1) - instance = computer.instance_list[0] - instance.software.setPeriodicity(0) - instance.timestamp = timestamp - with patch.object(slapos.grid.slapgrid.Partition, 'install', return_value=None) as mock_method: - self.launchSlapgrid() - self.launchSlapgrid() - self.assertEqual(mock_method.call_count, 2) + with httmock.HTTMock(computer.request_handler): + timestamp = str(int(time.time())) + instance = computer.instance_list[0] + instance.software.setPeriodicity(0) + instance.timestamp = timestamp + with patch.object(slapos.grid.slapgrid.Partition, 'install', return_value=None) as mock_method: + self.launchSlapgrid() + self.launchSlapgrid() + self.assertEqual(mock_method.call_count, 2) def test_one_partition_buildout_fail_does_not_disturb_others(self): """ @@ -1435,16 +1432,17 @@ class TestSlapgridCPPartitionProcessing(MasterMixin, unittest.TestCase): 2. One will fail but the other one will be processed correctly """ computer = ComputerForTest(self.software_root, self.instance_root, 2, 2) - instance0 = computer.instance_list[0] - instance1 = computer.instance_list[1] - instance1.software = computer.software_list[1] - instance0.software.setBuildout("""#!/bin/sh + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + instance1 = computer.instance_list[1] + instance1.software = computer.software_list[1] + instance0.software.setBuildout("""#!/bin/sh exit 42""") - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['softwareInstanceError']) - self.assertEqual(instance1.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/softwareInstanceError']) + self.assertEqual(instance1.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_one_partition_lacking_software_path_does_not_disturb_others(self): """ @@ -1452,15 +1450,16 @@ exit 42""") 2. One will fail but the other one will be processed correctly """ computer = ComputerForTest(self.software_root, self.instance_root, 2, 2) - instance0 = computer.instance_list[0] - instance1 = computer.instance_list[1] - instance1.software = computer.software_list[1] - shutil.rmtree(instance0.software.srdir) - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['softwareInstanceError']) - self.assertEqual(instance1.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + instance1 = computer.instance_list[1] + instance1.software = computer.software_list[1] + shutil.rmtree(instance0.software.srdir) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/softwareInstanceError']) + self.assertEqual(instance1.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_one_partition_lacking_software_bin_path_does_not_disturb_others(self): """ @@ -1468,15 +1467,16 @@ exit 42""") 2. One will fail but the other one will be processed correctly """ computer = ComputerForTest(self.software_root, self.instance_root, 2, 2) - instance0 = computer.instance_list[0] - instance1 = computer.instance_list[1] - instance1.software = computer.software_list[1] - shutil.rmtree(instance0.software.srbindir) - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['softwareInstanceError']) - self.assertEqual(instance1.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + instance1 = computer.instance_list[1] + instance1.software = computer.software_list[1] + shutil.rmtree(instance0.software.srbindir) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/softwareInstanceError']) + self.assertEqual(instance1.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_one_partition_lacking_path_does_not_disturb_others(self): """ @@ -1484,15 +1484,16 @@ exit 42""") 2. One will fail but the other one will be processed correctly """ computer = ComputerForTest(self.software_root, self.instance_root, 2, 2) - instance0 = computer.instance_list[0] - instance1 = computer.instance_list[1] - instance1.software = computer.software_list[1] - shutil.rmtree(instance0.partition_path) - self.launchSlapgrid() - self.assertEqual(instance0.sequence, - ['softwareInstanceError']) - self.assertEqual(instance1.sequence, - ['availableComputerPartition', 'stoppedComputerPartition']) + with httmock.HTTMock(computer.request_handler): + instance0 = computer.instance_list[0] + instance1 = computer.instance_list[1] + instance1.software = computer.software_list[1] + shutil.rmtree(instance0.partition_path) + self.launchSlapgrid() + self.assertEqual(instance0.sequence, + ['/softwareInstanceError']) + self.assertEqual(instance1.sequence, + ['/availableComputerPartition', '/stoppedComputerPartition']) def test_one_partition_buildout_fail_is_correctly_logged(self): """ @@ -1500,18 +1501,19 @@ exit 42""") 2. It will fail, make sure that whole log is sent to master """ computer = ComputerForTest(self.software_root, self.instance_root, 1, 1) - instance = computer.instance_list[0] + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - line1 = "Nerdy kitten: Can I has a process crash?" - line2 = "Cedric: Sure, here it is." - instance.software.setBuildout("""#!/bin/sh + line1 = "Nerdy kitten: Can I haz a process crash?" + line2 = "Cedric: Sure, here it is." + instance.software.setBuildout("""#!/bin/sh echo %s; echo %s; exit 42""" % (line1, line2)) - self.launchSlapgrid() - self.assertEqual(instance.sequence, ['softwareInstanceError']) - # We don't care of actual formatting, we just want to have full log - self.assertIn(line1, instance.error_log) - self.assertIn(line2, instance.error_log) - self.assertIn('Failed to run buildout', instance.error_log) + self.launchSlapgrid() + self.assertEqual(instance.sequence, ['/softwareInstanceError']) + # We don't care of actual formatting, we just want to have full log + self.assertIn(line1, instance.error_log) + self.assertIn(line2, instance.error_log) + self.assertIn('Failed to run buildout', instance.error_log) class TestSlapgridUsageReport(MasterMixin, unittest.TestCase): @@ -1524,41 +1526,42 @@ class TestSlapgridUsageReport(MasterMixin, unittest.TestCase): Test than an instance in "destroyed" state is correctly destroyed """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - instance.software.setBuildout(WRAPPER_CONTENT) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', - 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual(instance.state, 'started') - - # Then destroy the instance - computer.sequence = [] - instance.requested_state = 'destroyed' - self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) - # Assert partition directory is empty - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), []) - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - # Assert supervisor stopped process - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertIsNotCreated(wrapper_log) - - self.assertEqual(computer.sequence, - ['getFullComputerInformation', - 'stoppedComputerPartition', - 'destroyedComputerPartition']) - self.assertEqual(instance.state, 'destroyed') + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + instance.software.setBuildout(WRAPPER_CONTENT) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', + '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual(instance.state, 'started') + + # Then destroy the instance + computer.sequence = [] + instance.requested_state = 'destroyed' + self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) + # Assert partition directory is empty + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), []) + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + # Assert supervisor stopped process + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertIsNotCreated(wrapper_log) + + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', + '/stoppedComputerPartition', + '/destroyedComputerPartition']) + self.assertEqual(instance.state, 'destroyed') def test_partition_list_is_complete_if_empty_destroyed_partition(self): """ @@ -1570,64 +1573,66 @@ class TestSlapgridUsageReport(MasterMixin, unittest.TestCase): 2. See if it destroyed """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - computer.sequence = [] - instance.requested_state = 'destroyed' - self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) - # Assert partition directory is empty - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), []) - self.assertItemsEqual(os.listdir(self.software_root), - [instance.software.software_hash]) - # Assert supervisor stopped process - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertIsNotCreated(wrapper_log) - - self.assertEqual( - computer.sequence, - ['getFullComputerInformation', 'stoppedComputerPartition', 'destroyedComputerPartition']) + computer.sequence = [] + instance.requested_state = 'destroyed' + self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) + # Assert partition directory is empty + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), []) + self.assertItemsEqual(os.listdir(self.software_root), + [instance.software.software_hash]) + # Assert supervisor stopped process + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertIsNotCreated(wrapper_log) + + self.assertEqual( + computer.sequence, + ['/getFullComputerInformation', '/stoppedComputerPartition', '/destroyedComputerPartition']) def test_slapgrid_not_destroy_bad_instance(self): """ Checks that slapgrid-ur don't destroy instance not to be destroyed. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - instance.software.setBuildout(WRAPPER_CONTENT) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, - ['getFullComputerInformation', - 'availableComputerPartition', - 'startedComputerPartition']) - self.assertEqual('started', instance.state) - - # Then run usage report and see if it is still working - computer.sequence = [] - self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), - ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', - 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) - wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') - self.assertLogContent(wrapper_log, 'Working') - self.assertEqual(computer.sequence, - ['getFullComputerInformation']) - self.assertEqual('started', instance.state) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + instance.software.setBuildout(WRAPPER_CONTENT) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, + ['/getFullComputerInformation', + '/availableComputerPartition', + '/startedComputerPartition']) + self.assertEqual('started', instance.state) + + # Then run usage report and see if it is still working + computer.sequence = [] + self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), + ['.slapgrid', '.0_wrapper.log', 'buildout.cfg', + 'etc', 'software_release', 'worked', '.slapos-retention-lock-delay']) + wrapper_log = os.path.join(instance.partition_path, '.0_wrapper.log') + self.assertLogContent(wrapper_log, 'Working') + self.assertEqual(computer.sequence, + ['/getFullComputerInformation']) + self.assertEqual('started', instance.state) def test_slapgrid_instance_ignore_free_instance(self): """ @@ -1635,17 +1640,18 @@ class TestSlapgridUsageReport(MasterMixin, unittest.TestCase): software_release URI) is ignored by slapgrid-cp. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.software.name = None + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.software.name = None - computer.sequence = [] - instance.requested_state = 'destroyed' - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - # Assert partition directory is empty - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), []) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, ['getFullComputerInformation']) + computer.sequence = [] + instance.requested_state = 'destroyed' + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + # Assert partition directory is empty + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), []) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, ['/getFullComputerInformation']) def test_slapgrid_report_ignore_free_instance(self): """ @@ -1653,17 +1659,18 @@ class TestSlapgridUsageReport(MasterMixin, unittest.TestCase): software_release URI) is ignored by slapgrid-ur. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.software.name = None + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.software.name = None - computer.sequence = [] - instance.requested_state = 'destroyed' - self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) - # Assert partition directory is empty - self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) - self.assertItemsEqual(os.listdir(instance.partition_path), []) - self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) - self.assertEqual(computer.sequence, ['getFullComputerInformation']) + computer.sequence = [] + instance.requested_state = 'destroyed' + self.assertEqual(self.grid.agregateAndSendUsage(), slapgrid.SLAPGRID_SUCCESS) + # Assert partition directory is empty + self.assertItemsEqual(os.listdir(self.instance_root), ['0', 'etc', 'var']) + self.assertItemsEqual(os.listdir(instance.partition_path), []) + self.assertItemsEqual(os.listdir(self.software_root), [instance.software.software_hash]) + self.assertEqual(computer.sequence, ['/getFullComputerInformation']) class TestSlapgridSoftwareRelease(MasterMixin, unittest.TestCase): @@ -1673,19 +1680,20 @@ class TestSlapgridSoftwareRelease(MasterMixin, unittest.TestCase): 2. It will fail, make sure that whole log is sent to master """ computer = ComputerForTest(self.software_root, self.instance_root, 1, 1) - software = computer.software_list[0] + with httmock.HTTMock(computer.request_handler): + software = computer.software_list[0] - line1 = "Nerdy kitten: Can I has a process crash?" - line2 = "Cedric: Sure, here it is." - software.setBuildout("""#!/bin/sh + line1 = "Nerdy kitten: Can I haz a process crash?" + line2 = "Cedric: Sure, here it is." + software.setBuildout("""#!/bin/sh echo %s; echo %s; exit 42""" % (line1, line2)) - self.launchSlapgridSoftware() - self.assertEqual(software.sequence, - ['buildingSoftwareRelease', 'softwareReleaseError']) - # We don't care of actual formatting, we just want to have full log - self.assertIn(line1, software.error_log) - self.assertIn(line2, software.error_log) - self.assertIn('Failed to run buildout', software.error_log) + self.launchSlapgridSoftware() + self.assertEqual(software.sequence, + ['/buildingSoftwareRelease', '/softwareReleaseError']) + # We don't care of actual formatting, we just want to have full log + self.assertIn(line1, software.error_log) + self.assertIn(line2, software.error_log) + self.assertIn('Failed to run buildout', software.error_log) class SlapgridInitialization(unittest.TestCase): @@ -1733,167 +1741,173 @@ buildout = /path/to/buildout/binary class TestSlapgridCPWithMasterPromise(MasterMixin, unittest.TestCase): def test_one_failing_promise(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - worked_file = os.path.join(instance.partition_path, 'fail_worked') - fail = textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%s" - exit 127""" % worked_file) - instance.setPromise('fail', fail) - self.assertEqual(self.grid.processComputerPartitionList(), - slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) - self.assertTrue(os.path.isfile(worked_file)) - self.assertTrue(instance.error) - self.assertNotEqual('started', instance.state) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + worked_file = os.path.join(instance.partition_path, 'fail_worked') + fail = textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%s" + exit 127""" % worked_file) + instance.setPromise('fail', fail) + self.assertEqual(self.grid.processComputerPartitionList(), + slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) + self.assertTrue(os.path.isfile(worked_file)) + self.assertTrue(instance.error) + self.assertNotEqual('started', instance.state) def test_one_succeeding_promise(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - self.fake_waiting_time = 0.1 - worked_file = os.path.join(instance.partition_path, 'succeed_worked') - succeed = textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%s" - exit 0""" % worked_file) - instance.setPromise('succeed', succeed) - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - self.assertTrue(os.path.isfile(worked_file)) - - self.assertFalse(instance.error) - self.assertEqual(instance.state, 'started') + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + self.fake_waiting_time = 0.1 + worked_file = os.path.join(instance.partition_path, 'succeed_worked') + succeed = textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%s" + exit 0""" % worked_file) + instance.setPromise('succeed', succeed) + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + self.assertTrue(os.path.isfile(worked_file)) + + self.assertFalse(instance.error) + self.assertEqual(instance.state, 'started') def test_stderr_has_been_sent(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - httplib.HTTPConnection._callback = computer.getServerResponse() - - instance.requested_state = 'started' - self.fake_waiting_time = 0.5 - - promise_path = os.path.join(instance.partition_path, 'etc', 'promise') - os.makedirs(promise_path) - succeed = os.path.join(promise_path, 'stderr_writer') - worked_file = os.path.join(instance.partition_path, 'stderr_worked') - with open(succeed, 'w') as f: - f.write(textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%s" - echo Error 1>&2 - exit 127""" % worked_file)) - os.chmod(succeed, 0o777) - self.assertEqual(self.grid.processComputerPartitionList(), - slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) - self.assertTrue(os.path.isfile(worked_file)) - - self.assertEqual(instance.error_log[-5:], 'Error') - self.assertTrue(instance.error) - self.assertIsNone(instance.state) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - def test_timeout_works(self): - computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] + instance.requested_state = 'started' + self.fake_waiting_time = 0.5 - instance.requested_state = 'started' - self.fake_waiting_time = 0.1 - - promise_path = os.path.join(instance.partition_path, 'etc', 'promise') - os.makedirs(promise_path) - succeed = os.path.join(promise_path, 'timed_out_promise') - worked_file = os.path.join(instance.partition_path, 'timed_out_worked') - with open(succeed, 'w') as f: - f.write(textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%s" - sleep 5 - exit 0""" % worked_file)) - os.chmod(succeed, 0o777) - self.assertEqual(self.grid.processComputerPartitionList(), - slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) - self.assertTrue(os.path.isfile(worked_file)) - - self.assertTrue(instance.error) - self.assertIsNone(instance.state) + promise_path = os.path.join(instance.partition_path, 'etc', 'promise') + os.makedirs(promise_path) + succeed = os.path.join(promise_path, 'stderr_writer') + worked_file = os.path.join(instance.partition_path, 'stderr_worked') + with open(succeed, 'w') as f: + f.write(textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%s" + echo Error 1>&2 + exit 127""" % worked_file)) + os.chmod(succeed, 0o777) + self.assertEqual(self.grid.processComputerPartitionList(), + slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) + self.assertTrue(os.path.isfile(worked_file)) - def test_two_succeeding_promises(self): + self.assertEqual(instance.error_log[-5:], 'Error') + self.assertTrue(instance.error) + self.assertIsNone(instance.state) + + def test_timeout_works(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] - self.fake_waiting_time = 0.1 + instance.requested_state = 'started' + self.fake_waiting_time = 0.1 - for i in range(2): - worked_file = os.path.join(instance.partition_path, 'succeed_%s_worked' % i) - succeed = textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%s" - exit 0""" % worked_file) - instance.setPromise('succeed_%s' % i, succeed) - - self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) - for i in range(2): - worked_file = os.path.join(instance.partition_path, 'succeed_%s_worked' % i) + promise_path = os.path.join(instance.partition_path, 'etc', 'promise') + os.makedirs(promise_path) + succeed = os.path.join(promise_path, 'timed_out_promise') + worked_file = os.path.join(instance.partition_path, 'timed_out_worked') + with open(succeed, 'w') as f: + f.write(textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%s" + sleep 5 + exit 0""" % worked_file)) + os.chmod(succeed, 0o777) + self.assertEqual(self.grid.processComputerPartitionList(), + slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) self.assertTrue(os.path.isfile(worked_file)) - self.assertFalse(instance.error) - self.assertEqual(instance.state, 'started') + + self.assertTrue(instance.error) + self.assertIsNone(instance.state) + + def test_two_succeeding_promises(self): + computer = ComputerForTest(self.software_root, self.instance_root) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + + self.fake_waiting_time = 0.1 + + for i in range(2): + worked_file = os.path.join(instance.partition_path, 'succeed_%s_worked' % i) + succeed = textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%s" + exit 0""" % worked_file) + instance.setPromise('succeed_%s' % i, succeed) + + self.assertEqual(self.grid.processComputerPartitionList(), slapgrid.SLAPGRID_SUCCESS) + for i in range(2): + worked_file = os.path.join(instance.partition_path, 'succeed_%s_worked' % i) + self.assertTrue(os.path.isfile(worked_file)) + self.assertFalse(instance.error) + self.assertEqual(instance.state, 'started') def test_one_succeeding_one_failing_promises(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - self.fake_waiting_time = 0.1 - - for i in range(2): - worked_file = os.path.join(instance.partition_path, 'promise_worked_%d' % i) - lockfile = os.path.join(instance.partition_path, 'lock') - promise = textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%(worked_file)s" - if [ ! -f %(lockfile)s ] - then - touch "%(lockfile)s" - exit 0 - else - exit 127 - fi""" % { - 'worked_file': worked_file, - 'lockfile': lockfile - }) - instance.setPromise('promise_%s' % i, promise) - self.assertEqual(self.grid.processComputerPartitionList(), - slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) - self.assertEquals(instance.error, 1) - self.assertNotEqual('started', instance.state) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + self.fake_waiting_time = 0.1 + + for i in range(2): + worked_file = os.path.join(instance.partition_path, 'promise_worked_%d' % i) + lockfile = os.path.join(instance.partition_path, 'lock') + promise = textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%(worked_file)s" + if [ ! -f %(lockfile)s ] + then + touch "%(lockfile)s" + exit 0 + else + exit 127 + fi""" % { + 'worked_file': worked_file, + 'lockfile': lockfile + }) + instance.setPromise('promise_%s' % i, promise) + self.assertEqual(self.grid.processComputerPartitionList(), + slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) + self.assertEquals(instance.error, 1) + self.assertNotEqual('started', instance.state) def test_one_succeeding_one_timing_out_promises(self): computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - self.fake_waiting_time = 0.1 - for i in range(2): - worked_file = os.path.join(instance.partition_path, 'promise_worked_%d' % i) - lockfile = os.path.join(instance.partition_path, 'lock') - promise = textwrap.dedent("""\ - #!/usr/bin/env sh - touch "%(worked_file)s" - if [ ! -f %(lockfile)s ] - then - touch "%(lockfile)s" - else - sleep 5 - fi - exit 0""" % { - 'worked_file': worked_file, - 'lockfile': lockfile} - ) - instance.setPromise('promise_%d' % i, promise) - - self.assertEqual(self.grid.processComputerPartitionList(), - slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) - - self.assertEquals(instance.error, 1) - self.assertNotEqual(instance.state, 'started') + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + self.fake_waiting_time = 0.1 + for i in range(2): + worked_file = os.path.join(instance.partition_path, 'promise_worked_%d' % i) + lockfile = os.path.join(instance.partition_path, 'lock') + promise = textwrap.dedent("""\ + #!/usr/bin/env sh + touch "%(worked_file)s" + if [ ! -f %(lockfile)s ] + then + touch "%(lockfile)s" + else + sleep 5 + fi + exit 0""" % { + 'worked_file': worked_file, + 'lockfile': lockfile} + ) + instance.setPromise('promise_%d' % i, promise) + + self.assertEqual(self.grid.processComputerPartitionList(), + slapos.grid.slapgrid.SLAPGRID_PROMISE_FAIL) + + self.assertEquals(instance.error, 1) + self.assertNotEqual(instance.state, 'started') class TestSlapgridDestructionLock(MasterMixin, unittest.TestCase): def test_retention_lock(self): @@ -1902,30 +1916,32 @@ class TestSlapgridDestructionLock(MasterMixin, unittest.TestCase): if specifying a retention lock delay. """ computer = ComputerForTest(self.software_root, self.instance_root) - instance = computer.instance_list[0] - instance.requested_state = 'started' - instance.filter_dict = {'retention_delay': 1.0 / (3600 * 24)} - self.grid.processComputerPartitionList() - dummy_instance_file_path = os.path.join(instance.partition_path, 'dummy') - with open(dummy_instance_file_path, 'w') as dummy_instance_file: - dummy_instance_file.write('dummy') - - self.assertTrue(os.path.exists(os.path.join( - instance.partition_path, - slapos.grid.SlapObject.Partition.retention_lock_delay_filename - ))) - - instance.requested_state = 'destroyed' - self.grid.agregateAndSendUsage() - self.assertTrue(os.path.exists(dummy_instance_file_path)) - self.assertTrue(os.path.exists(os.path.join( - instance.partition_path, - slapos.grid.SlapObject.Partition.retention_lock_date_filename - ))) - - self.grid.agregateAndSendUsage() - self.assertTrue(os.path.exists(dummy_instance_file_path)) - - time.sleep(1) - self.grid.agregateAndSendUsage() - self.assertFalse(os.path.exists(dummy_instance_file_path)) + with httmock.HTTMock(computer.request_handler): + instance = computer.instance_list[0] + instance.requested_state = 'started' + instance.filter_dict = {'retention_delay': 1.0 / (3600 * 24)} + self.grid.processComputerPartitionList() + dummy_instance_file_path = os.path.join(instance.partition_path, 'dummy') + with open(dummy_instance_file_path, 'w') as dummy_instance_file: + dummy_instance_file.write('dummy') + + self.assertTrue(os.path.exists(os.path.join( + instance.partition_path, + slapos.grid.SlapObject.Partition.retention_lock_delay_filename + ))) + + instance.requested_state = 'destroyed' + self.grid.agregateAndSendUsage() + self.assertTrue(os.path.exists(dummy_instance_file_path)) + self.assertTrue(os.path.exists(os.path.join( + instance.partition_path, + slapos.grid.SlapObject.Partition.retention_lock_date_filename + ))) + + self.grid.agregateAndSendUsage() + self.assertTrue(os.path.exists(dummy_instance_file_path)) + + time.sleep(1) + self.grid.agregateAndSendUsage() + self.assertFalse(os.path.exists(dummy_instance_file_path)) + diff --git a/slapos/tests/slapmock/httplib.py b/slapos/tests/slapmock/httplib.py deleted file mode 100644 index be9fbaa536e815c66dfa1bc2ab76920296a2d313..0000000000000000000000000000000000000000 --- a/slapos/tests/slapmock/httplib.py +++ /dev/null @@ -1,123 +0,0 @@ -#!/usr/bin/env python2 -# -*- coding: utf-8 -*- -"""Mocked httplib -""" - -__all__ = [] - -def log(message): - """Need to be overridden to get a proper logger - """ - pass - -class HTTPConnection(object): - - scheme = 'http' - - def _callback(self, path, method, body, headers): - """To get it works properly, you need to override - HTTPConnection._callback. This method received the instance, the path, - method and request body as parameter, and it has to return a tuple with - headers dictionary and body response string. - - @param self object instance reference - @param URL the parsed URL - @param method the http method - @param body the request body - @param headers the request headers - - @return tuple containing status integer, headers dictionary and body - response""" - return (0, {}, '', ) - - def __init__(self, host, port=None, strict=None, - timeout=None, source_address=None): - self.host = host - self.port = port - self.strict = strict - self.timeout = timeout - self.source_address = source_address - self.__response = None - - def request(self, method, url, body=None, headers=None): - status, headers, body = self._callback(url, method, body, headers) - self.__response = HTTPResponse('HTTP/1.1', status, 'OK', body, headers) - - - def getresponse(self): - response = self.__response - self.__response = None - return response - - def set_debuglevel(self, level): - pass - - def set_tunnel(self, host, port=None, headers=None): - pass - - def connect(self): - pass - - def close(self): - pass - - def putrequest(self, request, selector, skip_host=None, - skip_accept_encoding=None): - pass - - def putheader(self, *args): - pass - - def endheaders(self): - pass - - def send(self, data): - pass - -class HTTPSConnection(HTTPConnection): - - def __init__(self, host, port=None, key_file=None, - cert_file=None, strict=None, timeout=None, - source_address=None): - super(HTTPSConnection, self).__init__(host, port, strict, timeout, - source_address) - self.certificate = open(cert_file, 'r').read() - self.key = open(key_file, 'r').read() - - def request(self, method, url, body=None, headers=None): - headers['certificate'] = self.certificate - headers['key'] = self.key - status, headers, body = self._callback(url, method, body, headers) - self.__response = HTTPResponse('HTTP/1.1', status, 'OK', body, headers) - - def getresponse(self): - response = self.__response - self.__response = None - return response - - -class HTTPResponse(object): - - def __init__(self, version, status, reason, content, headers=()): - self.version = version - self.status = status - self.reason = reason - self.__headers = headers - self.__content = content - - def read(self, amt=None): - result = None - if amt is None: - result = self.__content - self.__content = '' - else: - end = max(amt, len(self.__content)) - result = self.__content[:end] - del self.__content[:end] - return result - - def getheader(self, name, default=None): - pass - - def getheaders(self): - pass diff --git a/slapos/tests/slapmock/requests.py b/slapos/tests/slapmock/requests.py new file mode 100644 index 0000000000000000000000000000000000000000..19ecb1bd9236c89d69c0b749c55c679876afeb3d --- /dev/null +++ b/slapos/tests/slapmock/requests.py @@ -0,0 +1,8 @@ +# -*- coding: utf-8 -*- + +def response_ok(url, request): + return { + 'status_code': 200, + 'content': '' + } + diff --git a/slapos/tests/slapproxy/__init__.py b/slapos/tests/slapproxy/__init__.py index d95e6fe1d6d6469405b61a4fcbe2b6616a411a8d..a26e102bdb12286df0c73b92168f465a61d0ae4b 100644 --- a/slapos/tests/slapproxy/__init__.py +++ b/slapos/tests/slapproxy/__init__.py @@ -968,7 +968,7 @@ database_uri = %(tempdir)s/lib/external_proxy.db 'xml': xml_marshaller.xml_marshaller.dumps(computer_dict), } self.external_proxy_slap._connection_helper.POST('/loadComputerConfigurationFromXML', - parameter_dict=request_dict) + data=request_dict) def _checkInstanceIsFowarded(self, name, partition_parameter_kw, software_release): """