def setUp( self ):
from DIRAC import gLogger
gLogger.setLevel( 'DEBUG' )
self.mockTransClient = MagicMock()
self.mockTransClient.setTaskStatusAndWmsID.return_value = {'OK':True}
self.WMSClientMock = MagicMock()
self.jobMonitoringClient = MagicMock()
self.mockReqClient = MagicMock()
self.jobMock = MagicMock()
self.jobMock2 = MagicMock()
mockWF = MagicMock()
mockPar = MagicMock()
mockWF.findParameter.return_value = mockPar
mockPar.getValue.return_value = 'MySite'
self.jobMock2.workflow = mockWF
self.jobMock2.setDestination.return_value = {'OK':True}
self.jobMock.workflow.return_value = ''
self.jobMock.return_value = self.jobMock2
self.maxDiff = None
def setUp(self):
super(UserJobTestCase, self).setUp()
self.d = Dirac()
integration_test_dir = "/DIRAC/tests/Workflow/Integration"
try:
self.exeScriptLocation = find_all("exe-script.py", rootPath,
integration_test_dir)[0]
self.helloWorld = find_all("helloWorld.py", rootPath,
integration_test_dir)[0]
self.mpExe = find_all("mpTest.py", rootPath,
"/DIRAC/tests/Utilities")[0]
self.mpExeFlex = find_all("mpTest-flexible.py", rootPath,
"/DIRAC/tests/Utilities")[0]
except IndexError: # we are in Jenkins
self.exeScriptLocation = find_all("exe-script.py",
os.environ["WORKSPACE"],
integration_test_dir)[0]
self.helloWorld = find_all("helloWorld.py",
os.environ["WORKSPACE"],
integration_test_dir)[0]
self.mpExe = find_all("mpTest.py", os.environ["WORKSPACE"],
"/DIRAC/tests/Utilities")[0]
self.mpExeFlex = find_all("mpTest-flexible.py",
os.environ["WORKSPACE"],
"/DIRAC/tests/Utilities")[0]
gLogger.setLevel("DEBUG")
def setupDB():
""" Get configuration from a cfg file and instantiate a DB
"""
gLogger.setLevel('DEBUG')
result = gConfig.getOption('/Systems/Databases/Host')
if not result['OK']:
result['Value'] = 'mysql'
host = result['Value']
result = gConfig.getOption('/Systems/Databases/User')
if not result['OK']:
result['Value'] = 'Dirac'
user = result['Value']
result = gConfig.getOption('/Systems/Databases/Password')
if not result['OK']:
result['Value'] = 'Dirac'
password = result['Value']
result = gConfig.getOption('/Systems/Databases/Port')
if not result['OK']:
result['Value'] = 3306
port = int(result['Value'])
return getDB(host, user, password, 'AccountingDB', port)
def setupDB():
"""Get configuration from a cfg file and instantiate a DB"""
gLogger.setLevel("DEBUG")
result = gConfig.getOption("/Systems/Databases/Host")
if not result["OK"]:
result["Value"] = "mysql"
host = result["Value"]
result = gConfig.getOption("/Systems/Databases/User")
if not result["OK"]:
result["Value"] = "Dirac"
user = result["Value"]
result = gConfig.getOption("/Systems/Databases/Password")
if not result["OK"]:
result["Value"] = "Dirac"
password = result["Value"]
result = gConfig.getOption("/Systems/Databases/Port")
if not result["OK"]:
result["Value"] = 3306
port = int(result["Value"])
return getDB(host, user, password, "AccountingDB", port)
def setUp(self):
gLogger.setLevel( 'DEBUG' )
self.RSMock = MagicMock()
self.RMMock = MagicMock()
self.RMMock.selectStatusElement.return_value = {'OK':True, 'Value': 'bla'}
self.mockPDP = MagicMock()
def setUp(self):
gLogger.setLevel('DEBUG')
self.mockDM = MagicMock()
self.mockDM.getReplicas.return_value = S_OK({
'Successful': {
'/a/lfn/1.txt': {
'SE1': '/a/lfn/at/SE1.1.txt',
'SE2': '/a/lfn/at/SE2.1.txt'
},
'/a/lfn/2.txt': {
'SE1': '/a/lfn/at/SE1.1.txt'
}
},
'Failed': {}
})
self.mockFC = MagicMock()
self.mockFC.getFileMetadata.return_value = S_OK({
'Successful': {
'/a/lfn/1.txt': {
'GUID': 'AABB11'
},
'/a/lfn/2.txt': {
'GUID': 'AABB22'
}
},
'Failed': {}
})
def setUp( self ):
'''
Setup
'''
gLogger.setLevel('DEBUG')
# # Mock external libraries / modules not interesting for the unit test
# mock_pathFinder = mock.Mock()
# mock_pathFinder.getServiceURL.return_value = 'cookiesURL'
# self.mock_pathFinder = mock_pathFinder
#
mock_RPC = mock.Mock()
mock_RPC.addFiles.return_value = { 'OK' : True, 'Value' : { 'Successful' : ['A'] , 'Failed' :['B']} }
mock_RPC.removeFiles.return_value = { 'OK' : True, 'Value' : { 'Successful' : ['A'] , 'Failed' : ['B']} }
mock_RPC.exists.return_value = { 'OK' : True, 'Value' : { 'A' : 1 , 'B' : 2} }
mock_RPC.getFileMetadata.return_value = { 'OK' : True, 'Value' : { 'Successful':{'A' : { 'FileSize' : 1} ,
'B' : { 'FileSize' : 2} } } }
# mock_RPC.removeMigratingFiles.return_value = { 'OK' : True }
# mock_RPC.removeMigratingReplicas.return_value = { 'OK' : True }
mock_RPCClient = mock.Mock()
mock_RPCClient.return_value = mock_RPC
self.mock_RPCClient = mock_RPCClient
#
# # Add mocks to moduleTested
# moduleTested.PathFinder = self.mock_pathFinder
moduleTested.RPCClient = self.mock_RPCClient
self.moduleTested = moduleTested
self.testClass = self.moduleTested.BookkeepingDBClient
def setUp(self):
from DIRAC import gLogger
gLogger.setLevel("DEBUG")
mockObjectDM = MagicMock()
mockObjectDM.getActiveReplicas.return_value = S_OK(
{
"Successful": {
"/a/lfn/1.txt": {"SE1": "/a/lfn/at/SE1.1.txt", "SE2": "/a/lfn/at/SE2.1.txt"},
"/a/lfn/2.txt": {"SE1": "/a/lfn/at/SE1.1.txt"},
},
"Failed": {},
}
)
self.mockDM = MagicMock()
self.mockDM.return_value = mockObjectDM
mockObjectSE = MagicMock()
mockObjectSE.getFileMetadata.return_value = S_OK(
{"Successful": {"/a/lfn/1.txt": {"Cached": 0}, "/a/lfn/2.txt": {"Cached": 1}}, "Failed": {}}
)
self.mockSE = MagicMock()
self.mockSE.return_value = mockObjectSE
def setUp( self ):
from DIRAC import gLogger
gLogger.setLevel( 'DEBUG' )
self.mockDM = MagicMock()
self.mockDM.return_value = dm_mock
mockObjectSE = MagicMock()
mockObjectSE.getFileMetadata.return_value = S_OK( {'Successful':{'/a/lfn/1.txt':{'Cached':0},
'/a/lfn/2.txt':{'Cached':1}},
'Failed':{}} )
mockObjectSE.getFile.return_value = S_OK( { 'Successful':{'/a/lfn/1.txt':{}},
'Failed':{}} )
mockObjectSE.getStatus.return_value = S_OK( {'Read': True, 'DiskSE': True} )
self.mockSE = MagicMock()
self.mockSE.return_value = mockObjectSE
self.dli = DownloadInputData( {'InputData': [],
'Configuration': 'boh',
'FileCatalog': S_OK( {'Successful': []} )} )
self.pilotAgentsDBMock = MagicMock()
self.jobDBMock = MagicMock()
self.tqDBMock = MagicMock()
self.jlDBMock = MagicMock()
self.opsHelperMock = MagicMock()
self.matcher = Matcher( pilotAgentsDB = self.pilotAgentsDBMock,
jobDB = self.jobDBMock,
tqDB = self.tqDBMock,
jlDB = self.jlDBMock,
opsHelper = self.opsHelperMock )
def test_Whizard2_ASI_RandomSeed_Prod( self ):
"""Whizard.applicationSpecificInputs: check setting of randomseed in production..................."""
gLogger.setLevel("ERROR")
self.whiz.workflow_commons = dict(IS_PROD=True, PRODUCTION_ID=6666, JOB_ID=123)
self.whiz.resolveInputVariables()
self.whiz.applicationSpecificInputs()
self.assertEqual( self.whiz.randomSeed, 6666123 )
def setUp(self):
"""
Make fake files for the test
"""
self.inputfile = "/ilc/prod/ilc/mc-dbd/generated/500-TDR_ws/6f_eeWW/v01-16-p05_500/00005160/000/E500-TDR_ws.I108640.P6f_eexyev.eL.pR_gen_5160_2_065.stdhep"
self.inputfiles = [ self.inputfile, self.inputfile ]
gLogger.setLevel("DEBUG")
def test_DDSim_ASI_StartFrom( self ):
"""DDSim.applicationSpecificInputs: check setting of startfrom variable........................."""
gLogger.setLevel("ERROR")
self.ddsim.workflow_commons = dict(StartFrom=321)
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual( self.ddsim.startFrom, 321 )
def setUp(self):
"""
Setup
"""
gLogger.setLevel('DEBUG')
# Mock external libraries / modules not interesting for the unit test
self.getStorageElementOptionsMock = mock.MagicMock()
self.getStorageElementOptionsMock.return_value = {
'OK': True,
'Value': {
'BackendType': 'aMassStorage',
'DiskSE': False,
'SEType': 'T1D0',
'TapeSE': True
}
}
self.CSHelpersMock = mock.MagicMock()
self.getStorageElementOptionsMock = mock.MagicMock()
self.CSHelpersMock.getSEHost.return_value = 'aRealName'
self.dowtimeCommandModule = importlib.import_module(
'DIRAC.ResourceStatusSystem.Command.DowntimeCommand')
self.dowtimeCommandModule.CSHelpers = self.CSHelpersMock
self.dowtimeCommandModule.getStorageElementOptions = self.getStorageElementOptionsMock
self.mock_GOCDBClient = mock.MagicMock()
self.args = {
'name': 'aName',
'element': 'Resource',
'elementType': 'StorageElement'
}
def setUp(self):
gLogger.setLevel("DEBUG")
self.RSMock = MagicMock()
self.RMMock = MagicMock()
self.RMMock.selectStatusElement.return_value = {"OK": True, "Value": "bla"}
self.mockPDP = MagicMock()
def setUp(self):
gLogger.setLevel('DEBUG')
self.maxDiff = None
self.jsu_mock = MagicMock()
self.jsu_mock.setJobApplicationStatus.return_value = {'OK': True, 'Value': ''}
self.jsu_mock = MagicMock()
self.jsu_mock.setJobApplicationStatus.return_value = {'OK': True, 'Value': ''}
self.ft_mock = MagicMock()
self.ft_mock.transferAndRegisterFile.return_value = {'OK': True, 'Value': {'uploadedSE': ''}}
self.ft_mock.transferAndRegisterFileFailover.return_value = {'OK': True, 'Value': {}}
self.ft_mock.request = rc_mock
self.ft_mock.FileCatalog = fc_mock
self.nc_mock = MagicMock()
self.nc_mock.sendMail.return_value = {'OK': True, 'Value': ''}
self.xf_o_mock = MagicMock()
self.xf_o_mock.inputFileStats = {'a': 1, 'b': 2}
self.xf_o_mock.outputFileStats = {'a': 1, 'b': 2}
self.xf_o_mock.analyse.return_value = True
self.jobStep_mock = MagicMock()
self.jobStep_mock.commit.return_value = {'OK': True, 'Value': ''}
self.jobStep_mock.setValuesFromDict.return_value = {'OK': True, 'Value': ''}
self.jobStep_mock.checkValues.return_value = {'OK': True, 'Value': ''}
def setUp(self):
super(RegressionTestCase, self).setUp()
gLogger.setLevel('DEBUG')
self.dirac = Dirac()
try:
exeScriptLoc = find_all('exe-script.py', rootPath, '/DIRAC/tests/Workflow/Regression')[0]
helloWorldLoc = find_all('helloWorld.py', rootPath, '/DIRAC/tests/Workflow/Regression')[0]
except IndexError: # we are in Jenkins
exeScriptLoc = find_all('exe-script.py', os.environ['WORKSPACE'], '/DIRAC/tests/Workflow/Regression')[0]
helloWorldLoc = find_all('helloWorld.py', os.environ['WORKSPACE'], '/DIRAC/tests/Workflow/Regression')[0]
shutil.copyfile(exeScriptLoc, './exe-script.py')
shutil.copyfile(helloWorldLoc, './helloWorld.py')
try:
helloWorldXMLLocation = find_all('helloWorld.xml', rootPath, '/DIRAC/tests/Workflow/Regression')[0]
except IndexError: # we are in Jenkins
helloWorldXMLLocation = find_all('helloWorld.xml', os.environ['WORKSPACE'], '/DIRAC/tests/Workflow/Regression')[0]
self.j_u_hello = Job(helloWorldXMLLocation)
try:
helloWorldXMLFewMoreLocation = find_all('helloWorld.xml', rootPath, '/DIRAC/tests/Workflow/Regression')[0]
except IndexError: # we are in Jenkins
helloWorldXMLFewMoreLocation = find_all(
'helloWorld.xml',
os.environ['WORKSPACE'],
'/DIRAC/tests/Workflow/Regression')[0]
self.j_u_helloPlus = Job(helloWorldXMLFewMoreLocation)
def setUp(self):
""" test case set up """
gLogger.setLevel('INFO')
self.stressRequests = 1000
self.bulkRequest = 1000
def test_DDSim_ASI_StartFrom(self):
"""DDSim.applicationSpecificInputs: check setting of startfrom variable........................."""
gLogger.setLevel("ERROR")
self.ddsim.workflow_commons = dict(StartFrom=321)
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual(self.ddsim.startFrom, 321)
def setUp( self ):
""" c'tor
:param self: self reference
"""
gLogger.setLevel( "VERBOSE" )
self.log = gLogger.getSubLogger( self.__class__.__name__ )
def test_DDSim_ASI_RandomSeed_Prod( self ):
"""DDSim.applicationSpecificInputs: check setting of randomseed in production..................."""
gLogger.setLevel("ERROR")
self.ddsim.workflow_commons = dict(StartFrom=321, IS_PROD=True, PRODUCTION_ID=6666, JOB_ID=123)
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual( self.ddsim.randomSeed, 6666123 )
def setUp( self ):
from DIRAC import gLogger
gLogger.setLevel( 'DEBUG' )
mockObjectDM = MagicMock()
mockObjectDM.getActiveReplicas.return_value = S_OK( {'Successful': {'/a/lfn/1.txt':{'SE1':'/a/lfn/at/SE1.1.txt',
'SE2':'/a/lfn/at/SE2.1.txt'},
'/a/lfn/2.txt':{'SE1':'/a/lfn/at/SE1.1.txt'}
},
'Failed':{}} )
self.mockDM = MagicMock()
self.mockDM.return_value = mockObjectDM
mockObjectSE = MagicMock()
mockObjectSE.getFileMetadata.return_value = S_OK( {'Successful':{'/a/lfn/1.txt':{'Cached':0},
'/a/lfn/2.txt':{'Cached':1}},
'Failed':{}} )
mockObjectSE.getFile.return_value = S_OK( {'Successful':{'/a/lfn/1.txt':{}},
'Failed':{}} )
mockObjectSE.getStatus.return_value = S_OK( {'Read': True, 'DiskSE': True} )
self.mockSE = MagicMock()
self.mockSE.return_value = mockObjectSE
self.dli = DownloadInputData( {'InputData': [],
'Configuration': 'boh',
'FileCatalog': S_OK( {'Successful': []} )} )
def setUp(self):
""" test case set up """
gLogger.setLevel('NOTICE')
self.file = File()
self.file.LFN = "/lhcb/user/c/cibak/testFile"
self.file.Checksum = "123456"
self.file.ChecksumType = "ADLER32"
self.file2 = File()
self.file2.LFN = "/lhcb/user/f/fstagni/testFile"
self.file2.Checksum = "654321"
self.file2.ChecksumType = "ADLER32"
self.operation = Operation()
self.operation.Type = "ReplicateAndRegister"
self.operation.TargetSE = "CERN-USER"
self.operation.addFile(self.file)
self.operation.addFile(self.file2)
self.request = Request()
self.request.RequestName = "RequestManagerHandlerTests"
self.request.OwnerDN = "/DC=ch/DC=cern/OU=Organic Units/OU=Users/CN=cibak/CN=605919/CN=Krzysztof Ciba"
self.request.OwnerGroup = "dirac_user"
self.request.JobID = 123
self.request.addOperation(self.operation)
# # JSON representation of a whole request
self.jsonStr = self.request.toJSON()['Value']
# # request client
self.requestClient = ReqClient()
self.stressRequests = 1000
self.bulkRequest = 1000
def setUp(self):
"""Setup"""
gLogger.setLevel("DEBUG")
self.moduleTested = moduleTested
self.testClass = self.moduleTested.DowntimePolicy
self.DTCommand = MagicMock()
def setUp( self ):
gLogger.setLevel( 'DEBUG' )
self.LOCAL_PATH = tempfile.mkdtemp()
self.storageName = STORAGE_NAME
self.tbt = None
# create the local structure
workPath = os.path.join( self.LOCAL_PATH, 'Workflow' )
os.mkdir( workPath )
os.mkdir( os.path.join( workPath, 'FolderA' ) )
with open( os.path.join( workPath, 'FolderA', 'FileA' ), 'w' ) as f:
f.write( 'FileA' )
os.mkdir( os.path.join( workPath, 'FolderA', 'FolderAA' ) )
with open( os.path.join( workPath, 'FolderA', 'FolderAA', 'FileAA' ), 'w' ) as f:
f.write( 'FileAA' )
os.mkdir( os.path.join( workPath, 'FolderB' ) )
with open( os.path.join( workPath, 'FolderB', 'FileB' ), 'w' ) as f:
f.write( 'FileB' )
for fn in ["File1", "File2", "File3"]:
with open( os.path.join( workPath, fn ), 'w' ) as f:
f.write( fn )
def setUp(self):
gLogger.setLevel('DEBUG')
self.LOCAL_PATH = tempfile.mkdtemp()
self.storageName = STORAGE_NAME
self.tbt = None
# create the local structure
workPath = os.path.join(self.LOCAL_PATH, 'Workflow')
os.mkdir(workPath)
os.mkdir(os.path.join(workPath, 'FolderA'))
with open(os.path.join(workPath, 'FolderA', 'FileA'), 'w') as f:
f.write('FileA')
os.mkdir(os.path.join(workPath, 'FolderA', 'FolderAA'))
with open(os.path.join(workPath, 'FolderA', 'FolderAA', 'FileAA'),
'w') as f:
f.write('FileAA')
os.mkdir(os.path.join(workPath, 'FolderB'))
with open(os.path.join(workPath, 'FolderB', 'FileB'), 'w') as f:
f.write('FileB')
for fn in ["File1", "File2", "File3"]:
with open(os.path.join(workPath, fn), 'w') as f:
f.write(fn)
def test_Whizard2_resolveIntegratedProcess_NoProc(self):
"""Test resolveIntegratedProcess with no integrated process"""
gLogger.setLevel('ERROR')
self.whiz = Whizard2Analysis()
self.whiz.integratedProcess = ''
ret = self.whiz.resolveIntegratedProcess()
self.assertTrue(ret['OK'])
def setUp( self ):
"""
Setup
"""
gLogger.setLevel('DEBUG')
# Mock external libraries / modules not interesting for the unit test
mock_pathFinder = mock.MagicMock()
mock_pathFinder.getServiceURL.return_value = 'cookiesURL'
self.mock_pathFinder = mock_pathFinder
mock_RPC = mock.MagicMock()
mock_RPC.addFile.return_value = { 'OK' : True }
# mock_RPC.addMigratingReplicas.return_value = { 'OK' : True }
# mock_RPC.removeMigratingFiles.return_value = { 'OK' : True }
# mock_RPC.removeMigratingReplicas.return_value = { 'OK' : True }
#
mock_RPCClient = mock.MagicMock()
mock_RPCClient.return_value = mock_RPC
self.mock_RPCClient = mock_RPCClient
# Add mocks to moduleTested
moduleTested.PathFinder = self.mock_pathFinder
moduleTested.RPCClient = self.mock_RPCClient
self.moduleTested = moduleTested
self.testClass = self.moduleTested.RAWIntegrityClient
def setUp( self ):
""" test case set up """
gLogger.setLevel( 'NOTICE' )
self.file = File()
self.file.LFN = "/lhcb/user/c/cibak/testFile"
self.file.Checksum = "123456"
self.file.ChecksumType = "ADLER32"
self.file2 = File()
self.file2.LFN = "/lhcb/user/f/fstagni/testFile"
self.file2.Checksum = "654321"
self.file2.ChecksumType = "ADLER32"
self.operation = Operation()
self.operation.Type = "ReplicateAndRegister"
self.operation.TargetSE = "CERN-USER"
self.operation.addFile( self.file )
self.operation.addFile( self.file2 )
self.request = Request()
self.request.RequestName = "RequestManagerHandlerTests"
self.request.OwnerDN = "/DC=ch/DC=cern/OU=Organic Units/OU=Users/CN=cibak/CN=605919/CN=Krzysztof Ciba"
self.request.OwnerGroup = "dirac_user"
self.request.JobID = 123
self.request.addOperation( self.operation )
# # JSON representation of a whole request
self.jsonStr = self.request.toJSON()['Value']
# # request client
self.requestClient = ReqClient()
self.stressRequests = 1000
self.bulkRequest = 1000
def setUp(self):
'''
Setup
'''
gLogger.setLevel("DEBUG")
self.moduleTested = moduleTested
self.testClass = self.moduleTested.ResourceManagementClient
def setUp(self):
""" test case set up """
gLogger.setLevel('INFO')
self.file = File()
self.file.LFN = "/lhcb/user/c/cibak/testFile"
self.file.Checksum = "123456"
self.file.ChecksumType = "ADLER32"
self.file2 = File()
self.file2.LFN = "/lhcb/user/f/fstagni/testFile"
self.file2.Checksum = "654321"
self.file2.ChecksumType = "ADLER32"
self.operation = Operation()
self.operation.Type = "ReplicateAndRegister"
self.operation.TargetSE = "CERN-USER"
self.operation.addFile(self.file)
self.operation.addFile(self.file2)
proxyInfo = getProxyInfo()['Value']
self.request = Request()
self.request.RequestName = "RequestManagerHandlerTests"
self.request.OwnerDN = proxyInfo['identity']
self.request.OwnerGroup = proxyInfo['group']
self.request.JobID = 123
self.request.addOperation(self.operation)
# # JSON representation of a whole request
self.jsonStr = self.request.toJSON()['Value']
# # request client
self.requestClient = ReqClient()
def setUp(self):
"""
Make fake files for the test
"""
self.inputfile = "/ilc/prod/ilc/mc-dbd/generated/500-TDR_ws/6f_eeWW/v01-16-p05_500/00005160/000/E500-TDR_ws.I108640.P6f_eexyev.eL.pR_gen_5160_2_065.stdhep"
self.inputfiles = [self.inputfile, self.inputfile]
gLogger.setLevel("DEBUG")
def test_DDSim_ASI_RandomSeed_Set( self ):
"""DDSim.applicationSpecificInputs: check setting of default randomseed in user jobs............"""
gLogger.setLevel("ERROR")
self.ddsim = DDSimAnalysis()
self.ddsim.workflow_commons = dict()
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual( int(self.ddsim.randomSeed), 12345 )
def test_DDSim_getDetectorXML_NoDetModels( self ):
"""DDSim.getDetectorXML Error no detectorModels................................................."""
gLogger.setLevel("ERROR")
self.ddsim.detectorModel = "camelot"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_ERROR("Nothing to see" ) )
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertEqual( res['Message'], "Failed to get list of DetectorModels from the ConfigSystem" )
def setUp( self ):
""" Setup
"""
gLogger.setLevel( 'DEBUG' )
self.moduleTested = moduleTested
self.testClass = self.moduleTested.DowntimePolicy
self.DTCommand = MagicMock()
def test_Whizard2_ASI_RandomSeed_Set(self):
"""Whizard.applicationSpecificInputs: check setting of default randomseed in user jobs............"""
gLogger.setLevel("ERROR")
self.whiz = Whizard2Analysis()
self.whiz.workflow_commons = dict()
self.whiz.resolveInputVariables()
self.whiz.applicationSpecificInputs()
self.assertEqual(int(self.whiz.randomSeed), 12345)
def test_Whizard2_ASI_RandomSeed_User_Zero( self ):
"""Whizard.applicationSpecificInputs: check setting of randomseed to zero in user jobs............"""
gLogger.setLevel("ERROR")
self.whiz = Whizard2Analysis()
self.whiz.randomSeed = 0
self.whiz.workflow_commons = dict()
self.whiz.resolveInputVariables()
self.whiz.applicationSpecificInputs()
self.assertEqual( int(self.whiz.randomSeed), 0)
def test_Whizard2_ASI_RandomSeed_Prod(self):
"""Whizard.applicationSpecificInputs: check setting of randomseed in production..................."""
gLogger.setLevel("ERROR")
self.whiz.workflow_commons = dict(IS_PROD=True,
PRODUCTION_ID=6666,
JOB_ID=123)
self.whiz.resolveInputVariables()
self.whiz.applicationSpecificInputs()
self.assertEqual(self.whiz.randomSeed, 6666123)
def test_DDSim_ASI_RandomSeed_User_Zero(self):
"""DDSim.applicationSpecificInputs: check setting of randomseed to zero in user jobs............"""
gLogger.setLevel("ERROR")
self.ddsim = DDSimAnalysis()
self.ddsim.randomSeed = 0
self.ddsim.workflow_commons = dict()
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual(int(self.ddsim.randomSeed), 0)
def setup(mocker):
tpName = "DIRAC.TransformationSystem.Agent.TransformationPlugin"
tuName = "DIRAC.TransformationSystem.Client.Utilities"
mocker.patch(tpName + ".TransformationClient", new=MagicMock("tClient"))
mocker.patch(tpName + ".TransformationPlugin._getSiteForSE", return_value=S_OK([]))
mocker.patch(tuName + ".DataManager", new=dm_mock)
mocker.patch(tuName + ".FileCatalog", new=fc_mock)
mocker.patch(tuName + ".StorageElement", new=MagicMock("SEMock"))
gLogger.setLevel("DEBUG")
def setUp(self):
gLogger.setLevel("DEBUG")
self.wrapperFile = None
# get proxy
proxyInfo = getProxyInfo(disableVOMS=True)
proxyChain = proxyInfo["Value"]["chain"]
proxyDumped = proxyChain.dumpAllToString()
self.payloadProxy = proxyDumped["Value"]
def setUp( self ):
gLogger.setLevel( 'DEBUG' )
self.wrapperFile = None
# get proxy
proxyInfo = getProxyInfo( disableVOMS = True )
proxyChain = proxyInfo['Value']['chain']
proxyDumped = proxyChain.dumpAllToString()
self.payloadProxy = proxyDumped['Value']
def test_DDSim_ASI_InputFiles( self ):
"""DDSim.applicationSpecificInputs: check setting inputData....................................."""
gLogger.setLevel("ERROR")
self.ddsim = DDSimAnalysis()
self.ddsim.InputData = ["myslcio.slcio","mystdhep.HEPEvt","my.notforsimulation"]
self.ddsim.workflow_commons = dict()
self.ddsim.resolveInputVariables()
self.ddsim.applicationSpecificInputs()
self.assertEqual( self.ddsim.InputFile, ["myslcio.slcio","mystdhep.HEPEvt"] )
def setUp(self):
gLogger.setLevel('DEBUG')
self.wrapperFile = None
# get proxy
proxyInfo = getProxyInfo(disableVOMS=True)
proxyChain = proxyInfo['Value']['chain']
proxyDumped = proxyChain.dumpAllToString()
self.payloadProxy = proxyDumped['Value']
def test_DDSim_getDetectorXML_NoSoftFolder( self ):
"""DDSim.getDetectorXML Error no SoftwareFolder................................................."""
gLogger.setLevel("ERROR")
xmlPath = "/path/to/camelot.xml"
self.ddsim.detectorModel = "camelot"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot=xmlPath ) ) )
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertEqual( res['Message'], "Windows not supported" )
def test_DDSim_getDetectorXML_relPatg( self ):
"""DDSim.getDetectorXML from CS with relative path.............................................."""
gLogger.setLevel("ERROR")
xmlPath = "rel/path/to/camelot.xml"
self.ddsim.detectorModel = "camelot"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot=xmlPath ) ) )
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertEqual( res['Value'], os.path.join("/win32",xmlPath) )
def setup(mocker):
tpName = 'DIRAC.TransformationSystem.Agent.TransformationPlugin'
tuName = 'DIRAC.TransformationSystem.Client.Utilities'
mocker.patch(tpName + '.TransformationClient', new=MagicMock('tClient'))
mocker.patch(tpName + '.TransformationPlugin._getSiteForSE',
return_value=S_OK([]))
mocker.patch(tuName + '.DataManager', new=dm_mock)
mocker.patch(tuName + '.FileCatalog', new=fc_mock)
mocker.patch(tuName + '.StorageElement', new=MagicMock('SEMock'))
gLogger.setLevel('DEBUG')
def test_DDSim_getDetectorXML_NoSoftFolder(self):
"""DDSim.getDetectorXML Error no SoftwareFolder................................................."""
gLogger.setLevel("ERROR")
xmlPath = "/path/to/camelot.xml"
self.ddsim.detectorModel = "camelot"
self.ddsim.ops.getOptionsDict = Mock(
return_value=S_OK(dict(camelot=xmlPath)))
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertEqual(res['Message'], "Windows not supported")
def test_DDSim_extractTar_Raise( self ):
"""DDSim._extractTar raised exception..........................................................."""
gLogger.setLevel("ERROR")
self.ddsim.detectorModel = "myDet"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot="/dev/null" ) ) )
self.ddsim.workflow_commons = dict()
with patch("tarfile.open", side_effect=RuntimeError("This is what happens") ):
res = self.ddsim._extractTar()
self.assertFalse( res['OK'] )
self.assertEqual( res['Message'], "Failed to untar detector model" )
def test_DDSim_getDetectorXML_relPatg(self):
"""DDSim.getDetectorXML from CS with relative path.............................................."""
gLogger.setLevel("ERROR")
xmlPath = "rel/path/to/camelot.xml"
self.ddsim.detectorModel = "camelot"
self.ddsim.ops.getOptionsDict = Mock(
return_value=S_OK(dict(camelot=xmlPath)))
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertEqual(res['Value'], os.path.join("/win32", xmlPath))
def test_DDSim_getDetectorXML_Fail( self ):
"""DDSim.getDetectorXML Failure................................................................."""
gLogger.setLevel("ERROR")
xmlPath = "/path/to/camelot.xml"
self.ddsim.detectorModel = "fortressOfSolitude"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot=xmlPath ) ) )
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
self.assertFalse( res['OK'] )
self.assertEqual( res['Message'], "Detector model was not found" )
def setUp(self):
gLogger.setLevel('DEBUG')
self.RSMock = MagicMock()
self.RMMock = MagicMock()
self.RMMock.selectStatusElement.return_value = {
'OK': True,
'Value': 'bla'
}
self.mockPDP = MagicMock()
def test_DDSim_getDetectorXML_Local_TarGZ( self ):
"""DDSim.getDetectorXML with local zip.........................................................."""
gLogger.setLevel("ERROR")
self.ddsim.detectorModel = "myDet"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot="/dev/null" ) ) )
self.ddsim.workflow_commons = dict()
res = self.ddsim._getDetectorXML()
gLogger.error( " res " , res )
expectedPath = os.path.join(os.getcwd(), self.ddsim.detectorModel, self.ddsim.detectorModel+".xml" )
self.assertEqual( res['Value'], expectedPath )
self.assertTrue( os.path.exists( expectedPath ) )
def test_DDSim_getDetectorXML_CustomWithOfficialName( self ):
"""DDSim.getDetectorXML CustomTarball with official name........................................"""
gLogger.setLevel("ERROR")
self.ddsim.detectorModel = "Camelot"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( {"Camelot": "/path/to/camelot.xml"} ) )
self.ddsim.workflow_commons = dict()
#only works for python 2
with patch.object(__builtin__, 'open', mock_open(read_data="RoundTable")):
res = self.ddsim._getDetectorXML()
print res
self.assertEqual( res['Value'], os.path.join( "Camelot", "Camelot.xml" ) )
def test_DDSim_extractZip_Raise( self ):
"""DDSim._extractZip raised exception..........................................................."""
gLogger.setLevel("ERROR")
self.ddsim.detectorModel = "myDet"
self.ddsim.ops.getOptionsDict = Mock( return_value = S_OK( dict(camelot="/dev/null" ) ) )
self.ddsim.workflow_commons = dict()
## myDet.zip does not exist
os.remove( "myDet.zip" )
res = self.ddsim._extractZip()
self.assertFalse( res['OK'] )
self.assertEqual( res['Message'], "Failed to unzip detector model" )
def setUp(self):
"""
Make fake files for the test
"""
self.inputfile = "/ilc/prod/ilc/mc-dbd/generated/500-TDR_ws/6f_eeWW/v01-16-p05_500/00005160/000/E500-TDR_ws.I108640.P6f_eexyev.eL.pR_gen_5160_2_065.stdhep"
self.utils = importlib.import_module( 'ILCDIRAC.Core.Utilities.InputFilesUtilities' )
self.utils.FileCatalogClient.getDirectoryUserMetadata = Mock(return_value=S_OK({"NumberOfEvents":500}))
self.utils.FileCatalogClient.getFileUserMetadata = Mock(return_value=S_OK({"NumberOfEvents":500}))
#self.utils.FileCatalogClient.getDirectoryUserMetadata.return_value(S_OK())
self.inputfiles = [ self.inputfile, self.inputfile ]
gLogger.setLevel("DEBUG")
def cleanOldOutputData(baseDir, logLevel="INFO"):
gLogger.setLevel(logLevel)
res = getProxyInfo(False, False)
if not res["OK"]:
gLogger.error("Failed to get client proxy information.", res["Message"])
return {"OK": False, "Message": "Failed to get client proxy information: %s" % str(res["Message"]), "RC": 71}
result = removeOutputData(baseDir)
if not result["OK"]:
return {"OK": False, "Message": "Failed to remove files %s" % result["Message"], "RC": 41}
else:
return S_OK(baseDir + " has been supressed")
return S_OK("No previous outputdata found.")
def setUp( self ):
gLogger.setLevel( 'DEBUG' )
self.mockDM = MagicMock()
self.mockDM.getReplicas.return_value = S_OK( {'Successful': {'/a/lfn/1.txt':{'SE1':'/a/lfn/at/SE1.1.txt',
'SE2':'/a/lfn/at/SE2.1.txt'},
'/a/lfn/2.txt':{'SE1':'/a/lfn/at/SE1.1.txt'}},
'Failed':{}} )
self.mockFC = MagicMock()
self.mockFC.getFileMetadata.return_value = S_OK( {'Successful': {'/a/lfn/1.txt':{'GUID':'AABB11'},
'/a/lfn/2.txt':{'GUID':'AABB22'}},
'Failed':{}} )
def removeOutputData(baseDir, logLevel="INFO"):
gLogger.setLevel(logLevel)
res = getProxyInfo(False, False)
if not res["OK"]:
gLogger.error("Failed to get client proxy information.", res["Message"])
return {"OK": False, "Message": "Failed to get client proxy information: %s" % str(res["Message"]), "RC": 71}
# ######################################################################################################## #
rm = DataManager()
try:
result = rm.cleanLogicalDirectory(baseDir)
except KeyError, ke:
return {"OK": False, "Message": "Caught key error, full stacktrace below\n%s" % str(ke), "RC": 137}
