Ignore:
Timestamp:
11/02/09 09:26:16 (11 years ago)
Author:
cbyrom
Message:

Update tests for the lib package - removing tests for redundant code +
adding new tests where needed + improve old tests to better set up and
remove the required test environment.

Location:
ndgCommon/trunk/ndg/common/unittests/lib
Files:
1 added
3 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • ndgCommon/trunk/ndg/common/unittests/lib/testatomvalidator.py

    r4849 r4943  
    1818        set up data used in the tests. 
    1919        ''' 
    20         self.atom = tu(tc.EXIST_DBCONFIG_FILE).createAtom(tc.xmlString) 
    21         self.v = v(self.atom, tc.EXIST_DBCONFIG_FILE) 
     20        self.utils = tu(tc.EXIST_DBCONFIG_FILE) 
     21        self.atom = self.utils.createAtom(tc.xmlString) 
     22        self.v = v(self.atom, tc.EXIST_DBCONFIG_FILE, dbHostName = tc.EXIST_DB) 
     23        #self.createdAtoms = []    # array to store paths to atoms created - in order to then delete them 
     24        #self.createdAtoms.append(self.atom.getFullPath()) 
     25         
     26    #def tearDown(self): 
     27    #    for path  in self.createdAtoms: 
     28    #        # delete the test file, in case it has been used in a test 
     29    #        self.utils.deleteDoc(path) 
    2230 
    2331    def __setInvalidAtom(self): 
     
    4250            errors = self.v.validateAtom() 
    4351        except Exception, e: 
    44             import pdb 
    45             pdb.set_trace() 
    4652            self.fail("An exception shouldn't have been thrown") 
    4753 
     
    7783        except Exception, e: 
    7884            self.fail("An exception shouldn't have been thrown") 
    79  
     85         
    8086        if self.v.errors: 
    8187            self.fail("No schema validation errors should have been detected") 
  • ndgCommon/trunk/ndg/common/unittests/lib/testgranulite.py

    r4849 r4943  
    66''' 
    77import unittest, logging 
    8 logging.basicConfig(level=logging.DEBUG,\ 
    9                     format='%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s') 
    10  
    118from ndg.common.src.lib.granulite import granulite 
    12 from ndg.common.src.clients.xmldb.eXist.eXistConnector import eXistConnector 
    139import ndg.common.unittests.testconstants as tc 
    1410from ndg.common.unittests.testutils import testUtils as tu 
    1511from ndg.common.src.models.Atom import Atom 
    16 import ndg.common.src.clients.xmldb.eXist.existdbclient as dbc 
    1712from ndg.common.src.models.vocabtermdata import VocabTermData as VTD 
    1813import ndg.common.src.lib.utilities as utilities 
     14import ndg.common.src.clients.xmldb.eXist.dbconstants as dc 
     15from ndg.common.src.models.ndgObject import ndgObject as no 
    1916 
    2017class testGranulite(unittest.TestCase): 
     
    2522        ''' 
    2623        self.utils = tu(tc.EXIST_DBCONFIG_FILE) 
    27         self.g = granulite(tc.TEST_GRANULITE, eXistClient = self.utils.dbc) 
     24        self.g = granulite(tc.TEST_GRANULITE, eXistClient = self.utils.ac) 
    2825 
    2926    def createGranuliteDEs(self): 
     
    3835            atom = self.utils.createAtom(tc.xmlString) 
    3936            atom.atomTypeID = VTD.DE_TERM 
    40             atom.setDatasetID('dataent_' + id) 
    41             atom = self.utils.dbc.createAtomInExist(atom) 
     37            atom.setDatasetID(id) 
     38            atom = self.utils.ac.createAtom(atom) 
    4239            self.DEs.append(atom) 
    4340 
     
    4744        ''' 
    4845        for de in self.DEs: 
    49             self.utils.dbc.deleteAtomInExist(de) 
     46            self.utils.deleteDoc(de.getFullPath()) 
    5047             
    5148         
     
    6461 
    6562        except Exception, e: 
    66             import pdb 
    67             pdb.set_trace() 
    6863            self.fail("An exception should not have been thrown") 
    6964        finally: 
    7065            if atom is not None: 
    71                 self.utils.dbc.deleteAtomInExist(atom) 
     66                self.utils.deleteDoc(atom.getFullPath()) 
    7267            self.deleteGranuliteDEs() 
    7368         
     
    142137            atom.fromString(tc.xmlString) 
    143138            atom.atomTypeID = VTD.DE_TERM 
    144             atom = self.utils.dbc.createAtomInExist(atom) 
     139            atom = self.utils.ac.createAtom(atom) 
    145140     
    146141            # now set up the granulite 
     
    150145             
    151146            # and now update DE 
    152             self.g._granulite__updateDataEntity(atom.datasetID) 
     147            self.g._granulite__updateDataEntity(atom.datasetID, atom.ME.providerID) 
    153148            atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    154             self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance(atomPath)) 
     149            self.assertEqual([], self.utils.ac.checkAtomSchemaCompliance(atomPath)) 
    155150     
    156             updatedAtom = Atom() 
    157             updatedAtom.fromString(self.utils.dbc.getAtom(tc.datasetID)) 
     151            xml = self.utils.ac.getNDGDoc(atom.ME.providerID, no.ATOM_DOC_TYPE, 
     152                                          tc.datasetID,  
     153                                          targetCollection = dc.ATOM_COLLECTION_PATH) 
     154            updatedAtom = Atom(xmlString = xml) 
     155             
    158156            self.assertNotEqual(atom, updatedAtom) 
    159157             
     
    161159            self.assertEqual(len(atom.relatedLinks) + 1, len(updatedAtom.relatedLinks)) 
    162160        except Exception, e: 
    163             import pdb 
    164             pdb.set_trace() 
    165161            self.fail("An exception shouldn't have been thrown") 
    166162        finally: 
    167             self.utils.dbc.deleteAtomInExist(atom) 
     163            self.utils.deleteDoc(atom.getFullPath()) 
    168164 
    169165 
     
    173169        atom.fromString(tc.xmlString) 
    174170        atom.atomTypeID = VTD.DE_TERM 
    175         atom = self.utils.dbc.createAtomInExist(atom) 
     171        atom = self.utils.ac.createAtom(atom) 
    176172 
    177173        # now set up the granulite 
     
    184180        self.g._granulite__addGranuleToDataEntityRecords() 
    185181        atomPath = atom.getDefaultCollectionPath() + atom.atomName 
    186         self.assertEqual([], self.utils.dbc.checkAtomSchemaCompliance(atomPath)) 
     182        self.assertEqual([], self.utils.ac.checkAtomSchemaCompliance(atomPath)) 
    187183 
    188         updatedAtom = Atom() 
    189         updatedAtom.fromString(self.utils.dbc.getAtom(tc.datasetID)) 
     184        xml = self.utils.ac.getNDGDoc(atom.ME.providerID, no.ATOM_DOC_TYPE, 
     185                                      tc.datasetID,  
     186                                      targetCollection = dc.ATOM_COLLECTION_PATH) 
     187        updatedAtom = Atom(xmlString = xml) 
    190188        self.assertNotEqual(atom, updatedAtom) 
    191189         
    192190        # there should be one extra link on the new atom 
    193191        self.assertEqual(len(atom.relatedLinks) + 1, len(updatedAtom.relatedLinks)) 
    194         self.utils.dbc.deleteEXistFile(atomPath) 
     192        self.utils.deleteDoc(atomPath) 
    195193         
    196194         
  • ndgCommon/trunk/ndg/common/unittests/lib/testutilities.py

    r4844 r4943  
    77import unittest 
    88import ndg.common.src.lib.utilities as utilities 
     9import ndg.common.unittests.testconstants as tc 
    910 
    1011class testUtilities(unittest.TestCase): 
     
    1718        set up data used in the tests. 
    1819        ''' 
     20 
     21         
     22    def testLoadConfigDetailsValid(self): 
     23        id, pw = utilities.loadConfigDetails(tc.EXIST_DBCONFIG_FILE, dbName = tc.EXIST_DB)[0:2] 
     24        self.assertTrue(id) 
     25        self.assertTrue(pw) 
     26 
     27         
     28    def testLoadConfigDetailsValidAllOutput(self): 
     29        id, pw, host = utilities.loadConfigDetails(tc.EXIST_DBCONFIG_FILE, dbName = tc.EXIST_DB) 
     30        self.assertTrue(id) 
     31        self.assertTrue(pw) 
     32        self.assertTrue(host) 
     33         
     34    def testLoadConfigDetailsInvalid(self): 
     35        self.assertRaises(ValueError, utilities.loadConfigDetails, "blah" + tc.EXIST_DBCONFIG_FILE) 
     36 
    1937 
    2038    def testOpenURLWithProxy(self): 
Note: See TracChangeset for help on using the changeset viewer.