diff --git a/src/DIRAC/ConfigurationSystem/scripts/dirac_admin_check_config_options.py b/src/DIRAC/ConfigurationSystem/scripts/dirac_admin_check_config_options.py
index 82635175fdc..4361da26578 100755
--- a/src/DIRAC/ConfigurationSystem/scripts/dirac_admin_check_config_options.py
+++ b/src/DIRAC/ConfigurationSystem/scripts/dirac_admin_check_config_options.py
@@ -174,6 +174,8 @@ def _printDiff(self, entry, level=""):
             diffType, entryName, _value, changes, _comment = entry
         elif len(entry) == 4:
             diffType, entryName, _value, changes = entry
+        else:
+            raise ValueError(f"Invalid entry {entry}")
 
         fullPath = os.path.join(level, entryName)
 
diff --git a/src/DIRAC/Core/Base/AgentModule.py b/src/DIRAC/Core/Base/AgentModule.py
index 1453390f446..24a1481bd4f 100644
--- a/src/DIRAC/Core/Base/AgentModule.py
+++ b/src/DIRAC/Core/Base/AgentModule.py
@@ -329,6 +329,7 @@ def _setShifterProxy(self):
 
     def am_go(self):
         # Set the shifter proxy if required
+        initialWallTime = initialCPUTime = cpuPercentage = -1
         result = self._setShifterProxy()
         if not result["OK"]:
             return result
diff --git a/src/DIRAC/Core/DISET/ServiceReactor.py b/src/DIRAC/Core/DISET/ServiceReactor.py
index 03abc2635bd..eec216b6e40 100644
--- a/src/DIRAC/Core/DISET/ServiceReactor.py
+++ b/src/DIRAC/Core/DISET/ServiceReactor.py
@@ -14,6 +14,7 @@
   must inherit from the base class RequestHandler
 
 """
+
 import time
 import datetime
 import selectors
@@ -201,6 +202,7 @@ def __acceptIncomingConnection(self, svcName=False):
         """
         sel = self.__getListeningSelector(svcName)
         while self.__alive:
+            clientTransport = None
             try:
                 events = sel.select(timeout=10)
                 if len(events) == 0:
diff --git a/src/DIRAC/Core/Security/VOMS.py b/src/DIRAC/Core/Security/VOMS.py
index b09716037df..c9a9171e530 100644
--- a/src/DIRAC/Core/Security/VOMS.py
+++ b/src/DIRAC/Core/Security/VOMS.py
@@ -1,5 +1,6 @@
 """ Module for dealing with VOMS (Virtual Organization Membership Service)
 """
+
 from datetime import datetime
 import os
 import stat
@@ -74,6 +75,7 @@ def getVOMSAttributes(self, proxy, switch="all"):
                     if value and value not in attributes and value in validVOMSAttrs:
                         attributes.append(value)
 
+        returnValue = None
         # Sorting and joining attributes
         if switch == "db":
             returnValue = ":".join(attributes)
diff --git a/src/DIRAC/Core/Utilities/Graphs/Graph.py b/src/DIRAC/Core/Utilities/Graphs/Graph.py
index b92ec9e4d3f..2162dd8d968 100644
--- a/src/DIRAC/Core/Utilities/Graphs/Graph.py
+++ b/src/DIRAC/Core/Utilities/Graphs/Graph.py
@@ -25,6 +25,7 @@ def __init__(self, *args, **kw):
 
     def layoutFigure(self, legend):
         prefs = self.prefs
+        nsublines = left = bottom = None
 
         # Get the main Figure object
         # self.figure = Figure()
@@ -182,7 +183,7 @@ def makeTextGraph(self, text="Empty image"):
 
     def makeGraph(self, data, *args, **kw):
         start = time.time()
-
+        plot_type = None
         # Evaluate all the preferences
         self.prefs = evalPrefs(*args, **kw)
         prefs = self.prefs
diff --git a/src/DIRAC/Core/Utilities/Graphs/GraphUtilities.py b/src/DIRAC/Core/Utilities/Graphs/GraphUtilities.py
index b8a43fdf79a..a93ef553e94 100644
--- a/src/DIRAC/Core/Utilities/Graphs/GraphUtilities.py
+++ b/src/DIRAC/Core/Utilities/Graphs/GraphUtilities.py
@@ -145,6 +145,7 @@ def add_time_to_title(begin, end, metadata={}):
     representing 168 Hours, but needed the format to show the date as
     well as the time.
     """
+    format_str = None
     if "span" in metadata:
         interval = metadata["span"]
     else:
diff --git a/src/DIRAC/Core/Utilities/Graphs/Legend.py b/src/DIRAC/Core/Utilities/Graphs/Legend.py
index 1fe0db592c6..00aa5a8a662 100644
--- a/src/DIRAC/Core/Utilities/Graphs/Legend.py
+++ b/src/DIRAC/Core/Utilities/Graphs/Legend.py
@@ -3,6 +3,7 @@
     The DIRAC Graphs package is derived from the GraphTool plotting package of the
     CMS/Phedex Project by ... <to be added>
 """
+
 from matplotlib.patches import Rectangle
 from matplotlib.text import Text
 from matplotlib.figure import Figure
@@ -63,6 +64,7 @@ def getLegendSize(self):
         legend_padding = float(self.prefs["legend_padding"])
         legend_text_size = self.prefs.get("legend_text_size", self.prefs["text_size"])
         legend_text_padding = self.prefs.get("legend_text_padding", self.prefs["text_padding"])
+        legend_max_height = -1
         if legend_position in ["right", "left"]:
             # One column in case of vertical legend
             legend_width = self.column_width + legend_padding
diff --git a/src/DIRAC/Core/Utilities/Graphs/QualityMapGraph.py b/src/DIRAC/Core/Utilities/Graphs/QualityMapGraph.py
index ea8d9fbec3d..2831883a235 100644
--- a/src/DIRAC/Core/Utilities/Graphs/QualityMapGraph.py
+++ b/src/DIRAC/Core/Utilities/Graphs/QualityMapGraph.py
@@ -3,6 +3,7 @@
     The DIRAC Graphs package is derived from the GraphTool plotting package of the
     CMS/Phedex Project by ... <to be added>
 """
+
 import datetime
 from pylab import setp
 from matplotlib.colors import Normalize
@@ -39,7 +40,6 @@
 
 
 class QualityMapGraph(PlotBase):
-
     """
     The BarGraph class is a straightforward bar graph; given a dictionary
     of values, it takes the keys as the independent variable and the values
@@ -167,7 +167,7 @@ def draw(self):
         setp(self.ax.get_xticklines(), markersize=0.0)  # pylint: disable=not-callable
         setp(self.ax.get_yticklines(), markersize=0.0)  # pylint: disable=not-callable
 
-        cax, kw = make_axes(self.ax, orientation="vertical", fraction=0.07)
+        cax, _kw = make_axes(self.ax, orientation="vertical", fraction=0.07)  # pylint: disable=unpacking-non-sequence
         ColorbarBase(
             cax, cmap=self.cmap, norm=self.norms, boundaries=self.cbBoundaries, values=self.cbValues, ticks=self.cbTicks
         )
diff --git a/src/DIRAC/Core/Utilities/Graphs/__init__.py b/src/DIRAC/Core/Utilities/Graphs/__init__.py
index 0b721155c08..bef0dd671dd 100644
--- a/src/DIRAC/Core/Utilities/Graphs/__init__.py
+++ b/src/DIRAC/Core/Utilities/Graphs/__init__.py
@@ -115,7 +115,7 @@
 def graph(data, fileName, *args, **kw):
     prefs = evalPrefs(*args, **kw)
     graph_size = prefs.get("graph_size", "normal")
-
+    defaults = None
     if graph_size == "normal":
         defaults = graph_normal_prefs
     elif graph_size == "small":
diff --git a/src/DIRAC/Core/Utilities/MySQL.py b/src/DIRAC/Core/Utilities/MySQL.py
index 46f5428c27c..21efc261771 100755
--- a/src/DIRAC/Core/Utilities/MySQL.py
+++ b/src/DIRAC/Core/Utilities/MySQL.py
@@ -1231,7 +1231,7 @@ def buildCondition(
         """
         condition = ""
         conjunction = "WHERE"
-
+        attrName = None
         if condDict is not None:
             for aName, attrValue in condDict.items():
                 if isinstance(aName, str):
diff --git a/src/DIRAC/DataManagementSystem/Client/DataManager.py b/src/DIRAC/DataManagementSystem/Client/DataManager.py
index e604c00d729..f414501e0c0 100644
--- a/src/DIRAC/DataManagementSystem/Client/DataManager.py
+++ b/src/DIRAC/DataManagementSystem/Client/DataManager.py
@@ -8,6 +8,7 @@
 This module consists of DataManager and related classes.
 
 """
+
 # # imports
 from datetime import datetime, timedelta
 import fnmatch
@@ -988,6 +989,8 @@ def registerFile(self, fileTuple, catalog=""):
             fileTuples = fileTuple
         elif isinstance(fileTuple, tuple):
             fileTuples = [fileTuple]
+        else:
+            return S_ERROR(f"fileTuple is none of list,set,tuple: {type(fileTuple)}")
         for fileTuple in fileTuples:
             if not isinstance(fileTuple, tuple):
                 errStr = "Supplied file info must be tuple or list of tuples."
@@ -1041,6 +1044,8 @@ def registerReplica(self, replicaTuple, catalog=""):
             replicaTuples = replicaTuple
         elif isinstance(replicaTuple, tuple):
             replicaTuples = [replicaTuple]
+        else:
+            return S_ERROR(f"replicaTuple is not of type list,set or tuple: {type(replicaTuple)}")
         for replicaTuple in replicaTuples:
             if not isinstance(replicaTuple, tuple):
                 errStr = "Supplied file info must be tuple or list of tuples."
diff --git a/src/DIRAC/DataManagementSystem/Client/DirectoryListing.py b/src/DIRAC/DataManagementSystem/Client/DirectoryListing.py
index 61f5d09d2de..b61dc802f68 100644
--- a/src/DIRAC/DataManagementSystem/Client/DirectoryListing.py
+++ b/src/DIRAC/DataManagementSystem/Client/DirectoryListing.py
@@ -60,6 +60,7 @@ def addDirectory(self, name, dirDict, numericid):
         date = dirDict["ModificationDate"]
         nlinks = 0
         size = 0
+        gname = None
         if "Owner" in dirDict:
             uname = dirDict["Owner"]
         elif "OwnerDN" in dirDict:
diff --git a/src/DIRAC/DataManagementSystem/Client/FileCatalogClientCLI.py b/src/DIRAC/DataManagementSystem/Client/FileCatalogClientCLI.py
index 8f84785d25b..65eb8317f05 100644
--- a/src/DIRAC/DataManagementSystem/Client/FileCatalogClientCLI.py
+++ b/src/DIRAC/DataManagementSystem/Client/FileCatalogClientCLI.py
@@ -671,9 +671,8 @@ def do_ancestorset(self, args):
     def complete_ancestorset(self, text, line, begidx, endidx):
         args = line.split()
 
-        if len(args) == 1:
-            cur_path = ""
-        elif len(args) > 1:
+        cur_path = ""
+        if len(args) > 1:
             # If the line ends with ' '
             # this means a new parameter begin.
             if line.endswith(" "):
diff --git a/src/DIRAC/DataManagementSystem/Service/StorageElementHandler.py b/src/DIRAC/DataManagementSystem/Service/StorageElementHandler.py
index cdfba8a635a..d27d89d41af 100755
--- a/src/DIRAC/DataManagementSystem/Service/StorageElementHandler.py
+++ b/src/DIRAC/DataManagementSystem/Service/StorageElementHandler.py
@@ -286,10 +286,12 @@ def export_createDirectory(self, dir_path):
     def export_listDirectory(self, dir_path, mode):
         """Return the dir_path directory listing"""
         is_file = False
+        fname = None
+        dirList = None
         path = self.__resolveFileID(dir_path)
         if not os.path.exists(path):
             return S_ERROR(f"Directory {dir_path} does not exist")
-        elif os.path.isfile(path):
+        if os.path.isfile(path):
             fname = os.path.basename(path)
             is_file = True
         else:
diff --git a/src/DIRAC/FrameworkSystem/Client/SystemAdministratorClientCLI.py b/src/DIRAC/FrameworkSystem/Client/SystemAdministratorClientCLI.py
index d1df510df2e..be7246baf91 100644
--- a/src/DIRAC/FrameworkSystem/Client/SystemAdministratorClientCLI.py
+++ b/src/DIRAC/FrameworkSystem/Client/SystemAdministratorClientCLI.py
@@ -623,6 +623,7 @@ def do_install(self, args):
           install executor <system> <executor> [-m <ModuleName>] [-p <Option>=<Value>] [-p <Option>=<Value>] ...
         """
         argss = args.split()
+        hostSetup = extension = None
         if not argss:
             gLogger.notice(self.do_install.__doc__)
             return
diff --git a/src/DIRAC/FrameworkSystem/DB/NotificationDB.py b/src/DIRAC/FrameworkSystem/DB/NotificationDB.py
index be24902919d..5374267a9e5 100644
--- a/src/DIRAC/FrameworkSystem/DB/NotificationDB.py
+++ b/src/DIRAC/FrameworkSystem/DB/NotificationDB.py
@@ -280,6 +280,7 @@ def __getAlarmIdFromKey(self, alarmKey):
     def updateAlarm(self, updateReq):
         # Discover alarm identification
         idOK = False
+        alarmModsSQL = None
         for field in self.__updateAlarmIdentificationFields:
             if field in updateReq:
                 idOK = True
diff --git a/src/DIRAC/FrameworkSystem/Service/BundleDeliveryHandler.py b/src/DIRAC/FrameworkSystem/Service/BundleDeliveryHandler.py
index 8b8ad8ae21e..6ad77ebe487 100644
--- a/src/DIRAC/FrameworkSystem/Service/BundleDeliveryHandler.py
+++ b/src/DIRAC/FrameworkSystem/Service/BundleDeliveryHandler.py
@@ -107,7 +107,7 @@ def transfer_toClient(self, fileId, token, fileHelper):
             if len(fileId) == 0:
                 fileHelper.markAsTransferred()
                 return S_ERROR("No bundle specified!")
-            elif len(fileId) == 1:
+            if len(fileId) == 1:
                 bId = fileId[0]
             else:
                 bId = fileId[0]
diff --git a/src/DIRAC/FrameworkSystem/Service/TornadoBundleDeliveryHandler.py b/src/DIRAC/FrameworkSystem/Service/TornadoBundleDeliveryHandler.py
index 081a6b0e220..5e0553674da 100644
--- a/src/DIRAC/FrameworkSystem/Service/TornadoBundleDeliveryHandler.py
+++ b/src/DIRAC/FrameworkSystem/Service/TornadoBundleDeliveryHandler.py
@@ -1,5 +1,6 @@
 """ Handler for CAs + CRLs bundles
 """
+
 from base64 import b64encode
 
 from DIRAC import S_OK, S_ERROR
@@ -13,6 +14,7 @@ class TornadoBundleDeliveryHandler(BundleDeliveryHandlerMixin, TornadoService):
 
     def export_streamToClient(self, fileId):
         version = ""
+        bId = None
         if isinstance(fileId, str):
             if fileId in ["CAs", "CRLs"]:
                 retVal = Utilities.generateCAFile() if fileId == "CAs" else Utilities.generateRevokedCertsFile()
diff --git a/src/DIRAC/Interfaces/scripts/dirac_admin_get_banned_sites.py b/src/DIRAC/Interfaces/scripts/dirac_admin_get_banned_sites.py
index b2d081cf5f6..a240a1f5374 100755
--- a/src/DIRAC/Interfaces/scripts/dirac_admin_get_banned_sites.py
+++ b/src/DIRAC/Interfaces/scripts/dirac_admin_get_banned_sites.py
@@ -23,12 +23,11 @@ def main():
     diracAdmin = DiracAdmin()
 
     result = diracAdmin.getBannedSites()
-    if result["OK"]:
-        bannedSites = result["Value"]
-    else:
+    if not result["OK"]:
         gLogger.error(result["Message"])
         DIRACExit(2)
 
+    bannedSites = result["Value"]
     for site in bannedSites:
         result = diracAdmin.getSiteMaskLogging(site, printOutput=True)
         if not result["OK"]:
diff --git a/src/DIRAC/Interfaces/scripts/dirac_wms_jobs_select_output_search.py b/src/DIRAC/Interfaces/scripts/dirac_wms_jobs_select_output_search.py
index 96b5b6888af..f4fa92f6cd4 100755
--- a/src/DIRAC/Interfaces/scripts/dirac_wms_jobs_select_output_search.py
+++ b/src/DIRAC/Interfaces/scripts/dirac_wms_jobs_select_output_search.py
@@ -80,12 +80,11 @@ def main():
         jobGroup=jobGroup,
         date=date,
     )
-    if result["OK"]:
-        jobs = result["Value"]
-    else:
+    if not result["OK"]:
         print("Error in selectJob", result["Message"])
         DIRAC.exit(2)
 
+    jobs = result["Value"]
     for job in jobs:
         result = dirac.getOutputSandbox(job)
         if result["OK"]:
diff --git a/src/DIRAC/Interfaces/scripts/dmeta.py b/src/DIRAC/Interfaces/scripts/dmeta.py
index 971b900f9ef..0318dabbb95 100755
--- a/src/DIRAC/Interfaces/scripts/dmeta.py
+++ b/src/DIRAC/Interfaces/scripts/dmeta.py
@@ -132,6 +132,7 @@ def getListIndex(self):
         else:
             fdType = "-" + params.getIndex()
             for arg in args:
+                rtype = None
                 meta, mtype = arg.split("=")
                 if mtype.lower()[:3] == "int":
                     rtype = "INT"
diff --git a/src/DIRAC/ProductionSystem/Utilities/ProdTransManager.py b/src/DIRAC/ProductionSystem/Utilities/ProdTransManager.py
index 35709504a93..bc0536805b6 100644
--- a/src/DIRAC/ProductionSystem/Utilities/ProdTransManager.py
+++ b/src/DIRAC/ProductionSystem/Utilities/ProdTransManager.py
@@ -33,8 +33,10 @@ def deleteProductionTransformations(self, prodID):
         :param int prodID: the ProductionID
         """
         res = self.prodClient.getProductionTransformations(prodID)
-        if res["OK"]:
-            transList = res["Value"]
+        if not res["OK"]:
+            return res
+
+        transList = res["Value"]
 
         gLogger.notice(f"Deleting production transformations {transList} from the TS")
 
diff --git a/src/DIRAC/ProductionSystem/scripts/dirac_prod_get_description.py b/src/DIRAC/ProductionSystem/scripts/dirac_prod_get_description.py
index beaca109322..97e93cd1966 100755
--- a/src/DIRAC/ProductionSystem/scripts/dirac_prod_get_description.py
+++ b/src/DIRAC/ProductionSystem/scripts/dirac_prod_get_description.py
@@ -23,12 +23,12 @@ def main():
     prodID = args[0]
     res = prodClient.getProduction(prodID)
 
-    if res["OK"]:
-        prod = res["Value"]
-    else:
+    if not res["OK"]:
         DIRAC.gLogger.error(res["Message"])
         DIRAC.exit(-1)
 
+    prod = res["Value"]
+
     print(f"Description for production {prodID}:\n")
     print(prod["Description"])
 
diff --git a/src/DIRAC/RequestManagementSystem/Service/ReqManagerHandler.py b/src/DIRAC/RequestManagementSystem/Service/ReqManagerHandler.py
index 36325b640ed..9d51ba7a17d 100755
--- a/src/DIRAC/RequestManagementSystem/Service/ReqManagerHandler.py
+++ b/src/DIRAC/RequestManagementSystem/Service/ReqManagerHandler.py
@@ -70,12 +70,8 @@ def validate(cls, request):
     @classmethod
     def export_getRequestIDForName(cls, requestName):
         """get requestID for given :requestName:"""
-        if isinstance(requestName, str):
-            result = cls.__requestDB.getRequestIDForName(requestName)
-            if not result["OK"]:
-                return result
-            requestID = result["Value"]
-        return S_OK(requestID)
+
+        return cls.__requestDB.getRequestIDForName(requestName)
 
     types_cancelRequest = [int]
 
diff --git a/src/DIRAC/ResourceStatusSystem/Client/ResourceStatus.py b/src/DIRAC/ResourceStatusSystem/Client/ResourceStatus.py
index 9df58e313fb..217da7531e8 100644
--- a/src/DIRAC/ResourceStatusSystem/Client/ResourceStatus.py
+++ b/src/DIRAC/ResourceStatusSystem/Client/ResourceStatus.py
@@ -197,7 +197,7 @@ def __getCSElementStatus(self, elementName, elementType, statusType, default):
         :param default: defult value
         :type default: None, str
         """
-
+        cs_path = None
         # DIRAC doesn't store the status of ComputingElements nor FTS in the CS, so here we can just return 'Active'
         if elementType in ("ComputingElement", "FTS"):
             return S_OK({elementName: {"all": "Active"}})
@@ -270,7 +270,7 @@ def __setCSElementStatus(self, elementName, elementType, statusType, status):
         """
         Sets on the CS the Elements status
         """
-
+        cs_path = None
         # DIRAC doesn't store the status of ComputingElements nor FTS in the CS, so here we can just do nothing
         if elementType in ("ComputingElement", "FTS"):
             return S_OK()
diff --git a/src/DIRAC/ResourceStatusSystem/Command/DIRACAccountingCommand.py b/src/DIRAC/ResourceStatusSystem/Command/DIRACAccountingCommand.py
index 0cb7a2ca478..8ac7724e584 100644
--- a/src/DIRAC/ResourceStatusSystem/Command/DIRACAccountingCommand.py
+++ b/src/DIRAC/ResourceStatusSystem/Command/DIRACAccountingCommand.py
@@ -4,6 +4,7 @@
   interrogate the DIRAC Accounting.
 
 """
+
 # FIXME: NOT Usable ATM
 # missing doNew, doCache, doMaster
 
@@ -56,6 +57,7 @@ def doCommand(self):
         period = self.args[4]
         grouping = self.args[5]
 
+        fromT = toT = None
         if period["Format"] == "LastHours":
             fromT = datetime.utcnow() - timedelta(hours=period["hours"])
             toT = datetime.utcnow()
diff --git a/src/DIRAC/ResourceStatusSystem/scripts/dirac_rss_query_db.py b/src/DIRAC/ResourceStatusSystem/scripts/dirac_rss_query_db.py
index a3a153249c9..4a7d03da953 100755
--- a/src/DIRAC/ResourceStatusSystem/scripts/dirac_rss_query_db.py
+++ b/src/DIRAC/ResourceStatusSystem/scripts/dirac_rss_query_db.py
@@ -49,6 +49,7 @@ def parseSwitches():
 
     Script.parseCommandLine(ignoreErrors=True)
     args = Script.getPositionalArgs()
+    query = None
     if len(args) < 3:
         error("Missing all mandatory 'query', 'element', 'tableType' arguments")
     elif args[0].lower() not in ("select", "add", "modify", "delete"):
diff --git a/src/DIRAC/Resources/Catalog/Utilities.py b/src/DIRAC/Resources/Catalog/Utilities.py
index b3a27e25d97..7207dcb8773 100644
--- a/src/DIRAC/Resources/Catalog/Utilities.py
+++ b/src/DIRAC/Resources/Catalog/Utilities.py
@@ -66,6 +66,7 @@ def checkCatalogArguments(f):
     @functools.wraps(f)
     def processWithCheckingArguments(*args, **kwargs):
         checkFlag = kwargs.pop("LFNChecking", True)
+        lfnMap = None
         if checkFlag:
             argList = list(args)
             lfnArgument = argList[1]
diff --git a/src/DIRAC/Resources/Cloud/OpenStackEndpoint.py b/src/DIRAC/Resources/Cloud/OpenStackEndpoint.py
index d93208dab4c..55a65da0db4 100644
--- a/src/DIRAC/Resources/Cloud/OpenStackEndpoint.py
+++ b/src/DIRAC/Resources/Cloud/OpenStackEndpoint.py
@@ -164,6 +164,7 @@ def createInstance(self, instanceID=""):
 
         if not self.initialized:
             self.initialize()
+        numberOfProcessors = -1
 
         imageID = self.parameters.get("ImageID")
         if not imageID:
diff --git a/src/DIRAC/Resources/Computing/BatchSystems/TimeLeft/SGEResourceUsage.py b/src/DIRAC/Resources/Computing/BatchSystems/TimeLeft/SGEResourceUsage.py
index 95e21fcf5ba..4930ff9ebba 100644
--- a/src/DIRAC/Resources/Computing/BatchSystems/TimeLeft/SGEResourceUsage.py
+++ b/src/DIRAC/Resources/Computing/BatchSystems/TimeLeft/SGEResourceUsage.py
@@ -1,6 +1,7 @@
 """ The SGE TimeLeft utility interrogates the SGE batch system for the
     current CPU consumed, as well as its limit.
 """
+
 import os
 import re
 import time
@@ -43,10 +44,11 @@ def getResourceUsage(self):
         lines = str(result["Value"]).split("\n")
         for line in lines:
             if re.search("usage.*cpu.*", line):
-                match = re.search(r"cpu=([\d,:]*),", line)
-                if match:
-                    cpuList = match.groups()[0].split(":")
                 try:
+                    match = re.search(r"cpu=([\d,:]*),", line)
+
+                    cpuList = match.groups()[0].split(":")
+
                     newcpu = 0.0
                     if len(cpuList) == 3:
                         newcpu = float(cpuList[0]) * 3600 + float(cpuList[1]) * 60 + float(cpuList[2])
@@ -59,8 +61,8 @@ def getResourceUsage(self):
                         )
                     if not cpu or newcpu > cpu:
                         cpu = newcpu
-                except ValueError:
-                    self.log.warn(f'Problem parsing "{line}" for CPU consumed')
+                except (ValueError, AttributeError) as e:
+                    self.log.warn(f'Problem parsing "{line}" for CPU consumed {e!r}')
             if re.search("hard resource_list.*cpu.*", line):
                 match = re.search(r"_cpu=(\d*)", line)
                 if match:
diff --git a/src/DIRAC/Resources/Computing/InProcessComputingElement.py b/src/DIRAC/Resources/Computing/InProcessComputingElement.py
index 00c48d5e884..5df0e77b0b7 100755
--- a/src/DIRAC/Resources/Computing/InProcessComputingElement.py
+++ b/src/DIRAC/Resources/Computing/InProcessComputingElement.py
@@ -35,6 +35,7 @@ def submitJob(self, executableFile, proxy=None, inputs=None, **kwargs):
         """
         payloadEnv = dict(os.environ)
         payloadProxy = ""
+        renewTask = None
         if proxy:
             self.log.verbose("Setting up proxy for payload")
             result = self.writeProxyToFile(proxy)
@@ -52,7 +53,6 @@ def submitJob(self, executableFile, proxy=None, inputs=None, **kwargs):
                 renewTask = result["Value"]
             else:
                 self.log.warn("Failed to start proxy renewal task")
-                renewTask = None
 
         self.submittedJobs += 1
         self.runningJobs += 1
diff --git a/src/DIRAC/Resources/Computing/SSHBatchComputingElement.py b/src/DIRAC/Resources/Computing/SSHBatchComputingElement.py
index ac51e7c1a0c..1171c90c589 100644
--- a/src/DIRAC/Resources/Computing/SSHBatchComputingElement.py
+++ b/src/DIRAC/Resources/Computing/SSHBatchComputingElement.py
@@ -1,6 +1,7 @@
 """ SSH (Virtual) Computing Element: For a given list of ip/cores pair it will send jobs
     directly through ssh
 """
+
 import os
 import socket
 import stat
@@ -126,6 +127,7 @@ def killJob(self, jobIDs):
         jobIDList = list(jobIDs)
         if isinstance(jobIDs, str):
             jobIDList = [jobIDs]
+        message = None
 
         hostDict = {}
         for job in jobIDList:
diff --git a/src/DIRAC/Resources/Computing/SingularityComputingElement.py b/src/DIRAC/Resources/Computing/SingularityComputingElement.py
index f31f053fdef..f0e153d11b4 100644
--- a/src/DIRAC/Resources/Computing/SingularityComputingElement.py
+++ b/src/DIRAC/Resources/Computing/SingularityComputingElement.py
@@ -11,6 +11,7 @@
     See the Configuration/Resources/Computing documention for details on
     where to set the option parameters.
 """
+
 import io
 import json
 import os
@@ -359,7 +360,7 @@ def submitJob(self, executableFile, proxy=None, **kwargs):
         :return: S_OK(payload exit code) / S_ERROR() if submission issue
         """
         rootImage = self.__root
-
+        renewTask = None
         # Check that singularity is available
         if not self.__hasSingularity():
             self.log.error("Singularity is not installed on PATH.")
@@ -386,7 +387,6 @@ def submitJob(self, executableFile, proxy=None, **kwargs):
                 renewTask = result["Value"]
             else:
                 self.log.warn("Failed to start proxy renewal task")
-                renewTask = None
 
         # Very simple accounting
         self.__submittedJobs += 1
diff --git a/src/DIRAC/Resources/Storage/GFAL2_StorageBase.py b/src/DIRAC/Resources/Storage/GFAL2_StorageBase.py
index b4f2a009c07..83038cec35a 100644
--- a/src/DIRAC/Resources/Storage/GFAL2_StorageBase.py
+++ b/src/DIRAC/Resources/Storage/GFAL2_StorageBase.py
@@ -473,6 +473,8 @@ def _getSingleFile(self, src_url: str, dest_file: str, disableChecksum: bool = F
         # gfal2 needs a protocol to copy local which is 'file:'
         if not dest_file.startswith("file://"):
             dest = f"file://{os.path.abspath(dest_file)}"
+        else:
+            dest = dest_file
 
         # We can remove the context manager when https://its.cern.ch/jira/browse/DMC-1371
         # is solved
diff --git a/src/DIRAC/Resources/Storage/StorageElement.py b/src/DIRAC/Resources/Storage/StorageElement.py
index 2c2a57f244d..dbf00b070cf 100755
--- a/src/DIRAC/Resources/Storage/StorageElement.py
+++ b/src/DIRAC/Resources/Storage/StorageElement.py
@@ -964,7 +964,7 @@ def getURL(self, lfn, protocol=False, replicaDict=None):
         self.log.getSubLogger("getURL").debug(
             f"Getting accessUrl {f'({protocol})' if protocol else ''} for lfn in {self.name}."
         )
-
+        protocols = None
         if not protocol:
             # This turlProtocols seems totally useless.
             # Get ride of it when gfal2 is totally ready
diff --git a/src/DIRAC/Resources/Storage/test/FIXME_Test_RFIOPlugIn.py b/src/DIRAC/Resources/Storage/test/FIXME_Test_RFIOPlugIn.py
deleted file mode 100755
index 26567061186..00000000000
--- a/src/DIRAC/Resources/Storage/test/FIXME_Test_RFIOPlugIn.py
+++ /dev/null
@@ -1,696 +0,0 @@
-""" test for RFIO plugin
-"""
-
-# FIXME: doesn't work ATM
-
-
-import unittest
-import time
-import os
-import shutil
-from unittest import mock
-
-from DIRAC import S_OK
-
-from DIRAC.Resources.Storage.test.Test_FilePlugin import (
-    mock_StorageFactory_getConfigStorageOptions,
-    mock_StorageFactory_getConfigStorageProtocols,
-    mock_StorageFactory_getConfigStorageName,
-)
-
-# from DIRAC.Resources.Storage.StorageFactory     import StorageFactory
-from DIRAC.Resources.Storage.StorageElement import StorageElementItem
-from DIRAC.Core.Utilities.File import getSize
-
-
-def mock_StorageFactory_getCurrentURL(storageName, derivedStorageName):
-    """Get the options associated to the StorageElement as defined in the CS"""
-    optionsDict = {"BackendType": "local", "ReadAccess": "Active", "WriteAccess": "Active"}
-
-    return S_OK(optionsDict)
-
-
-# class StoragePlugInTestCase( unittest.TestCase ):
-#   """ Base class for the StoragePlugin test cases
-#   """
-#   def setUp( self ):
-#     factory = StorageFactory()
-#     res = factory.getStorages( 'CERN-RAW', ['RFIO'] )
-#     self.assertTrue(res['OK'])
-#     storageDetails = res['Value']
-
-
-class StoragePlugInTestCase(unittest.TestCase):
-    """Base test class. Defines all the method to test"""
-
-    @mock.patch(
-        "DIRAC.Resources.Storage.StorageFactory.StorageFactory._getConfigStorageName",
-        side_effect=mock_StorageFactory_getConfigStorageName,
-    )
-    @mock.patch(
-        "DIRAC.Resources.Storage.StorageFactory.StorageFactory._getConfigStorageOptions",
-        side_effect=mock_StorageFactory_getConfigStorageOptions,
-    )
-    @mock.patch(
-        "DIRAC.Resources.Storage.StorageFactory.StorageFactory._getConfigStorageProtocols",
-        side_effect=mock_StorageFactory_getConfigStorageProtocols,
-    )
-    @mock.patch(
-        "DIRAC.Resources.Storage.StorageElement.StorageElementItem._StorageElementItem__isLocalSE",
-        return_value=S_OK(True),
-    )  # Pretend it's local
-    @mock.patch(
-        "DIRAC.Resources.Storage.StorageElement.StorageElementItem.addAccountingOperation", return_value=None
-    )  # Don't send accounting
-    # @mock.patch( 'DIRAC.Resources.Storage.StorageFactory.StorageFactory._getCurrentURL',
-    #              side_effect = mock_StorageFactory_getCurrentURL_getCurrentURL )
-    def setUp(
-        self,
-        mk_getConfigStorageName,
-        mk_getConfigStorageOptions,
-        mk_getConfigStorageProtocols,
-        mk_isLocalSE,
-        mk_addAccountingOperation,
-    ):
-        self.storage = StorageElementItem("FAKE")
-        self.storage.vo = "test"
-
-        # self.storage = storageDetails['StorageObjects'][0]
-        # self.storage.changeDirectory( 'lhcb/test/unit-test/Storage/RFIOStorage' )
-
-    def test_createUnitTestDir(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tCreate Directory test\n"
-        )
-        # destDir = self.storage.getCurrentURL( '' )['Value']
-        destDir = "/bla/"
-        res = self.storage.createDirectory(destDir)
-        print(res)
-        self.assertTrue(res["OK"])
-        self.assertTrue(destDir in res["Value"]["Successful"])
-        self.assertTrue(res["Value"]["Successful"][destDir])
-
-
-class DirectoryTestCase(StoragePlugInTestCase):
-    def test_isDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tIs Directory test\n"
-        )
-        # Test that we can determine what is a directory
-        destDir = self.storage.getCurrentURL("")["Value"]
-        isDirRes = self.storage.isDirectory(destDir)
-        # Test that we can determine that a directory is not a directory
-        destDir = self.storage.getCurrentURL("NonExistantFile")["Value"]
-        nonExistantDirRes = self.storage.isDirectory(destDir)
-
-        # Check the is directory operation
-        self.assertTrue(isDirRes["OK"])
-        self.assertTrue(destDir in isDirRes["Value"]["Successful"])
-        self.assertTrue(isDirRes["Value"]["Successful"][destDir])
-        # Check the non existant directory operation
-        self.assertTrue(nonExistantDirRes["OK"])
-        self.assertTrue(destDir in nonExistantDirRes["Value"]["Successful"])
-        self.assertFalse(nonExistantDirRes["Value"]["Successful"][destDir])
-
-    def test_putRemoveDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPut Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("putDirTest")["Value"]
-        ignore = self.storage.removeDirectory(remoteDir)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        numberOfFiles = 5
-        sizeOfLocalFile = getSize(srcFile)
-        print(f"Creating local directory: {localDir}")
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirTuple = (localDir, remoteDir)
-        putDirRes = self.storage.putDirectory(dirTuple)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        resDict = putDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Perform the checks for the remove dir operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        resDict = removeDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-
-    def test_putGetDirectoryMetadata(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory Metadata test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("putDirTest")["Value"]
-        ignore = self.storage.removeDirectory(remoteDir)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        numberOfFiles = 5
-        sizeOfLocalFile = getSize(srcFile)
-        print(f"Creating local directory: {localDir}")
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirTuple = (localDir, remoteDir)
-        putDirRes = self.storage.putDirectory(dirTuple)
-        # Get the directory metadata
-        getMetadataRes = self.storage.getDirectoryMetadata(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        resDict = putDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Perform the checks for the get metadata operation
-        self.assertTrue(getMetadataRes["OK"])
-        self.assertTrue(remoteDir in getMetadataRes["Value"]["Successful"])
-        resDict = getMetadataRes["Value"]["Successful"][remoteDir]
-        self.assertTrue("Mode" in resDict)
-        self.assertEqual(resDict["Mode"], 493)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        resDict = removeDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-
-    def test_putGetDirectorySize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory Size test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("putDirTest")["Value"]
-        ignore = self.storage.removeDirectory(remoteDir)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        numberOfFiles = 5
-        sizeOfLocalFile = getSize(srcFile)
-        print(f"Creating local directory: {localDir}")
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirTuple = (localDir, remoteDir)
-        putDirRes = self.storage.putDirectory(dirTuple)
-        # Now get the directory size
-        getDirSizeRes = self.storage.getDirectorySize(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        resDict = putDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Now perform the checks for the get directory size operation
-        self.assertTrue(getDirSizeRes["OK"])
-        self.assertTrue(remoteDir in getDirSizeRes["Value"]["Successful"])
-        resDict = getDirSizeRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        resDict = removeDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-
-    def test_putListDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tList Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("putDirTest")["Value"]
-        ignore = self.storage.removeDirectory(remoteDir)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        numberOfFiles = 5
-        sizeOfLocalFile = getSize(srcFile)
-        print(f"Creating local directory: {localDir}")
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirTuple = (localDir, remoteDir)
-        putDirRes = self.storage.putDirectory(dirTuple)
-        # List the remote directory
-        listDirRes = self.storage.listDirectory(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        resDict = putDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Perform the checks for the list dir operation
-        self.assertTrue(listDirRes["OK"])
-        self.assertTrue(remoteDir in listDirRes["Value"]["Successful"])
-        resDict = listDirRes["Value"]["Successful"][remoteDir]
-        self.assertTrue("SubDirs" in resDict)
-        self.assertTrue("Files" in resDict)
-        self.assertEqual(len(resDict["Files"]), numberOfFiles)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        resDict = removeDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-
-    def test_putGetDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("putDirTest")["Value"]
-        ignore = self.storage.removeDirectory(remoteDir)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        numberOfFiles = 5
-        sizeOfLocalFile = getSize(srcFile)
-        print(f"Creating local directory: {localDir}")
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirTuple = (localDir, remoteDir)
-        putDirRes = self.storage.putDirectory(dirTuple)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-        # Check that we can get directories from the storage element
-        directoryTuple = (remoteDir, localDir)
-        getDirRes = self.storage.getDirectory(directoryTuple)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir)
-        # Clean up the locally created directory
-        print(f"Removing local directory: {localDir}")
-        localFiles = os.listdir(localDir)
-        for fileName in localFiles:
-            fullPath = f"{localDir}/{fileName}"
-            os.remove(fullPath)
-        os.removedirs(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        resDict = putDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Perform the checks for the get dir operation
-        self.assertTrue(getDirRes["OK"])
-        self.assertTrue(remoteDir in getDirRes["Value"]["Successful"])
-        resDict = getDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        resDict = removeDirRes["Value"]["Successful"][remoteDir]
-        self.assertEqual(resDict["Files"], numberOfFiles)
-        self.assertEqual(resDict["Size"], numberOfFiles * sizeOfLocalFile)
-
-
-class FileTestCase(StoragePlugInTestCase):
-    def test_putRemoveFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPut and Remove test\n"
-        )
-        # First test that we are able to determine whether the file sizes of the transfer don't match
-        srcFile = "/etc/group"
-        fileSize = 10  # This is a made up value
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        failedPutFileRes = self.storage.putFile(fileTuple)
-        # Now make sure that we can actually upload a file properly
-        fileSize = getSize(srcFile)
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Make sure we are able to remove the file
-        removeFileRes = self.storage.removeFile(destFile)
-
-        # Check the failed put file operation
-        self.assertTrue(failedPutFileRes["OK"])
-        self.assertTrue(destFile in failedPutFileRes["Value"]["Failed"])
-        expectedError = "RFIOStorage.putFile: Source and destination file sizes do not match."
-        self.assertEqual(failedPutFileRes["Value"]["Failed"][destFile], expectedError)
-        # Check the successful put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-
-    """
-  def test_putGetFile(self):
-    print '\n\n#########################################################################\n\n\t\t\tPut and Get test\n'
-    # First upload a file to the storage
-    srcFile = '/etc/group'
-    fileSize = getSize(srcFile)
-    testFileName = 'testFile.%s' % time.time()
-    destFile = self.storage.getCurrentURL(testFileName)['Value']
-    fileTuple = (srcFile,destFile,fileSize)
-    putRes = self.storage.putFile(fileTuple)
-    # Make sure we can detect when the file transferred incorrectly
-    destLocalFile = "%s/%s.%s" % (os.getcwd(),'unitTestFile',time.time())
-    wrongSize = 10
-    fileTuple = (destFile,destLocalFile,wrongSize)
-    failedGetRes = self.storage.getFile(fileTuple)
-    # Then make sure we can get a local copy of the file
-    destLocalFile = "%s/%s.%s" % (os.getcwd(),'unitTestFile',time.time())
-    fileTuple = (destFile,destLocalFile,fileSize)
-    getFileRes = self.storage.getFile(fileTuple)
-    # Cleanup the remote mess
-    removeFileRes = self.storage.removeFile(destFile)
-    #Cleanup the mess locally
-    os.remove(destLocalFile)
-
-    # Check the put operation
-    self.assertTrue(putRes['OK'])
-    self.assertTrue(putRes['Value']['Successful'].has_key(destFile))
-    # Check the failed get operation
-    self.assertTrue(failedGetRes['OK'])
-    self.assertTrue(failedGetRes['Value']['Failed'].has_key(destFile))
-    expectedError = 'RFIOStorage.getFile: Source and destination file sizes do not match.'
-    self.assertEqual(failedGetRes['Value']['Failed'][destFile],expectedError)
-    # Check the get operation
-    self.assertTrue(getFileRes['OK'])
-    self.assertTrue(getFileRes['Value']['Successful'].has_key(destFile))
-    # Check the remove operation
-    self.assertTrue(removeFileRes['OK'])
-    self.assertTrue(removeFileRes['Value']['Successful'].has_key(destFile))
-
-  """
-
-    def test_putExistsFile(self):
-        print("\n\n#########################################################" "################\n\n\t\t\tExists test\n")
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Then get the file's existance
-        existsFileRes = self.storage.exists(destFile)
-        # Now remove the file
-        removeFileRes = self.storage.removeFile(destFile)
-        # Check  again that the file exists
-        failedExistRes = self.storage.exists(destFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check the exists operation
-        self.assertTrue(existsFileRes["OK"])
-        self.assertTrue(destFile in existsFileRes["Value"]["Successful"])
-        self.assertTrue(existsFileRes["Value"]["Successful"][destFile])
-        # Check the removal operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        # Check the failed exists operation
-        self.assertTrue(failedExistRes["OK"])
-        self.assertTrue(destFile in failedExistRes["Value"]["Successful"])
-        self.assertFalse(failedExistRes["Value"]["Successful"][destFile])
-
-    def test_putIsFile(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tIs file test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Check we are able to determine that it is a file
-        isFileRes = self.storage.isFile(destFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(destFile)
-        # Check that everything isn't a file
-        destDir = os.path.dirname(destFile)
-        failedIsFileRes = self.storage.isFile(destDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check the is file operation
-        self.assertTrue(isFileRes["OK"])
-        self.assertTrue(destFile in isFileRes["Value"]["Successful"])
-        self.assertTrue(isFileRes["Value"]["Successful"][destFile])
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        # Check that the directory is not a file
-        self.assertTrue(failedIsFileRes["OK"])
-        self.assertTrue(destDir in failedIsFileRes["Value"]["Successful"])
-        self.assertFalse(failedIsFileRes["Value"]["Successful"][destDir])
-
-    def test_putGetFileMetaData(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file metadata test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Check that we can get the file metadata
-        getMetadataRes = self.storage.getFileMetadata(destFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(destFile)
-        # See what happens with non existant files
-        failedMetadataRes = self.storage.getFileMetadata(destFile)
-        # Check directories are handled properly
-        destDir = os.path.dirname(destFile)
-        directoryMetadataRes = self.storage.getFileMetadata(destDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check the get metadata operation
-        self.assertTrue(getMetadataRes["OK"])
-        self.assertTrue(destFile in getMetadataRes["Value"]["Successful"])
-        fileMetaData = getMetadataRes["Value"]["Successful"][destFile]
-        # self.assertTrue(fileMetaData['Cached'])
-        # self.assertFalse(fileMetaData['Migrated'])
-        self.assertEqual(fileMetaData["Size"], fileSize)
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        # Check the get metadata for non existant file
-        self.assertTrue(failedMetadataRes["OK"])
-        self.assertTrue(destFile in failedMetadataRes["Value"]["Failed"])
-        expectedError = "No such file or directory"
-        self.assertEqual(failedMetadataRes["Value"]["Failed"][destFile], expectedError)
-        # Check that metadata operation with a directory
-        self.assertTrue(directoryMetadataRes["OK"])
-        self.assertTrue(destDir in directoryMetadataRes["Value"]["Failed"])
-        expectedError = "RFIOStorage.getFileMetadata: Supplied path is not a file."
-        self.assertEqual(directoryMetadataRes["Value"]["Failed"][destDir], expectedError)
-
-    def test_putGetFileSize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file size test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Check that we can get the file size
-        getSizeRes = self.storage.getFileSize(destFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(destFile)
-        # Check non existant files
-        failedSizeRes = self.storage.getFileMetadata(destFile)
-        # Check directories are handled properly
-        destDir = os.path.dirname(destFile)
-        directorySizeRes = self.storage.getFileSize(destDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check that we got the file size correctly
-        self.assertTrue(getSizeRes["OK"])
-        self.assertTrue(destFile in getSizeRes["Value"]["Successful"])
-        self.assertEqual(getSizeRes["Value"]["Successful"][destFile], fileSize)
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        # Check the get size with non existant file works properly
-        self.assertTrue(failedSizeRes["OK"])
-        self.assertTrue(destFile in failedSizeRes["Value"]["Failed"])
-        expectedError = "No such file or directory"
-        self.assertEqual(failedSizeRes["Value"]["Failed"][destFile], expectedError)
-        # Check that the passing a directory is handled correctly
-        self.assertTrue(directorySizeRes["OK"])
-        self.assertTrue(destDir in directorySizeRes["Value"]["Failed"])
-        expectedError = "RFIOStorage.getFileSize: Supplied path is not a file."
-        self.assertEqual(directorySizeRes["Value"]["Failed"][destDir], expectedError)
-
-    def test_putPrestageFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tFile prestage test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Check that we can issue a stage request
-        prestageRes = self.storage.prestageFile(destFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(destFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # Check the prestage file operation
-        self.assertTrue(prestageRes["OK"])
-        self.assertTrue(destFile in prestageRes["Value"]["Successful"])
-        self.assertTrue(prestageRes["Value"]["Successful"][destFile])
-        # Check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-
-        # These checks are currently disabled until a bug is fixed
-        # Check what happens with deleted files
-        # deletedPrestageRes = self.storage.prestageFile(destFile)
-        # self.assertTrue(deletedPrestageRes['OK'])
-        # self.assertTrue(deletedPrestageRes['Value']['Failed'].has_key(destFile))
-
-        # Check what happens with non-existant files #THIS IS A BUG, REPORT IR
-        # testFile = "%s-THIS-IS-DEFINATELY-NOT-A-FILE" % destFile
-        # nonExistantPrestageRes= self.storage.prestageFile(testFile)
-        # self.assertTrue(nonExistantPrestageRes['OK'])
-        # self.assertTrue(nonExistantPrestageRes['Value']['Failed'].has_key(destFile))
-
-    def test_putFilegetTransportURL(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tGet tURL test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        fileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileTuple = (srcFile, destFile, fileSize)
-        putFileRes = self.storage.putFile(fileTuple)
-        # Check that we can get a turl
-        getTurlRes = self.storage.getTransportURL(destFile, ["dcap", "gsidcap"])
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(destFile)
-        # Try and get a turl for a non existant file
-        failedGetTurlRes = self.storage.getTransportURL(destFile, ["dcap", "gsidcap"])
-
-        # Check the put file operation
-        print(putFileRes)
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        # check the get turl operation
-        print(getTurlRes, destFile)
-        self.assertTrue(getTurlRes["OK"])
-        self.assertTrue(destFile in getTurlRes["Value"]["Successful"])
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        # Check the get turl with non existant file operation
-        self.assertTrue(failedGetTurlRes["OK"])
-        self.assertTrue(destFile in failedGetTurlRes["Value"]["Failed"])
-        expectedError = "RFIOStorage.getTransportURL: File does not exist."
-        self.assertEqual(failedGetTurlRes["Value"]["Failed"][destFile], expectedError)
-
-
-if __name__ == "__main__":
-    suite = unittest.defaultTestLoader.loadTestsFromTestCase(StoragePlugInTestCase)
-    # suite = unittest.defaultTestLoader.loadTestsFromTestCase( FileTestCase )
-    # suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(DirectoryTestCase))
-    testResult = unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/src/DIRAC/Resources/Storage/test/FIXME_Test_StorageElement.py b/src/DIRAC/Resources/Storage/test/FIXME_Test_StorageElement.py
deleted file mode 100755
index ad16b2dc33b..00000000000
--- a/src/DIRAC/Resources/Storage/test/FIXME_Test_StorageElement.py
+++ /dev/null
@@ -1,772 +0,0 @@
-#! /usr/bin/env python
-
-# FIXME: if it requires a dirac.cfg it is not a unit test and should be moved to tests directory
-
-import unittest
-import time
-import os
-import shutil
-import sys
-
-from DIRAC.Core.Base.Script import parseCommandLine, getPositionalArgs
-
-parseCommandLine()
-
-from DIRAC import gLogger
-
-from DIRAC.Resources.Storage.StorageElement import StorageElement
-from DIRAC.Core.Utilities.ReturnValues import returnSingleResult
-from DIRAC.Core.Utilities.File import getSize
-
-positionalArgs = getPositionalArgs()
-if len(positionalArgs) < 3:
-    print("Usage: TestStoragePlugIn.py StorageElement <lfnDir> <localFile>")
-    sys.exit()
-else:
-    storageElementToTest = positionalArgs[0]
-    lfnDirToTest = positionalArgs[1]
-    fileToTest = positionalArgs[2]
-
-
-class StorageElementTestCase(unittest.TestCase):
-    """Base class for the StorageElement test cases"""
-
-    def setUp(self):
-        self.numberOfFiles = 1
-        self.storageElement = StorageElement(storageElementToTest)
-        self.localSourceFile = fileToTest
-        self.localFileSize = getSize(self.localSourceFile)
-        self.destDirectory = lfnDirToTest
-        # destinationDir = returnSingleResult( self.storageElement.getURL( self.destDirectory ) )['Value']
-        destinationDir = self.destDirectory
-        res = self.storageElement.createDirectory(destinationDir)
-        self.assertTrue(res["OK"])
-
-    def tearDown(self):
-        # destinationDir = returnSingleResult( self.storageElement.getURL( self.destDirectory ) )['Value']
-        res = self.storageElement.removeDirectory(self.destDirectory, recursive=True)
-        self.assertTrue(res["OK"])
-
-
-class GetInfoTestCase(StorageElementTestCase):
-    def test_dump(self):
-        print("\n\n#########################################################" "################\n\n\t\t\tDump test\n")
-        self.storageElement.dump()
-
-    def test_isValid(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tIs valid test\n"
-        )
-        res = self.storageElement.isValid()
-        self.assertTrue(res["OK"])
-
-    def test_getRemoteProtocolSections(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet remote protocols test\n"
-        )
-        res = self.storageElement.getRemoteProtocolSections()
-        self.assertTrue(res["OK"])
-        self.assertEqual(type(res["Value"]), list)
-
-    def test_getLocalProtocolSections(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet local protocols test\n"
-        )
-        res = self.storageElement.getLocalProtocolSections()
-        self.assertTrue(res["OK"])
-        self.assertEqual(type(res["Value"]), list)
-
-    def test_getPlugins(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet protocols test\n"
-        )
-        res = self.storageElement.getPlugins()
-        self.assertTrue(res["OK"])
-        self.assertEqual(type(res["Value"]), list)
-
-    # def test_isLocalSE( self ):
-    #  print '\n\n#########################################################################\n\n\t\t\tIs local SE test\n'
-    #  res = self.storageElement.isLocalSE()
-    #  self.assertTrue(res['OK'])
-    #  self.assertFalse( res['Value'] )
-
-    # def test_getStorageElementOption( self ):
-    #  print '\n\n########################################################################
-    #  \n\n\t\t\tGet storage element option test\n'
-    #  res = self.storageElement.getStorageElementOption( 'BackendType' )
-    #  self.assertTrue(res['OK'])
-    #  self.assertEqual( res['Value'], 'DISET' )
-
-    def test_getStorageParameters(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet storage parameters test\n"
-        )
-        result = self.storageElement.getStorageParameters("DIP")
-        self.assertTrue(result["OK"])
-        resDict = result["Value"]
-        self.assertEqual(resDict["Protocol"], "dips")
-        # self.assertEqual( resDict['SpaceToken'], 'LHCb_RAW' )
-        # self.assertEqual( resDict['WSUrl'], '/srm/managerv2?SFN=' )
-        # self.assertEqual( resDict['Host'], 'srm-lhcb.cern.ch' )
-        # self.assertEqual( resDict['Path'], '/castor/cern.ch/grid' )
-        # self.assertEqual( resDict['ProtocolName'], 'SRM2' )
-        # self.assertEqual( resDict['Port'], '8443' )
-
-
-class FileTestCases(StorageElementTestCase):
-    def test_exists(self):
-        print("\n\n#########################################################" "################\n\n\t\t\tExists test\n")
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = self.storageElement.getURL( destinationFilePath )
-        # destinationPfn = list(pfnForLfnRes['Value']['Successful'].values())[0]
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # File exists
-        existsRes = returnSingleResult(self.storageElement.exists(destinationFilePath))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Check removed file
-        missingExistsRes = returnSingleResult(self.storageElement.exists(destinationFilePath))
-        # Check directories are handled properly
-        destinationDir = os.path.dirname(destinationFilePath)
-        directoryExistsRes = returnSingleResult(self.storageElement.exists(destinationDir))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that we checked the file correctly
-        self.assertTrue(existsRes["OK"])
-        self.assertTrue(existsRes["Value"])
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-        # Check the exists for non existant file
-        self.assertTrue(missingExistsRes["OK"])
-        self.assertFalse(missingExistsRes["Value"])
-        # Check that directories exist
-        self.assertTrue(directoryExistsRes["OK"])
-        self.assertTrue(directoryExistsRes["Value"])
-
-    def test_isFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tIs file size test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Is a file
-        isFileRes = returnSingleResult(self.storageElement.isFile(destinationFilePath))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Get metadata for a removed file
-        missingIsFileRes = returnSingleResult(self.storageElement.isFile(destinationFilePath))
-        # Check directories are handled properly
-        destinationDir = os.path.dirname(destinationFilePath)
-        directoryIsFileRes = returnSingleResult(self.storageElement.isFile(destinationDir))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that we checked the file correctly
-        self.assertTrue(isFileRes["OK"])
-        self.assertTrue(isFileRes["Value"])
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-        # Check the is file for non existant file
-        self.assertFalse(missingIsFileRes["OK"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in missingIsFileRes["Message"])
-        # Check that is file operation with a directory
-        self.assertTrue(directoryIsFileRes["OK"])
-        self.assertFalse(directoryIsFileRes["Value"])
-
-    def test_putFile(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tPut file test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-
-    def test_getFile(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tGet file test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Now get a local copy of the file
-        getFileRes = returnSingleResult(self.storageElement.getFile(destinationFilePath))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Clean up the local mess
-        os.remove(os.path.basename(destinationFilePath))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that we got the file correctly
-        self.assertTrue(getFileRes["OK"])
-        self.assertEqual(getFileRes["Value"], self.localFileSize)
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-
-    def test_getFileMetadata(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file metadata test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Get the file metadata
-        getFileMetadataRes = returnSingleResult(self.storageElement.getFileMetadata(destinationFilePath))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Get metadata for a removed file
-        getMissingFileMetadataRes = returnSingleResult(self.storageElement.getFileMetadata(destinationFilePath))
-        # Check directories are handled properly
-        destinationDir = os.path.dirname(destinationFilePath)
-        directoryMetadataRes = returnSingleResult(self.storageElement.getFileMetadata(destinationDir))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that the metadata was done correctly
-        self.assertTrue(getFileMetadataRes["OK"])
-        metadataDict = getFileMetadataRes["Value"]
-
-        # Works only for SRM2 plugin
-        # self.assertTrue( metadataDict['Cached'] )
-        # self.assertFalse( metadataDict['Migrated'] )
-        self.assertEqual(metadataDict["Size"], self.localFileSize)
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-        # Check the get metadata for non existant file
-        self.assertFalse(getMissingFileMetadataRes["OK"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in getMissingFileMetadataRes["Message"])
-        # Check that metadata operation with a directory
-        self.assertFalse(directoryMetadataRes["OK"])
-        expectedError = "Supplied path is not a file"
-        self.assertTrue(expectedError in directoryMetadataRes["Message"])
-
-    def test_getFileSize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file size test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Get the file metadata
-        getFileSizeRes = returnSingleResult(self.storageElement.getFileSize(destinationFilePath))
-        # Now remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Get metadata for a removed file
-        getMissingFileSizeRes = returnSingleResult(self.storageElement.getFileSize(destinationFilePath))
-        # Check directories are handled properly
-        destinationDir = os.path.dirname(destinationFilePath)
-        directorySizeRes = returnSingleResult(self.storageElement.getFileSize(destinationDir))
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that the metadata was done correctly
-        self.assertTrue(getFileSizeRes["OK"])
-        self.assertEqual(getFileSizeRes["Value"], self.localFileSize)
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-        # Check the get metadata for non existant file
-        self.assertFalse(getMissingFileSizeRes["OK"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in getMissingFileSizeRes["Message"])
-        # Check that metadata operation with a directory
-        self.assertFalse(directorySizeRes["OK"])
-        expectedError = "Supplied path is not a file"
-        self.assertTrue(expectedError in directorySizeRes["Message"])
-
-    def test_getURL(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\tGet access url test\n"
-        )
-        destinationFilePath = f"{self.destDirectory}/testFile.{time.time()}"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( destinationFilePath ) )
-        # destinationPfn = pfnForLfnRes['Value']
-        fileDict = {destinationFilePath: self.localSourceFile}
-        putFileRes = returnSingleResult(self.storageElement.putFile(fileDict))
-        # Get a transfer url for the file
-        getTurlRes = self.storageElement.getURL(destinationFilePath, protocol="dips")
-        # Remove the destination file
-        removeFileRes = returnSingleResult(self.storageElement.removeFile(destinationFilePath))
-        # Get missing turl res
-        getMissingTurlRes = self.storageElement.getURL(destinationFilePath, protocol="dips")
-
-        # Check that the put was done correctly
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(putFileRes["Value"])
-        self.assertEqual(putFileRes["Value"], self.localFileSize)
-        # Check that we can get the tURL properly
-        self.assertTrue(getTurlRes["OK"])
-        self.assertTrue(getTurlRes["Value"])
-        self.assertTrue(isinstance(getTurlRes["Value"], dict))
-        self.assertTrue(type(getTurlRes["Value"]["Successful"][destinationFilePath]) in (str,))
-        # Check that the removal was done correctly
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(removeFileRes["Value"])
-
-        # Works only for SRM2 plugins
-        # # Check that non-existant files are handled correctly
-        # self.assertFalse( getMissingTurlRes['OK'] )
-        # expectedError = "File does not exist"
-        # self.assertTrue( expectedError in getMissingTurlRes['Message'] )
-
-
-# Works only for SRM2 plugins
-#   def test_prestageFile( self ):
-#     destinationFilePath = '%s/testFile.%s' % ( self.destDirectory, time.time() )
-#     pfnForLfnRes = self.storageElement.getURL( destinationFilePath )
-#     destinationPfn = pfnForLfnRes['Value']
-#     fileDict = {destinationPfn:self.localSourceFile}
-#     putFileRes = self.storageElement.putFile( fileDict, singleFile = True )
-#     # Get the file metadata
-#     prestageFileRes = self.storageElement.prestageFile( destinationPfn, singleFile = True )
-#     # Now remove the destination file
-#     removeFileRes = self.storageElement.removeFile( destinationPfn, singleFile = True )
-#     # Get metadata for a removed file
-#     missingPrestageFileRes = self.storageElement.prestageFile( destinationPfn, singleFile = True )
-#
-#     # Check that the put was done correctly
-#     self.assertTrue( putFileRes['OK'] )
-#     self.assertTrue( putFileRes['Value'] )
-#     self.assertEqual( putFileRes['Value'], self.localFileSize )
-#     # Check that the prestage was done correctly
-#     self.assertTrue( prestageFileRes['OK'] )
-#     self.assertEqual( type( prestageFileRes['Value'] ), types.StringType )
-#     # Check that the removal was done correctly
-#     self.assertTrue( removeFileRes['OK'] )
-#     self.assertTrue( removeFileRes['Value'] )
-#     # Check the prestage for non existant file
-#     self.assertFalse( missingPrestageFileRes['OK'] )
-#     expectedError = "No such file or directory"
-#     self.assertTrue( expectedError in missingPrestageFileRes['Message'] )
-
-# Works only for SRM2 plugins
-#   def test_prestageStatus( self ):
-#     destinationFilePath = '%s/testFile.%s' % ( self.destDirectory, time.time() )
-#     pfnForLfnRes = self.storageElement.getURL( destinationFilePath )
-#     destinationPfn = pfnForLfnRes['Value']
-#     fileDict = {destinationPfn:self.localSourceFile}
-#     putFileRes = self.storageElement.putFile( fileDict, singleFile = True )
-#     # Get the file metadata
-#     prestageFileRes = self.storageElement.prestageFile( destinationPfn, singleFile = True )
-#     srmID = ''
-#     if prestageFileRes['OK']:
-#       srmID = prestageFileRes['Value']
-#     # Take a quick break to allow the SRM to realise the file is available
-#     sleepTime = 10
-#     print 'Sleeping for %s seconds' % sleepTime
-#     time.sleep( sleepTime )
-#     # Check that we can monitor the stage request
-#     prestageStatusRes = self.storageElement.prestageFileStatus( {destinationPfn:srmID}, singleFile = True )
-#     # Now remove the destination file
-#     removeFileRes = self.storageElement.removeFile( destinationPfn, singleFile = True )
-#
-#     # Check that the put was done correctly
-#     self.assertTrue( putFileRes['OK'] )
-#     self.assertTrue( putFileRes['Value'] )
-#     self.assertEqual( putFileRes['Value'], self.localFileSize )
-#     # Check that the prestage was done correctly
-#     self.assertTrue( prestageFileRes['OK'] )
-#     self.assertEqual( type( prestageFileRes['Value'] ), types.StringType )
-#     # Check the file was found to be staged
-#     self.assertTrue( prestageStatusRes['OK'] )
-#     self.assertTrue( prestageStatusRes['Value'] )
-#     # Check that the removal was done correctly
-#     self.assertTrue( removeFileRes['OK'] )
-#     self.assertTrue( removeFileRes['Value'] )
-
-
-# Works only for SRM2 plugins
-#   def test_pinRelease( self ):
-#     print '\n\n#########################################################################\n\n\t\tPin release test\n'
-#     destinationFilePath = '%s/testFile.%s' % ( self.destDirectory, time.time() )
-#     pfnForLfnRes = self.storageElement.getURL( destinationFilePath )
-#     destinationPfn = pfnForLfnRes['Value']
-#     fileDict = {destinationPfn:self.localSourceFile}
-#     putFileRes = self.storageElement.putFile( fileDict, singleFile = True )
-#     # Get the file metadata
-#     pinFileRes = self.storageElement.pinFile( destinationPfn, singleFile = True )
-#     srmID = ''
-#     if pinFileRes['OK']:
-#       srmID = pinFileRes['Value']
-#     # Check that we can release the file
-#     releaseFileRes = self.storageElement.releaseFile( {destinationPfn:srmID}, singleFile = True )
-#     # Now remove the destination file
-#     removeFileRes = self.storageElement.removeFile( destinationPfn, singleFile = True )
-#
-#     # Check that the put was done correctly
-#     self.assertTrue( putFileRes['OK'] )
-#     self.assertTrue( putFileRes['Value'] )
-#     self.assertEqual( putFileRes['Value'], self.localFileSize )
-#     # Check that the file pin was done correctly
-#     self.assertTrue( pinFileRes['OK'] )
-#     self.assertEqual( type( pinFileRes['Value'] ), types.StringType )
-#     # Check the file was found to be staged
-#     self.assertTrue( releaseFileRes['OK'] )
-#     self.assertTrue( releaseFileRes['Value'] )
-#     # Check that the removal was done correctly
-#     self.assertTrue( removeFileRes['OK'] )
-#     self.assertTrue( removeFileRes['Value'] )
-
-
-class DirectoryTestCases(StorageElementTestCase):
-    def test_createDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tCreate directory test\n"
-        )
-        directory = f"{self.destDirectory}/createDirectoryTest"
-        # pfnForLfnRes = returnSingleResult( self.storageElement.getURL( directory ) )
-        # directoryPfn = pfnForLfnRes['Value']
-
-        createDirRes = self.storageElement.createDirectory(directory)
-        # Remove the target dir
-        removeDirRes = self.storageElement.removeDirectory(directory, recursive=True)
-
-        # Check that the creation was done correctly
-        self.assertTrue(createDirRes["OK"])
-        self.assertTrue(createDirRes["Value"])
-        # Remove the directory
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-
-    def test_isDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tIs directory test\n"
-        )
-        destDirectory = self.destDirectory
-        # Test that it is a directory
-        isDirectoryRes = self.storageElement.isDirectory(destDirectory)
-        # Test that no existant dirs are handled correctly
-        nonExistantDir = f"{destDirectory}/NonExistant"
-        nonExistantDirRes = self.storageElement.isDirectory(nonExistantDir)
-
-        # Check that it works with the existing dir
-        self.assertTrue(isDirectoryRes["OK"])
-        self.assertTrue(isDirectoryRes["Value"])
-        # Check that we handle non existant correctly
-        self.assertTrue(nonExistantDirRes["Value"]["Failed"][nonExistantDir] in ["Path does not exist"])
-
-    def test_listDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tList directory test\n"
-        )
-        destDirectory = f"{self.destDirectory}/listDirectoryTest"
-        # destDirectory = returnSingleResult( self.storageElement.getURL( directory ) )['Value']
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {destDirectory: localDir}
-        putDirRes = self.storageElement.putDirectory(dirDict)
-        print(putDirRes)
-        # List the remote directory
-        listDirRes = self.storageElement.listDirectory(destDirectory)
-        # Now remove the remove directory
-        removeDirRes = self.storageElement.removeDirectory(destDirectory, recursive=True)
-        print(removeDirRes)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(putDirRes["Value"])
-        if putDirRes["Value"]["Successful"][destDirectory]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][destDirectory]["Files"], self.numberOfFiles)
-            self.assertEqual(
-                putDirRes["Value"]["Successful"][destDirectory]["Size"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Files"]) in (int,))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Size"]) in (int,))
-        # Perform the checks for the list dir operation
-        self.assertTrue(listDirRes["OK"])
-        self.assertTrue(listDirRes["Value"])
-        self.assertTrue("SubDirs" in listDirRes["Value"]["Successful"][destDirectory])
-        self.assertTrue("Files" in listDirRes["Value"]["Successful"][destDirectory])
-        self.assertEqual(len(listDirRes["Value"]["Successful"][destDirectory]["Files"]), self.numberOfFiles)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-        if removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]) in (int,))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"]) in (int,))
-
-    def test_getDirectoryMetadata(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tDirectory metadata test\n"
-        )
-        destDirectory = f"{self.destDirectory}/getDirectoryMetadataTest"
-        # destDirectory = returnSingleResult( self.storageElement.getURL( directory ) )['Value']
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {destDirectory: localDir}
-        putDirRes = self.storageElement.putDirectory(dirDict)
-        # Get the directory metadata
-        metadataDirRes = self.storageElement.getDirectoryMetadata(destDirectory)
-        # Now remove the remove directory
-        removeDirRes = self.storageElement.removeDirectory(destDirectory, recursive=True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(putDirRes["Value"])
-        if putDirRes["Value"]["Successful"][destDirectory]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][destDirectory]["Files"], self.numberOfFiles)
-            self.assertEqual(
-                putDirRes["Value"]["Successful"][destDirectory]["Size"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Files"]) in (int,))
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Size"]) in (int,))
-        # Perform the checks for the list dir operation
-        self.assertTrue(metadataDirRes["OK"])
-        self.assertTrue(metadataDirRes["Value"])
-
-        # Works only for the SRM2 plugin
-        # self.assertTrue( metadataDirRes['Value']['Mode'] )
-        # self.assertTrue( type( metadataDirRes['Value']['Mode'] ) == int )
-
-        self.assertTrue(metadataDirRes["Value"]["Successful"][destDirectory]["Exists"])
-        self.assertEqual(metadataDirRes["Value"]["Successful"][destDirectory]["Type"], "Directory")
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-        if removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]) in (int,))
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"]) in (int,))
-
-    def test_getDirectorySize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet directory size test\n"
-        )
-        destDirectory = f"{self.destDirectory}/getDirectorySizeTest"
-        # destDirectory = returnSingleResult( self.storageElement.getURL( directory ) )['Value']
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {destDirectory: localDir}
-        putDirRes = self.storageElement.putDirectory(dirDict)
-        # Get the directory metadata
-        getDirSizeRes = self.storageElement.getDirectorySize(destDirectory)
-        # Now remove the remove directory
-        removeDirRes = self.storageElement.removeDirectory(destDirectory, recursive=True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(putDirRes["Value"])
-        if putDirRes["Value"]["Successful"][destDirectory]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][destDirectory]["Files"], self.numberOfFiles)
-            self.assertEqual(
-                putDirRes["Value"]["Successful"][destDirectory]["Size"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Files"]) in (int,))
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Size"]) in (int,))
-        # Perform the checks for the get dir size operation
-        self.assertTrue(getDirSizeRes["OK"])
-        self.assertTrue(getDirSizeRes["Value"])
-        self.assertFalse(getDirSizeRes["Value"]["Successful"][destDirectory]["SubDirs"])
-        self.assertTrue(type(getDirSizeRes["Value"]["Successful"][destDirectory]["Files"]) in (int,))
-        self.assertTrue(type(getDirSizeRes["Value"]["Successful"][destDirectory]["Size"]) in (int,))
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-        if removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]) in (int,))
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"]) in (int,))
-
-    def test_removeDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tRemove directory test\n"
-        )
-        destDirectory = f"{self.destDirectory}/removeDirectoryTest"
-        # destDirectory = returnSingleResult( self.storageElement.getURL( directory ) )['Value']
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {destDirectory: localDir}
-        putDirRes = self.storageElement.putDirectory(dirDict)
-        # Get the directory metadata
-        # Now remove the remove directory
-        removeDirRes = self.storageElement.removeDirectory(destDirectory, recursive=True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(putDirRes["Value"])
-        if putDirRes["Value"]["Successful"][destDirectory]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][destDirectory]["Files"], self.numberOfFiles)
-            self.assertEqual(
-                putDirRes["Value"]["Successful"][destDirectory]["Size"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Files"]) in (int,))
-            self.assertTrue(type(putDirRes["Value"]["Successful"][destDirectory]["Size"]) in (int,))
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-        if removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]) in (int,))
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"]) in (int,))
-
-    def test_getDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet directory test\n"
-        )
-        destDirectory = f"{self.destDirectory}/getDirectoryTest"
-        # destDirectory = returnSingleResult( self.storageElement.getURL( directory ) )['Value']
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {destDirectory: localDir}
-        putDirRes = self.storageElement.putDirectory(dirDict)
-        # Get the directory metadata
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-        getDirRes = self.storageElement.getDirectory(destDirectory, localPath=localDir)
-        # Now remove the remove directory
-        removeDirRes = self.storageElement.removeDirectory(destDirectory, recursive=True)
-        # Clean up the locally created directory
-        if os.path.exists(localDir):
-            shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(putDirRes["Value"])
-        for _dir in dirDict:
-            if putDirRes["Value"]["Successful"][_dir]["Files"]:
-                self.assertEqual(putDirRes["Value"]["Successful"][_dir]["Files"], self.numberOfFiles)
-                self.assertEqual(putDirRes["Value"]["Successful"][_dir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-                self.assertTrue(type(putDirRes["Value"]["Successful"][_dir]["Files"]) in (int,))
-                self.assertTrue(type(putDirRes["Value"]["Successful"][_dir]["Size"]) in (int,))
-        # Perform the checks for the get directory operation
-        self.assertTrue(getDirRes["OK"])
-        self.assertTrue(getDirRes["Value"])
-        for _dir in dirDict:
-            if getDirRes["Value"]["Successful"][_dir]["Files"]:
-                self.assertEqual(getDirRes["Value"]["Successful"][_dir]["Files"], self.numberOfFiles)
-                self.assertEqual(getDirRes["Value"]["Successful"][_dir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-                self.assertTrue(type(getDirRes["Value"]["Successful"][_dir]["Files"]) in (int,))
-                self.assertTrue(type(getDirRes["Value"]["Successful"][_dir]["Size"]) in (int,))
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(removeDirRes["Value"])
-        if removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["FilesRemoved"]) in (int,))
-            self.assertTrue(type(removeDirRes["Value"]["Successful"][destDirectory]["SizeRemoved"]) in (int,))
-
-
-if __name__ == "__main__":
-    gLogger.setLevel("DEBUG")
-    suite = unittest.defaultTestLoader.loadTestsFromTestCase(DirectoryTestCases)
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(FileTestCases))
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(GetInfoTestCase))
-    testResult = unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/src/DIRAC/Resources/Storage/test/FIXME_Test_StoragePlugIn.py b/src/DIRAC/Resources/Storage/test/FIXME_Test_StoragePlugIn.py
deleted file mode 100755
index 8e57975eb93..00000000000
--- a/src/DIRAC/Resources/Storage/test/FIXME_Test_StoragePlugIn.py
+++ /dev/null
@@ -1,719 +0,0 @@
-#! /usr/bin/env python
-
-# FIXME: if it requires a dirac.cfg it is not a unit test and should be moved to tests directory
-
-
-import unittest
-import time
-import os
-import shutil
-import sys
-
-from DIRAC.Core.Base.Script import parseCommandLine, getPositionalArgs
-
-parseCommandLine()
-
-from DIRAC.Resources.Storage.StorageFactory import StorageFactory
-from DIRAC.Core.Utilities.File import getSize
-
-positionalArgs = getPositionalArgs()
-if len(positionalArgs) < 2:
-    print("Usage: TestStoragePlugIn.py StorageElement plugin")
-    sys.exit()
-else:
-    storageElementToTest = positionalArgs[0]
-    plugin = positionalArgs[1]
-
-
-class StoragePlugInTestCase(unittest.TestCase):
-    """Base class for the StoragePlugin test cases"""
-
-    def setUp(self):
-        factory = StorageFactory("lhcb")
-        res = factory.getStorages(storageElementToTest, [plugin])
-        self.assertTrue(res["OK"])
-        storageDetails = res["Value"]
-        self.storage = storageDetails["StorageObjects"][0]
-        self.storage.changeDirectory("lhcb/test/unit-test/TestStoragePlugIn")
-        destDir = self.storage.getCurrentURL("")["Value"]
-        res = self.storage.createDirectory(destDir)
-        self.assertTrue(res["OK"])
-        self.assertTrue(destDir in res["Value"]["Successful"])
-        self.assertTrue(res["Value"]["Successful"][destDir])
-        self.numberOfFiles = 1
-
-    def tearDown(self):
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-
-class DirectoryTestCase(StoragePlugInTestCase):
-    def test_putRemoveDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPut Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {remoteDir: localDir}
-        putDirRes = self.storage.putDirectory(dirDict)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir, True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        if putDirRes["Value"]["Successful"][remoteDir]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Files"], self.numberOfFiles)
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(putDirRes["Value"]["Successful"][remoteDir]["Files"], int))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][remoteDir]["Size"]) in (int,))
-        # Perform the checks for the remove dir operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        if removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(isinstance(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], int))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"]) in (int,))
-
-    def test_isDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tIs Directory test\n"
-        )
-        # Test that we can determine what is a directory
-        destDir = self.storage.getCurrentURL("")["Value"]
-        isDirRes = self.storage.isDirectory(destDir)
-        # Test that we can determine that a directory is not a directory
-        dummyDir = self.storage.getCurrentURL("NonExistantFile")["Value"]
-        nonExistantDirRes = self.storage.isDirectory(dummyDir)
-
-        # Check the is directory operation
-        self.assertTrue(isDirRes["OK"])
-        self.assertTrue(destDir in isDirRes["Value"]["Successful"])
-        self.assertTrue(isDirRes["Value"]["Successful"][destDir])
-        # Check the non existant directory operation
-        self.assertTrue(nonExistantDirRes["OK"])
-        self.assertTrue(dummyDir in nonExistantDirRes["Value"]["Failed"])
-        expectedError = "Path does not exist"
-        self.assertTrue(expectedError in nonExistantDirRes["Value"]["Failed"][dummyDir])
-
-    def test_putGetDirectoryMetadata(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory Metadata test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {remoteDir: localDir}
-        putDirRes = self.storage.putDirectory(dirDict)
-
-        # Get the directory metadata
-        getMetadataRes = self.storage.getDirectoryMetadata(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir, True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        if putDirRes["Value"]["Successful"][remoteDir]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Files"], self.numberOfFiles)
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(putDirRes["Value"]["Successful"][remoteDir]["Files"], int))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][remoteDir]["Size"]) in (int,))
-        # Perform the checks for the get metadata operation
-        self.assertTrue(getMetadataRes["OK"])
-        self.assertTrue(remoteDir in getMetadataRes["Value"]["Successful"])
-        resDict = getMetadataRes["Value"]["Successful"][remoteDir]
-        self.assertTrue("Mode" in resDict)
-        self.assertTrue(isinstance(resDict["Mode"], int))
-        # Perform the checks for the remove directory operation
-        if removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(isinstance(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], int))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"]) in (int,))
-
-    def test_putGetDirectorySize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory Size test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {remoteDir: localDir}
-        putDirRes = self.storage.putDirectory(dirDict)
-        # Now get the directory size
-        getDirSizeRes = self.storage.getDirectorySize(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir, True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        if putDirRes["Value"]["Successful"][remoteDir]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Files"], self.numberOfFiles)
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(putDirRes["Value"]["Successful"][remoteDir]["Files"], int))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][remoteDir]["Size"]) in (int,))
-        # Now perform the checks for the get directory size operation
-        self.assertTrue(getDirSizeRes["OK"])
-        self.assertTrue(remoteDir in getDirSizeRes["Value"]["Successful"])
-        resDict = getDirSizeRes["Value"]["Successful"][remoteDir]
-        self.assertTrue(type(resDict["Size"]) in (int,))
-        self.assertTrue(isinstance(resDict["Files"], int))
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        if removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(isinstance(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], int))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"]) in (int,))
-
-    def test_putListDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tList Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {remoteDir: localDir}
-        putDirRes = self.storage.putDirectory(dirDict)
-        # List the remote directory
-        listDirRes = self.storage.listDirectory(remoteDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir, True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        if putDirRes["Value"]["Successful"][remoteDir]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Files"], self.numberOfFiles)
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(putDirRes["Value"]["Successful"][remoteDir]["Files"], int))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][remoteDir]["Size"]) in (int,))
-        # Perform the checks for the list dir operation
-        self.assertTrue(listDirRes["OK"])
-        self.assertTrue(remoteDir in listDirRes["Value"]["Successful"])
-        resDict = listDirRes["Value"]["Successful"][remoteDir]
-        self.assertTrue("SubDirs" in resDict)
-        self.assertTrue("Files" in resDict)
-        self.assertEqual(len(resDict["Files"]), self.numberOfFiles)
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        if removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(isinstance(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], int))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"]) in (int,))
-
-    def test_putGetDirectory(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet Directory test\n"
-        )
-        # First clean the remote directory incase something was left there
-        remoteDir = self.storage.getCurrentURL("")["Value"]
-        _ = self.storage.removeDirectory(remoteDir, True)
-
-        # Create a local directory to upload
-        localDir = "/tmp/unit-test"
-        srcFile = "/etc/group"
-        sizeOfLocalFile = getSize(srcFile)
-        if not os.path.exists(localDir):
-            os.mkdir(localDir)
-        for i in range(self.numberOfFiles):
-            shutil.copy(srcFile, f"{localDir}/testFile.{time.time()}")
-            time.sleep(1)
-        # Check that we can successfully upload the directory to the storage element
-        dirDict = {remoteDir: localDir}
-        putDirRes = self.storage.putDirectory(dirDict)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-        # Check that we can get directories from the storage element
-        getDirRes = self.storage.getDirectory(remoteDir, localPath=localDir)
-        # Now remove the remove directory
-        removeDirRes = self.storage.removeDirectory(remoteDir, True)
-        # Clean up the locally created directory
-        shutil.rmtree(localDir)
-
-        # Perform the checks for the put dir operation
-        self.assertTrue(putDirRes["OK"])
-        self.assertTrue(remoteDir in putDirRes["Value"]["Successful"])
-        if putDirRes["Value"]["Successful"][remoteDir]["Files"]:
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Files"], self.numberOfFiles)
-            self.assertEqual(putDirRes["Value"]["Successful"][remoteDir]["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(putDirRes["Value"]["Successful"][remoteDir]["Files"], int))
-        self.assertTrue(type(putDirRes["Value"]["Successful"][remoteDir]["Size"]) in (int,))
-        # Perform the checks for the get dir operation
-        self.assertTrue(getDirRes["OK"])
-        self.assertTrue(remoteDir in getDirRes["Value"]["Successful"])
-        resDict = getDirRes["Value"]["Successful"][remoteDir]
-        if resDict["Files"]:
-            self.assertEqual(resDict["Files"], self.numberOfFiles)
-            self.assertEqual(resDict["Size"], self.numberOfFiles * sizeOfLocalFile)
-        self.assertTrue(isinstance(resDict["Files"], int))
-        self.assertTrue(type(resDict["Size"]) in (int,))
-        # Perform the checks for the remove directory operation
-        self.assertTrue(removeDirRes["OK"])
-        self.assertTrue(remoteDir in removeDirRes["Value"]["Successful"])
-        if removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"]:
-            self.assertEqual(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], self.numberOfFiles)
-            self.assertEqual(
-                removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"], self.numberOfFiles * sizeOfLocalFile
-            )
-        self.assertTrue(isinstance(removeDirRes["Value"]["Successful"][remoteDir]["FilesRemoved"], int))
-        self.assertTrue(type(removeDirRes["Value"]["Successful"][remoteDir]["SizeRemoved"]) in (int,))
-
-
-class FileTestCase(StoragePlugInTestCase):
-    def test_putRemoveFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPut and Remove test\n"
-        )
-
-        # Make sure that we can actually upload a file properly
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        destFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {destFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Make sure we are able to remove the file
-        removeFileRes = self.storage.removeFile(destFile)
-
-        # Check the successful put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(destFile in putFileRes["Value"]["Successful"])
-        self.assertEqual(putFileRes["Value"]["Successful"][destFile], srcFileSize)
-        # Check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(destFile in removeFileRes["Value"]["Successful"])
-        self.assertTrue(removeFileRes["Value"]["Successful"][destFile])
-
-    def test_putGetFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPut and Get test\n"
-        )
-
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-
-        # Then make sure we can get a local copy of the file
-        getFileRes = self.storage.getFile(remoteFile)
-        # Cleanup the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Cleanup the mess locally
-        os.remove(testFileName)
-
-        # Check the put operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the get operation
-        self.assertTrue(getFileRes["OK"])
-        self.assertTrue(remoteFile in getFileRes["Value"]["Successful"])
-        self.assertEqual(getFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the remove operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        self.assertTrue(removeFileRes["Value"]["Successful"][remoteFile])
-
-    def test_putExistsFile(self):
-        print("\n\n#########################################################" "################\n\n\t\t\tExists test\n")
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Then get the file's existance
-        existsFileRes = self.storage.exists(remoteFile)
-        # Now remove the file
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Check  again that the file exists
-        failedExistRes = self.storage.exists(remoteFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the exists operation
-        self.assertTrue(existsFileRes["OK"])
-        self.assertTrue(remoteFile in existsFileRes["Value"]["Successful"])
-        self.assertTrue(existsFileRes["Value"]["Successful"][remoteFile])
-        # Check the removal operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check the failed exists operation
-        self.assertTrue(failedExistRes["OK"])
-        self.assertTrue(remoteFile in failedExistRes["Value"]["Successful"])
-        self.assertFalse(failedExistRes["Value"]["Successful"][remoteFile])
-
-    def test_putIsFile(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tIs file test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check we are able to determine that it is a file
-        isFileRes = self.storage.isFile(remoteFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Check that everything isn't a file
-        remoteDir = os.path.dirname(remoteFile)
-        failedIsFileRes = self.storage.isFile(remoteDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the is file operation
-        self.assertTrue(isFileRes["OK"])
-        self.assertTrue(remoteFile in isFileRes["Value"]["Successful"])
-        self.assertTrue(isFileRes["Value"]["Successful"][remoteFile])
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check that the directory is not a file
-        self.assertTrue(failedIsFileRes["OK"])
-        self.assertTrue(remoteDir in failedIsFileRes["Value"]["Successful"])
-        self.assertFalse(failedIsFileRes["Value"]["Successful"][remoteDir])
-
-    def test_putGetFileMetaData(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file metadata test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can get the file metadata
-        getMetadataRes = self.storage.getFileMetadata(remoteFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # See what happens with non existant files
-        failedMetadataRes = self.storage.getFileMetadata(remoteFile)
-        # Check directories are handled properly
-        remoteDir = os.path.dirname(remoteFile)
-        directoryMetadataRes = self.storage.getFileMetadata(remoteDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the get metadata operation
-        self.assertTrue(getMetadataRes["OK"])
-        self.assertTrue(remoteFile in getMetadataRes["Value"]["Successful"])
-        fileMetaData = getMetadataRes["Value"]["Successful"][remoteFile]
-        self.assertTrue(fileMetaData["Cached"])
-        self.assertFalse(fileMetaData["Migrated"])
-        self.assertEqual(fileMetaData["Size"], srcFileSize)
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check the get metadata for non existant file
-        self.assertTrue(failedMetadataRes["OK"])
-        self.assertTrue(remoteFile in failedMetadataRes["Value"]["Failed"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in failedMetadataRes["Value"]["Failed"][remoteFile])
-        # Check that metadata operation with a directory
-        self.assertTrue(directoryMetadataRes["OK"])
-        self.assertTrue(remoteDir in directoryMetadataRes["Value"]["Failed"])
-        expectedError = "Supplied path is not a file"
-        self.assertTrue(expectedError in directoryMetadataRes["Value"]["Failed"][remoteDir])
-
-    def test_putGetFileSize(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tGet file size test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can get the file size
-        getSizeRes = self.storage.getFileSize(remoteFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Check non existant files
-        failedSizeRes = self.storage.getFileMetadata(remoteFile)
-        # Check directories are handled properly
-        remoteDir = os.path.dirname(remoteFile)
-        directorySizeRes = self.storage.getFileSize(remoteDir)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check that we got the file size correctly
-        self.assertTrue(getSizeRes["OK"])
-        self.assertTrue(remoteFile in getSizeRes["Value"]["Successful"])
-        self.assertEqual(getSizeRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check the get size with non existant file works properly
-        self.assertTrue(failedSizeRes["OK"])
-        self.assertTrue(remoteFile in failedSizeRes["Value"]["Failed"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in failedSizeRes["Value"]["Failed"][remoteFile])
-        # Check that the passing a directory is handled correctly
-        self.assertTrue(directorySizeRes["OK"])
-        self.assertTrue(remoteDir in directorySizeRes["Value"]["Failed"])
-        expectedError = "Supplied path is not a file"
-        self.assertTrue(expectedError in directorySizeRes["Value"]["Failed"][remoteDir])
-
-    def test_putPrestageFile(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tFile prestage test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can issue a stage request
-        prestageRes = self.storage.prestageFile(remoteFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Check what happens with deleted files
-        deletedPrestageRes = self.storage.prestageFile(remoteFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the prestage file operation
-        self.assertTrue(prestageRes["OK"])
-        self.assertTrue(remoteFile in prestageRes["Value"]["Successful"])
-        self.assertTrue(prestageRes["Value"]["Successful"][remoteFile])
-        # Check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check that pre-staging non-existant file fails
-        self.assertTrue(deletedPrestageRes["OK"])
-        self.assertTrue(remoteFile in deletedPrestageRes["Value"]["Failed"])
-        expectedError = "No such file or directory"
-        self.assertTrue(expectedError in deletedPrestageRes["Value"]["Failed"][remoteFile])
-
-    def test_putFilegetTransportURL(self):
-        print(
-            "\n\n#########################################################" "################\n\n\t\t\tGet tURL test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can get a turl
-        getTurlRes = self.storage.getTransportURL(remoteFile)
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-        # Try and get a turl for a non existant file
-        failedGetTurlRes = self.storage.getTransportURL(remoteFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # check the get turl operation
-        self.assertTrue(getTurlRes["OK"])
-        self.assertTrue(remoteFile in getTurlRes["Value"]["Successful"])
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-        # Check the get turl with non existant file operation
-        self.assertTrue(failedGetTurlRes["OK"])
-        self.assertTrue(remoteFile in failedGetTurlRes["Value"]["Failed"])
-        expectedError = "File does not exist"
-        self.assertTrue(expectedError in failedGetTurlRes["Value"]["Failed"][remoteFile])
-
-    def test_putPinRelease(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPin and Release test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can pin the file
-        pinFileRes = self.storage.pinFile(remoteFile)
-        srmID = ""
-        if pinFileRes["OK"]:
-            if remoteFile in pinFileRes["Value"]["Successful"]:
-                srmID = pinFileRes["Value"]["Successful"][remoteFile]
-        # Check that we can release the file
-        releaseFileRes = self.storage.releaseFile({remoteFile: srmID})
-        # Clean up the mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the pin file operation
-        self.assertTrue(pinFileRes["OK"])
-        self.assertTrue(remoteFile in pinFileRes["Value"]["Successful"])
-        self.assertTrue(type(pinFileRes["Value"]["Successful"][remoteFile]) in (str,))
-        # Check the release file operation
-        self.assertTrue(releaseFileRes["OK"])
-        self.assertTrue(remoteFile in releaseFileRes["Value"]["Successful"])
-        # check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-
-    def test_putPrestageStatus(self):
-        print(
-            "\n\n#########################################################"
-            "################\n\n\t\t\tPrestage status test\n"
-        )
-        # First upload a file to the storage
-        srcFile = "/etc/group"
-        srcFileSize = getSize(srcFile)
-        testFileName = f"testFile.{time.time()}"
-        remoteFile = self.storage.getCurrentURL(testFileName)["Value"]
-        fileDict = {remoteFile: srcFile}
-        putFileRes = self.storage.putFile(fileDict)
-        # Check that we can issue a stage request
-        prestageRes = self.storage.prestageFile(remoteFile)
-        srmID = ""
-        if prestageRes["OK"]:
-            if remoteFile in prestageRes["Value"]["Successful"]:
-                srmID = prestageRes["Value"]["Successful"][remoteFile]
-        # Take a quick break to allow the SRM to realise the file is available
-        sleepTime = 10
-        print(f"Sleeping for {sleepTime} seconds")
-        time.sleep(sleepTime)
-        # Check that we can monitor the stage request
-        prestageStatusRes = self.storage.prestageFileStatus({remoteFile: srmID})
-        # Clean up the remote mess
-        removeFileRes = self.storage.removeFile(remoteFile)
-
-        # Check the put file operation
-        self.assertTrue(putFileRes["OK"])
-        self.assertTrue(remoteFile in putFileRes["Value"]["Successful"])
-        self.assertTrue(putFileRes["Value"]["Successful"][remoteFile])
-        self.assertEqual(putFileRes["Value"]["Successful"][remoteFile], srcFileSize)
-        # Check the prestage file operation
-        self.assertTrue(prestageRes["OK"])
-        self.assertTrue(remoteFile in prestageRes["Value"]["Successful"])
-        self.assertTrue(prestageRes["Value"]["Successful"][remoteFile])
-        self.assertTrue(type(prestageRes["Value"]["Successful"][remoteFile]) in (str,))
-        # Check the prestage status operation
-        self.assertTrue(prestageStatusRes["OK"])
-        self.assertTrue(remoteFile in prestageStatusRes["Value"]["Successful"])
-        self.assertTrue(prestageStatusRes["Value"]["Successful"][remoteFile])
-        # Check the remove file operation
-        self.assertTrue(removeFileRes["OK"])
-        self.assertTrue(remoteFile in removeFileRes["Value"]["Successful"])
-
-
-if __name__ == "__main__":
-    suite = unittest.defaultTestLoader.loadTestsFromTestCase(FileTestCase)
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(DirectoryTestCase))
-    testResult = unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/src/DIRAC/TransformationSystem/Client/RequestTasks.py b/src/DIRAC/TransformationSystem/Client/RequestTasks.py
index b93af7cc9e1..a3fee6a7202 100644
--- a/src/DIRAC/TransformationSystem/Client/RequestTasks.py
+++ b/src/DIRAC/TransformationSystem/Client/RequestTasks.py
@@ -200,6 +200,7 @@ def _singleOperationsBody(self, transBody, taskDict, ownerDN, ownerGroup):
 
             # If there are input files
             if task.get("InputData"):
+                files = []
                 if isinstance(task["InputData"], list):
                     files = task["InputData"]
                 elif isinstance(task["InputData"], str):
diff --git a/src/DIRAC/WorkloadManagementSystem/Client/CPUNormalization.py b/src/DIRAC/WorkloadManagementSystem/Client/CPUNormalization.py
index 008d7ed8ac4..ab216d6f1fb 100644
--- a/src/DIRAC/WorkloadManagementSystem/Client/CPUNormalization.py
+++ b/src/DIRAC/WorkloadManagementSystem/Client/CPUNormalization.py
@@ -88,7 +88,7 @@ def queueNormalizedCPU(ceUniqueID):
 
     benchmarkSI00 = __getQueueNormalization(queueCSSection, siteCSSEction)
     maxCPUTime = __getMaxCPUTime(queueCSSection)
-
+    normCPUTime = -1
     if maxCPUTime and benchmarkSI00:
         normCPUTime = NORMALIZATIONCONSTANT * maxCPUTime * benchmarkSI00
     else:
diff --git a/src/DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.py b/src/DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.py
index 2cce006c368..7d7e3cb873c 100755
--- a/src/DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.py
+++ b/src/DIRAC/WorkloadManagementSystem/DB/PilotAgentsDB.py
@@ -1157,6 +1157,7 @@ def getPilotMonitorWeb(self, selectDict, sortList, startItem, maxItems):
         pilotDict = result["Value"]
         records = []
         for pilot in pilotList:
+            gridSite = None
             parList = []
             for parameter in paramNames:
                 if not isinstance(pilotDict[pilot][parameter], int):
diff --git a/src/DIRAC/WorkloadManagementSystem/JobWrapper/JobWrapper.py b/src/DIRAC/WorkloadManagementSystem/JobWrapper/JobWrapper.py
index a4fb4ea8ec8..37ab3390ecf 100755
--- a/src/DIRAC/WorkloadManagementSystem/JobWrapper/JobWrapper.py
+++ b/src/DIRAC/WorkloadManagementSystem/JobWrapper/JobWrapper.py
@@ -461,8 +461,7 @@ def execute(self):
                 self.log.error("Failed to execute the payload", threadResult["Message"])
 
                 self.__report(status=JobStatus.FAILED, minorStatus=JobMinorStatus.APP_THREAD_FAILED, sendFlag=True)
-                if "Value" in threadResult:
-                    outs = threadResult["Value"]
+                outs = threadResult.get("Value")
                 if outs:
                     self.__setJobParam("ApplicationError", outs[0], sendFlag=True)
                 else:
diff --git a/src/DIRAC/WorkloadManagementSystem/Service/JobStateUpdateHandler.py b/src/DIRAC/WorkloadManagementSystem/Service/JobStateUpdateHandler.py
index 156389a985a..4bb2ab0f0c2 100755
--- a/src/DIRAC/WorkloadManagementSystem/Service/JobStateUpdateHandler.py
+++ b/src/DIRAC/WorkloadManagementSystem/Service/JobStateUpdateHandler.py
@@ -6,6 +6,7 @@
     setJobStatus()
 
 """
+
 import time
 import datetime as dateTime
 
@@ -356,6 +357,7 @@ def export_setJobsParameter(cls, jobsParameterDict):
         for job specified by its JobId
         """
         failed = False
+        message = ""
 
         for jobID in jobsParameterDict:
             if cls.elasticJobParametersDB:
diff --git a/src/DIRAC/WorkloadManagementSystem/Service/OptimizationMindHandler.py b/src/DIRAC/WorkloadManagementSystem/Service/OptimizationMindHandler.py
index 9f313b010e1..a5aeca2a100 100644
--- a/src/DIRAC/WorkloadManagementSystem/Service/OptimizationMindHandler.py
+++ b/src/DIRAC/WorkloadManagementSystem/Service/OptimizationMindHandler.py
@@ -63,6 +63,7 @@ def msg_OptimizeJobs(self, msgObj):
 
     @classmethod
     def __loadJobs(cls, eTypes=None):
+        jobCond = {}
         log = cls.log
         if cls.__loadTaskId:
             period = cls.srv_getCSOption("LoadJobPeriod", 300)