slapos_*: Bootstrap caucase server/connector

  Only launch caucase when needed.  Not all tests need
  caucase, this saves a bit the overhead to run it

master/bt5/slapos_accounting/TestTemplateItem/portal_components/test.erp5.testSlapOSAccountingBuilder.py

@@ -13,6 +13,7 @@ def convertCategoryList(base, l):
 
 
 class TestSlapOSBuilderMixin(SlapOSTestCaseMixin):
+  launch_caucase = 1
 
   def checkSimulationMovement(self, simulation_movement):
     self.assertEqual(1.0, simulation_movement.getDeliveryRatio())

master/bt5/slapos_accounting/TestTemplateItem/portal_components/test.erp5.testSlapOSAccountingRule.py

@@ -28,6 +28,8 @@ def getSimulationStatePlannedDelivered(self, *args, **kwargs):
   return 'planned'
 
 class TestDefaultInvoiceTransactionRule(SlapOSTestCaseMixin):
+  launch_caucase = 1
+
   @withAbort
   def test_simulation(self):
     SimulationMovement.original_getSimulationState = SimulationMovement\
@@ -169,6 +171,8 @@ class TestDefaultInvoiceTransactionRule(SlapOSTestCaseMixin):
 
 
 class TestDefaultInvoiceRule(SlapOSTestCaseMixin):
+  launch_caucase = 1
+  
   @withAbort
   def test_simulation(self):
     SimulationMovement.original_getSimulationState = SimulationMovement\
@@ -249,6 +253,8 @@ class TestDefaultInvoiceRule(SlapOSTestCaseMixin):
 
 
 class TestDefaultInvoicingRule(SlapOSTestCaseMixin):
+  launch_caucase = 1
+
   @withAbort
   def test_simulation(self):
     SimulationMovement.original_getSimulationState = SimulationMovement\
@@ -381,6 +387,8 @@ class TestDefaultInvoicingRule(SlapOSTestCaseMixin):
         .original_getSimulationState
 
 class TestDefaultPaymentRule(SlapOSTestCaseMixin):
+  launch_caucase = 1
+
   @withAbort
   def test_simulation(self):
     SimulationMovement.original_getSimulationState = SimulationMovement\
@@ -856,6 +864,7 @@ class TestDefaultTradeModelRule(SlapOSTestCaseMixin):
         .original_getSimulationState
 
 class TestDefaultDeliveryRule(SlapOSTestCaseMixin):
+  launch_caucase = 1
 
   def test(self):
     resource, _, _, _, _, aggregate = self.bootstrapAllocableInstanceTree(is_accountable=True)
@@ -949,6 +958,8 @@ class TestDefaultDeliveryRule(SlapOSTestCaseMixin):
         for q in simulation_movement.contentValues(portal_type='Applied Rule')])
 
 class TestDefaultDeliveryRuleConsumption(SlapOSTestCaseMixin):
+  launch_caucase = 1
+
   def test(self):
     resource, _, _, _, _, aggregate = self.bootstrapAllocableInstanceTree(is_accountable=True)
     project = aggregate.getFollowUpValue()

master/bt5/slapos_accounting/TestTemplateItem/portal_components/test.erp5.testSlapOSConsumptionSkins.py

@@ -257,6 +257,8 @@ class TestSlapOSComputerConsumptionTioXMLFile_parseXml(SlapOSTestCaseMixinWithAb
 class TestSlapOSComputerConsumptionTioXMLFile_solveInvoicingGeneration(
                                                            SlapOSTestCaseMixin):
 
+  launch_caucase = 1
+
   def createTioXMLFile(self):
     document = self.portal.consumption_document_module.newContent(
       title=self.generateNewId(),

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.SlapOSTestCaseDefaultScenarioMixin.py

@@ -30,6 +30,8 @@ from AccessControl.SecurityManagement import getSecurityManager, \
 
 class DefaultScenarioMixin(TestSlapOSSecurityMixin):
 
+  launch_caucase = 1
+
   def afterSetUp(self):
     TestSlapOSSecurityMixin.afterSetUp(self)
     preference = self.portal.portal_preferences.slapos_default_system_preference

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloud.py

@@ -44,6 +44,8 @@ def hashData(data):
 class TestSlapOSCloudSlapOSCacheMixin(
     SlapOSTestCaseMixin):
 
+  launch_caucase = 1
+
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
     self.pinDateTime(DateTime())
@@ -375,6 +377,8 @@ class TestSlapOSCloudSlapOSCacheMixin(
 class TestSlapOSCloudSoftwareInstance(
     SlapOSTestCaseMixin):
 
+  launch_caucase = 1
+
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
     self.project = self.addProject()
@@ -496,6 +500,7 @@ class TestSlapOSCloudSoftwareInstance(
 
 class TestSlapOSCloudSlapOSComputeNodeMixin_getCacheComputeNodeInformation(
       SlapOSTestCaseMixin):
+  launch_caucase = 1
 
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
@@ -705,4 +710,3 @@ class TestSlapOSCloudSlapOSComputeNodeMixin_getCacheComputeNodeInformation(
     self.assertEqual(fourth_body_fingerprint, hashData(body))
     self.assertEqual(0, len(self.portal.portal_activities.getMessageList()))
 
-

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloudAlarm.py

@@ -7,6 +7,7 @@ from erp5.component.module.DateUtils import addToDate
 
 
 class TestSlapOSCoreSlapOSAssertInstanceTreeSuccessorAlarm(SlapOSTestCaseMixin):
+  launch_caucase = 1
   #################################################################
   # slapos_assert_instance_tree_successor
   #################################################################
@@ -115,6 +116,7 @@ class TestSlapOSCoreSlapOSAssertInstanceTreeSuccessorAlarm(SlapOSTestCaseMixin):
 
 class TestSlapOSFreeComputePartitionAlarm(SlapOSTestCaseMixin):
 
+  launch_caucase = 1
   #################################################################
   # slapos_free_compute_partition
   #################################################################
@@ -353,6 +355,7 @@ class TestSlapOSFreeComputePartitionAlarm(SlapOSTestCaseMixin):
 
 
 class TestSlapOSGarbageCollectDestroyedRootTreeAlarm(SlapOSTestCaseMixin):
+  launch_caucase = 1
   #################################################################
   # slapos_garbage_collect_destroyed_root_tree
   #################################################################
@@ -470,6 +473,7 @@ class TestSlapOSGarbageCollectDestroyedRootTreeAlarm(SlapOSTestCaseMixin):
 
 
 class TestSlapOSUpdateComputeNodeCapacityScopeAlarm(SlapOSTestCaseMixin):
+  launch_caucase = 1 
   #################################################################
   # slapos_update_compute_node_capacity_scope
   #################################################################
@@ -700,6 +704,7 @@ class TestSlapOSUpdateComputeNodeCapacityScopeAlarm(SlapOSTestCaseMixin):
 
 
 class TestSlapOSGarbageCollectStoppedRootTreeAlarm(SlapOSTestCaseMixin):
+  launch_caucase = 1 
   #################################################################
   # slapos_stop_collect_instance
   #################################################################
@@ -766,6 +771,7 @@ class TestSlapOSGarbageCollectStoppedRootTreeAlarm(SlapOSTestCaseMixin):
 
 
 class TestSlapOSGarbageCollectNonAllocatedRootTreeAlarm(SlapOSTestCaseMixin):
+  launch_caucase = 1 
   #################################################################
   # slapos_garbage_collect_non_allocated_root_tree
   #################################################################
@@ -980,6 +986,7 @@ class TestSlapOSGarbageCollectNonAllocatedRootTreeAlarm(SlapOSTestCaseMixin):
 
 
 class TestSlapOSInvalidateDestroyedInstance(SlapOSTestCaseMixin):
+  launch_caucase = 1 
   #################################################################
   # slapos_cloud_invalidate_destroyed_instance
   #################################################################
@@ -1157,6 +1164,8 @@ class TestSlapOSInvalidateDestroyedInstance(SlapOSTestCaseMixin):
 
 
 class TestSlapOSPropagateRemoteNodeInstance(SlapOSTestCaseMixin):
+  launch_caucase = 1
+
   #################################################################
   # slapos_cloud_propagate_remote_node_instance
   #################################################################

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloudAllocationAlarm.py

@@ -6,6 +6,8 @@ from unittest import skip
 
 class TestSlapOSAllocation(SlapOSTestCaseMixin):
 
+  launch_caucase = 1
+
   def makeAllocableComputeNode(self, project, software_product,
                                release_variation, type_variation):
     with TemporaryAlarmScript(self.portal, 'SoftwareInstance_tryToAllocatePartition'):

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloudComputeNodeSlapInterfaceWorkflow.py

@@ -21,9 +21,13 @@
 from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin
 import transaction
 from Products.ERP5Type.Errors import UnsupportedWorkflowMethod
-
+from cryptography import x509
+from cryptography.x509.oid import NameOID
 
 class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
+
+  launch_caucase = 1
+
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
     self.project = self.addProject()
@@ -44,6 +48,14 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     self.portal.REQUEST['compute_node_key'] = None
     self.portal.REQUEST['compute_node_certificate'] = None
 
+  def _getCommonNameList(self, ssl_certificate):
+    cn_list = [i.value for i in ssl_certificate.subject \
+                 if i.oid == NameOID.COMMON_NAME and i.value != "erp5-user"]
+
+    self.assertEqual(len(cn_list), 1)
+    return cn_list[0]
+
+
   def test_generateCertificate(self):
     self.login(self.compute_node.getUserId())
     self.compute_node.generateCertificate()
@@ -56,10 +68,15 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     certificate_login = certificate_login_list[0]
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
+
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
+ 
+    # TODO: Should we check for csr_id
+    # self.assertTrue(certificate_login.getCsrId() in compute_node_certificate)
 
   def test_generateCertificate_twice(self):
     self.login(self.compute_node.getUserId())
@@ -68,17 +85,22 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     compute_node_certificate = self.portal.REQUEST.get('compute_node_certificate')
     self.assertNotEqual(None, compute_node_key)
     self.assertNotEqual(None, compute_node_certificate)
-    self.assertEqual(None, self.compute_node.getDestinationReference())
+    self.assertEqual(None, self.compute_node.getSourceReference())
 
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
     self.assertEqual(len(certificate_login_list), 1)
     certificate_login = certificate_login_list[0]
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
+
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
+ 
+    # TODO: Should we check for csr_id
+    # self.assertTrue(certificate_login.getCsrId() in compute_node_certificate)
     
     self.assertRaises(ValueError, self.compute_node.generateCertificate)
     self.assertEqual(None, self.portal.REQUEST.get('compute_node_key'))
@@ -270,10 +292,16 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     certificate_login = certificate_login_list[0]
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
+
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
+ 
+    # TODO: Should we check for csr_id
+    # self.assertTrue(certificate_login.getCsrId() in compute_node_certificate)
+    
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
 
@@ -288,7 +316,7 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     self.assertRaises(ValueError, self.compute_node.revokeCertificate)
     self.assertEqual(None, self.portal.REQUEST.get('compute_node_key'))
     self.assertEqual(None, self.portal.REQUEST.get('compute_node_certificate'))
-    self.assertEqual(None, self.compute_node.getDestinationReference())
+    self.assertEqual(None, self.compute_node.getSourceReference())
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
     self.assertEqual(len(certificate_login_list), 0)
 
@@ -304,13 +332,18 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     certificate_login = certificate_login_list[0]
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
 
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
+ 
+    # TODO: Should we check for csr_id
+    #self.assertTrue(certificate_login.getCsrId() in compute_node_certificate)
+
     self.compute_node.revokeCertificate()
     self.assertEqual(None, self.portal.REQUEST.get('compute_node_key'))
     self.assertEqual(None, self.portal.REQUEST.get('compute_node_certificate'))
@@ -335,17 +368,22 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
     self.assertEqual(len(certificate_login_list), 1)
     certificate_login = certificate_login_list[0]
-    destination_reference = certificate_login.getDestinationReference()
+    source_reference = certificate_login.getCsrId()
 
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
-    self.assertNotEqual(None, destination_reference)
+
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
+ 
+    # TODO: Should we check for csr_id
+    #self.assertTrue(certificate_login.getCsrId() in compute_node_certificate)
+    self.assertNotEqual(None, source_reference)
 
     self.compute_node.revokeCertificate()
     self.compute_node.generateCertificate()
@@ -356,7 +394,7 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     self.assertNotEqual(compute_node_certificate, self.portal.REQUEST.get('compute_node_certificate'))
 
     self.assertEqual(certificate_login.getValidationState(), 'invalidated')
-    self.assertEqual(certificate_login.getDestinationReference(), destination_reference)
+    self.assertEqual(certificate_login.getCsrId(), source_reference)
     self.assertNotEqual(certificate_login.getReference(), None)
 
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
@@ -364,21 +402,25 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     new_certificate_login = [i for i in certificate_login_list \
       if i.getId() != certificate_login.getId()][0]
     
-    destination_reference = certificate_login.getDestinationReference()
+    source_reference = certificate_login.getCsrId()
     self.assertEqual(new_certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(new_certificate_login.getReference(), None)
     self.assertNotEqual(new_certificate_login.getReference(),
       certificate_login.getReference())
   
-    self.assertNotEqual(new_certificate_login.getDestinationReference(), None)
-    self.assertNotEqual(new_certificate_login.getDestinationReference(),
-      certificate_login.getDestinationReference())
-    serial = '0x%x' % int(new_certificate_login.getDestinationReference(), 16)
-
+    self.assertNotEqual(new_certificate_login.getCsrId(), None)
+    self.assertNotEqual(new_certificate_login.getCsrId(),
+      certificate_login.getCsrId())
     compute_node_certificate = self.portal.REQUEST.get('compute_node_certificate')
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(new_certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
-    self.assertNotIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = [i.value for i in ssl_certificate.subject if i.oid == NameOID.COMMON_NAME][-1]
+    self.assertEqual(new_certificate_login.getReference().decode("UTF-8"), cn)
+    self.assertNotEqual(certificate_login.getReference().decode("UTF-8"), cn)
+
+    # TODO: Should we check for csr_id
+    #self.assertIn(certificate_login.getCsrId(), compute_node_certificate)
     
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
@@ -394,17 +436,19 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
     self.assertEqual(len(certificate_login_list), 1)
     certificate_login = certificate_login_list[0]
-    destination_reference = certificate_login.getDestinationReference()
+    source_reference = certificate_login.getCsrId()
 
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
+
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
-    self.assertNotEqual(None, destination_reference)
+    self.assertNotEqual(None, source_reference)
 
     self.compute_node.revokeCertificate()
     self.compute_node.generateCertificate()
@@ -415,7 +459,7 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     self.assertNotEqual(compute_node_certificate, self.portal.REQUEST.get('compute_node_certificate'))
 
     self.assertEqual(certificate_login.getValidationState(), 'invalidated')
-    self.assertEqual(certificate_login.getDestinationReference(), destination_reference)
+    self.assertEqual(certificate_login.getCsrId(), source_reference)
     self.assertNotEqual(certificate_login.getReference(), None)
 
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
@@ -423,22 +467,22 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     new_certificate_login = [i for i in certificate_login_list \
       if i.getId() != certificate_login.getId()][0]
     
-    destination_reference = certificate_login.getDestinationReference()
+    source_reference = certificate_login.getCsrId()
     self.assertEqual(new_certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(new_certificate_login.getReference(), None)
     self.assertNotEqual(new_certificate_login.getReference(),
       certificate_login.getReference())
   
-    self.assertNotEqual(new_certificate_login.getDestinationReference(), None)
-    self.assertNotEqual(new_certificate_login.getDestinationReference(),
-      certificate_login.getDestinationReference())
-    serial = '0x%x' % int(new_certificate_login.getDestinationReference(), 16)
-
+    self.assertNotEqual(new_certificate_login.getCsrId(), None)
+    self.assertNotEqual(new_certificate_login.getCsrId(),
+      certificate_login.getCsrId())
     compute_node_certificate = self.portal.REQUEST.get('compute_node_certificate')
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(new_certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
-    self.assertNotIn(certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
 
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(new_certificate_login.getReference().decode("UTF-8"), cn)
+    self.assertNotEqual(certificate_login.getReference().decode("UTF-8"), cn)
     self.assertNotEqual(certificate_login.getReference(),
                         self.compute_node.getReference())
 
@@ -451,7 +495,7 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     self.assertNotEqual(compute_node_certificate, self.portal.REQUEST.get('compute_node_certificate'))
 
     self.assertEqual(new_certificate_login.getValidationState(), 'invalidated')
-    self.assertNotEqual(new_certificate_login.getDestinationReference(), destination_reference)
+    self.assertNotEqual(new_certificate_login.getCsrId(), source_reference)
     self.assertNotEqual(new_certificate_login.getReference(), None)
 
     certificate_login_list = self.compute_node.objectValues(portal_type="Certificate Login")
@@ -460,22 +504,23 @@ class TestSlapOSCoreComputeNodeSlapInterfaceWorkflow(SlapOSTestCaseMixin):
     third_certificate_login = [i for i in certificate_login_list \
       if i.getId() not in [certificate_login.getId(), new_certificate_login.getId()]][0]
     
-    destination_reference = new_certificate_login.getDestinationReference()
+    source_reference = new_certificate_login.getCsrId()
     self.assertEqual(third_certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(third_certificate_login.getReference(), None)
     self.assertNotEqual(third_certificate_login.getReference(),
       certificate_login.getReference())
   
-    self.assertNotEqual(third_certificate_login.getDestinationReference(), None)
-    self.assertNotEqual(third_certificate_login.getDestinationReference(),
-      new_certificate_login.getDestinationReference())
-    serial = '0x%x' % int(third_certificate_login.getDestinationReference(), 16)
+    self.assertNotEqual(third_certificate_login.getCsrId(), None)
+    self.assertNotEqual(third_certificate_login.getCsrId(),
+      new_certificate_login.getCsrId())
 
     compute_node_certificate = self.portal.REQUEST.get('compute_node_certificate')
-    self.assertIn(serial, compute_node_certificate)
-    self.assertIn(third_certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
-    self.assertNotIn(new_certificate_login.getReference(), compute_node_certificate.decode('string_escape'))
 
+    ssl_certificate = x509.load_pem_x509_certificate(compute_node_certificate)
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = self._getCommonNameList(ssl_certificate)
+    self.assertEqual(third_certificate_login.getReference().decode("UTF-8"), cn)
+    self.assertNotEqual(new_certificate_login.getReference().decode("UTF-8"), cn)
     self.assertNotEqual(third_certificate_login.getReference(),
                         self.compute_node.getReference())
 

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloudInstanceSlapInterfaceWorkflow.py

@@ -22,11 +22,14 @@ from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin
 from erp5.component.document.SoftwareInstance import SoftwareInstance, \
   DisconnectedSoftwareTree, CyclicSoftwareTree
 import transaction
-
+from cryptography import x509
+from cryptography.x509.oid import NameOID
 
 class TestSlapOSCoreInstanceSlapInterfaceWorkflow(SlapOSTestCaseMixin):
   """Tests instance.requestInstance"""
   
+  launch_caucase = 1
+
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
     portal = self.getPortalObject()
@@ -1050,6 +1053,7 @@ class TestSlapOSCoreInstanceSlapInterfaceWorkflow(SlapOSTestCaseMixin):
 
 class TestSlapOSCoreInstanceSlapInterfaceWorkflowTransfer(SlapOSTestCaseMixin):
   """Tests instance.requestTransfer"""
+  launch_caucase = 1
 
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
@@ -1142,7 +1146,6 @@ class TestSlapOSCoreInstanceSlapInterfaceWorkflowTransfer(SlapOSTestCaseMixin):
     self.software_instance.generateCertificate()
     self.assertNotEqual(self.software_instance.getSslKey(), None)
     self.assertNotEqual(self.software_instance.getSslCertificate(), None)
-    self.assertEqual(self.software_instance.getDestinationReference(), None)
 
     certificate_login_list = self.software_instance.objectValues(portal_type="Certificate Login")
     self.assertEqual(len(certificate_login_list), 1)
@@ -1150,11 +1153,11 @@ class TestSlapOSCoreInstanceSlapInterfaceWorkflowTransfer(SlapOSTestCaseMixin):
 
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
-    serial = '0x%x' % int(certificate_login.getDestinationReference(), 16)
-    self.assertIn(serial, self.software_instance.getSslCertificate())
-    self.assertIn(certificate_login.getReference(), \
-       self.software_instance.getSslCertificate().decode('string_escape'))
+    self.assertNotEqual(certificate_login.getCsrId(), None)
+    ssl_certificate = x509.load_pem_x509_certificate(self.software_instance.getSslCertificate())
+    self.assertEqual(len(ssl_certificate.subject), 2)
+    cn = [i.value for i in ssl_certificate.subject if i.oid == NameOID.COMMON_NAME][0]
+    self.assertEqual(certificate_login.getReference().decode("UTF-8"), cn)
     self.assertRaises(ValueError, self.software_instance.generateCertificate)
 
   def test_revokeCertificate(self):
@@ -1183,7 +1186,7 @@ class TestSlapOSCoreInstanceSlapInterfaceWorkflowTransfer(SlapOSTestCaseMixin):
     certificate_login = certificate_login_list[0]
     self.assertEqual(certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(certificate_login.getReference(), None)
-    self.assertNotEqual(certificate_login.getDestinationReference(), None)
+    self.assertNotEqual(certificate_login.getCsrId(), None)
 
     self.assertNotEqual(self.software_instance.getSslKey(),
       ssl_key)
@@ -1210,12 +1213,11 @@ class TestSlapOSCoreInstanceSlapInterfaceWorkflowTransfer(SlapOSTestCaseMixin):
 
     self.assertEqual(another_certificate_login.getValidationState(), 'validated')
     self.assertNotEqual(another_certificate_login.getReference(), None)
-    self.assertNotEqual(another_certificate_login.getDestinationReference(), None)
+    self.assertNotEqual(another_certificate_login.getCsrId(), None)
 
     self.assertEqual(certificate_login.getValidationState(), 'invalidated')
     self.assertNotEqual(certificate_login.getReference(),
       another_certificate_login.getReference())
-    self.assertNotEqual(certificate_login.getDestinationReference(),
-      another_certificate_login.getDestinationReference())
-
+    self.assertNotEqual(certificate_login.getCsrId(),
+      another_certificate_login.getCsrId())
 

master/bt5/slapos_cloud/TestTemplateItem/portal_components/test.erp5.testSlapOSCloudPersonSlapInterfaceWorkflow.py

@@ -25,6 +25,7 @@ from AccessControl.SecurityManagement import getSecurityManager, \
 
 class TestSlapOSCorePersonRequest(SlapOSTestCaseMixin):
 
+  launch_caucase = 1
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
 

master/bt5/slapos_crm/TestTemplateItem/portal_components/test.erp5.testSlapOSCRMAlarm.py

@@ -1032,6 +1032,7 @@ class TestSlapOSCrmStopInstanceTree(SlapOSTestCaseMixinWithAbort):
 
 
 class TestSlapOSCrmDeleteInstanceTree(SlapOSTestCaseMixinWithAbort):
+  launch_caucase = 1
 
   def createRegularisationRequest(self):
     new_id = self.generateNewId()
@@ -1253,6 +1254,7 @@ class TestSlapOSCrmDeleteInstanceTree(SlapOSTestCaseMixinWithAbort):
 
 
 class TestSlapOSCrmMonitoringCheckComputeNodeState(SlapOSTestCaseMixinWithAbort):
+  launch_caucase = 1
 
   #################################################################
   # slapos_crm_check_compute_node_state
@@ -1529,6 +1531,8 @@ class TestSlapOSCrmMonitoringCheckComputeNodeState(SlapOSTestCaseMixinWithAbort)
 
 class TestSlapOSCrmMonitoringCheckComputeNodeSoftwareInstallation(SlapOSTestCaseMixinWithAbort):
 
+  launch_caucase = 1
+
   #################################################################
   # slapos_crm_check_software_installation_state
   #################################################################
@@ -1771,6 +1775,7 @@ class TestSlapOSCrmMonitoringCheckComputeNodeSoftwareInstallation(SlapOSTestCase
 
 
 class TestSlapOSCrmMonitoringCheckInstanceInError(SlapOSTestCaseMixinWithAbort):
+  launch_caucase = 1
 
   def _makeInstanceTree(self):
     person = self.portal.person_module\

master/bt5/slapos_crm/TestTemplateItem/portal_components/test.erp5.testSlapOSCRMSkins.py

@@ -108,9 +108,12 @@ class TestCRMSkinsMixin(SlapOSTestCaseMixinWithAbort):
     return software_installation
 
 class TestSlapOSSupportRequestModule_getMonitoringUrlList(TestCRMSkinsMixin):
+  launch_caucase = 1
 
   def test_SupportRequestModule_getMonitoringUrlList(self):
     module = self.portal.support_request_module
+    # Tic to ensure caucase is indexed
+    self.tic()
     # We assume here that several objects created by others tests don't influentiate
     # this test.
     self.assertEqual(module.SupportRequestModule_getMonitoringUrlList(), [])

master/bt5/slapos_jio/TestTemplateItem/portal_components/test.erp5.testSlapOSHalJsonStyleSkins.py

@@ -543,6 +543,7 @@ class TestPerson_newLogin(TestSlapOSHalJsonStyleMixin):
     self.assertIn(person.getRelativeUrl(), result)
     
 class TestPerson_get_Certificate(TestSlapOSHalJsonStyleMixin):
+  launch_caucase = 1
   def test_Person_getCertificate_unauthorized(self):
     person = self._makePerson(user=1)
     self.assertEqual(1 , len(person.objectValues(portal_type="ERP5 Login")))
@@ -562,7 +563,7 @@ class TestPerson_get_Certificate(TestSlapOSHalJsonStyleMixin):
 
     self.assertSameSet(response_dict.keys(), ["common_name", "certificate", "id", "key"])
 
-    self.assertEqual(response_dict["id"], login.getDestinationReference())
+    self.assertEqual(response_dict["id"], login.getCsrId())
     self.assertEqual(json.dumps(response_dict["common_name"]), json.dumps(login.getReference()))
     self.assertEqual(self.portal.REQUEST.RESPONSE.getStatus(), 200)
 
@@ -576,11 +577,11 @@ class TestPerson_get_Certificate(TestSlapOSHalJsonStyleMixin):
     self.assertEqual("validated" , login.getValidationState())
     self.assertEqual("validated" , new_login.getValidationState())
     self.assertNotEqual(login.getReference(), new_login.getReference())
-    self.assertNotEqual(login.getDestinationReference(), new_login.getDestinationReference())
+    self.assertNotEqual(login.getCsrId(), new_login.getCsrId())
 
     self.assertSameSet(new_response_dict.keys(), ["common_name", "certificate", "id", "key"])
     self.assertEqual(json.dumps(new_response_dict["common_name"]), json.dumps(new_login.getReference()))
-    self.assertEqual(new_response_dict["id"], new_login.getDestinationReference())
+    self.assertEqual(new_response_dict["id"], new_login.getCsrId())
     
     self.assertNotEqual(new_response_dict["common_name"], response_dict["common_name"])
     self.assertNotEqual(new_response_dict["id"], response_dict["id"])
@@ -645,6 +646,7 @@ class TestERP5Site_invalidate(TestSlapOSHalJsonStyleMixin):
 
 
 class TestComputeNode_get_revoke_Certificate(TestSlapOSHalJsonStyleMixin):
+  launch_caucase = 1
   def test_ComputeNode_getCertificate(self):
     compute_node = self._makeComputeNode()
     self.assertEqual(0, len(compute_node.objectValues(portal_type=["ERP5 Login", "Certificate Login"])))
@@ -1517,6 +1519,8 @@ return []""")
 
 class TestSoftwareInstance_getAllocationInformation(TestSlapOSHalJsonStyleMixin): 
 
+  launch_caucase = 1
+
   def test_SoftwareInstance_getAllocationInformation_not_allocated(self):
     self._makeTree()
     self.changeSkin('RJS')

master/bt5/slapos_jio_ui_test/TestTemplateItem/portal_components/test.erp5.testFunctionalSlapOSUIHalStyle.py

@@ -32,6 +32,7 @@ from Products.ERP5Type.tests.ERP5TypeFunctionalTestCase import ERP5TypeFunctiona
 class TestSlapOSUIHalStyle(SlapOSTestCaseMixin, ERP5TypeFunctionalTestCase):
   foreground = 0
   run_only = "slaposjs_zuite"
+  launch_caucase = 1
 
   def afterSetUp(self):
     ERP5TypeFunctionalTestCase.afterSetUp(self)

master/bt5/slapos_jio_ui_test/TestTemplateItem/portal_components/test.erp5.testFunctionalSlapOSUIZHHalStyle.py

@@ -32,6 +32,7 @@ from Products.ERP5Type.tests.ERP5TypeFunctionalTestCase import ERP5TypeFunctiona
 class TestSlapOSUIZHHalStyle(SlapOSTestCaseMixin, ERP5TypeFunctionalTestCase):
   foreground = 0
   run_only = "slaposjs_zuite"
+  launch_caucase = 1
 
   def afterSetUp(self):
     ERP5TypeFunctionalTestCase.afterSetUp(self)

master/bt5/slapos_panel_ui_test/TestTemplateItem/portal_components/test.erp5.testFunctionalSlapOSPanelStyle.py

@@ -32,6 +32,7 @@ from Products.ERP5Type.tests.ERP5TypeFunctionalTestCase import ERP5TypeFunctiona
 class TestSlapOSPanelStyle(SlapOSTestCaseMixin, ERP5TypeFunctionalTestCase):
   foreground = 0
   run_only = "slapos_panel_zuite"
+  launch_caucase = 1
 
   def afterSetUp(self):
     ERP5TypeFunctionalTestCase.afterSetUp(self)

master/bt5/slapos_pdm/TestTemplateItem/portal_components/test.erp5.testSlapOSPDMCreateUpgradeDecisionSkins.py

@@ -23,6 +23,8 @@ from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin
 
 class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
+  launch_caucase = 1
+
   def test_createUpgradeDecision_destroyed_instance(self):
     instance_tree = self.portal.instance_tree_module.newContent(
       portal_type="Instance Tree"

master/bt5/slapos_pdm/TestTemplateItem/portal_components/test.erp5.testSlapOSPDMDestroySoftwareInstallation.py

@@ -22,6 +22,7 @@
 from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin
 
 class TestSlapOSDestroySoftwareInstallation(SlapOSTestCaseMixin):
+  launch_caucase = 1
 
   def bootstrapSoftwareInstallation(self, is_allocated=True, is_supplied=True):
     if is_allocated:

master/bt5/slapos_pdm/TestTemplateItem/portal_components/test.erp5.testSlapOSPDMSkins.py

@@ -22,6 +22,7 @@
 from erp5.component.test.SlapOSTestCaseMixin import SlapOSTestCaseMixin
 
 class TestSlapOSPDMSkins(SlapOSTestCaseMixin):
+  launch_caucase = 1
 
   def test_requestUpgrade(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()

master/bt5/slapos_slap_tool/TestTemplateItem/portal_components/test.erp5.testSlapOSSlapTool.py

@@ -49,6 +49,7 @@ def canonical_xml(xml):
 
 
 class TestSlapOSSlapToolMixin(SlapOSTestCaseMixin):
+  launch_caucase = 1
   def afterSetUp(self):
     SlapOSTestCaseMixin.afterSetUp(self)
     self.portal_slap = self.portal.portal_slap

master/product/SlapOS/tests/testSlapOSMixin.py

@@ -30,6 +30,7 @@ import random
 import transaction
 import unittest
 from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
+from Products.ERP5Type.tests.ERP5TypeCaucaseTestCase import ERP5TypeCaucaseTestCase
 from Products.ERP5Type.Utils import convertToUpperCase
 import os
 import glob
@@ -40,9 +41,10 @@ from App.config import getConfiguration
 
 config = getConfiguration()
 
-class testSlapOSMixin(ERP5TypeTestCase):
+class testSlapOSMixin(ERP5TypeCaucaseTestCase):
 
   abort_transaction = 0
+  launch_caucase = 0
 
   def clearCache(self):
     self.portal.portal_caches.clearAllCache()
@@ -96,6 +98,8 @@ class testSlapOSMixin(ERP5TypeTestCase):
     self.portal.email_from_address = 'romain@nexedi.com'
     self.portal.email_to_address = 'romain@nexedi.com'
 
+    if not self.isLiveTest() and self.launch_caucase:
+      self.setUpCaucase()
 
     if getattr(self.portal.portal_caches, 'erp5_site_global_id', None):
       # we are not on live test so multiple tests can run in parallel
@@ -103,8 +107,6 @@ class testSlapOSMixin(ERP5TypeTestCase):
       self.portal.portal_caches.erp5_site_global_id = '%s' % random.random()
       self.portal.portal_caches._p_changed = 1
 
-    if self.isLiveTest():
-      return
     self.commit()
     self.portal.portal_caches.updateCache()