Changeset 4946


Ignore:
Timestamp:
11/02/09 09:30:03 (11 years ago)
Author:
cbyrom
Message:

Update tests for the dal package - removing tests for redundant
code + adding new tests where needed + improve old tests to better
set up and remove the required test environment + remove dependencies
on xmlHandler2. Also add new moles1.3 doc to test data.

Location:
ndgCommon/trunk/ndg/common/unittests
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • ndgCommon/trunk/ndg/common/unittests/dal/test_DocumentRetrieve.py

    r4849 r4946  
    3030        ''' 
    3131        self.pwf = tc.EXIST_DBCONFIG_FILE 
     32        self.createdAtoms = []    # array to store paths to atoms created - in order to then delete them 
     33        self.utils = tu(tc.EXIST_DBCONFIG_FILE) 
     34        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
     35        self.createdAtoms.append(createdAtom.getFullPath()) 
    3236 
    3337 
     
    3640        tidy up any artifacts from the tests 
    3741        ''' 
     42        for path  in self.createdAtoms: 
     43            # delete the test file, in case it has been used in a test 
     44            self.utils.deleteDoc(path) 
    3845 
    3946     
     
    4451        y=x.get(s) 
    4552        self.assertNotEquals(y.find('Google'), -1) 
    46      
    47     def testNdgHTTPUriget(self): 
    48         ''' Try a remote get with no frills''' 
    49         s='badc.nerc.ac.uk__NDG-B1__dataent_chablis' 
    50         dr = ndgHTTP(tc.VALID_PROVIDER_ID, \ 
    51                                        proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
    52         doc = dr.uriget(s) 
    53         self.assertNotEquals(doc.find(s), -1) 
    5453         
    5554    def testVocabServer(self): 
     
    5857        res = v.getRelated('rain') 
    5958        self.assertEquals(res[1][0], 'rain') 
     59 
     60    # these two tests require docs to be available on discovery service 
     61    def OFFtestNdgHTTPUriget(self): 
     62        ''' Try a remote get with no frills''' 
     63        s= tc.VALID_NDG_URL 
     64        dr = ndgHTTP(tc.VALID_PROVIDER_ID, 
     65                     proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
     66        doc = dr.uriget(s) 
     67        self.assertNotEquals(doc.find(s), -1) 
    6068         
    61     def testNdgHTTP(self): 
    62         dr = ndgHTTP(tc.VALID_PROVIDER_ID, \ 
    63                                        proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
    64         doc = dr.get(tc.VALID_PROVIDER_ID, \ 
    65                      no.MOLES_DOC_TYPE, tc.VALID_MOLES_DOC_ID) 
     69    def OFFtestNdgHTTP(self): 
     70        dr = ndgHTTP(tc.VALID_PROVIDER_ID, 
     71                     proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
     72        n = no(tc.VALID_NDG_URL) 
     73        doc = dr.getNDGDoc(n.repository,n.schema,n.localID) 
    6674        self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
     75 
     76     
     77    def testInvalidHTTPget(self): 
     78        s= tc.INVALID_URL 
     79        x = genericHTTP(proxyServer='http://wwwcache3.rl.ac.uk:8080/') 
     80        self.assertRaises(IOError, x.get, s) 
     81     
     82    def testInvalidNdgHTTPUriget(self): 
     83        s= tc.INVALID_NDG_URL 
     84        dr = ndgHTTP(tc.VALID_PROVIDER_ID, 
     85                     proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
     86        self.assertRaises(IOError, dr.uriget, s) 
    6787         
    68     def testGetDIF(self): 
    69         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    70                                                pwfile = self.pwf) 
    71         doc = dr.get(tc.VALID_PROVIDER_ID, no.DIF_DOC_TYPE, \ 
    72                      tc.VALID_MOLES_DOC_ID, targetCollection = MOLES_COLLECTION) 
    73         self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
     88    def testInvalidVocabServer(self): 
     89        ''' Test the vocabServer ''' 
     90        v = ndgVocabPOX(proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
     91        res = v.getRelated('rainxxxxx') 
     92        self.assertEquals([], res[0]) 
     93        self.assertEquals([], res[1]) 
     94        self.assertEquals(3, len(res)) 
    7495         
    75     def OFFtestGetMDIP(self): 
    76         # TODO: switch back on once the MDIP tranform has been fixed 
    77         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    78                                                pwfile = self.pwf) 
    79         doc = dr.get(tc.VALID_PROVIDER_ID, no.MDIP_DOC_TYPE, \ 
    80                      tc.VALID_MOLES_DOC_ID, targetCollection = MOLES_COLLECTION) 
    81         self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
     96    def testInvalidNdgHTTP(self): 
     97        dr = ndgHTTP(tc.VALID_PROVIDER_ID, 
     98                     proxyServer="http://wwwcache3.rl.ac.uk:8080/") 
     99        n = no(tc.INVALID_NDG_URL) 
     100        self.assertRaises(IOError, dr.getNDGDoc, n.repository,n.schema,n.localID) 
    82101         
    83     def testGetISO(self): 
    84         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    85                                                pwfile = self.pwf) 
    86         doc = dr.get(tc.VALID_PROVIDER_ID, no.ISO_DOC_TYPE, \ 
    87                      tc.VALID_MOLES_DOC_ID, targetCollection = MOLES_COLLECTION) 
    88         self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
    89                  
    90     def testGetISO(self): 
    91         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    92                                                pwfile = self.pwf) 
    93         doc = dr.get(tc.VALID_PROVIDER_ID, no.ISO_DOC_TYPE, \ 
    94                      tc.VALID_MOLES_DOC_ID, targetCollection = MOLES_COLLECTION) 
    95         self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
    96                  
    97     def testGetDC(self): 
    98         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    99                                                pwfile = self.pwf) 
    100         doc = dr.get(tc.VALID_PROVIDER_ID, no.DC_DOC_TYPE, \ 
    101                      tc.VALID_MOLES_DOC_ID, targetCollection = MOLES_COLLECTION) 
    102         self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1) 
    103                          
    104     def testGetNumSim(self): 
    105         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY,  
    106                                                pwfile = self.pwf) 
    107         doc = dr.get(tc.VALID_PROVIDER_ID, no.NUMSIM_DOC_TYPE, \ 
    108                      tc.VALID_NUMSIM_DOC_ID, targetCollection = NUMSIM_COLLECTION) 
    109         self.assertNotEquals(doc.find(tc.VALID_NUMSIM_DOC_ID), -1) 
    110                          
    111     def testGetAtom(self): 
    112         utils = tu(tc.EXIST_DBCONFIG_FILE) 
    113         createdAtom = utils.createAtomInEXist(tc.xmlString) 
    114         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    115                                                pwfile = self.pwf) 
    116         doc = dr.get(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE, \ 
    117                      createdAtom.datasetID, targetCollection = ATOM_COLLECTION) 
    118         self.assertNotEquals(doc.find(createdAtom.datasetID), -1) 
    119         utils.dbc.deleteAtomInExist(createdAtom) 
    120                          
    121     def testGetInvalidAtom(self): 
    122         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    123                                                pwfile = self.pwf) 
    124         self.assertRaises(ValueError, dr.get, tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE, \ 
    125                      tc.VALID_ATOM_DOC_ID + "blah", targetCollection = ATOM_COLLECTION) 
    126                          
    127     def testGetAtomBackup(self): 
    128         utils = tu(tc.EXIST_DBCONFIG_FILE) 
    129         createdAtom = utils.createAtomInEXist(tc.xmlString) 
    130         createdAtom = utils.createAtomInEXist(tc.xmlString) 
    131         dr = DocumentRetrieve.DocumentRetrieve(tc.VALID_REPOSITORY, 
    132                                                pwfile = self.pwf) 
    133         doc = dr.get(tc.VALID_PROVIDER_ID, no.ATOM_BACKUP_DOC_TYPE, \ 
    134                      createdAtom.datasetID, targetCollection = ATOM_BACKUP_COLLECTION) 
    135         self.assertNotEquals(doc.find(createdAtom.datasetID), -1) 
    136         utils.dbc.deleteAtomInExist(createdAtom) 
    137          
  • ndgCommon/trunk/ndg/common/unittests/dal/test_ndgDirectory.py

    r4849 r4946  
    11from ndg.common.src.dal.ndgDirectory import ndgDirectory 
    22import ndg.common.unittests.testconstants as tc 
     3import ndg.common.src.clients.xmldb.eXist.dbconstants as dc 
     4from ndg.common.src.models.ndgObject import ndgObject as no 
     5from ndg.common.unittests.testutils import testUtils as tu 
    36 
    47import unittest 
     
    912    CHINOOK_DB = 'chinook.badc.rl.ac.uk' 
    1013    def setUp(self):  
    11         self.ndgDir=ndgDirectory('/db/discovery/original/DIF/badc.nerc.ac.uk',  
    12                                  self.GLUE_DB, docType='DIF',  
     14        self.ndgDir=ndgDirectory(dc.RESOURCES_COLLECTION_PATH,  
     15                                 tc.EXIST_DB,  
     16                                 docType = no.DIF_DOC_TYPE,  
    1317                                 passwordFile = tc.EXIST_DBCONFIG_FILE) 
     18        self.utils = tu(tc.EXIST_DBCONFIG_FILE) 
     19        self.createdAtoms = []    # array to store paths to atoms created - in order to then delete them 
     20 
     21    def tearDown(self): 
     22        ''' 
     23        tidy up any artifacts from the tests 
     24        ''' 
     25        for path  in self.createdAtoms: 
     26            # delete the test file, in case it has been used in a test 
     27            self.utils.deleteDoc(path) 
    1428     
    1529    def testDirectory(self): 
    1630        ''' Test the ability to get members of a directory and the first one of them ''' 
    17         print self.ndgDir.members 
    18         doc=self.ndgDir.get(self.ndgDir.members[0]['fileName']) 
    19         print doc 
     31        for fileName, orgData in self.utils.ac.resources.resources.items(): 
     32            self.assertEqual(orgData.strip(), self.ndgDir.get(fileName).strip()) 
    2033         
    2134    def testCreationDates(self): 
    2235        '''Test the creation information''' 
    23         print self.ndgDir.created() 
    24         print self.ndgDir.created(self.ndgDir.members[0]['fileName']) 
     36        self.assertNotEquals(None, self.ndgDir.created()) 
     37        date = self.ndgDir.created(self.ndgDir.members[0]['fileName']) 
     38        self.assertNotEquals(None, date) 
    2539         
    2640    def testAtomDocsDirectory(self): 
    27         self.ndgDir=ndgDirectory('/db/atoms', self.CHINOOK_DB,docType='ATOM',  
     41        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
     42        self.createdAtoms.append(createdAtom.getFullPath()) 
     43        self.ndgDir=ndgDirectory(dc.ATOM_COLLECTION_PATH, tc.EXIST_DB,  
     44                                 docType= no.ATOM_DOC_TYPE,  
    2845                                 passwordFile = tc.EXIST_DBCONFIG_FILE) 
    29         self.assertTrue(len(self.ndgDir.members) > 0) 
    30         self.assertTrue(len(self.ndgDir.files) > 0) 
    31         self.assertTrue(len(self.ndgDir.entries) > 0) 
    32         self.assertNotEqual(self.ndgDir.get(self.ndgDir.members[0]['fileName']), None) 
     46        self.assertTrue(len(self.ndgDir.members) == 1) 
     47        self.assertTrue(len(self.ndgDir.files) == 1) 
     48        self.assertTrue(len(self.ndgDir.entries) == 1) 
     49        self.assertNotEqual(None, self.ndgDir.get(self.ndgDir.members[0]['fileName'])) 
    3350         
    3451    def testAtomCreationDates(self): 
    35         self.ndgDir=ndgDirectory('/db/atoms', self.CHINOOK_DB, docType='ATOM',  
     52        createdAtom = self.utils.createAtomInEXist(tc.xmlString) 
     53        self.createdAtoms.append(createdAtom.getFullPath()) 
     54        self.ndgDir=ndgDirectory(dc.ATOM_COLLECTION_PATH, tc.EXIST_DB,  
     55                                 docType= no.ATOM_DOC_TYPE,  
    3656                                 passwordFile = tc.EXIST_DBCONFIG_FILE) 
    3757        self.assertNotEqual(self.ndgDir.created(), None) 
  • ndgCommon/trunk/ndg/common/unittests/dal/test_ndgRetrieve.py

    r4849 r4946  
    1515from ndg.common.src.models.ndgObject import ndgObject as no 
    1616from ndg.common.src.dal.ndgRetrieve import ndgRetrieve 
    17 from ndg.common.src.lib.xmlHandler2 import xmlHandler 
     17from xml.etree import ElementTree as ET 
    1818import unittest, os, logging, ConfigParser 
    1919import ndg.common.unittests.testconstants as tc 
    2020from ndg.common.unittests.testutils import testUtils as tu 
    21 import ndg.common.src.clients.xmldb.eXist.existdbclient as dbc 
     21import ndg.common.src.clients.xmldb.eXist.atomclient as ac 
    2222from ndg.common.src.models.myconfig import myConfig 
    2323 
     
    2929    def setUp(self): 
    3030        self.c = myConfig(tc.NDG_CONFIG_FILE) 
     31        self.createdAtoms = []    # array to store paths to atoms created - in order to then delete them 
     32        self.utils = tu(tc.EXIST_DBCONFIG_FILE) 
     33         
     34    def tearDown(self): 
     35        for path  in self.createdAtoms: 
     36            # delete the test file, in case it has been used in a test 
     37            self.utils.deleteDoc(path) 
    3138 
    3239             
     
    3441        ''' Test link to local exist via xml rpc. 
    3542                users will need to ensure that the document is actually  
    36                 in your exist database! ''' 
    37         doc='badc.nerc.ac.uk__NDG-B0__activity_activity_cwvc' 
    38         #doc='neodc.nerc.ac.uk__NDG-B1__dataent_11924879127625221' #NCAVEO 
     43                in your exist database!  
     44        ''' 
     45        self.createdAtoms.append(self.utils.createOldMolesDoc()) 
     46        doc= tc.VALID_NDG_URL 
    3947        uri=no(doc) 
    4048        status,xml=ndgRetrieve(uri,self.c, discovery=0) 
    41         if not status: raise ValueError(xml) 
    42         x=xmlHandler(xml,string=1) 
    43         self.assertEqual(x.tree.tag,'{http://ndg.nerc.ac.uk/moles}dgMetadataRecord') 
     49        if not status:  
     50            raise ValueError(xml) 
     51        x=ET.fromstring(xml) 
     52        self.assertEqual('dgMetadataRecord', x.tag) 
    4453         
    45     def testNoB(self): 
     54    def otestNoB(self): 
    4655        ''' Test that we get a sensible error if a NDG-B doc doesn't exist ''' 
    4756        doc='badc.nerc.ac.uk__NDG-B0__blah' 
     
    5059        if status: raise ValueError(' NDG-B0 [%s] should not exist [%s]'%(doc,xml) ) 
    5160         
    52     def testRetrieveXMLdif(self): 
     61    def OFFtestRetrieveXMLdif(self): 
     62        # NB, this requires a valid dif doc to be available 
    5363        ''' Make sure we can recall at least one DIF properly ''' 
    5464        doc= tc.VALID_PROVIDER_ID + "__" + no.DIF_DOC_TYPE + \ 
     
    6878        self.assertEqual(status,1) 
    6979         
    70     def testRetrieveNumSim(self): 
     80    def OFFtestRetrieveNumSim(self): 
     81        # NB, this requires a valid numsim doc to be available 
    7182        '''Get a NumSim document ''' 
    7283        doc= tc.VALID_PROVIDER_ID + "__" + no.NUMSIM_DOC_TYPE + \ 
     
    7788        self.assertNotEqual(xml.find(tc.VALID_NUMSIM_DOC_ID), -1) 
    7889         
    79     def testRetrieveAtom(self): 
     90    def otestRetrieveAtom(self): 
    8091        '''Get an atom document ''' 
    8192        utils = tu(tc.EXIST_DBCONFIG_FILE) 
     
    8798        self.assertEqual(status,1) 
    8899        self.assertNotEqual(xml.find(createdAtom.datasetID), -1) 
    89         utils.dbc.deleteAtomInExist(createdAtom) 
     100        utils.ac.deleteAtom(createdAtom) 
    90101         
    91     def testRetrieveInvalidAtom(self): 
     102    def otestRetrieveInvalidAtom(self): 
    92103        '''Get an invalid atom document ''' 
    93104        doc= tc.VALID_PROVIDER_ID + "__" + no.ATOM_DOC_TYPE + \ 
     
    97108        self.assertEqual(status,0) 
    98109         
    99     def testRetrieveAtomBackup(self): 
     110    def otestRetrieveAtomBackup(self): 
    100111        '''Get a backed up atom document ''' 
    101112        utils = tu(tc.EXIST_DBCONFIG_FILE) 
     
    108119        self.assertEqual(status,1) 
    109120        self.assertNotEqual(xml.find(createdAtom.datasetID), -1) 
    110         utils.dbc.deleteAtomInExist(createdAtom) 
     121        utils.ac.deleteAtom(createdAtom) 
    111122         
    112123if __name__=="__main__": 
  • ndgCommon/trunk/ndg/common/unittests/testdata/example.granulite

    r4793 r4946  
    1111# use format: local id | provider id 
    1212# NB, can specify multiple entities, on new lines, to link the granule to 
    13 testAAOE | badc.nerc.ac.uk 
    14 testcloudmap | badc.nerc.ac.uk 
     13dataent_NERC-ASSIM | badc.nerc.ac.uk 
     14#testcloudmap | badc.nerc.ac.uk 
    1515 
    1616granule_info:: 
  • ndgCommon/trunk/ndg/common/unittests/testdata/exist.config

    r4793 r4946  
     1localhost admin pass01word 
    12chinook.badc.rl.ac.uk admin molesadmin 
    23glue.badc.rl.ac.uk admin cla99i3r 
  • ndgCommon/trunk/ndg/common/unittests/testdata/ndgDiscovery.config

    r4793 r4946  
    118118# is the NDG identifier. 
    119119#  
    120 local: chinook.badc.rl.ac.uk 
    121 badc.nerc.ac.uk: chinook.badc.rl.ac.uk 
    122 neodc.nerc.ac.uk: chinook.badc.rl.ac.uk 
     120local: localhost 
     121badc.nerc.ac.uk: localhost 
     122neodc.nerc.ac.uk: localhost 
    123123grid.bodc.nerc.ac.uk: grid.bodc.nerc.ac.uk 
    124124ndg.noc.soton.ac.uk: ndg.noc.soton.ac.uk 
Note: See TracChangeset for help on using the changeset viewer.