source: ndgCommon/trunk/ndg/common/unittests/clients/xmldb/eXist/testsearchclient.py @ 4942

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/ndgCommon/trunk/ndg/common/unittests/clients/xmldb/eXist/testsearchclient.py@4942
Revision 4942, 8.4 KB checked in by cbyrom, 11 years ago (diff)

Replace old eXist connector tests with tests based on the new clients
+ extend and fix this wherever necessary.

Line 
1'''
2A test class for the SearchClient class.
3
4@author C Byrom, Tessella Feb 2009
5'''
6
7import unittest,os, time
8from ndg.common.src.clients.xmldb.eXist.searchclient import *
9import ndg.common.src.clients.xmldb.eXist.dbconstants as dc
10import ndg.common.unittests.testconstants as tc
11from ndg.common.unittests.testutils import testUtils as tu
12from ndg.common.src.models.ndgObject import ndgObject as no
13
14class TestCase(unittest.TestCase): 
15
16    def setUp(self):
17        '''
18        set up data used in the tests.
19        '''
20        self.client = SearchClient(dbHostName = tc.EXIST_DB, 
21                                   configFileName = tc.EXIST_DBCONFIG_FILE)
22        self.createdAtoms = []    # array to store paths to atoms created - in order to then delete them
23        self.utils = tu(tc.EXIST_DBCONFIG_FILE)
24       
25
26    def testInit(self):
27        self.assertTrue(self.client.client)
28       
29    def testSearch(self):
30        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
31        self.createdAtoms.append(createdAtom.getFullPath())
32        results = self.client.search(tc.title, target = self.client.ATOM_TARGET)
33        self.assertEquals(tc.title, results[0]['name'])
34       
35    def testSearchMany(self):
36        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
37        self.createdAtoms.append(createdAtom.getFullPath())
38        atom2 = self.utils.createAtom(tc.xmlString)
39        atom2.setDatasetID(tc.datasetID2)
40        self.utils.ac.createAtom(atom2)
41        self.createdAtoms.append(atom2.getFullPath())
42        results = self.client.search(tc.GRANULITE_PROVIDER_ID, target = self.client.ATOM_TARGET)
43        self.assertTrue(len(results) > 1)
44       
45    def testSearchManyUseChunked(self):
46        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
47        self.createdAtoms.append(createdAtom.getFullPath())
48        atom2 = self.utils.createAtom(tc.xmlString)
49        atom2.setDatasetID(tc.datasetID2)
50        self.utils.ac.createAtom(atom2)
51        self.createdAtoms.append(atom2.getFullPath())
52        results = self.client.search(tc.GRANULITE_PROVIDER_ID, 
53                                     target = self.client.ATOM_TARGET,
54                                     useChunked = True)
55        self.assertTrue(len(results) > 1)
56       
57    def testSearchManyUseChunkedPerformanceTest(self):
58        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
59        self.createdAtoms.append(createdAtom.getFullPath())
60        chunkedSearchTime = time.time()
61        results1 = self.client.search(tc.GRANULITE_PROVIDER_ID, 
62                                     target = self.client.ATOM_TARGET)
63        chunkedSearchTime = time.time() - chunkedSearchTime
64        nonChunkedSearchTime = time.time()
65        results2 = self.client.search(tc.GRANULITE_PROVIDER_ID, 
66                                     target = self.client.ATOM_TARGET,
67                                     useChunked = False)
68        nonChunkedSearchTime = time.time() - nonChunkedSearchTime
69        print "Chunked Search took: %s" %chunkedSearchTime
70        print "Non chunked search took: %s" %nonChunkedSearchTime
71       
72        self.assertEqual(results1, results2)
73       
74       
75    def testInvalidSearch(self):
76        results = self.client.search(tc.ABBREVIATION + 'blllaaa', 
77                                     target = self.client.ATOM_TARGET)
78        self.assertFalse(results)
79
80    def testGetDocsSingle(self):
81        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
82        self.createdAtoms.append(createdAtom.getFullPath())
83        results = self.client.getDocs([createdAtom.getFullPath()])
84        self.assertTrue(results.has_key(createdAtom.getFullPath()))
85        self.assertTrue(results[createdAtom.getFullPath()])
86
87    def testGetDocsMultiple(self):
88        createdAtom = self.utils.createAtomInEXist(tc.xmlString)
89        self.createdAtoms.append(createdAtom.getFullPath())
90        results = self.client.getDocs([createdAtom.getFullPath()])
91        self.assertTrue(results.has_key(createdAtom.getFullPath()))
92        self.assertTrue(results[createdAtom.getFullPath()])
93        self.assertEquals(1, len(results))
94        atom2 = self.utils.createAtom(tc.xmlString)
95        atom2.ME.providerID = tc.GRANULITE_PROVIDER_ID2
96        self.utils.ac.createAtom(atom2)
97        self.createdAtoms.append(atom2.getFullPath())
98        results = self.client.getDocs(self.createdAtoms)
99        for path in self.createdAtoms:
100            self.assertTrue(results.has_key(path))
101            self.assertTrue(results[path])
102        self.assertEquals(2, len(results))
103       
104       
105    def testGetDIF(self):
106        self.createdAtoms.append(self.utils.createOldMolesDoc())
107        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.DIF_DOC_TYPE, 
108                                    tc.VALID_MOLES_ID,
109                                    targetCollection = dc.MOLES_COLLECTION_PATH)
110        self.assertTrue(doc.find('DIF') > -1)
111        self.assertTrue(doc.find(tc.VALID_MOLES_ID) > -1)
112       
113    def FFtestGetMDIP(self):
114        # TODO: switch back on once the MDIP tranform has been fixed
115        self.createdAtoms.append(self.utils.createOldMolesDoc())
116        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.MDIP_DOC_TYPE,
117                        tc.VALID_MOLES_ID, targetCollection = dc.MOLES_COLLECTION_PATH)
118        self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1)
119       
120    def testGetISO(self):
121        self.createdAtoms.append(self.utils.createOldMolesDoc())
122        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ISO_DOC_TYPE, 
123                                    tc.VALID_MOLES_ID, 
124                                    targetCollection = dc.MOLES_COLLECTION_PATH)
125        self.assertTrue(doc.find('MD_Metadata') > -1)
126        self.assertNotEquals(doc.find(tc.VALID_MOLES_ID), -1)
127               
128    def testGetDC(self):
129        self.createdAtoms.append(self.utils.createOldMolesDoc())
130        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.DC_DOC_TYPE,
131                                    tc.VALID_MOLES_ID, 
132                                    targetCollection = dc.MOLES_COLLECTION_PATH)
133        self.assertTrue(doc.find('oai_dc:dc') > -1)
134        self.assertNotEquals(doc.find(tc.VALID_MOLES_ID), -1)
135                       
136    def FFtestGetNumSim(self):
137        # TODO: need to get a numsim doc to use here
138        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.NUMSIM_DOC_TYPE,
139                                    tc.VALID_NUMSIM_DOC_ID, targetCollection = dc.NUMSIM_COLLECTION_PATH)
140        self.assertNotEquals(doc.find(tc.VALID_NUMSIM_DOC_ID), -1)
141                       
142    def testGetAtom(self):
143        utils = tu(tc.EXIST_DBCONFIG_FILE)
144        createdAtom = utils.createAtomInEXist(tc.xmlString)
145        self.createdAtoms.append(createdAtom.getFullPath())
146        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE, 
147                                    createdAtom.datasetID, 
148                                    targetCollection = dc.ATOM_COLLECTION_PATH)
149        self.assertNotEquals(doc.find(createdAtom.datasetID), -1)
150                       
151    def testGetInvalidAtom(self):
152        self.assertRaises(ValueError, self.client.getNDGDoc, tc.VALID_PROVIDER_ID, 
153                          no.ATOM_DOC_TYPE, tc.VALID_ATOM_DOC_ID + "blah", 
154                          targetCollection = dc.ATOM_COLLECTION_PATH)
155                       
156    def testGetAtomBackup(self):
157        utils = tu(tc.EXIST_DBCONFIG_FILE)
158        createdAtom = utils.createAtomInEXist(tc.xmlString)
159        createdAtom = utils.createAtomInEXist(tc.xmlString)
160        self.createdAtoms.append(createdAtom.getFullPath())
161        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_BACKUP_DOC_TYPE,
162                                    createdAtom.datasetID, 
163                                    targetCollection = dc.BACKUP_COLLECTION_PATH)
164        self.assertNotEquals(doc.find(createdAtom.datasetID), -1)
165        doc1 = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE,
166                                    createdAtom.datasetID, 
167                                    targetCollection = dc.ATOM_COLLECTION_PATH)
168        self.assertNotEquals(doc1.find(createdAtom.datasetID), -1)
169        self.assertNotEquals(doc, doc1)
170
171
172       
173    def tearDown(self):
174        for path  in self.createdAtoms:
175            # delete the test file, in case it has been used in a test
176            self.utils.deleteDoc(path)
177
178           
179if __name__=="__main__":
180    unittest.main()
Note: See TracBrowser for help on using the repository browser.