def test_broadcast_processed_checkchunking(self): from DIRAC import S_OK from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin import copy files = {} for i in xrange(0, 599): files[('/file/dir/input%s.txt' % i)] = ['child'] dataman_mock = Mock() trans_mock = Mock() util_mock = Mock() util_mock.fc.getFileDescendents.return_value = S_OK({ 'Successful': files, 'Failed': {} }) util_mock.transClient = trans_mock self.tfp = TransformationPlugin('BroadcastProcessed', dataman_mock, trans_mock) self.tfp.params['Status'] = '' self.tfp.util = util_mock self.tfp.setInputData(copy.deepcopy(files)) del self.tfp.data['/file/dir/input542.txt'] with patch('%s.TransformationPlugin._Broadcast' % MODULE_NAME, new=Mock(return_value=S_OK(98124))): assertDiracSucceedsWith_equals(self.tfp.run(), 98124, self) expected = {} for i in xrange(0, 599): if i != 542: expected[('/file/dir/input%s.txt' % i)] = ['child'] assertListContentEquals(self.tfp.data, expected, self) assertEqualsImproved(len(util_mock.fc.getFileDescendents.mock_calls), 3, self)
def test_execute_getfilemetadata_empty( self ): exists_dict = { 'list_of.txt' : True, 'something' : True } self.ujf.jobID = 512 request_mock = Mock() request_mock.RequestName = 'job_512_request.xml' request_mock.JobID = 512 request_mock.SourceComponent = "Job_512" report_mock = Mock() self.ujf.jobReport = report_mock self.ujf.workflow_commons = { 'TotalSteps' : '42', 'Request' : request_mock, 'JOB_ID' : '512', 'IS_PROD' : True, 'PRODUCTION_ID' : '98245', 'Platform' : 'myTestPlatform', 'Owner' : 'myTestOwner123RichGuy', 'VO' : 'myTestVirtualOrga', 'JobReport' : report_mock } self.ujf.workflowStatus = S_OK() self.ujf.stepStatus = S_OK() self.ujf.userOutputData = [ 'something' ] self.ujf.userOutputSE = 'myTestReceivingSE' self.ujf.userOutputPath = 'my/User/OPPath' with patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=lambda path: exists_dict[path])), \ patch('%s.open' % MODULE_NAME, mock_open(read_data='myfilecontent,makeniceadlerchecksum')), \ patch('%s.os.path.getsize' % MODULE_NAME, new=Mock(return_value=3048)), \ patch('%s.os.getcwd' % MODULE_NAME, new=Mock(return_value='/mycurdirTestMe')), \ patch('%s.getDestinationSEList' % MODULE_NAME, new=Mock(return_value=S_OK(['CERN-DIP-4']))), \ patch('%s.UserJobFinalization.getFileMetadata' % MODULE_NAME, new=Mock(return_value=S_OK())): result = self.ujf.execute() assertDiracSucceedsWith_equals( result, None, self ) report_mock.setApplicationStatus.assert_called_once_with( 'No Output Data Files To Upload', True )
def test_getsoftwarefolder_from_cvmfs(self): with patch('%s.checkCVMFS' % MODULE_NAME, new=Mock(return_value=S_OK(('mycvmfsfolder/txt', 'otherentry')))) as cvmfs_mock: result = getSoftwareFolder('a', 'b', 'c') cvmfs_mock.assert_called_once_with('a', ['b', 'c']) assertDiracSucceedsWith_equals(result, 'mycvmfsfolder/txt', self)
def test_checkcvmfs_exists( self ): with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(side_effect=['testcvmfspath', 'testenvscript'])), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(return_value=True)): result = checkCVMFS( 'mytestplatform', ('appnametesttest123', 'appversionv77testp2') ) assertDiracSucceedsWith_equals( result, ('testcvmfspath', 'testenvscript'), self )
def test_getEnvironmentScript(self): with patch('%s.checkCVMFS' % MODULE_NAME, new=Mock(return_value=S_OK(('/otherfolder/otherfile', '/cvmfsfolder/myenvscript')))): result = getEnvironmentScript('a', 'b', 'c', None) assertDiracSucceedsWith_equals(result, '/cvmfsfolder/myenvscript', self)
def test_getfilesfromcastor(self): self.over.machine = 'testMach12' import subprocess popen_mock = Mock() popen_mock.communicate.side_effect = [ ('myfile1\nfile1923\n813tev_collision ', 'ignoreme'), ('file1.stdhep\nsome_other_file', 'ignoreme'), ('', 'ignoreme'), ('\nlast_file.txt', 'ignoreme') ] castor_dict = { 'ProdID': 121345, 'Energy': '813', 'EvtType': 'myTestEvt', 'DetectorType': 'myTestDetectorv3' } with patch('subprocess.Popen', new=Mock(return_value=popen_mock)) as proc_mock: proc_command_dir = '/castor/cern.ch/grid/ilc/prod/testMach12/813/myTestEvt/myTestDetectorv3/SIM/00121345/' assertDiracSucceedsWith_equals( self.over._OverlayInput__getFilesFromCastor(castor_dict), [ proc_command_dir + 'myfile1/file1.stdhep', proc_command_dir + 'myfile1/some_other_file', proc_command_dir + 'file1923/', proc_command_dir + '813tev_collision/', proc_command_dir + '813tev_collision/last_file.txt' ], self) assertEqualsImproved(proc_mock.mock_calls, [ call(['nsls', proc_command_dir], stdout=subprocess.PIPE), call(['nsls', proc_command_dir + 'myfile1'], stdout=subprocess.PIPE), call(['nsls', proc_command_dir + 'file1923'], stdout=subprocess.PIPE), call(['nsls', proc_command_dir + '813tev_collision'], stdout=subprocess.PIPE) ], self)
def test_getnumberofevents_othercases( self ): # Expected behavior: # If one file in a directory, get its tags, if Number of events defined go to next entry # Else go to directory and check there. if nbevts go to next # Else iterate over all files in directory. # If numberevents defined nowhere, method fails file_meta_dict = { '/unique/dir/file3' : S_OK( { 'Luminosity' : '49.2' } ), '/one/file/myfile' : S_OK( { 'NumberOfEvents' : '14' } ), '/other/myfile2' : S_OK( { 'Luminosity' : 1489, 'NumberOfEvents' : 941.2 } ), '/a/b/c/Dir1/someFile' : S_OK( { 'NumberOfEvents' : '14' } ), '/a/b/c/Dir1/other_file' : S_OK( { 'NumberOfEvents' : '14' } ), '/a/b/c/Dir1/dontforget_me' : S_OK( { 'NumberOfEvents' : '14' } ) } directory_meta_dict = { '/a/b/c/Dir1' : S_OK( { 'Luminosity' : 84.1, 'evttype' : 'testEvt' } ), '/unique/dir' : S_OK( { 'NumberOfEvents' : 814, 'Luminosity' : None } ), '/other' : S_OK( { 'NumberOfEvents' : None, 'Luminosity' : None } ), '/one/file' : S_OK( {} ) } fcMock = Mock() fcMock.getDirectoryUserMetadata = Mock(side_effect=lambda path: directory_meta_dict[path]) fcMock.getFileUserMetadata = Mock(side_effect=lambda filename : file_meta_dict[filename] ) with patch( "%s.FileCatalogClient" % MODULE_NAME, new=Mock(return_value=fcMock)): assertDiracSucceedsWith_equals( getNumberOfEvents( [ '/a/b/c/Dir1/someFile', '', '/a/b/c/Dir1/other_file', '/unique/dir/file3', '', '', '', '/a/b/c/Dir1/dontforget_me', '/one/file/myfile', '/other/myfile2' ] ), { 'AdditionalMeta': { 'evttype' : 'testEvt' }, 'EvtType' : '', 'lumi' : 1790.5, 'nbevts' : 1811 }, self )
def test_setfilestatus_useexistingfilereport( self ): report_mock = Mock() report_mock.setFileStatus.return_value = S_OK('my_report_test_returnval') self.moba.workflow_commons['FileReport'] = report_mock assertDiracSucceedsWith_equals( self.moba.setFileStatus( 'production', 'lfn', 'status' ), 'my_report_test_returnval', self ) assertEqualsImproved( self.moba.workflow_commons['FileReport'], report_mock, self )
def test_limited_add_up_to_maximum( self ): from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin from DIRAC import S_OK dataman_mock = Mock() util_mock = Mock() util_mock.groupByReplicas.return_value = S_OK( [ ( 'testSE', [ 'mylfn1', 'testLFN2' ] ), ( 'testSE', [ 'other_test_lfn' ] ), ( 'testSE', [ 'mylfn' ] ), ( 'testSE', [ 'MyLFN' ] ) ] ) trans_mock = Mock() trans_mock.getCounters.return_value = S_OK( [ ( { 'Status' : 'Processed' }, 3 ), ( { 'Status' : 'junk' }, 6 ), ( { 'Status' : 'Ignore_me' }, 8 ), ( { 'Status' : 'Assigned' }, 1 ) ] ) util_mock.transClient = trans_mock self.tfp = TransformationPlugin( 'Limited', dataman_mock, trans_mock ) self.tfp.params[ 'Status' ] = 'Processed' self.tfp.params[ 'MaxNumberOfTasks' ] = 6 self.tfp.params[ 'TransformationID' ] = 78456 self.tfp.util = util_mock test_data = [ ( '/my/file/here_abc', [ 'myTestSE' ] ), ( '/my/file/other_file.txt', [ 'secretSE', 'StorageSE', 'TestSE' ] ), ( '/my/file/newfile.pdf', [ 'TestSE' ] ), ( '/my/file/a', [] ), ( '/dir/somefile', [ '' ] ) ] self.tfp.setInputData( test_data ) assertDiracSucceedsWith_equals( self.tfp.run(), [ ( '', [ 'mylfn1', 'testLFN2' ] ), ( '', [ 'other_test_lfn' ] ) ], self ) util_mock.groupByReplicas.assert_called_once_with( test_data, 'Processed' ) trans_mock.getCounters.assert_called_once_with( 'TransformationFiles', [ 'Status' ], { 'TransformationID' : 78456 } )
def test_writeproclist(self): expected_write = 'Processes\n{\n mytestprocess123\n {\n TarBallCSPath = /test/cs/path/bal.tarr\n Detail = TestNoDetails\n Generator = mytestGen21\n Model = testmodel3001\n Restrictions = \n InFile = my/file.in\n CrossSection = 0\n }\n}\n' self.prol._addEntry( 'mytestprocess123', { 'TarBallCSPath': '/test/cs/path/bal.tarr', 'Detail': 'TestNoDetails', 'Generator': 'mytestGen21', 'Model': 'testmodel3001', 'Restrictions': '', 'InFile': 'my/file.in' }) exists_dict = { '/temp/dir': False, '/temp/dir/mytempfile.txt': True, '/my/folder/testpath.xml': True } fhandle_mock = Mock() with patch('tempfile.mkstemp', new=Mock(return_value=('handle', '/temp/dir/mytempfile.txt'))), \ patch('__builtin__.file', new=Mock(return_value=fhandle_mock)) as file_mock, \ patch('os.makedirs') as mkdir_mock, \ patch('os.path.exists', new=Mock(side_effect=lambda path: exists_dict[path])), \ patch('shutil.move') as move_mock, \ patch('os.close') as close_mock: assertDiracSucceedsWith_equals( self.prol.writeProcessList('/my/folder/testpath.xml'), '/my/folder/testpath.xml', self) mkdir_mock.assert_called_once_with('/temp/dir') file_mock.assert_called_once_with('/temp/dir/mytempfile.txt', 'w') fhandle_mock.write.assert_called_once_with(expected_write) close_mock.assert_called_once_with('handle') move_mock.assert_called_once_with('/temp/dir/mytempfile.txt', '/my/folder/testpath.xml')
def test_sliced_empty( self ): from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin dataman_mock = Mock() trans_mock = Mock() self.tfp = TransformationPlugin( 'Sliced', dataman_mock, trans_mock ) self.tfp.setInputData( {} ) assertDiracSucceedsWith_equals( self.tfp.run(), [], self )
def test_applicationSpecificInputs_with_setters(self): tmp_dict = { 'Detector': 'othertestdetectorv3000', 'Energy': '10000GeV', 'BXOverlay': '651', 'ggtohadint': 9.5, 'ProdID': 429875, 'NbSigEvtsPerJob': 94, 'BkgEvtType': 'bgoijaf', 'STEP_NUMBER': 1, } self.over.step_commons = tmp_dict self.over.InputData = ['abc'] self.over.NumberOfEvents = 15 with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(return_value=2)): result = self.over.applicationSpecificInputs() assertDiracSucceedsWith_equals(result, TestOverlayUnittests.GOOD_EXIT, self) assertEqualsImproved( (self.over.detectormodel, self.over.energytouse, self.over.BXOverlay, self.over.ggtohadint, self.over.prodid, self.over.NbSigEvtsPerJob, self.over.BkgEvtType), ('othertestdetectorv3000', '10000GeV', '651', 9.5, 429875, 94, 'bgoijaf'), self) assertEqualsImproved(self.over.nbsigeventsperfile, 15, self) assertEqualsImproved(self.over.nbinputsigfile, 1, self)
def test_broadcast_processed_checkchunking( self ): from DIRAC import S_OK from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin import copy files = {} for i in xrange(0, 599): files[ ( '/file/dir/input%s.txt' % i ) ] = [ 'child' ] dataman_mock = Mock() trans_mock = Mock() util_mock = Mock() util_mock.fc.getFileDescendents.return_value = S_OK( { 'Successful' : files, 'Failed' : {} } ) util_mock.transClient = trans_mock self.tfp = TransformationPlugin( 'BroadcastProcessed', dataman_mock, trans_mock ) self.tfp.params[ 'Status' ] = '' self.tfp.util = util_mock self.tfp.setInputData( copy.deepcopy( files ) ) del self.tfp.data[ '/file/dir/input542.txt' ] with patch('%s.TransformationPlugin._Broadcast' % MODULE_NAME, new=Mock(return_value=S_OK(98124))): assertDiracSucceedsWith_equals( self.tfp.run(), 98124, self ) expected = {} for i in xrange(0, 599): if i != 542: expected[ ( '/file/dir/input%s.txt' % i ) ] = [ 'child' ] assertListContentEquals( self.tfp.data, expected, self ) assertEqualsImproved( len( util_mock.fc.getFileDescendents.mock_calls ), 3, self )
def test_getfcfiles(self): ops_dict = { '/Overlay/clic_cdr/200TeV/testdetectorv2000/myTestBkgEvt/ProdID': 98421, '/Overlay/clic_cdr/200TeV/testdetectorv2000/myTestBkgEvt/NbEvts': 482, '/Overlay/clic_cdr/200TeV/testdetectorv2000/myTestBkgEvt/EvtType': 'someTestEventType' } self.over.energy = 123 self.over.useEnergyForFileLookup = True self.over.BkgEvtType = 'myTestBkgEvt' self.over.machine = 'clic_cdr' ops_mock = Mock() ops_mock.getValue.side_effect = lambda key, default: ops_dict[key] self.over.ops = ops_mock fcc_mock = Mock() fcc_mock.findFilesByMetadata.return_value = S_OK(9824) self.over.fcc = fcc_mock result = self.over._OverlayInput__getFilesFromFC() assertDiracSucceedsWith_equals(result, 9824, self) fcc_mock.findFilesByMetadata.assert_called_once_with({ 'Energy': '123', 'EvtType': 'someTestEventType', 'ProdID': 98421, 'Datatype': 'SIM', 'DetectorModel': 'testdetectorv2000', 'Machine': 'clic' })
def test_applicationspecificinputs_isprod_false( self ): self.shs.OutputFile = 'something' self.shs.InputFile = 'input.stdhep' self.shs.InputData = [] assertDiracSucceedsWith_equals( self.shs.applicationSpecificInputs(), 'Parameters resolved', self ) assertEqualsImproved( self.shs.OutputFile, 'something', self ) assertEqualsImproved( self.shs.listoutput, {}, self )
def test_getjobsatsite_no_site_found(self): con_mock = Mock() with patch('%s.OverlayDB._query' % MODULE_NAME, new=Mock(return_value=S_OK([]))): assertDiracSucceedsWith_equals( self.odb.getJobsAtSite('nonexistent_site_testme', con_mock), 0, self)
def test_applicationSpecificInputs(self): # Compare to this. Get outside of patch, else constructor fails reference = OverlayInput() with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(return_value=2)): result = self.over.applicationSpecificInputs() assertDiracSucceedsWith_equals(result, TestOverlayUnittests.GOOD_EXIT, self) # Assert nothing has been changed, except the values in setUp (and DataManager/FileCatalogClient since theyre created anew for every object) assertEqualsImproved( (self.over.enable, self.over.STEP_NUMBER, self.over.log, self.over.applicationName, self.over.curdir, self.over.applicationLog, self.over.printoutflag, self.over.prodid, self.over.detector, self.over.energy, self.over.nbofeventsperfile, self.over.lfns, self.over.nbfilestoget, self.over.BkgEvtType, self.over.ggtohadint, self.over.nbsigeventsperfile, self.over.nbinputsigfile, self.over.site, self.over.useEnergyForFileLookup, self.over.machine, self.over.pathToOverlayFiles), (reference.enable, reference.STEP_NUMBER, reference.log, reference.applicationName, reference.curdir, reference.applicationLog, reference.printoutflag, reference.prodid, reference.detector, reference.energy, reference.nbofeventsperfile, reference.lfns, reference.nbfilestoget, reference.BkgEvtType, reference.ggtohadint, reference.nbsigeventsperfile, reference.nbinputsigfile, reference.site, reference.useEnergyForFileLookup, reference.machine, reference.pathToOverlayFiles), self) if self.over.fcc is None: self.fail('FCC not initialized') if self.over.datMan is None: self.fail('DataManager not initialized')
def test_getdestinationse_noassoc_country(self): options_dict = { '/Resources/StorageElements/myOutputSE': S_ERROR('bla') } option_dict = { '/Resources/Countries/country/AssignedTo': S_OK('MyTestCountry.Assigned'), '/Resources/Countries/MyTestCountry.Assigned/AssociatedSEs': S_OK('something') } values_dict = { '/Resources/Sites/pre/pre.myTestSite.country/AssociatedSEs/myOutputSE': [], '/Resources/StorageElementGroups/myOutputSE': ['some_elements', 'ignore_me'], '/Resources/Countries/MyTestCountry.Assigned/AssociatedSEs/myOutputSE': ['myassociated_alias_se'], '/Resources/Countries/country/AssociatedSEs/myOutputSE': '' } conf_mock = Mock() conf_mock.getOptions.side_effect = lambda path: options_dict[path] conf_mock.getOption.side_effect = lambda path: option_dict[path] conf_mock.getValue.side_effect = lambda path, _: values_dict[path] with patch('%s.getSEsForSite' % MODULE_NAME, new=Mock(return_value=S_OK([ 'myTestStorageElement1', 'otherStorageElem2' ]))), \ patch('%s.gConfig' % MODULE_NAME, conf_mock): result = getDestinationSEList('myOutputSE', 'pre.myTestSite.country', 'Local') assertDiracSucceedsWith_equals(result, ['myassociated_alias_se'], self)
def test_runit_complete( self ): exists_dict = { '/my/steer/dir/SteerFile.testme' : False, 'SteerFile.testme' : False, 'myAppTestLog.log' : True } open_mock = Mock() open_mock.readlines.side_effect = [ 'line1\n', 'line2\n', 'newline\n', '\n', 'ok\n' ] open_mock.__enter__.return_value = [ 'Events kept 12', 'Events passing cuts 2984', 'Events total 2996' ] self.shc.applicationLog = 'myAppTestLog.log' self.shc.OutputFile = 'something' self.shc.SteeringFile = '/my/dir/SteerFile.testme' self.shc.workflow_commons[ 'Luminosity' ] = 13.0 ( self.shc.platform, self.shc.applicationName, self.shc.applicationVersion ) = ( 'testPlatform', 'AppTestName', 'vT' ) with patch('%s.getSoftwareFolder' % MODULE_NAME, new=Mock(return_value=S_OK('SoftDir'))), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=lambda path: exists_dict[path])), \ patch('%s.open' % MODULE_NAME, new=Mock(return_value=open_mock)) as open_mock, \ patch('%s.os.remove' % MODULE_NAME, new=Mock()) as remove_mock, \ patch('%s.os.chmod' % MODULE_NAME, new=Mock()), \ patch('%s.shellCall' % MODULE_NAME, new=Mock(return_value=S_OK( ( 0, )))), \ patch('%s.StdHepCut.prepareScript' % MODULE_NAME, new=Mock()), \ patch('%s.getSteeringFileDirName' % MODULE_NAME, new=Mock(return_value=S_OK('/my/steer/dir'))): assertDiracSucceedsWith_equals( self.shc.runIt(), 'AppTestName vT Successful', self ) remove_mock.assert_called_once_with( 'myAppTestLog.log' ) assertEqualsImproved( self.shc.workflow_commons[ 'Luminosity' ], 13.0 * ( 1. * 12 / 2984 ), self ) assertEqualsImproved( self.shc.workflow_commons[ 'Info' ], { 'stdhepcut' : { 'Reduction' : 1. * 12 / 2984, 'CutEfficiency' : 1. * 2984 / 2996 } }, self )
def test_runit_othercases( self ): exists_dict = { 'SteerFile.testme' : True, 'myAppTestLog.log' : False } open_mock = Mock() open_mock.readlines.side_effect = [ 'line1\n', 'line2\n', 'newline\n', '\n', 'ok\n' ] open_mock.__enter__.return_value = [ 'Events kept 23', 'Events passing cuts 14', 'Events total 37' ] self.shc.scriptName = 'my_test_script.sh' self.shc.ignoreapperrors = True self.shc.OutputFile = 'something' self.shc.applicationLog = 'myAppTestLog.log' self.shc.SteeringFile = '/my/dir/SteerFile.testme' self.shc.workflow_commons[ 'Info' ] = { 'some_entry' : 'rememberMe' } self.shc.MaxNbEvts = 100 ( self.shc.platform, self.shc.applicationName, self.shc.applicationVersion ) = ( 'testPlatform', 'AppTestName', 'vT' ) with patch('%s.getSoftwareFolder' % MODULE_NAME, new=Mock(return_value=S_OK('SoftDir'))), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=lambda path: exists_dict[path])), \ patch('%s.open' % MODULE_NAME, new=Mock(return_value=open_mock)) as open_mock, \ patch('%s.os.remove' % MODULE_NAME, new=Mock()), \ patch('%s.os.chmod' % MODULE_NAME, new=Mock()), \ patch('%s.shellCall' % MODULE_NAME, new=Mock(return_value=S_OK( ( 0, )))), \ patch('%s.StdHepCut.prepareScript' % MODULE_NAME, new=Mock()): assertDiracSucceedsWith_equals( self.shc.runIt(), 'AppTestName vT Successful', self ) assertEqualsImproved( self.shc.workflow_commons[ 'Info'], { 'some_entry' : 'rememberMe', 'stdhepcut' : { 'Reduction' : 1. * 23 / 14, 'CutEfficiency' : 1. * 14 / 37 } }, self ) assert 'Luminosity' not in self.shc.workflow_commons
def test_getfcfiles_othercase(self): ops_dict = { '/Overlay/ilc_dbd/TestILCDetectorv1/200TeV/otherTestEvt/ProdID': 139, '/Overlay/ilc_dbd/200TeV/TestILCDetectorv1/otherTestEvt/NbEvts': 2145, '/Overlay/ilc_dbd/200TeV/TestILCDetectorv1/otherTestEvt/EvtType': 'ilc_evt_testme' } self.over.energy = 0 self.over.useEnergyForFileLookup = False self.over.detectormodel = '' self.over.BkgEvtType = 'otherTestEvt' self.over.machine = 'ilc_dbd' self.over.detector = 'TestILCDetectorv1' self.over.prodid = 82492 ops_mock = Mock() ops_mock.getValue.side_effect = lambda key, default: ops_dict[key] self.over.ops = ops_mock fcc_mock = Mock() fcc_mock.findFilesByMetadata.return_value = S_OK(2948) self.over.fcc = fcc_mock result = self.over._OverlayInput__getFilesFromFC() assertDiracSucceedsWith_equals(result, 2948, self) fcc_mock.findFilesByMetadata.assert_called_once_with({ 'EvtType': 'ilc_evt_testme', 'ProdID': 82492, 'Datatype': 'SIM', 'Machine': 'ilc' })
def test_broadcast_processed_selectsome( self ): from DIRAC import S_OK from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin dataman_mock = Mock() trans_mock = Mock() util_mock = Mock() util_mock.fc.getFileDescendents.return_value = S_OK( { 'Successful' : { '/some/deep/dir/structure/file1.stdio' : [ 'child' ], '/file/dir/input1.txt' : [], '/dir/file.xml' : [ 'child' ], '/nodir.txt' : [ 'child' ], 'input_file.txt' : [ 'child' ] }, 'Failed' : { '/my/dir/pphys.ics' : [] } } ) util_mock.transClient = trans_mock self.tfp = TransformationPlugin( 'BroadcastProcessed', dataman_mock, trans_mock ) self.tfp.params[ 'Status' ] = '' self.tfp.util = util_mock self.tfp.setInputData( { '/some/deep/dir/structure/file1.stdio' : [ 'myTestSE1' ], '/file/dir/input1.txt' : [ 'other_SE' ], '/dir/file.xml' : [ 'myTestSE1', 'SecondTestSE' ], '/nodir.txt' : [ 'secretSE' ], 'input_file.txt' : [ 'SE_to_test' ], '/my/dir/pphys.ics' : [ '' ] } ) with patch('%s.TransformationPlugin._Broadcast' % MODULE_NAME, new=Mock(return_value=S_OK(98124))): assertDiracSucceedsWith_equals( self.tfp.run(), 98124, self ) assertListContentEquals( self.tfp.data, [ '/some/deep/dir/structure/file1.stdio', '/dir/file.xml', '/nodir.txt', 'input_file.txt' ], self ) util_mock.fc.getFileDescendents.assert_called_once()
def test_limited_add_all(self): from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin from DIRAC import S_OK dataman_mock = Mock() new_tasks = [('otherSE', ['unique_lfn', 'testme_lfn']), ('testSE', ['LFN_to_add']), ('testSE', ['LFN:/mydir/subdir/file.stdhep']), ('testSE', ['testSE/storage/LFN.txt'])] util_mock = Mock() util_mock.groupByReplicas.return_value = S_OK(new_tasks) trans_mock = Mock() trans_mock.getCounters.return_value = S_OK([({ 'Status': 'Processed' }, 3), ({ 'Status': 'junk' }, 6), ({ 'Status': 'Ignore_me' }, 8), ({ 'Status': 'Assigned' }, 1)]) util_mock.transClient = trans_mock self.tfp = TransformationPlugin('Limited', dataman_mock, trans_mock) self.tfp.params['Status'] = 'Processed' self.tfp.params['MaxNumberOfTasks'] = 12 self.tfp.params['TransformationID'] = 78456 self.tfp.util = util_mock self.tfp.setInputData([('/my/file/here_abc', ['myTestSE']), ('/my/file/other_file.txt', ['secretSE', 'StorageSE', 'TestSE']), ('/my/file/newfile.pdf', ['TestSE']), ('/my/file/a', []), ('/dir/somefile', [''])]) assertDiracSucceedsWith_equals(self.tfp.run(), [('', tup) for (_se, tup) in new_tasks], self)
def test_setfilestatus( self ): report_mock = Mock() report_mock.setFileStatus.return_value = S_OK('other_my_report_test') with patch('%s.FileReport' % MODULE_NAME, new=Mock(return_value=report_mock)): assertDiracSucceedsWith_equals( self.moba.setFileStatus( 'production', 'lfn', 'status' ), 'other_my_report_test', self ) assertEqualsImproved( self.moba.workflow_commons['FileReport'], report_mock, self )
def test_resolveinput_productionjob4(self): self.marAna.workflow_commons["IS_PROD"] = True self.marAna.OutputFile = '' prodId = "123" self.marAna.workflow_commons["PRODUCTION_ID"] = prodId jobId = "456" self.marAna.workflow_commons["JOB_ID"] = jobId self.marAna.workflow_commons.pop( 'ProductionOutputData', None) #default value needed, else maybe KeyError self.marAna.InputFile = 'in3.slcio' self.marAna.outputREC = 'out1.stdhep' self.marAna.outputDST = 'test2.stdhep' assertDiracSucceedsWith_equals(self.marAna.applicationSpecificInputs(), "Parameters resolved", self) files = [ self.marAna.outputREC, self.marAna.outputDST, self.marAna.InputFile[0] ] for filename in files: # TODO: check for file extension, differentiate 'test'/'test2' in filename... self.assertInMultiple([prodId, jobId], filename) self.assertInMultiple(['in3', '.slcio'], self.marAna.InputFile[0]) self.assertInMultiple(['out1', '.stdhep'], self.marAna.outputREC) self.assertInMultiple(['test2', '.stdhep'], self.marAna.outputDST)
def test_applicationSpecificInputs(self): assertDiracSucceedsWith_equals(self.spa.applicationSpecificInputs(), 'Parameters resolved', self) assertEqualsImproved(self.spa.pandorasettings, 'PandoraSettings.xml', self) assertEqualsImproved(self.spa.InputFile, [], self) assertEqualsImproved(self.spa.InputData, [], self)
def test_getenvscript_other_prefixpath( self ): def replace_abspath( path ): """ Mock implementation of os.path.abspath """ if path == 'SLICPandora.sh': return '/abs/test/path/SLICPandora.sh' else: sys.exit() exists_dict = { 'PandoraFrontend' : False, '/my/dir/test/me/Executable/PandoraFrontend' : True } with patch('%s.getSoftwareFolder' % MODULE_NAME, new=Mock(return_value=S_OK('/my/dir/test/me'))) as getsoft_mock, \ patch('%s.removeLibc' % MODULE_NAME) as removelib_mock, \ patch('%s.getNewLDLibs' % MODULE_NAME, new=Mock(return_value='/new/ldpath')) as getlib_mock, \ patch('%s.getNewPATH' % MODULE_NAME, new=Mock(return_value='/new/test/path')) as getpath_mock, \ patch('%s.open' % MODULE_NAME, mock_open()) as open_mock: with patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=lambda path: exists_dict[path])) as exists_mock, \ patch('%s.os.chmod' % MODULE_NAME) as chmod_mock, \ patch('%s.os.path.abspath' % MODULE_NAME, new=Mock(side_effect=replace_abspath)) as abspath_mock: result = self.spa.getEnvScript( 'mytestsysconfig', 'SLIC Pandora', 'V2' ) chmod_mock.assert_called_once_with('SLICPandora.sh', 0o755) assertMockCalls( exists_mock, [ 'PandoraFrontend', '/my/dir/test/me/Executable/PandoraFrontend' ], self ) abspath_mock.assert_called_once_with( 'SLICPandora.sh' ) assertDiracSucceedsWith_equals( result, '/abs/test/path/SLICPandora.sh', self ) getsoft_mock.assert_called_once_with( 'mytestsysconfig', 'SLIC Pandora', 'V2' ) removelib_mock.assert_called_once_with( '/my/dir/test/me/LDLibs' ) getlib_mock.assert_called_once_with( 'mytestsysconfig', 'SLIC Pandora', 'V2' ) getpath_mock.assert_called_once_with( 'mytestsysconfig', 'SLIC Pandora', 'V2' ) open_mock.assert_any_call( 'SLICPandora.sh', 'w' ) open_mock = open_mock() assertMockCalls( open_mock.write, [ '#!/bin/sh \n', '############################################################\n', '# Dynamically generated script to get the SLICPandora env. #\n', '############################################################\n', "declare -x PATH=/new/test/path:$PATH\n", 'declare -x ROOTSYS=/my/dir/test/me/ROOT\n', 'declare -x LD_LIBRARY_PATH=$ROOTSYS/lib:/my/dir/test/me/LDLibs:/new/ldpath\n', 'declare -x PANDORASETTINGSDIR=/my/dir/test/me/Settings\n', "declare -x PATH=/my/dir/test/me/Executable:$PATH\n" ], self )
def test_execute_noinput(self): self.shs.platform = 'TestPlatV1' self.shs.InputFile = '' with patch('%s.StdHepSplit.resolveInputVariables' % MODULE_NAME, new=Mock(return_value=S_OK())): assertDiracSucceedsWith_equals(self.shs.execute(), 'No files found to process', self)
def test_application_specific_inputs_jobid_zero( self ): self.ujf.jobID = 0 self.ujf.enable = True result = self.ujf.applicationSpecificInputs() assertDiracSucceedsWith_equals( result, 'Parameters resolved', self ) assertEqualsImproved( self.ujf.jobID, 0, self ) assertEqualsImproved( self.ujf.enable, False, self )
def test_sliced_empty(self): from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin dataman_mock = Mock() trans_mock = Mock() self.tfp = TransformationPlugin('Sliced', dataman_mock, trans_mock) self.tfp.setInputData({}) assertDiracSucceedsWith_equals(self.tfp.run(), [], self)
def test_getmainfields(self): result = self.whop.getMainFields() assertDiracSucceedsWith_equals(result, [ 'process_input', 'integration_input', 'simulation_input', 'diagnostics_input', 'parameter_input', 'beam_input_1', 'beam_input_2' ], self)
def test_applicationspecificinputs_isprod_false(self): self.shs.OutputFile = 'something' self.shs.InputFile = 'input.stdhep' self.shs.InputData = [] assertDiracSucceedsWith_equals(self.shs.applicationSpecificInputs(), 'Parameters resolved', self) assertEqualsImproved(self.shs.OutputFile, 'something', self) assertEqualsImproved(self.shs.listoutput, {}, self)
def test_runit_statusbad(self): self.shc.workflowStatus['OK'] = True self.shc.workflowStatus['OK'] = False self.shc.applicationName = 'testApp' assertDiracSucceedsWith_equals( self.shc.runIt(), 'testApp should not proceed as previous step did not end properly', self)
def test_execute_disabled( self ): self.ulf.enable = False with patch.object(self.ulf, 'resolveInputVariables', new=Mock(return_value=S_OK())), \ patch.object(self.ulf, '_determineRelevantFiles', new=Mock(return_value=S_OK([ 'first_selected_file', 'other_files' ]))), \ patch.object(self.ulf, '_populateLogDirectory', new=Mock(return_value=S_OK())), \ patch('%s.UploadLogFile.logWorkingDirectory' % MODULE_NAME, new=Mock()): assertDiracSucceedsWith_equals( self.ulf.execute(), 'Module is disabled by control flag', self ) self.assertFalse(self.log_mock.error.called)
def test_checkcvmfs_exists(self): with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(side_effect=['testcvmfspath', 'testenvscript'])), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(return_value=True)): result = checkCVMFS('mytestplatform', ('appnametesttest123', 'appversionv77testp2')) assertDiracSucceedsWith_equals(result, ('testcvmfspath', 'testenvscript'), self)
def test_getsites(self): con_mock = Mock() with patch('%s.OverlayDB._getConnection' % MODULE_NAME, new=Mock(return_value=S_OK(con_mock))), \ patch('%s.OverlayDB._query' % MODULE_NAME, new=Mock(return_value=S_OK([ ('some_row',), ('other_row', )]))) as query_mock: assertDiracSucceedsWith_equals(self.odb.getSites(), ['some_row', 'other_row'], self) query_mock.assert_called_once_with('SELECT Site From OverlayData;', con_mock)
def test_resolveinput_productionjob3(self): self.marAna.workflow_commons["IS_PROD"] = True self.marAna.OutputFile = "c.c" self.marAna.InputFile = [] inputlist = ["a.slcio", "b.slcio", "c.exe"] self.marAna.InputData = inputlist assertDiracSucceedsWith_equals(self.marAna.applicationSpecificInputs(), "Parameters resolved", self) self.assertEquals([inputlist[0], inputlist[1]], self.marAna.InputFile)
def test_resolveinput_productionjob2( self ): self.marAna.workflow_commons[ 'ParametricInputSandbox' ] = [] self.marAna.workflow_commons[ "IS_PROD" ] = False self.marAna.workflow_commons[ "PRODUCTION_ID" ] = "123" self.marAna.workflow_commons[ "JOB_ID" ] = 456 assertDiracSucceedsWith_equals( self.marAna.applicationSpecificInputs(), "Parameters resolved", self ) self.assertEquals( self.marAna.InputFile, [] ) self.assertEquals( self.marAna.InputData, [] )
def test_resolveinput_productionjob3( self ): self.marAna.workflow_commons[ "IS_PROD" ] = True self.marAna.OutputFile = "c.c" self.marAna.InputFile = [] inputlist = [ "a.slcio", "b.slcio", "c.exe" ] self.marAna.InputData = inputlist assertDiracSucceedsWith_equals( self.marAna.applicationSpecificInputs(), "Parameters resolved", self ) self.assertEquals([inputlist[0], inputlist[1]], self.marAna.InputFile )
def test_canrun_toomanyjobs(self): con_mock = Mock() with patch('%s.OverlayDB._query' % MODULE_NAME, new=Mock(return_value=S_OK([[2]]))) as query_mock: assertDiracSucceedsWith_equals( self.odb.canRun('testSite1', con_mock), False, self) query_mock.assert_called_once_with( "SELECT NumberOfJobs FROM OverlayData WHERE Site='testSite1';", con_mock)
def test_getjobsatsite(self): con_mock = Mock() with patch('%s.OverlayDB._query' % MODULE_NAME, new=Mock(return_value=S_OK([[123]]))) as query_mock: assertDiracSucceedsWith_equals( self.odb.getJobsAtSite('myTest_Site1', con_mock), 123, self) query_mock.assert_called_once_with( "SELECT NumberOfJobs FROM OverlayData WHERE Site='myTest_Site1';", con_mock)
def test_submit_createnew_dirac_instance( self ): ilc_mock = Mock() ilc_mock().submitJob.return_value = S_OK('test_submission_successful') self.ujo.proxyinfo = S_OK( { 'group' : 'ilc_user' } ) with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_OK())), \ patch('%s.DiracILC' % MODULE_NAME, new=ilc_mock): assertDiracSucceedsWith_equals( self.ujo.submit(), 'test_submission_successful', self ) ilc_mock().submitJob.assert_called_once_with(self.ujo, 'wms') assert self.ujo.oktosubmit
def test_submit_existing_dirac_instance(self): """Test submit with dirac instance.""" ilc_mock = Mock() ilc_mock.submitJob.return_value = S_OK('test_submission_successful') self.ujo.proxyinfo = S_OK({'group': 'ilc_user'}) with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_OK())): assertDiracSucceedsWith_equals(self.ujo.submit(diracinstance=ilc_mock), 'test_submission_successful', self) ilc_mock.submitJob.assert_called_once_with(self.ujo, 'wms') assert self.ujo.oktosubmit
def test_overlayinput_getEosFile_lfn_success( self ): """ test success when getting an lfn to copy from eos """ testLFN = "/lfn/to/overlay/overlayFile.slcio" res = self.over.getEOSFile( testLFN ) print(res) print("self result", self.over.result) assertDiracSucceedsWith_equals( res, os.path.basename( testLFN ), self ) with open("overlayinput.sh") as overscript: self.assertIn( "xrdcp -s root://eospublic.cern.ch//eos/experiment/clicdp/grid%s" % testLFN , overscript.read() )
def test_overlayinput_getEosFile_fullpath_success( self ): """ test that we don't predent if we get a fullpath for eos, however that might happen""" testLFN = "/eos/experiment/clicdp/grid/lfn/to/overlay/overlayFile.slcio" res = self.over.getEOSFile( testLFN ) print(res) print("self result", self.over.result) assertDiracSucceedsWith_equals( res, os.path.basename( testLFN ), self ) with open("overlayinput.sh") as overscript: self.assertIn( "xrdcp -s root://eospublic.cern.ch/%s" % testLFN , overscript.read() )
def test_getsteerfiledir_cvmfs_success(self): cvmfs_mock = Mock(return_value=S_OK( ['mytestListEntry#1', 'other_entry_dontusethis', '', '18319'])) with patch('%s.checkCVMFS' % MODULE_NAME, new=cvmfs_mock): assertDiracSucceedsWith_equals( getSteeringFileDir('myTestPlatform_1', 'v123Test'), 'mytestListEntry#1', self) cvmfs_mock.assert_called_once_with('myTestPlatform_1', ['steeringfiles', 'v123Test'])
def test_broadcast_processed_flush( self ): from DIRAC import S_OK from ILCDIRAC.ILCTransformationSystem.Agent.TransformationPlugin import TransformationPlugin dataman_mock = Mock() trans_mock = Mock() self.tfp = TransformationPlugin( 'BroadcastProcessed', dataman_mock, trans_mock ) self.tfp.params[ 'Status' ] = 'Flush' with patch('%s.TransformationPlugin._Broadcast' % MODULE_NAME, new=Mock(return_value=S_OK(8124))): assertDiracSucceedsWith_equals( self.tfp.run(), 8124, self )
def test_applicationSpecificInputs_1( self ): self.spa.pandorasettings = 'something' self.spa.InputData = [ 'myfile.slcio', 'ignorethisfile', 'testPart1.slcio', 'myarchive.slcio.tar.gz' ] assertDiracSucceedsWith_equals( self.spa.applicationSpecificInputs(), 'Parameters resolved', self ) assertEqualsImproved( self.spa.InputFile, [ 'myfile.slcio', 'testPart1.slcio', 'myarchive.slcio.tar.gz' ], self )
def test_resolveinput_productionjob2(self): self.marAna.workflow_commons['ParametricInputSandbox'] = [] self.marAna.workflow_commons["IS_PROD"] = False self.marAna.workflow_commons["PRODUCTION_ID"] = "123" self.marAna.workflow_commons["JOB_ID"] = 456 assertDiracSucceedsWith_equals(self.marAna.applicationSpecificInputs(), "Parameters resolved", self) self.assertEquals(self.marAna.InputFile, []) self.assertEquals(self.marAna.InputData, [])
def test_getsoftwarefolder_uselocal( self ): with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(return_value='myapparchivev2.test.tar.gz')) as getval_mock, \ patch('%s.getLocalAreaLocation' % MODULE_NAME, new=Mock(return_value='/mylocalarea/test')), \ patch('%s.getSharedAreaLocation' % MODULE_NAME, new=Mock(return_value='/testshared/area')), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=[ False, True, False ])) as exists_mock: result = getSoftwareFolder( 'a', 'b', 'c' ) exists_mock.assert_called_with( '/mylocalarea/test/myapparchivev2.test' ) getval_mock.assert_called_with( '/AvailableTarBalls/a/b/c/TarBall', '' ) assertEqualsImproved( len(exists_mock.mock_calls), 2, self ) #One exists call in checkCVMFS assertDiracSucceedsWith_equals( result, '/mylocalarea/test/myapparchivev2.test', self )
def test_setfilestatus(self): report_mock = Mock() report_mock.setFileStatus.return_value = S_OK('other_my_report_test') with patch('%s.FileReport' % MODULE_NAME, new=Mock(return_value=report_mock)): assertDiracSucceedsWith_equals( self.moba.setFileStatus('production', 'lfn', 'status'), 'other_my_report_test', self) assertEqualsImproved(self.moba.workflow_commons['FileReport'], report_mock, self)
def test_sendstoredstatinfo( self ): self.moba.jobID = 24986 report_mock = Mock() report_mock.sendStoredStatusInfo.return_value = S_OK('mytest_success!!!') self.moba.workflow_commons['JobReport'] = report_mock assertDiracSucceedsWith_equals( self.moba.sendStoredStatusInfo(), 'mytest_success!!!', self ) self.assertFalse(self.log_mock.called) self.assertFalse(self.log_mock.warn.called) self.assertFalse(self.log_mock.error.called) report_mock.sendStoredStatusInfo.assert_called_once_with()
def test_overlayinput_getEosFile_fullpath_success(self): """ test that we don't predent if we get a fullpath for eos, however that might happen""" testLFN = "/eos/experiment/clicdp/grid/lfn/to/overlay/overlayFile.slcio" res = self.over.getEOSFile(testLFN) print res print "self result", self.over.result assertDiracSucceedsWith_equals(res, os.path.basename(testLFN), self) with open("overlayinput.sh") as overscript: self.assertIn("xrdcp -s root://eospublic.cern.ch/%s" % testLFN, overscript.read())
def test_getoptionsforfield( self ): assertDiracSucceedsWith_equals( self.whop.getOptionsForField( 'process_input' ), [ 'process_id', 'cm_frame', 'sqrts', 'luminosity', 'polarized_beams', 'structured_beams', 'beam_recoil', 'recoil_conserve_momentum', 'filename','directory', 'input_file', 'input_slha_format' ], self ) assertDiracSucceedsWith_equals( self.whop.getOptionsForField( 'parameter_input' ), ['GF', 'mZ', 'mW', 'mH', 'alphas', 'me', 'mmu', 'mtau', 'ms', 'mc', 'mb', 'mtop', 'wtop', 'wZ', 'wW', 'wH', 'vckm11', 'vckm12', 'vckm13', 'vckm21', 'vckm22', 'vckm23', 'vckm31', 'vckm32', 'vckm33', 'khgaz', 'khgaga', 'khgg'], self )
def test_getsoftwarefolder_uselocal( self ): exists_dict = { 'myapparchivev2.test.tar.gz' : False, '/mylocalarea/test/myapparchivev2.test' : True } with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(return_value='myapparchivev2.test.tar.gz')) as getval_mock, \ patch('%s.getLocalAreaLocation' % MODULE_NAME, new=Mock(return_value='/mylocalarea/test')), \ patch('%s.getSharedAreaLocation' % MODULE_NAME, new=Mock(return_value='/testshared/area')), \ patch('%s.os.path.exists' % MODULE_NAME, new=Mock(side_effect=lambda path: exists_dict[path])) as exists_mock: result = getSoftwareFolder( 'a', 'b', 'c' ) assertMockCalls( exists_mock, [ '/mylocalarea/test/myapparchivev2.test', 'myapparchivev2.test.tar.gz' ], self ) getval_mock.assert_called_with( '/AvailableTarBalls/a/b/c/TarBall', '' ) assertDiracSucceedsWith_equals( result, '/mylocalarea/test/myapparchivev2.test', self )
def test_resolveinput_productionjob1( self ): self.marAna.workflow_commons[ "IS_PROD" ] = True outputfile1 = "/dir/a_REC_.a" outputfile2 = "/otherdir/b_DST_.b" inputfile = "/inputdir/input_SIM_.i" self.marAna.workflow_commons[ "ProductionOutputData" ] = ";".join([outputfile1, outputfile2, inputfile]) assertDiracSucceedsWith_equals( self.marAna.applicationSpecificInputs(), "Parameters resolved", self ) assertEqualsImproved( ( self.marAna.outputREC, self.marAna.outputDST, self.marAna.InputFile ), ( "a_REC_.a", "b_DST_.b", [ "input_SIM_.i" ] ), self )
def test_applicationspecificinputs_2( self ): self.shs.OutputFile = 'something' self.shs.workflow_commons.update( { 'IS_PROD' : True, 'PRODUCTION_ID' : '1248', 'JOB_ID' : 173 } ) self.shs.InputFile = 'input.stdhep' self.shs.InputData = [] self.shs.listoutput = 'my_test_list' with patch('%s.getProdFilename' % MODULE_NAME, new=Mock(return_value='myoutputfile.stdio')) as getfile_mock: assertDiracSucceedsWith_equals( self.shs.applicationSpecificInputs(), 'Parameters resolved', self ) assertEqualsImproved( self.shs.OutputFile, 'myoutputfile.stdio', self ) assertEqualsImproved( self.shs.listoutput, 'my_test_list', self ) getfile_mock.assert_called_once_with( 'something', 1248, 173 )
def test_applicationSpecificInputs_with_setters( self ): tmp_dict = { 'Detector' : 'othertestdetectorv3000', 'Energy' : '10000GeV', 'BXOverlay' : '651', 'ggtohadint' : 9.5, 'ProdID' : 429875, 'NbSigEvtsPerJob' : 94, 'BkgEvtType' : 'bgoijaf' } self.over.step_commons = tmp_dict self.over.InputData = [ 'abc' ] self.over.NumberOfEvents = 15 with patch('%s.Operations.getValue' % MODULE_NAME, new=Mock(return_value=2)): result = self.over.applicationSpecificInputs() assertDiracSucceedsWith_equals( result, TestOverlayUnittests.GOOD_EXIT, self ) assertEqualsImproved( ( self.over.detectormodel, self.over.energytouse, self.over.BXOverlay, self.over.ggtohadint, self.over.prodid, self.over.NbSigEvtsPerJob, self.over.BkgEvtType ), ( 'othertestdetectorv3000', '10000GeV', '651', 9.5, 429875, 94, 'bgoijaf' ), self ) assertEqualsImproved( self.over.nbsigeventsperfile, 15, self ) assertEqualsImproved( self.over.nbinputsigfile, 1, self )
def test_getdestinationse( self ): options_dict = { '/Resources/StorageElements/myOutputSE' : S_ERROR( 'bla' ) } values_dict = { '/Resources/Sites/pre/pre.myTestSite.country/AssociatedSEs/myOutputSE' : [], '/Resources/StorageElementGroups/myOutputSE' : [ 'some_grp_member', 'GroupElement', 'StorEl', 'LocalElement' ] } conf_mock = Mock() conf_mock.getOptions.side_effect = lambda path: options_dict[path] conf_mock.getValue.side_effect = lambda path, _: values_dict[path] with patch('%s.getSEsForSite' % MODULE_NAME, new=Mock(return_value=S_OK([ 'StorEl', 'LocalElement' ]))), \ patch('%s.gConfig' % MODULE_NAME, conf_mock): result = getDestinationSEList( 'myOutputSE', 'pre.myTestSite.country', 'AnyOutputmodeTest' ) assertDiracSucceedsWith_equals( result, [ 'StorEl', 'LocalElement', 'some_grp_member', 'GroupElement' ], self )
def test_setjobparameter( self ): self.moba.jobID = 24986 report_mock = Mock() report_mock.setJobParameter.return_value = S_OK('mytest_success!!!') self.moba.workflow_commons['JobReport'] = report_mock assertDiracSucceedsWith_equals( self.moba.setJobParameter( 'mytestName', 135 ), 'mytest_success!!!', self ) self.assertFalse(self.log_mock.called) self.assertFalse(self.log_mock.warn.called) self.assertFalse(self.log_mock.error.called) report_mock.setJobParameter.assert_called_once_with( 'mytestName', '135', True )