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