Testing: Standardise rule lifetimes #6505

The use of multiple values may bring into question why a particular
value has been chosen.  It seems preferable to standardise on two
possible values:

* By default, use `None`.  This implies that the rule lifetime has no
  effect on the test.
* When denoting an expired rule, use `-1`.

tests/test_api_external_representation.py

@@ -440,7 +440,7 @@ def test_api_subscription(self, vo, vo2):
                                     'source_replica_expression': self.rse4_name}],
                                   '', False, 0, 0, 3, 'root', vo=test_vo)
         add_replication_rule(dids=[{'scope': new_scope_name, 'name': did}], copies=1, rse_expression=self.rse3_name, weight=None,
-                             lifetime=180, grouping='DATASET', account=new_acc_name, locked=False, subscription_id=sub_id,
+                             lifetime=None, grouping='DATASET', account=new_acc_name, locked=False, subscription_id=sub_id,
                              source_replica_expression=self.rse4_name, activity='Functional Test', notify=None,
                              purge_replicas=False, ignore_availability=False, comment='', ask_approval=False, asynchronous=False,
                              delay_injection=None, priority=0, split_container=False, meta='', issuer='root', vo=test_vo)

tests/test_bb8.py

@@ -159,10 +159,10 @@ def test_bb8_full_workflow(vo, root_account, jdoe_account, rse_factory, mock_sco
 
     # Add one secondary file
     files = create_files(1, mock_scope, rse1_id, bytes_=1)
-    add_rule(dids=[{'scope': mock_scope, 'name': files[0]['name']}], account=jdoe_account, copies=1, rse_expression=rse1, grouping='DATASET', weight=None, lifetime=-86400, locked=False, subscription_id=None)[0]
+    add_rule(dids=[{'scope': mock_scope, 'name': files[0]['name']}], account=jdoe_account, copies=1, rse_expression=rse1, grouping='DATASET', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
     for cnt in range(3, tot_rses):
         add_replicas(rses[cnt][1], files, jdoe_account)
-        add_rule(dids=[{'scope': mock_scope, 'name': files[0]['name']}], account=jdoe_account, copies=1, rse_expression=rses[cnt][0], grouping='DATASET', weight=None, lifetime=-86400, locked=False, subscription_id=None)[0]
+        add_rule(dids=[{'scope': mock_scope, 'name': files[0]['name']}], account=jdoe_account, copies=1, rse_expression=rses[cnt][0], grouping='DATASET', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
     rule_cleaner(once=True)
 
     # Create dataset 1 of 800 GB and create a rule on RSE 1 and RSE 3
@@ -196,7 +196,7 @@ def test_bb8_full_workflow(vo, root_account, jdoe_account, rse_factory, mock_sco
     rules.append(rule_id)
 
     add_replicas(rse3_id, files, jdoe_account)
-    rule_id = add_rule(dids=[{'scope': mock_scope, 'name': dsn[2]}], account=jdoe_account, copies=1, rse_expression=rse3, grouping='DATASET', weight=None, lifetime=-86400, locked=False, subscription_id=None)[0]
+    rule_id = add_rule(dids=[{'scope': mock_scope, 'name': dsn[2]}], account=jdoe_account, copies=1, rse_expression=rse3, grouping='DATASET', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
     rule_cleaner(once=True)
     try:
         rule = get_rule(rule_id)
@@ -211,7 +211,7 @@ def test_bb8_full_workflow(vo, root_account, jdoe_account, rse_factory, mock_sco
     rules.append(rule_id)
 
     add_replicas(rse2_id, files, jdoe_account)
-    rule_id = add_rule(dids=[{'scope': mock_scope, 'name': dsn[3]}], account=jdoe_account, copies=1, rse_expression=rse2, grouping='DATASET', weight=None, lifetime=-86400, locked=False, subscription_id=None)[0]
+    rule_id = add_rule(dids=[{'scope': mock_scope, 'name': dsn[3]}], account=jdoe_account, copies=1, rse_expression=rse2, grouping='DATASET', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
     rule_cleaner(once=True)
     try:
         rule = get_rule(rule_id)
@@ -262,7 +262,7 @@ def test_bb8_full_workflow(vo, root_account, jdoe_account, rse_factory, mock_sco
             child_rule = get_rule(child_rule_id)
             assert (child_rule['rse_expression'] == rse2)
             # For teardown, delete child rule
-            update_rule(child_rule_id, {'lifetime': -86400})
+            update_rule(child_rule_id, {'lifetime': -1})
     rule_cleaner(once=True)
 
     for dataset in dsn:

tests/test_conveyor.py

@@ -176,15 +176,15 @@ def test_multihop_intermediate_replica_lifecycle(vo, did_factory, root_account,
     did = did_factory.upload_test_file(src_rse1_name)
 
     # Copy replica to a second source. To avoid the special case of having a unique last replica, which could be handled in a special (more careful) way
-    rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=src_rse2_name, grouping='ALL', weight=None, lifetime=3600, locked=False, subscription_id=None)
+    rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=src_rse2_name, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
     submitter(once=True, rses=[{'id': rse_id} for rse_id in all_rses], partition_wait_time=0, transfertype='single', filter_transfertool=None)
     replica = __wait_for_replica_transfer(dst_rse_id=src_rse2_id, **did)
     assert replica['state'] == ReplicaState.AVAILABLE
 
     rse_core.set_rse_limits(rse_id=jump_rse_id, name='MinFreeSpace', value=1)
     rse_core.set_rse_usage(rse_id=jump_rse_id, source='storage', used=1, free=0)
     try:
-        rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse_name, grouping='ALL', weight=None, lifetime=3600, locked=False, subscription_id=None)
+        rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse_name, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
 
         # Submit transfers to FTS
         # Ensure a replica was created on the intermediary host with epoch tombstone
@@ -575,7 +575,7 @@ def test_multihop_receiver_on_success(vo, did_factory, root_account, caches_mock
 
         did = did_factory.upload_test_file(src_rse)
         rule_priority = 5
-        rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=3600, locked=False, subscription_id=None, priority=rule_priority)
+        rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None, priority=rule_priority)
         submitter(once=True, rses=[{'id': rse_id} for rse_id in all_rses], group_bulk=2, partition_wait_time=0, transfertype='single', filter_transfertool=None)
 
         request = __wait_for_state_transition(dst_rse_id=jump_rse_id, run_poller=False, **did)
@@ -687,8 +687,8 @@ def test_preparer_throttler_submitter(rse_factory, did_factory, root_account, fi
 
     did1 = did_factory.upload_test_file(src_rse)
     did2 = did_factory.upload_test_file(src_rse)
-    rule_core.add_rule(dids=[did1], account=root_account, copies=1, rse_expression=dst_rse1, grouping='ALL', weight=None, lifetime=3600, locked=False, subscription_id=None)
-    rule_core.add_rule(dids=[did2], account=root_account, copies=1, rse_expression=dst_rse1, grouping='ALL', weight=None, lifetime=3600, locked=False, subscription_id=None)
+    rule_core.add_rule(dids=[did1], account=root_account, copies=1, rse_expression=dst_rse1, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
+    rule_core.add_rule(dids=[did2], account=root_account, copies=1, rse_expression=dst_rse1, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
     rule_core.add_rule(dids=[did1], account=root_account, copies=1, rse_expression=dst_rse2, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
 
     request = request_core.get_request_by_did(rse_id=dst_rse_id1, **did1)
@@ -757,9 +757,9 @@ def test_preparer_throttler_submitter(rse_factory, did_factory, root_account, fi
     did3 = did_factory.upload_test_file(src_rse)
     did4 = did_factory.upload_test_file(src_rse)
     rule_core.add_rule(dids=[did3], account=root_account, copies=1, rse_expression=dst_rse2, grouping='ALL',
-                       weight=None, lifetime=3600, locked=False, subscription_id=None)
+                       weight=None, lifetime=None, locked=False, subscription_id=None)
     rule_core.add_rule(dids=[did4], account=root_account, copies=1, rse_expression=dst_rse2, grouping='ALL',
-                       weight=None, lifetime=3600, locked=False, subscription_id=None)
+                       weight=None, lifetime=None, locked=False, subscription_id=None)
     request3 = request_core.get_request_by_did(rse_id=dst_rse_id2, **did3)
     request4 = request_core.get_request_by_did(rse_id=dst_rse_id2, **did4)
     assert request3['state'] == RequestState.PREPARING
@@ -891,7 +891,7 @@ def test_transfer_to_mas_existing_replica(rse_factory, did_factory, root_account
 
     did = did_factory.upload_test_file(rse_name=src_rse)
 
-    rule1_id = rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
+    rule1_id = rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)[0]
     request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
 
     assert request['request_type'] == RequestType.TRANSFER
@@ -912,7 +912,7 @@ def test_transfer_to_mas_existing_replica(rse_factory, did_factory, root_account
 
     # now test a second rule, different account
     set_local_account_limit(jdoe_account, dst_rse_id, bytes_=-1)
-    rule2_id = rule_core.add_rule(dids=[did], account=jdoe_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=-1, locked=False, subscription_id=None, source_replica_expression=dst_rse)[0]
+    rule2_id = rule_core.add_rule(dids=[did], account=jdoe_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None, source_replica_expression=dst_rse)[0]
     request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
 
     assert request['request_type'] == RequestType.STAGEIN
@@ -952,7 +952,7 @@ def test_failed_transfers_to_mas_existing_replica(rse_factory, did_factory, root
 
     did = did_factory.upload_test_file(rse_name=src_rse)
 
-    rule1_id = rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=-1, locked=False, subscription_id=None)[0]
+    rule1_id = rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)[0]
     request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
 
     assert request['request_type'] == RequestType.TRANSFER
@@ -973,7 +973,7 @@ def test_failed_transfers_to_mas_existing_replica(rse_factory, did_factory, root
 
     # now test a second rule, different account
     set_local_account_limit(jdoe_account, dst_rse_id, bytes_=-1)
-    rule2_id = rule_core.add_rule(dids=[did], account=jdoe_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=-1, locked=False, subscription_id=None, source_replica_expression=dst_rse)[0]
+    rule2_id = rule_core.add_rule(dids=[did], account=jdoe_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None, source_replica_expression=dst_rse)[0]
     request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
 
     # since the first rule is STUCK assert a transfer not stagein

tests/test_judge_cleaner.py

@@ -86,7 +86,7 @@ def test_judge_expire_rule(self):
         add_did(scope, dataset, DIDType.DATASET, self.jdoe)
         attach_dids(scope, dataset, files, self.jdoe)
 
-        add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='NONE', weight='fakeweight', lifetime=-3, locked=False, subscription_id=None)[0]
+        add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='NONE', weight='fakeweight', lifetime=-1, locked=False, subscription_id=None)[0]
         add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=2, rse_expression=self.T1, grouping='NONE', weight='fakeweight', lifetime=None, locked=False, subscription_id=None)[0]
         add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=3, rse_expression=self.T1, grouping='NONE', weight='fakeweight', lifetime=None, locked=False, subscription_id=None)[0]
 
@@ -105,7 +105,7 @@ def test_judge_expire_rule_with_child_rule(self):
         attach_dids(scope, dataset, files, self.jdoe)
 
         rule_id = add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='NONE', weight='fakeweight', lifetime=None, locked=False, subscription_id=None)[0]
-        child_rule = add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse3, grouping='NONE', weight='fakeweight', lifetime=-3, locked=False, subscription_id=None)[0]
+        child_rule = add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse3, grouping='NONE', weight='fakeweight', lifetime=-1, locked=False, subscription_id=None)[0]
         update_rule(rule_id, {'child_rule_id': child_rule})
 
         rule_cleaner(once=True)

tests/test_judge_injector.py

@@ -190,7 +190,7 @@ def test_add_rule_with_r2d2_container_treating(self):
             add_did(scope, dataset, DIDType.DATASET, self.jdoe)
             attach_dids(scope, dataset, files, self.jdoe)
             attach_dids(scope, container, [{'scope': scope, 'name': dataset}], self.jdoe)
-        rule_id = add_rule(dids=[{'scope': scope, 'name': container}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=900, locked=False, subscription_id=None, ask_approval=True)[0]
+        rule_id = add_rule(dids=[{'scope': scope, 'name': container}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=None, locked=False, subscription_id=None, ask_approval=True)[0]
         approve_rule(rule_id, approver=self.jdoe)
         assert (get_rule(rule_id)['state'] == RuleState.INJECT)
         rule_injector(once=True)
@@ -213,8 +213,8 @@ def test_add_rule_with_r2d2_container_treating_and_duplicate_rule(self):
             add_did(scope, dataset, DIDType.DATASET, self.jdoe)
             attach_dids(scope, dataset, files, self.jdoe)
             attach_dids(scope, container, [{'scope': scope, 'name': dataset}], self.jdoe)
-        add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=900, locked=False, subscription_id=None, ask_approval=False)
-        rule_id = add_rule(dids=[{'scope': scope, 'name': container}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=900, locked=False, subscription_id=None, ask_approval=True)[0]
+        add_rule(dids=[{'scope': scope, 'name': dataset}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=None, locked=False, subscription_id=None, ask_approval=False)
+        rule_id = add_rule(dids=[{'scope': scope, 'name': container}], account=self.jdoe, copies=1, rse_expression=self.rse1, grouping='DATASET', weight=None, lifetime=None, locked=False, subscription_id=None, ask_approval=True)[0]
         approve_rule(rule_id, approver=self.jdoe)
         assert (get_rule(rule_id)['state'] == RuleState.INJECT)
         rule_injector(once=True)

tests/test_rule.py

@@ -1466,11 +1466,11 @@ def test_change_rule_lifetime(self, mock_scope, did_factory, jdoe_account):
         add_did(did_type=DIDType.DATASET, account=jdoe_account, **dataset)
         attach_dids(dids=files, account=jdoe_account, **dataset)
 
-        rule_id_1 = add_rule(dids=[dataset], account=jdoe_account, copies=1, rse_expression=self.rse1, grouping='DATASET', weight='fakeweight', lifetime=150, locked=True, subscription_id=None)[0]
+        rule_id_1 = add_rule(dids=[dataset], account=jdoe_account, copies=1, rse_expression=self.rse1, grouping='DATASET', weight='fakeweight', lifetime=None, locked=True, subscription_id=None)[0]
 
         get = self.rule_client.get_replication_rule(rule_id_1)
 
-        self.rule_client.update_replication_rule(rule_id_1, options={'lifetime': 10000})
+        self.rule_client.update_replication_rule(rule_id_1, options={'lifetime': -1})
 
         get2 = self.rule_client.get_replication_rule(rule_id_1)
 
@@ -1483,7 +1483,7 @@ def test_approve_rule(self, mock_scope, did_factory, jdoe_account):
         add_did(did_type=DIDType.DATASET, account=jdoe_account, **dataset)
         attach_dids(dids=files, account=jdoe_account, **dataset)
 
-        rule_id = add_rule(dids=[dataset], account=jdoe_account, copies=1, rse_expression=self.rse1, grouping='DATASET', weight='fakeweight', lifetime=150, locked=True, subscription_id=None, ask_approval=True)[0]
+        rule_id = add_rule(dids=[dataset], account=jdoe_account, copies=1, rse_expression=self.rse1, grouping='DATASET', weight='fakeweight', lifetime=None, locked=True, subscription_id=None, ask_approval=True)[0]
         rule = self.rule_client.get_replication_rule(rule_id)
         assert rule['state'] == RuleState.WAITING_APPROVAL.name
         self.rule_client.approve_replication_rule(rule_id)