DIRAC 9.0.0a42__py3-none-any.whl → 9.0.7__py3-none-any.whl

DIRAC/TransformationSystem/Service/TransformationManagerHandler.py

@@ -3,22 +3,12 @@
 import datetime
 
 from DIRAC import S_ERROR, S_OK
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.DISET.RequestHandler import RequestHandler
 from DIRAC.Core.Security.Properties import SecurityProperty
 from DIRAC.Core.Utilities.Decorators import deprecated
 from DIRAC.Core.Utilities.DEncode import ignoreEncodeWarning
 from DIRAC.Core.Utilities.JEncode import encode as jencode
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
-from DIRAC.RequestManagementSystem.Client.Operation import Operation
-from DIRAC.RequestManagementSystem.Client.Request import Request
-from DIRAC.TransformationSystem.Client import TransformationFilesStatus
-from DIRAC.WorkloadManagementSystem.Client import JobStatus
-
-TASKS_STATE_NAMES = ["TotalCreated", "Created"] + sorted(
-    set(JobStatus.JOB_STATES) | set(Request.ALL_STATES) | set(Operation.ALL_STATES)
-)
-FILES_STATE_NAMES = ["PercentProcessed", "Total"] + TransformationFilesStatus.TRANSFORMATION_FILES_STATES
 
 
 class TransformationManagerHandlerMixin:
@@ -530,39 +520,12 @@ class TransformationManagerHandlerMixin:
         """Set metadata to a file or to a directory (path)"""
         return cls.transformationDB.setMetadata(path, querydict)
 
-    ####################################################################
-    #
-    # These are the methods used for web monitoring
-    #
-
-    # TODO Get rid of this (talk to Matvey)
-    types_getDistinctAttributeValues = [str, dict]
-
-    @classmethod
-    def export_getDistinctAttributeValues(cls, attribute, selectDict):
-        res = cls.transformationDB.getTableDistinctAttributeValues("Transformations", [attribute], selectDict)
-        if not res["OK"]:
-            return res
-        return S_OK(res["Value"][attribute])
-
     types_getTableDistinctAttributeValues = [str, list, dict]
 
     @classmethod
     def export_getTableDistinctAttributeValues(cls, table, attributes, selectDict):
         return cls.transformationDB.getTableDistinctAttributeValues(table, attributes, selectDict)
 
-    types_getTransformationStatusCounters = []
-
-    @classmethod
-    def export_getTransformationStatusCounters(cls):
-        res = cls.transformationDB.getCounters("Transformations", ["Status"], {})
-        if not res["OK"]:
-            return res
-        statDict = {}
-        for attrDict, count in res["Value"]:
-            statDict[attrDict["Status"]] = count
-        return S_OK(statDict)
-
     types_getTransformationSummary = []
 
     def export_getTransformationSummary(self):
@@ -587,302 +550,6 @@ class TransformationManagerHandlerMixin:
             resultDict[transID] = transDict
         return S_OK(resultDict)
 
-    types_getTabbedSummaryWeb = [str, dict, dict, list, int, int]
-
-    def export_getTabbedSummaryWeb(self, table, requestedTables, selectDict, sortList, startItem, maxItems):
-        tableDestinations = {
-            "Transformations": {
-                "TransformationFiles": ["TransformationID"],
-                "TransformationTasks": ["TransformationID"],
-            },
-            "TransformationFiles": {
-                "Transformations": ["TransformationID"],
-                "TransformationTasks": ["TransformationID", "TaskID"],
-            },
-            "TransformationTasks": {
-                "Transformations": ["TransformationID"],
-                "TransformationFiles": ["TransformationID", "TaskID"],
-            },
-        }
-
-        tableSelections = {
-            "Transformations": ["TransformationID", "AgentType", "Type", "TransformationGroup", "Plugin"],
-            "TransformationFiles": ["TransformationID", "TaskID", "Status", "UsedSE", "TargetSE"],
-            "TransformationTasks": ["TransformationID", "TaskID", "ExternalStatus", "TargetSE"],
-        }
-
-        tableTimeStamps = {
-            "Transformations": "CreationDate",
-            "TransformationFiles": "LastUpdate",
-            "TransformationTasks": "CreationTime",
-        }
-
-        tableStatusColumn = {
-            "Transformations": "Status",
-            "TransformationFiles": "Status",
-            "TransformationTasks": "ExternalStatus",
-        }
-
-        resDict = {}
-        res = self.__getTableSummaryWeb(
-            table,
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=tableSelections[table],
-            timeStamp=tableTimeStamps[table],
-            statusColumn=tableStatusColumn[table],
-        )
-        if not res["OK"]:
-            self.log.error("Failed to get Summary for table", f"{table} {res['Message']}")
-            return res
-        resDict[table] = res["Value"]
-        selections = res["Value"]["Selections"]
-        tableSelection = {}
-        for destination in tableDestinations[table].keys():
-            tableSelection[destination] = {}
-            for parameter in tableDestinations[table][destination]:
-                tableSelection[destination][parameter] = selections.get(parameter, [])
-
-        for table, paramDict in requestedTables.items():
-            sortList = paramDict.get("SortList", [])
-            startItem = paramDict.get("StartItem", 0)
-            maxItems = paramDict.get("MaxItems", 50)
-            res = self.__getTableSummaryWeb(
-                table,
-                tableSelection[table],
-                sortList,
-                startItem,
-                maxItems,
-                selectColumns=tableSelections[table],
-                timeStamp=tableTimeStamps[table],
-                statusColumn=tableStatusColumn[table],
-            )
-            if not res["OK"]:
-                self.log.error("Failed to get Summary for table", f"{table} {res['Message']}")
-                return res
-            resDict[table] = res["Value"]
-        return S_OK(resDict)
-
-    types_getTransformationsSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationsSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "Transformations",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "AgentType", "Type", "Group", "Plugin"],
-            timeStamp="CreationDate",
-            statusColumn="Status",
-        )
-
-    types_getTransformationTasksSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationTasksSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "TransformationTasks",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "ExternalStatus", "TargetSE"],
-            timeStamp="CreationTime",
-            statusColumn="ExternalStatus",
-        )
-
-    types_getTransformationFilesSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationFilesSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        return self.__getTableSummaryWeb(
-            "TransformationFiles",
-            selectDict,
-            sortList,
-            startItem,
-            maxItems,
-            selectColumns=["TransformationID", "Status", "UsedSE", "TargetSE"],
-            timeStamp="LastUpdate",
-            statusColumn="Status",
-        )
-
-    def __getTableSummaryWeb(
-        self, table, selectDict, sortList, startItem, maxItems, selectColumns=[], timeStamp=None, statusColumn="Status"
-    ):
-        fromDate = selectDict.get("FromDate", None)
-        if fromDate:
-            del selectDict["FromDate"]
-        # if not fromDate:
-        #  fromDate = last_update
-        toDate = selectDict.get("ToDate", None)
-        if toDate:
-            del selectDict["ToDate"]
-        # Sorting instructions. Only one for the moment.
-        if sortList:
-            orderAttribute = sortList[0][0] + ":" + sortList[0][1]
-        else:
-            orderAttribute = None
-        # Get the columns that match the selection
-        fcn = None
-        fcnName = f"get{table}"
-        if hasattr(self.transformationDB, fcnName) and callable(getattr(self.transformationDB, fcnName)):
-            fcn = getattr(self.transformationDB, fcnName)
-        if not fcn:
-            return S_ERROR(f"Unable to invoke gTransformationDB.{fcnName}, it isn't a member function")
-        res = fcn(condDict=selectDict, older=toDate, newer=fromDate, timeStamp=timeStamp, orderAttribute=orderAttribute)
-        if not res["OK"]:
-            return res
-
-        # The full list of columns in contained here
-        allRows = res["Records"]
-        # Prepare the standard structure now within the resultDict dictionary
-        resultDict = {}
-        # Create the total records entry
-        resultDict["TotalRecords"] = len(allRows)
-        # Create the ParameterNames entry
-        resultDict["ParameterNames"] = res["ParameterNames"]
-        # Find which element in the tuple contains the requested status
-        if statusColumn not in resultDict["ParameterNames"]:
-            return S_ERROR("Provided status column not present")
-        statusColumnIndex = resultDict["ParameterNames"].index(statusColumn)
-
-        # Get the rows which are within the selected window
-        if resultDict["TotalRecords"] == 0:
-            return S_OK(resultDict)
-        ini = startItem
-        last = ini + maxItems
-        if ini >= resultDict["TotalRecords"]:
-            return S_ERROR("Item number out of range")
-        if last > resultDict["TotalRecords"]:
-            last = resultDict["TotalRecords"]
-        selectedRows = allRows[ini:last]
-        resultDict["Records"] = selectedRows
-
-        # Generate the status dictionary
-        statusDict = {}
-        for row in selectedRows:
-            status = row[statusColumnIndex]
-            statusDict[status] = statusDict.setdefault(status, 0) + 1
-        resultDict["Extras"] = statusDict
-
-        # Obtain the distinct values of the selection parameters
-        res = self.transformationDB.getTableDistinctAttributeValues(
-            table, selectColumns, selectDict, older=toDate, newer=fromDate
-        )
-        distinctSelections = zip(selectColumns, [])
-        if res["OK"]:
-            distinctSelections = res["Value"]
-        resultDict["Selections"] = distinctSelections
-
-        return S_OK(resultDict)
-
-    types_getTransformationSummaryWeb = [dict, list, int, int]
-
-    def export_getTransformationSummaryWeb(self, selectDict, sortList, startItem, maxItems):
-        """Get the summary of the transformation information for a given page in the generic format"""
-
-        # Obtain the timing information from the selectDict
-        last_update = selectDict.get("CreationDate", None)
-        if last_update:
-            del selectDict["CreationDate"]
-        fromDate = selectDict.get("FromDate", None)
-        if fromDate:
-            del selectDict["FromDate"]
-        if not fromDate:
-            fromDate = last_update
-        toDate = selectDict.get("ToDate", None)
-        if toDate:
-            del selectDict["ToDate"]
-        # Sorting instructions. Only one for the moment.
-        if sortList:
-            orderAttribute = []
-            for i in sortList:
-                orderAttribute += [i[0] + ":" + i[1]]
-        else:
-            orderAttribute = None
-
-        # Get the transformations that match the selection
-        res = self.transformationDB.getTransformations(
-            condDict=selectDict, older=toDate, newer=fromDate, orderAttribute=orderAttribute
-        )
-        if not res["OK"]:
-            return res
-
-        ops = Operations()
-        # Prepare the standard structure now within the resultDict dictionary
-        resultDict = {}
-        trList = res["Records"]
-        # Create the total records entry
-        nTrans = len(trList)
-        resultDict["TotalRecords"] = nTrans
-        # Create the ParameterNames entry
-        # As this list is a reference to the list in the DB, we cannot extend it, therefore copy it
-        resultDict["ParameterNames"] = list(res["ParameterNames"])
-        # Add the job states to the ParameterNames entry
-        taskStateNames = TASKS_STATE_NAMES + ops.getValue("Transformations/AdditionalTaskStates", [])
-        resultDict["ParameterNames"] += ["Jobs_" + x for x in taskStateNames]
-        # Add the file states to the ParameterNames entry
-        fileStateNames = FILES_STATE_NAMES + ops.getValue("Transformations/AdditionalFileStates", [])
-        resultDict["ParameterNames"] += ["Files_" + x for x in fileStateNames]
-
-        # Get the transformations which are within the selected window
-        if nTrans == 0:
-            return S_OK(resultDict)
-        ini = startItem
-        last = ini + maxItems
-        if ini >= nTrans:
-            return S_ERROR("Item number out of range")
-        if last > nTrans:
-            last = nTrans
-        transList = trList[ini:last]
-
-        statusDict = {}
-        extendableTranfs = ops.getValue("Transformations/ExtendableTransfTypes", ["Simulation", "MCsimulation"])
-        givenUpFileStatus = ops.getValue("Transformations/GivenUpFileStatus", ["MissingInFC"])
-        problematicStatuses = ops.getValue("Transformations/ProblematicStatuses", ["Problematic"])
-        # Add specific information for each selected transformation
-        for trans in transList:
-            transDict = dict(zip(resultDict["ParameterNames"], trans))
-
-            # Update the status counters
-            status = transDict["Status"]
-            statusDict[status] = statusDict.setdefault(status, 0) + 1
-
-            # Get the statistics on the number of jobs for the transformation
-            transID = transDict["TransformationID"]
-            res = self.transformationDB.getTransformationTaskStats(transID)
-            taskDict = {}
-            if res["OK"] and res["Value"]:
-                taskDict = res["Value"]
-            for state in taskStateNames:
-                trans.append(taskDict.get(state, 0))
-
-            # Get the statistics for the number of files for the transformation
-            fileDict = {}
-            transType = transDict["Type"]
-            if transType.lower() in extendableTranfs:
-                fileDict["PercentProcessed"] = "-"
-            else:
-                res = self.transformationDB.getTransformationStats(transID)
-                if res["OK"]:
-                    fileDict = res["Value"]
-                    total = fileDict["Total"]
-                    for stat in givenUpFileStatus:
-                        total -= fileDict.get(stat, 0)
-                    processed = fileDict.get(TransformationFilesStatus.PROCESSED, 0)
-                    fileDict["PercentProcessed"] = f"{int(processed * 1000.0 / total) / 10.0:.1f}" if total else 0.0
-            problematic = 0
-            for stat in problematicStatuses:
-                problematic += fileDict.get(stat, 0)
-            fileDict["Problematic"] = problematic
-            for state in fileStateNames:
-                trans.append(fileDict.get(state, 0))
-
-        resultDict["Records"] = transList
-        resultDict["Extras"] = statusDict
-        return S_OK(resultDict)
-
 
 class TransformationManagerHandler(TransformationManagerHandlerMixin, RequestHandler):
     pass

DIRAC/TransformationSystem/Utilities/ReplicationCLIParameters.py

@@ -1,10 +1,10 @@
 """
 Command Line Parameters for creating the Replication transformations Script
 """
-from DIRAC import S_OK, S_ERROR, gLogger
+from DIRAC import S_ERROR, S_OK, gLogger
+from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOForGroup
 from DIRAC.Core.Security.Properties import SecurityProperty
 from DIRAC.Core.Security.ProxyInfo import getProxyInfo
-from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOMSVOForGroup
 
 
 class Params:
@@ -144,7 +144,7 @@ class Params:
             return False
         proxyValues = proxyInfo.get("Value", {})
         group = proxyValues.get("group", "")
-        vomsvo = getVOMSVOForGroup(group)
+        vomsvo = getVOForGroup(group)
         if not vomsvo:
             self.errorMessages.append("ERROR: ProxyGroup not associated to VOMS VO, get a different proxy")
             return False

DIRAC/TransformationSystem/Utilities/TransformationInfo.py

@@ -2,19 +2,19 @@
 from collections import OrderedDict, defaultdict
 from itertools import zip_longest
 
-from DIRAC import gLogger, S_OK
+from DIRAC import S_OK, gLogger
 from DIRAC.Core.Utilities.List import breakListIntoChunks
 from DIRAC.Core.Utilities.Proxy import UserProxy
 from DIRAC.DataManagementSystem.Client.DataManager import DataManager
 from DIRAC.TransformationSystem.Utilities.JobInfo import JobInfo
 from DIRAC.WorkloadManagementSystem.Client import JobStatus
-from DIRAC.WorkloadManagementSystem.Client.JobStateUpdateClient import JobStateUpdateClient
+from DIRAC.WorkloadManagementSystem.Utilities.JobStatusUtility import JobStatusUtility
 
 
 class TransformationInfo:
     """Hold information about a transformation."""
 
-    def __init__(self, transformationID, transInfoDict, enabled, tClient, fcClient, jobMon):
+    def __init__(self, transformationID, transInfoDict, enabled, tClient, fcClient, jobMon, jobStatusUtility=None):
         """Store clients etc."""
         self.log = gLogger.getSubLogger(__name__ + f"[{transformationID}]")
         self.enabled = enabled
@@ -26,7 +26,7 @@ class TransformationInfo:
         self.transType = transInfoDict["Type"]
         self.author = transInfoDict["Author"]
         self.authorGroup = transInfoDict["AuthorGroup"]
-        self.jobStateClient = JobStateUpdateClient()
+        self.jobStatusUtility = jobStatusUtility or JobStatusUtility()
 
     def checkTasksStatus(self):
         """Check the status for the task of given transformation and taskID"""
@@ -97,7 +97,9 @@ class TransformationInfo:
         """Update the job status."""
         if self.enabled:
             source = "DataRecoveryAgent"
-            result = self.jobStateClient.setJobStatus(jobID, status, minorstatus, source, None, True)
+            result = self.jobStatusUtility.setJobStatus(
+                int(jobID), status=status, minorStatus=minorstatus, source=source, dateTime=None, force=True
+            )
         else:
             return S_OK("DisabledMode")
         if not result["OK"]:

DIRAC/TransformationSystem/scripts/dirac_production_runjoblocal.py

@@ -16,7 +16,7 @@ from urllib.request import urlopen
 from DIRAC.Interfaces.API.Dirac import Dirac
 from DIRAC.Core.Utilities.File import mkDir
 from DIRAC.Core.Base.Script import Script
-from DIRAC.ConfigurationSystem.Client.Helpers.CSGlobals import getVO, getSetup
+from DIRAC.ConfigurationSystem.Client.Helpers.CSGlobals import getVO
 from DIRAC.ConfigurationSystem.Client.ConfigurationData import gConfigurationData
 
 
@@ -79,14 +79,12 @@ def __configurePilot(basepath, vo):
     This method was created specifically for LHCb pilots, more info
     about othe VOs is needed to make it more general.
     """
-    currentSetup = getSetup()
     masterCS = gConfigurationData.getMasterServer()
 
     os.system(
         "python "
         + basepath
-        + "dirac-pilot.py -S %s -l %s -C %s -N ce.debug.ch -Q default -n DIRAC.JobDebugger.ch -dd"
-        % (currentSetup, vo, masterCS)
+        + f"dirac-pilot.py -l {vo} -C {masterCS} -N ce.debug.ch -Q default -n DIRAC.JobDebugger.ch -dd"
     )
 
     diracdir = os.path.expanduser("~") + os.path.sep

DIRAC/TransformationSystem/test/Test_TransformationInfo.py

@@ -1,20 +1,20 @@
 """Test the Transformationinfo."""
 from collections import OrderedDict
 from contextlib import contextmanager
+from unittest.mock import MagicMock as Mock
+from unittest.mock import patch
 
 import pytest
-from unittest.mock import MagicMock as Mock, patch
 
-from DIRAC import S_OK, S_ERROR
 import DIRAC
-import DIRAC.TransformationSystem.Client.TransformationClient
 import DIRAC.Resources.Catalog.FileCatalogClient
+import DIRAC.TransformationSystem.Client.TransformationClient
 import DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient
+from DIRAC import S_ERROR, S_OK
+from DIRAC.tests.Utilities.utils import MatchStringWith
 from DIRAC.TransformationSystem.Utilities.JobInfo import JobInfo
 from DIRAC.TransformationSystem.Utilities.TransformationInfo import TransformationInfo
 
-from DIRAC.tests.Utilities.utils import MatchStringWith
-
 # pylint: disable=W0212, redefined-outer-name
 
 
@@ -53,7 +53,7 @@ def tiFixture():
     tMock.setFileStatusForTransformation = Mock(name="setFileStat")
     fcMock = Mock(name="fcMock", spec=DIRAC.Resources.Catalog.FileCatalogClient.FileCatalogClient)
     jmMock = Mock(name="jobMonMock", spec=DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient.JobMonitoringClient)
-    jsucMock = Mock(name="jsuc", spec=DIRAC.WorkloadManagementSystem.Client.JobStateUpdateClient.JobStateUpdateClient)
+    jsucMock = Mock(name="jsuc", spec=DIRAC.WorkloadManagementSystem.Utilities.JobStatusUtility.JobStatusUtility)
     transInfoDict = dict(
         TransformationID=1234,
         TransformationName="TestProd12",
@@ -63,10 +63,15 @@ def tiFixture():
     )
 
     tri = TransformationInfo(
-        transformationID=1234, transInfoDict=transInfoDict, enabled=False, tClient=tMock, fcClient=fcMock, jobMon=jmMock
+        transformationID=1234,
+        transInfoDict=transInfoDict,
+        enabled=False,
+        tClient=tMock,
+        fcClient=fcMock,
+        jobMon=jmMock,
+        jobStatusUtility=jsucMock,
     )
     tri.log = Mock(name="LogMock")
-    tri.jobStateClient = jsucMock
     return tri
 
 
@@ -216,23 +221,25 @@ def test_setTaskStatus(tiFixture):
 def test_updateJobStatus(tiFixture):
     """DIRAC.TransformationSystem.Utilities.TransformationInfo updateJobStatus................"""
 
-    tiFixture.jobStateClient.setJobStatus = Mock()
-    tiFixture.jobStateClient.setJobStatus.return_value = S_OK()
+    tiFixture.jobStatusUtility.setJobStatus = Mock()
+    tiFixture.jobStatusUtility.setJobStatus.return_value = S_OK()
     tiFixture.enabled = False
     res = tiFixture._TransformationInfo__updateJobStatus(1234, "Failed", minorstatus=None)
     assert res["OK"]
     assert res["Value"] == "DisabledMode"
-    tiFixture.jobStateClient.setJobStatus.assert_not_called()
+    tiFixture.jobStatusUtility.setJobStatus.assert_not_called()
 
-    tiFixture.jobStateClient.setJobStatus.reset()
-    tiFixture.jobStateClient.setJobStatus.return_value = S_OK("added record")
+    tiFixture.jobStatusUtility.setJobStatus.reset()
+    tiFixture.jobStatusUtility.setJobStatus.return_value = S_OK("added record")
     tiFixture.enabled = True
     res = tiFixture._TransformationInfo__updateJobStatus(1234, "Failed", minorstatus=None)
     assert res["OK"]
     assert res["Value"] == "added record"
-    tiFixture.jobStateClient.setJobStatus.assert_called_once_with(1234, "Failed", None, "DataRecoveryAgent", None, True)
+    tiFixture.jobStatusUtility.setJobStatus.assert_called_once_with(
+        1234, status="Failed", minorStatus=None, source="DataRecoveryAgent", dateTime=None, force=True
+    )
 
-    tiFixture.jobStateClient.setJobStatus.return_value = S_ERROR("Error setting job status")
+    tiFixture.jobStatusUtility.setJobStatus.return_value = S_ERROR("Error setting job status")
     tiFixture.enabled = True
     with pytest.raises(RuntimeError) as re:
         tiFixture._TransformationInfo__updateJobStatus(1234, "Failed", minorstatus=None)

DIRAC/TransformationSystem/test/Test_replicationTransformation.py

@@ -1,14 +1,13 @@
 """Test the dirac-transformation-replication script and helper"""
 import unittest
+from unittest.mock import MagicMock as Mock
+from unittest.mock import patch
 
-from unittest.mock import MagicMock as Mock, patch
-
-from DIRAC import S_OK, S_ERROR
-
-from DIRAC.TransformationSystem.Utilities.ReplicationTransformation import createDataTransformation
+from DIRAC import S_ERROR, S_OK
 from DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters import Params
+from DIRAC.TransformationSystem.Utilities.ReplicationTransformation import createDataTransformation
 
-GET_VOMS = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getVOMSVOForGroup"
+GET_VOMS = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getVOForGroup"
 GET_PROXY = "DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters.getProxyInfo"
 
 

DIRAC/Workflow/Modules/test/Test_Modules.py

@@ -5,6 +5,8 @@ import os
 import copy
 import shutil
 
+import pytest
+
 from unittest.mock import MagicMock as Mock
 
 from DIRAC import gLogger
@@ -742,6 +744,7 @@ class FailoverRequestSuccess(ModulesTestCase):
 class ScriptSuccess(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]
@@ -770,6 +773,7 @@ class ScriptSuccess(ModulesTestCase):
 class ScriptUnicode(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]
@@ -799,6 +803,7 @@ class ScriptUnicode(ModulesTestCase):
 class ScriptFailure(ModulesTestCase):
     #################################################
 
+    @pytest.mark.slow
     def test_execute(self):
         self.script.jobType = "merge"
         self.script.stepInputData = ["foo", "bar"]