test: adding test specific for SandboxMetadataDB

Author: fstagni

src/DIRAC/WorkloadManagementSystem/ConfigTemplate.cfg

@@ -101,6 +101,7 @@ Services
     Enable = No
     PilotsLoggingQueue = serviceURL::QueueType::QueueName
   }
+  ##BEGIN SandboxStore
   SandboxStore
   {
     Port = 9196
@@ -121,6 +122,7 @@ Services
       }
     }
   }
+  ##END
   OptimizationMind
   {
     Port = 9175

src/DIRAC/WorkloadManagementSystem/DB/SandboxMetadataDB.py

@@ -12,7 +12,7 @@ def __init__(self):
         DB.__init__(self, "SandboxMetadataDB", "WorkloadManagement/SandboxMetadataDB")
         result = self.__initializeDB()
         if not result["OK"]:
-	    raise RuntimeError(f"Can't create tables: {result['Message']}")
+            raise RuntimeError(f"Can't create tables: {result['Message']}")
         self.__assignedSBGraceDays = 0
         self.__unassignedSBGraceDays = 15
 
@@ -112,7 +112,7 @@ def registerAndGetSandbox(self, owner, ownerDN, ownerGroup, sbSE, sbPFN, size=0)
         Register a new sandbox in the metadata catalog
         Returns ( sbid, newSandbox )
         """
-	result = self.__registerAndGetOwnerId(owner, ownerDN, ownerGroup)
+        result = self.__registerAndGetOwnerId(owner, ownerDN, ownerGroup)
         if not result["OK"]:
             return result
         ownerId = result["Value"]
@@ -135,7 +135,7 @@ def registerAndGetSandbox(self, owner, ownerDN, ownerGroup, sbSE, sbPFN, size=0)
             if not result["OK"]:
                 return result
             if not result["Value"]:
-                return S_ERROR("Location %s already exists but doesn't belong to the user or setup")
+                return S_ERROR("SandBox already exists but doesn't belong to the user or setup")
             sbId = result["Value"][0][0]
             self.accessedSandboxById(sbId)
             return S_OK((sbId, False))
@@ -144,7 +144,7 @@ def registerAndGetSandbox(self, owner, ownerDN, ownerGroup, sbSE, sbPFN, size=0)
             return S_OK((result["lastRowId"], True))
         result = self._query("SELECT LAST_INSERT_ID()")
         if not result["OK"]:
-	    return S_ERROR("Can't determine sandbox id after insertion")
+            return S_ERROR("Can't determine sandbox id after insertion")
         return S_OK((result["Value"][0][0], True))
 
     def accessedSandboxById(self, sbId):
@@ -174,12 +174,12 @@ def assignSandboxesToEntities(self, enDict, requesterName, requesterGroup, enSet
         for entityId in enDict:
             for sbTuple in enDict[entityId]:
                 if not isinstance(sbTuple, (tuple, list)):
-                    return S_ERROR("Entry for entity %s is not a itterable of tuples/lists" % entityId)
+                    return S_ERROR(f"Entry for entity {entityId} is not an iterable of tuples/lists")
                 if len(sbTuple) != 2:
-                    return S_ERROR("SB definition is not ( SBLocation, Type )! It's '%s'" % str(sbTuple))
+                    return S_ERROR(f"SB definition is not ( SBLocation, Type )! It's {sbTuple}")
                 SBLocation = sbTuple[0]
                 if SBLocation.find("SB:") != 0:
-                    return S_ERROR("%s doesn't seem to be a sandbox" % SBLocation)
+                    return S_ERROR(f"{SBLocation} doesn't seem to be a sandbox")
                 SBLocation = SBLocation[3:]
                 splitted = List.fromChar(SBLocation, "|")
                 if len(splitted) < 2:
@@ -197,7 +197,8 @@ def assignSandboxesToEntities(self, enDict, requesterName, requesterGroup, enSet
             insertValues = []
             if not result["OK"]:
                 self.log.warn(
-                    "Cannot find id for %s:%s with requester %s@%s" % (SEName, SEPFN, requesterName, requesterGroup)
+                    f"Cannot find id for {SEName}:",
+                    f"{SEPFN} with requester {requesterName}@{requesterGroup}: {result['Message']}",
                 )
             else:
                 sbId = result["Value"]
@@ -273,7 +274,7 @@ def unassignEntities(self, entitiesDict, requesterName, requesterGroup):
             escapedSetup = self._escapeString(entitySetup)["Value"]
             result = self.__filterEntitiesByRequester(entitiesIds, escapedSetup, requesterName, requesterGroup)
             if not result["OK"]:
-		gLogger.error(f"Cannot filter entities: {result['Message']}")
+                gLogger.error("Cannot filter entities", result["Message"])
                 continue
             ids = result["Value"]
             if not ids:
@@ -283,7 +284,7 @@ def unassignEntities(self, entitiesDict, requesterName, requesterGroup):
             sqlCmd = "DELETE FROM `sb_EntityMapping` WHERE %s" % " AND ".join(sqlCond)
             result = self._update(sqlCmd)
             if not result["OK"]:
-		gLogger.error(f"Cannot unassign entities: {result['Message']}")
+                gLogger.error("Cannot unassign entities", result["Message"])
             else:
                 updated += 1
         return S_OK(updated)

src/DIRAC/WorkloadManagementSystem/Service/SandboxStoreHandler.py

@@ -1,5 +1,11 @@
 """ SandboxHandler is the implementation of the Sandbox service
     in the DISET framework
+
+.. literalinclude:: ../ConfigTemplate.cfg
+  :start-after: ##BEGIN SandboxStore
+  :end-before: ##END
+  :dedent: 2
+  :caption: SandboxStore options
 """
 import os
 import time
@@ -36,7 +42,7 @@ def initializeHandler(cls, serviceInfoDict):
             cls.sandboxDB = result["Value"]()
 
         except RuntimeError as excp:
-            return S_ERROR("Can't connect to DB: %s" % excp)
+            return S_ERROR("Can't connect to DB: %s" % repr(excp))
         return S_OK()
 
     def initialize(self):
@@ -95,7 +101,7 @@ def transfer_fromClient(self, fileId, token, fileSize, fileHelper):
         else:
             extension = ""
             aHash = fileId
-        gLogger.info("Upload requested for %s [%s]" % (aHash, extension))
+        gLogger.info("Upload requested", f"for {aHash} [{extension}]")
 
         credDict = self.getRemoteCredentials()
         sbPath = self.__getSandboxPath("%s.%s" % (aHash, extension))
@@ -123,10 +129,10 @@ def transfer_fromClient(self, fileId, token, fileSize, fileHelper):
         # Write to local file
         result = self.__networkToFile(fileHelper, hdPath)
         if not result["OK"]:
-            gLogger.error("Error while receiving sandbox file", "%s" % result["Message"])
+            gLogger.error("Error while receiving sandbox file", result["Message"])
             return result
         hdPath = result["Value"]
-        gLogger.info("Wrote sandbox to file %s" % hdPath)
+        gLogger.info("Wrote sandbox to file", hdPath)
         # Check hash!
         if fileHelper.getHash() != aHash:
             self.__secureUnlinkFile(hdPath)
@@ -141,7 +147,7 @@ def transfer_fromClient(self, fileId, token, fileSize, fileHelper):
                 return result
             sbPath = result["Value"][1]
         # Register!
-        gLogger.info("Registering sandbox in the DB with", "SB:%s|%s" % (self.__seNameToUse, sbPath))
+        gLogger.info("Registering sandbox in the DB with", f"SB:{self.__seNameToUse}|{sbPath}")
         result = self.sandboxDB.registerAndGetSandbox(
             credDict["username"],
             credDict["DN"],
@@ -154,7 +160,7 @@ def transfer_fromClient(self, fileId, token, fileSize, fileHelper):
             self.__secureUnlinkFile(hdPath)
             return result
 
-        sbURL = "SB:%s|%s" % (self.__seNameToUse, sbPath)
+        sbURL = f"SB:{self.__seNameToUse}|{sbPath}"
         assignTo = dict([(key, [(sbURL, assignTo[key])]) for key in assignTo])
         result = self.export_assignSandboxesToEntities(assignTo)
         if not result["OK"]:
@@ -521,7 +527,7 @@ def __deleteSandboxFromExternalBackend(self, SEName, SEPFN):
                 return ReqClient().putRequest(request)
             except Exception as e:
                 gLogger.exception("Exception while setting deletion request")
-                return S_ERROR("Cannot set deletion request: %s" % str(e))
+                return S_ERROR(f"Cannot set deletion request: {e}")
         else:
             gLogger.info("Deleting external Sandbox")
             try:

tests/Integration/WorkloadManagementSystem/Test_SandboxStoreClient.py

@@ -52,18 +52,18 @@ def test_SSCChain():
     exeScriptLocation = find_all("exe-script.py", "..", "/DIRAC/tests/Integration")[0]
     fileList = [exeScriptLocation]
     res = ssc.uploadFilesAsSandbox(fileList)
-    assert res["OK"] is True
+    assert res["OK"] is True, res["Message"]
     #     SEPFN = res['Value'].split( '|' )[1]
     res = ssc.uploadFilesAsSandboxForJob(fileList, 1, "Input")
-    assert res["OK"] is True
+    assert res["OK"] is True, res["Message"]
     res = ssc.downloadSandboxForJob(1, "Input")  # to run this we need the RSS on
     print(res)  # for debug...
-    assert res["OK"] is True
+    assert res["OK"] is True, res["Message"]
 
     # only ones needing the DB
     res = smDB.getUnusedSandboxes()
     print(res)
-    assert res["OK"] is True
+    assert res["OK"] is True, res["Message"]
     # smDB.getSandboxId(SEName, SEPFN, requesterName, requesterGroup)
     # # cleaning
     # res = smDB.deleteSandboxes(SBIdList)
@@ -72,4 +72,17 @@ def test_SSCChain():
 
 def test_SandboxMetadataDB():
     smDB = SandboxMetadataDB()
-    smDB.registerAndGetSandbox("owner_1", "owner_1_DN", "owner_1_group", "sbSE", "/sb/pfn/1.tar.bz2")
+
+    seNameToUse = "ProductionSandboxSE"
+    sbPath = "/sb/pfn/1.tar.bz2"
+    assignTo = {"adminusername": "dirac_admin"}
+
+    res = smDB.registerAndGetSandbox(
+        "adminusername", "/C=ch/O=DIRAC/OU=DIRAC CI/CN=ciuser", "dirac_admin", seNameToUse, sbPath, 123
+    )
+    assert res["OK"], res["Message"]
+
+    sbURL = f"SB:{seNameToUse}|{sbPath}"
+    assignTo = dict([(key, [(sbURL, assignTo[key])]) for key in assignTo])
+    res = smDB.assignSandboxesToEntities(assignTo, "adminusername", "dirac_admin", "enSetup")
+    assert res["OK"], res["Message"]