slapos_pdm: test: disable alarm when creating an allocation supply

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

@@ -68,10 +68,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_notAllocated_newReleaseOnComputeNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -81,10 +82,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newReleaseOnRemoteNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(node="remote")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -94,42 +96,46 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newReleaseOnInstanceNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state="impossible", node="instance")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for instance node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_notAllocated_sameRelease(self):
     software_product, release_variation, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     self.addAllocationSupply(
       "for compute node", compute_node, software_product,
-      release_variation, type_variation)
+      release_variation, type_variation, disable_alarm=True)
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_notAllocated_twoRelease(self):
     software_product, release_variation, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     self.addAllocationSupply(
       "for compute node", compute_node, software_product,
-      release_variation, type_variation)
+      release_variation, type_variation, disable_alarm=True)
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_notAllocated_newRelease_ongoingDecision(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -142,10 +148,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newRelease_ongoingDecisionActivity(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -158,10 +165,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newRelease_cancelledDecision(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     upgrade_decision = instance_tree.InstanceTree_createUpgradeDecision()
@@ -179,10 +187,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newRelease_rejectedDecisionSameRelease(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     upgrade_decision = instance_tree.InstanceTree_createUpgradeDecision()
@@ -197,10 +206,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_notAllocated_newRelease_rejectedDecisionAnotherRelease(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree()
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     supply = self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     upgrade_decision = instance_tree.InstanceTree_createUpgradeDecision()
@@ -214,7 +224,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
     new_release_variation2 = self._makeSoftwareRelease(software_product)
     supply = self.addAllocationSupply("for compute node 3", compute_node, software_product,
-                             new_release_variation2, type_variation)
+                             new_release_variation2, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -226,20 +236,22 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_sharedNotAllocated_newReleaseOnComputeNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(shared=True)
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_sharedNotAllocated_newReleaseOnRemoteNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(shared=True, node="remote")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -249,10 +261,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_sharedNotAllocated_newReleaseOnInstanceNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(shared=True, node="instance")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for instance node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -280,7 +293,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node2, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -290,7 +303,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -300,13 +313,14 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_allocatedOnComputeNode_twoRelease(self):
     software_product, release_variation, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated')
+    self.tic()
 
     self.addAllocationSupply(
       "for compute node", compute_node, software_product,
-      release_variation, type_variation)
+      release_variation, type_variation, disable_alarm=True)
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -316,10 +330,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_slaveAllocatedOnComputeNodeSameTree_newReleaseOnComputeNodeButNotTree(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True)
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -328,11 +343,12 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
     # A Slave Instance can not be the root instance and allocated on the same tree
     # at the same time
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True)
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
                              new_release_variation, type_variation,
-                             is_slave_on_same_instance_tree_allocable=True)
+                             is_slave_on_same_instance_tree_allocable=True, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -342,10 +358,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_allocatedOnRemoteNode_newReleaseOnRemoteNode(self):
     software_product, _, type_variation, remote_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', node="remote")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node", remote_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -355,19 +372,21 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_allocatedOnRemoteNode_twoRelease(self):
     software_product, release_variation, type_variation, remote_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', node="remote")
+    self.tic()
 
     self.addAllocationSupply(
       "for remote node", remote_node, software_product,
-      release_variation, type_variation)
+      release_variation, type_variation, disable_alarm=True)
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", remote_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_allocatedOnRemoteNode_newReleaseOnAnoterRemoteNode(self):
     software_product, _, type_variation, _, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', node="remote")
+    self.tic()
 
     project = instance_tree.getFollowUpValue()
     remote_node2 = self.portal.compute_node_module.newContent(
@@ -377,7 +396,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node 2", remote_node2, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -387,10 +406,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_slaveAllocatedOnRemoteNode_newReleaseOnComputeNode(self):
     software_product, _, type_variation, remote_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True, node="remote")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node", remote_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -400,19 +420,21 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
   def test_createUpgradeDecision_slaveAllocatedOnRemoteNode_twoRelease(self):
     software_product, release_variation, type_variation, remote_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True, node="remote")
+    self.tic()
 
     self.addAllocationSupply(
       "for remote node", remote_node, software_product,
-      release_variation, type_variation)
+      release_variation, type_variation, disable_alarm=True)
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node 2", remote_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
 
   def test_createUpgradeDecision_slaveAllocatedOnRemoteNode_newReleaseOnAnoterRemoteNode(self):
     software_product, _, type_variation, _, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True, node="remote")
+    self.tic()
 
     project = instance_tree.getFollowUpValue()
     remote_node2 = self.portal.compute_node_module.newContent(
@@ -422,7 +444,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for remote node 2", remote_node2, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())
@@ -432,10 +454,11 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
   ##########################################################################
   def test_createUpgradeDecision_slaveAllocatedOnInstanceNode_newReleaseOnInstanceNode(self):
     software_product, _, type_variation, compute_node, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True, node="instance")
+    self.tic()
 
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", compute_node, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.checkCreatedUpgradeDecision(
@@ -444,6 +467,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
     )
   def test_createUpgradeDecision_slaveAllocatedOnInstanceNode_newReleaseOnAnotherInstanceNode(self):
     software_product, _, type_variation, _, _, instance_tree = self.bootstrapAllocableInstanceTree(allocation_state='allocated', shared=True, node="instance")
+    self.tic()
 
     project = instance_tree.getFollowUpValue()
     instance_node2 = self.portal.compute_node_module.newContent(
@@ -452,7 +476,7 @@ class TestSlapOSPDMCreateUpgradeDecisionSkins(SlapOSTestCaseMixin):
     )
     new_release_variation = self._makeSoftwareRelease(software_product)
     self.addAllocationSupply("for compute node", instance_node2, software_product,
-                             new_release_variation, type_variation)
+                             new_release_variation, type_variation, disable_alarm=True)
     self.tic()
 
     self.assertEqual(None, instance_tree.InstanceTree_createUpgradeDecision())