Changeset 4655 for exist


Ignore:
Timestamp:
16/12/08 11:24:05 (11 years ago)
Author:
cbyrom
Message:

Create new class, testUtils, to handle various common test activities
and to make re-use of eXist client across different codebases easier -
due to problems with absolute references to the required config file
in the testconstants module. Refactor test suite to use.

Location:
exist/trunk/python
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • exist/trunk/python/ndgUtils/lib/existdbclient.py

    r4627 r4655  
    483483        logging.debug("Found collection path, '%s'" %collPath) 
    484484        return collPath 
    485          
     485 
     486 
     487    def deleteAtomInExist(self, atom): 
     488        ''' 
     489        Delete the given atom from the eXist DB - using the atom 
     490        details to work out the required path to delete 
     491        ''' 
     492        logging.info("Deleting atom from eXist") 
     493        atomPath = atom.getDefaultCollectionPath() + atom.atomName 
     494        self.deleteEXistFile(atomPath) 
     495        logging.info("Atom deleted") 
     496 
    486497             
    487498    def createAtomInExist(self, atom): 
  • exist/trunk/python/ndgutilstests/lib/testatomvalidator.py

    r4641 r4655  
    88from ndgUtils.lib.atomvalidator import AtomValidator as v, ValidationError 
    99import ndgutilstests.testconstants as tc 
     10from ndgutilstests.testutils import testUtils as tu 
    1011from ndgUtils.models.Atom import Atom 
    1112from ndgUtils.vocabtermdata import VocabTermData as VTD 
     
    1718        set up data used in the tests. 
    1819        ''' 
    19         self.atom = tc.createAtom(tc.xmlString) 
     20        self.atom = tu(tc.DBCONFIG_FILE).createAtom(tc.xmlString) 
    2021        self.v = v(self.atom, tc.DBCONFIG_FILE) 
    2122 
    2223    def __setInvalidAtom(self): 
    23         self.atom = tc.createAtom(tc.invalidXmlString) 
     24        #self.atom = tc.createAtom(tc.invalidXmlString) 
     25        self.atom = tu(tc.DBCONFIG_FILE).createAtom(tc.invalidXmlString) 
    2426        self.v.setAtom(self.atom) 
    2527         
  • exist/trunk/python/ndgutilstests/lib/testexistdbclient.py

    r4651 r4655  
    1313from ndgUtils.vocabtermdata import VocabTermData as VTD 
    1414import ndgutilstests.testconstants as tc 
     15from ndgutilstests.testutils import testUtils as tu 
    1516 
    1617class testEXistDBClient(unittest.TestCase): 
     
    2728        set up data used in the tests. 
    2829        ''' 
    29         print "Setting up..." 
    3030        self.tidyUp = False    #     switch to indicate to tearDown that we need to delete the created eXist file 
    31         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
     31        self.utils = tu(tc.DBCONFIG_FILE) 
    3232 
    3333    def testCreateOrUpdateEXistFile(self): 
    3434        self.tidyUp = True 
    3535        try: 
    36             self.dbc.createOrUpdateEXistFile(data.testdata.xmlString, \ 
     36            self.utils.dbc.createOrUpdateEXistFile(data.testdata.xmlString, \ 
    3737                                             self.VALID_COLLECTION_PATH, \ 
    3838                                             self.VALID_FILE) 
    39             self.dbc.createOrUpdateEXistFile(data.testdata.xmlString, \ 
     39            self.utils.dbc.createOrUpdateEXistFile(data.testdata.xmlString, \ 
    4040                                             self.VALID_COLLECTION_PATH, \ 
    4141                                             self.VALID_FILE) 
     
    4545 
    4646    def testAddTimeStamp(self): 
    47         file = self.dbc._eXistDBClient__addTimeStamp(self.VALID_FILE) 
     47        file = self.utils.dbc._eXistDBClient__addTimeStamp(self.VALID_FILE) 
    4848        self.assertTrue(file.startswith(self.VALID_FILE.split('.')[0])) 
    4949        self.assertTrue(file.endswith(self.VALID_FILE.split('.')[1])) 
     
    5151         
    5252    def testValidCheckAtomSchemaCompliance(self): 
    53         createdAtom = tc.createAtomInEXist(tc.xmlString) 
    54         atom = tc.createAtomInEXist(tc.xmlString) 
     53        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
     54        atom = self.utils.createAtomInEXist(tc.xmlString) 
    5555        atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    56         self.assertEqual([], self.dbc.checkAtomSchemaCompliance(atomPath)) 
    57         self.dbc.deleteEXistFile(atomPath) 
     56        self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance(atomPath)) 
     57        self.utils.dbc.deleteAtomInExists(atom) 
    5858 
    5959    def testValidCheckAtomSchemaComplianceWithKeyword(self): 
    60         atom = tc.createAtom(tc.xmlString) 
    61         self.assertEqual([], self.dbc.checkAtomSchemaCompliance('', atom = atom)) 
     60        atom = self.utils.createAtom(tc.xmlString) 
     61        self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance('', atom = atom)) 
    6262 
    6363    def testInValidCheckAtomSchemaCompliance(self): 
    64         atom = tc.createAtom(tc.xmlString) 
     64        atom = self.utils.createAtom(tc.xmlString) 
    6565        atom.author.name = '' 
    66         self.assertNotEqual([], self.dbc.checkAtomSchemaCompliance('', atom = atom)) 
     66        self.assertNotEqual([], self.utils.dbc.checkAtomSchemaCompliance('', atom = atom)) 
    6767         
    6868    def testCreateNoneAtomInExist(self): 
    69         self.assertRaises(ValueError,self.dbc.createAtomInExist, None) 
     69        self.assertRaises(ValueError,self.utils.dbc.createAtomInExist, None) 
    7070 
    7171    def testCreateNotAtomInExist(self): 
    72         self.assertRaises(ValueError,self.dbc.createAtomInExist, [1,2,4]) 
     72        self.assertRaises(ValueError,self.utils.dbc.createAtomInExist, [1,2,4]) 
    7373         
    7474    def testGetAtomFail(self): 
    75         self.assertRaises(ValueError, self.dbc.getAtom, self.INVALID_PATH) 
     75        self.assertRaises(ValueError, self.utils.dbc.getAtom, self.INVALID_PATH) 
    7676 
    7777    def testCreateAtomInExist(self): 
    78         createdAtom = tc.createAtomInEXist(tc.xmlString) 
     78        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
    7979        self.assertNotEquals(None, createdAtom) 
    80         self.dbc.deleteEXistFile(createdAtom.getDefaultCollectionPath() + createdAtom.atomName) 
     80        self.utils.dbc.deleteAtomInExist(createdAtom) 
    8181 
    8282    def testGetAtom(self): 
    83         createdAtom = tc.createAtomInEXist(tc.xmlString) 
     83        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
    8484        self.assertNotEquals(None, createdAtom) 
    85         self.assertNotEquals(None, self.dbc.getAtom(createdAtom.datasetID)) 
    86         atomPath = createdAtom.getDefaultCollectionPath() + createdAtom.atomName 
    87         self.dbc.deleteEXistFile(atomPath) 
     85        self.assertNotEquals(None, self.utils.dbc.getAtom(createdAtom.datasetID)) 
     86        self.utils.dbc.deleteAtomInExist(createdAtom) 
    8887 
    8988 
     
    9493 
    9594    def testNotLoadCollectionData(self): 
    96         self.assertEquals(None, self.dbc.collections) 
     95        self.assertEquals(None, self.utils.dbc.collections) 
    9796 
    9897 
    9998    def testGetSchema(self): 
    100         self.assertNotEquals(None, self.dbc.AtomSchema)   
     99        self.assertNotEquals(None, self.utils.dbc.AtomSchema)   
    101100         
    102101     
    103102    def testCreateCollections(self):   
    104         self.assertEquals(False, self.dbc.xmldb.removeCollection(self.DUMMY_COLLECTION)) 
    105         self.dbc.createCollections([self.DUMMY_COLLECTION])  
    106         self.assertEquals(True, self.dbc.xmldb.removeCollection(self.DUMMY_COLLECTION)) 
     103        self.assertEquals(False, self.utils.dbc.xmldb.removeCollection(self.DUMMY_COLLECTION)) 
     104        self.utils.dbc.createCollections([self.DUMMY_COLLECTION])  
     105        self.assertEquals(True, self.utils.dbc.xmldb.removeCollection(self.DUMMY_COLLECTION)) 
    107106         
    108107 
     
    110109        molesSchema = self.VALID_COLLECTION_PATH + \ 
    111110                ndgXqueries.ATOM_MOLES_SCHEMA  + '.xsd' 
    112         self.dbc.deleteEXistFile(molesSchema) 
    113         self.assertEquals(None, self.dbc._eXistDBClient__lookupEXistFile(molesSchema)) 
     111        self.utils.dbc.deleteEXistFile(molesSchema) 
     112        self.assertEquals(None, self.utils.dbc._eXistDBClient__lookupEXistFile(molesSchema)) 
    114113 
    115114        newClient = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
     
    120119        molesSchema = self.VALID_COLLECTION_PATH + \ 
    121120                ndgXqueries.ATOM_MOLES_SCHEMA  + '.xsd' 
    122         self.dbc.deleteEXistFile(molesSchema) 
    123         self.assertEquals(None, self.dbc._eXistDBClient__lookupEXistFile(molesSchema)) 
     121        self.utils.dbc.deleteEXistFile(molesSchema) 
     122        self.assertEquals(None, self.utils.dbc._eXistDBClient__lookupEXistFile(molesSchema)) 
    124123 
    125124        newClient = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE) 
     
    128127    def testSetUpEXistCollections(self): 
    129128        try: 
    130             self.dbc._eXistDBClient__setUpEXistAtomCollections() 
     129            self.utils.dbc._eXistDBClient__setUpEXistAtomCollections() 
    131130        except: 
    132131            self.fail("Should not have thrown an exception") 
    133132         
    134133    def testLoadDBDetailsValid(self): 
    135         self.dbc._eXistDBClient__loadDBDetails(tc.DBCONFIG_FILE) 
    136         if not self.dbc._pw or not self.dbc.eXistDBHostname or not self.dbc._username: 
     134        self.utils.dbc._eXistDBClient__loadDBDetails(tc.DBCONFIG_FILE) 
     135        if not self.utils.dbc._pw or not self.utils.dbc.eXistDBHostname or not self.utils.dbc._username: 
    137136            self.fail("Did not manage to read in db config data") 
    138137         
    139138    def testLoadDBDetailsInvalid(self): 
    140         self.assertRaises(ValueError,self.dbc._eXistDBClient__loadDBDetails, "blah" + tc.DBCONFIG_FILE) 
     139        self.assertRaises(ValueError,self.utils.dbc._eXistDBClient__loadDBDetails, "blah" + tc.DBCONFIG_FILE) 
    141140 
    142141    def testLookupEXistFileFail(self): 
    143         self.assertEquals(self.dbc._eXistDBClient__lookupEXistFile(self.VALID_FILE_PATH), None) 
     142        self.assertEquals(self.utils.dbc._eXistDBClient__lookupEXistFile(self.VALID_FILE_PATH), None) 
    144143 
    145144    def testLookupEXistFileFind(self): 
    146145        self.tidyUp = True 
    147         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    148         self.assertNotEquals(self.dbc._eXistDBClient__lookupEXistFile(self.VALID_FILE_PATH), None) 
     146        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     147        self.assertNotEquals(self.utils.dbc._eXistDBClient__lookupEXistFile(self.VALID_FILE_PATH), None) 
    149148         
    150149    def testIsNewEXistFile(self): 
    151         self.assertEquals(self.dbc.isNewEXistFile(self.VALID_FILE_PATH), True) 
     150        self.assertEquals(self.utils.dbc.isNewEXistFile(self.VALID_FILE_PATH), True) 
    152151 
    153152    def testIsNewEXistFileBeforeAndAfterCreateFile(self): 
    154153        self.tidyUp = True 
    155         self.assertEquals(self.dbc.isNewEXistFile(self.VALID_FILE_PATH), True) 
    156         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    157         self.assertEquals(self.dbc.isNewEXistFile(self.VALID_FILE_PATH), False) 
     154        self.assertEquals(self.utils.dbc.isNewEXistFile(self.VALID_FILE_PATH), True) 
     155        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     156        self.assertEquals(self.utils.dbc.isNewEXistFile(self.VALID_FILE_PATH), False) 
    158157             
    159158    def testCreateEXistFile(self): 
    160159        self.tidyUp = True 
    161         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     160        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    162161         
    163162    def testCreateEXistFileDuplicate(self): 
    164163        self.tidyUp = True 
    165         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     164        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    166165        # NB, this just overwrites the file - so is valid here 
    167         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     166        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    168167         
    169168    def testDeleteEXistFile(self): 
    170         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    171         self.assertEquals(self.dbc.deleteEXistFile(self.VALID_FILE_PATH), True) 
     169        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     170        self.assertEquals(self.utils.dbc.deleteEXistFile(self.VALID_FILE_PATH), True) 
    172171     
    173172    def testGetEXistFileFail(self): 
    174         self.assertEquals(self.dbc.getEXistFile(self.VALID_FILE_PATH), None) 
     173        self.assertEquals(self.utils.dbc.getEXistFile(self.VALID_FILE_PATH), None) 
    175174     
    176175    def testGetEXistFileSucceed(self): 
    177176        self.tidyUp = True 
    178         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    179         self.assertNotEquals(self.dbc.getEXistFile(self.VALID_FILE_PATH), None) 
     177        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     178        self.assertNotEquals(self.utils.dbc.getEXistFile(self.VALID_FILE_PATH), None) 
    180179     
    181180    def testBackupEXistFile(self): 
    182181        self.tidyUp = True 
    183         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    184         backupFile = self.dbc.backupEXistFile(self.VALID_COLLECTION_PATH, self.VALID_FILE) 
     182        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     183        backupFile = self.utils.dbc.backupEXistFile(self.VALID_COLLECTION_PATH, self.VALID_FILE) 
    185184        time.sleep(2) 
    186185        self.assertNotEquals(backupFile, None) 
    187         self.assertNotEquals(self.dbc.getEXistFile(backupFile), None) 
    188         self.dbc.deleteEXistFile(backupFile) 
     186        self.assertNotEquals(self.utils.dbc.getEXistFile(backupFile), None) 
     187        self.utils.dbc.deleteEXistFile(backupFile) 
    189188     
    190189    def testBackupEXistFileMissing(self): 
    191         self.assertRaises(SystemError, self.dbc.backupEXistFile, self.VALID_COLLECTION_PATH, self.VALID_FILE) 
     190        self.assertRaises(SystemError, self.utils.dbc.backupEXistFile, self.VALID_COLLECTION_PATH, self.VALID_FILE) 
    192191 
    193192             
    194193    def testGetAtomFileCollectionPath(self): 
    195194        self.tidyUp = True 
    196         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    197         self.dbc.getAtomFileCollectionPath(data.testdata.id) 
     195        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     196        self.utils.dbc.getAtomFileCollectionPath(data.testdata.id) 
    198197             
    199198    def testGetAtomFileCollectionPath(self): 
    200         self.assertEquals(None, self.dbc.getAtomFileCollectionPath(self.INVALID_PATH)) 
     199        self.assertEquals(None, self.utils.dbc.getAtomFileCollectionPath(self.INVALID_PATH)) 
    201200             
    202201    def testGetAllAtomIDs(self): 
    203202        self.tidyUp = True 
    204         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    205         ids = self.dbc.getAllAtomIDs() 
     203        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     204        ids = self.utils.dbc.getAllAtomIDs() 
    206205        self.assertNotEquals(0, len(ids)) 
    207206        self.assertNotEquals(None, ids[0]) 
     
    209208    def testGetAllAtomCollections(self): 
    210209        self.tidyUp = True 
    211         self.assertEquals(self.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
    212         ids = self.dbc.getAllAtomCollections() 
     210        self.assertEquals(self.utils.dbc.createEXistFile(data.testdata.xmlString, self.VALID_COLLECTION_PATH, self.VALID_FILE), True) 
     211        ids = self.utils.dbc.getAllAtomCollections() 
    213212        self.assertNotEquals(0, len(ids)) 
    214213        self.assertNotEquals({}, ids) 
     
    218217        if self.tidyUp: 
    219218            # delete the test file, in case it has been used in a test 
    220             self.dbc.deleteEXistFile(self.VALID_FILE_PATH) 
     219            self.utils.dbc.deleteEXistFile(self.VALID_FILE_PATH) 
    221220 
    222221if __name__ == '__main__': 
  • exist/trunk/python/ndgutilstests/lib/testgranulite.py

    r4652 r4655  
    1313from ndgUtils.eXistConnector import eXistConnector 
    1414import ndgutilstests.testconstants as tc 
     15from ndgutilstests.testutils import testUtils as tu 
    1516from ndgUtils.models.Atom import Atom 
    1617import ndgUtils.lib.existdbclient as dbc 
     
    2324        set up data used in the tests. 
    2425        ''' 
    25         self.g = granulite(tc.TEST_GRANULITE, eXistClient = tc.client) 
     26        self.utils = tu(tc.DBCONFIG_FILE) 
     27        self.g = granulite(tc.TEST_GRANULITE, eXistClient = tu.dbc) 
    2628 
    2729    def testProcessGranulite(self): 
     
    3335            self.assertEqual('-3.33984375', atom.maxX) 
    3436            self.assertEqual('-17.578125', atom.maxY) 
    35             atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    36             self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    37             self.dbc.deleteEXistFile(atomPath) 
     37            self.utils.dbc.deleteAtomInExist(atom) 
    3838        except Exception, e: 
    3939            self.fail("An exception should not have been thrown") 
     
    109109            atom.fromString(tc.xmlString) 
    110110            atom.atomTypeID = VTD.DE_TERM 
    111             self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    112             atom = self.dbc.createAtomInExist(atom) 
     111            atom = self.utils.dbc.createAtomInExist(atom) 
    113112     
    114113            # now set up the granulite 
     
    120119            self.g._granulite__updateDataEntity(atom.datasetID) 
    121120            atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    122             self.assertEqual([], self.dbc.checkAtomSchemaCompliance(atomPath)) 
     121            self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance(atomPath)) 
    123122     
    124123            updatedAtom = Atom() 
    125             updatedAtom.fromString(self.dbc.getAtom(tc.datasetID)) 
     124            updatedAtom.fromString(self.utils.dbc.getAtom(tc.datasetID)) 
    126125            self.assertNotEqual(atom, updatedAtom) 
    127126             
     
    131130            self.fail("An exception shouldn't have been thrown") 
    132131        finally: 
    133             self.dbc.deleteEXistFile(atomPath) 
     132            self.utils.dbc.deleteAtomInExist(atom) 
    134133 
    135134 
     
    139138        atom.fromString(tc.xmlString) 
    140139        atom.atomTypeID = VTD.DE_TERM 
    141         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    142         atom = self.dbc.createAtomInExist(atom) 
     140        atom = self.utils.dbc.createAtomInExist(atom) 
    143141 
    144142        # now set up the granulite 
     
    151149        self.g._granulite__addGranuleToDataEntityRecords() 
    152150        atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    153         self.assertEqual([], self.dbc.checkAtomSchemaCompliance(atomPath)) 
     151        self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance(atomPath)) 
    154152 
    155153        updatedAtom = Atom() 
    156         updatedAtom.fromString(self.dbc.getAtom(tc.datasetID)) 
     154        updatedAtom.fromString(self.utils.dbc.getAtom(tc.datasetID)) 
    157155        self.assertNotEqual(atom, updatedAtom) 
    158156         
    159157        # there should be one extra link on the new atom 
    160158        self.assertEqual(len(atom.relatedLinks) + 1, len(updatedAtom.relatedLinks)) 
    161         self.dbc.deleteEXistFile(atomPath) 
     159        self.utils.dbc.deleteEXistFile(atomPath) 
    162160         
    163161         
  • exist/trunk/python/ndgutilstests/test_DocumentRetrieve.py

    r4641 r4655  
    1717from ndgUtils.ndgRetrieve import * 
    1818import testconstants as tc 
     19from testutils import testUtils as tu 
    1920from ndgUtils.ndgObject import ndgObject as no 
    20 import ndgUtils.lib.existdbclient as dbc 
    2121 
    2222logging.basicConfig(level=logging.DEBUG, 
     
    103103                         
    104104    def testGetAtom(self): 
    105         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
    106         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
     105        utils = tu(tc.DBCONFIG_FILE) 
     106        createdAtom = utils.createAtomInEXist(tc.xmlString) 
    107107        dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY) 
    108108        doc = dr.get(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE, \ 
    109                      self.createdAtom.datasetID, targetCollection = ATOM_COLLECTION) 
    110         self.assertNotEquals(doc.find(self.createdAtom.datasetID), -1) 
    111         atomPath = self.createdAtom.getDefaultCollectionPath() + self.createdAtom.atomName 
    112         self.dbc.deleteEXistFile(atomPath) 
     109                     createdAtom.datasetID, targetCollection = ATOM_COLLECTION) 
     110        self.assertNotEquals(doc.find(createdAtom.datasetID), -1) 
     111        utils.dbc.deleteAtomInExist(createdAtom) 
    113112                         
    114113    def testGetInvalidAtom(self): 
     
    118117                         
    119118    def testGetAtomBackup(self): 
    120         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
    121         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    122         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
     119        utils = tu(tc.DBCONFIG_FILE) 
     120        createdAtom = utils.createAtomInEXist(tc.xmlString) 
     121        createdAtom = utils.createAtomInEXist(tc.xmlString) 
    123122        dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY) 
    124123        doc = dr.get(tc.VALID_PROVIDER_ID, no.ATOM_BACKUP_DOC_TYPE, \ 
    125                      self.createdAtom.datasetID, targetCollection = ATOM_BACKUP_COLLECTION) 
    126         self.assertNotEquals(doc.find(self.createdAtom.datasetID), -1) 
    127         atomPath = self.createdAtom.getDefaultCollectionPath() + self.createdAtom.atomName 
    128         self.dbc.deleteEXistFile(atomPath) 
     124                     createdAtom.datasetID, targetCollection = ATOM_BACKUP_COLLECTION) 
     125        self.assertNotEquals(doc.find(createdAtom.datasetID), -1) 
     126        utils.dbc.deleteAtomInExist(createdAtom) 
    129127         
  • exist/trunk/python/ndgutilstests/test_ndgRetrieve.py

    r4641 r4655  
    1818import unittest, os, logging, ConfigParser 
    1919import testconstants as tc 
     20from testutils import testUtils as tu 
    2021import ndgUtils.lib.existdbclient as dbc 
    2122 
     
    8182    def testRetrieveAtom(self): 
    8283        '''Get an atom document ''' 
    83         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
    84         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    85         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
     84        utils = tu(tc.DBCONFIG_FILE) 
     85        createdAtom = utils.createAtomInEXist(tc.xmlString) 
    8686        doc= tc.VALID_PROVIDER_ID + "__" + no.ATOM_DOC_TYPE + \ 
    87             "__" + self.createdAtom.datasetID 
     87            "__" + createdAtom.datasetID 
    8888        uri=no(doc) 
    8989        status,xml=ndgRetrieve(uri,self.c, discovery=0) 
    9090        self.assertEqual(status,1) 
    91         self.assertNotEqual(xml.find(self.createdAtom.datasetID), -1) 
    92         atomPath = self.createdAtom.getDefaultCollectionPath() + self.createdAtom.atomName 
    93         self.dbc.deleteEXistFile(atomPath) 
     91        self.assertNotEqual(xml.find(createdAtom.datasetID), -1) 
     92        utils.dbc.deleteAtomInExist(createdAtom) 
    9493         
    9594    def testRetrieveInvalidAtom(self): 
     
    103102    def testRetrieveAtomBackup(self): 
    104103        '''Get a backed up atom document ''' 
    105         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
    106         self.dbc = dbc.eXistDBClient(configFile = tc.DBCONFIG_FILE, setUpDB = True) 
    107         self.createdAtom = tc.createAtomInEXist(tc.xmlString) 
     104        utils = tu(tc.DBCONFIG_FILE) 
     105        createdAtom = utils.createAtomInEXist(tc.xmlString) 
     106        createdAtom = utils.createAtomInEXist(tc.xmlString) 
    108107        doc= tc.VALID_PROVIDER_ID + "__" + no.ATOM_BACKUP_DOC_TYPE + \ 
    109             "__" + self.createdAtom.datasetID 
     108            "__" + createdAtom.datasetID 
    110109        uri=no(doc) 
    111110        status,xml=ndgRetrieve(uri,self.c, discovery=0) 
    112111        self.assertEqual(status,1) 
    113         self.assertNotEqual(xml.find(self.createdAtom.datasetID), -1) 
    114         atomPath = self.createdAtom.getDefaultCollectionPath() + self.createdAtom.atomName 
    115         self.dbc.deleteEXistFile(atomPath) 
     112        self.assertNotEqual(xml.find(createdAtom.datasetID), -1) 
     113        utils.dbc.deleteAtomInExist(createdAtom) 
    116114         
    117115if __name__=="__main__": 
  • exist/trunk/python/ndgutilstests/testconstants.py

    r4651 r4655  
    1414 
    1515from ndgUtils.vocabtermdata import VocabTermData as VTD 
    16 import ndgUtils.lib.existdbclient as dbc 
    17 from ndgUtils.models.Atom import Atom 
    1816import os 
    1917 
     
    157155              '/db/moles_support/granuleAtom/famous_control_month_granule.moles'] 
    158156 
    159 client = dbc.eXistDBClient(configFile = DBCONFIG_FILE, setUpDB = True) 
    160  
    161 def createAtom(content): 
    162     atom = Atom(VTD.GRANULE_TERM) 
    163     atom.fromString(content) 
    164     return atom 
    165  
    166 def createAtomInEXist(content): 
    167     atom = createAtom(content) 
    168     return client.createAtomInExist(atom) 
    169  
Note: See TracChangeset for help on using the changeset viewer.