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

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

Move generic 'httpify' method to utilities + adjust utilities method
to retrive default proxy to cope with standard formatting + set this
up on each call to urlopen - since different urls may use different
proxies + tidyup and extend test suite.

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 testGetNDGB1(self):
106        self.createdAtoms.append(self.utils.createOldMolesDoc())
107        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.MOLES_DOC_TYPE, 
108                                    tc.VALID_MOLES_ID,
109                                    targetCollection = dc.MOLES_COLLECTION_PATH)
110        self.assertTrue(doc.find('dgMetadataRecord') > -1)
111        self.assertTrue(doc.find(tc.VALID_MOLES_ID) > -1)
112       
113       
114    def testGetDIF(self):
115        self.createdAtoms.append(self.utils.createOldMolesDoc())
116        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.DIF_DOC_TYPE, 
117                                    tc.VALID_MOLES_ID,
118                                    targetCollection = dc.MOLES_COLLECTION_PATH)
119        self.assertTrue(doc.find('DIF') > -1)
120        self.assertTrue(doc.find(tc.VALID_MOLES_ID) > -1)
121       
122    def FFtestGetMDIP(self):
123        # TODO: switch back on once the MDIP tranform has been fixed
124        self.createdAtoms.append(self.utils.createOldMolesDoc())
125        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.MDIP_DOC_TYPE,
126                        tc.VALID_MOLES_ID, targetCollection = dc.MOLES_COLLECTION_PATH)
127        self.assertNotEquals(doc.find(tc.VALID_MOLES_DOC_ID), -1)
128       
129    def testGetISO(self):
130        self.createdAtoms.append(self.utils.createOldMolesDoc())
131        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ISO_DOC_TYPE, 
132                                    tc.VALID_MOLES_ID, 
133                                    targetCollection = dc.MOLES_COLLECTION_PATH)
134        self.assertTrue(doc.find('MD_Metadata') > -1)
135        self.assertNotEquals(doc.find(tc.VALID_MOLES_ID), -1)
136               
137    def testGetDC(self):
138        self.createdAtoms.append(self.utils.createOldMolesDoc())
139        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.DC_DOC_TYPE,
140                                    tc.VALID_MOLES_ID, 
141                                    targetCollection = dc.MOLES_COLLECTION_PATH)
142        self.assertTrue(doc.find('oai_dc:dc') > -1)
143        self.assertNotEquals(doc.find(tc.VALID_MOLES_ID), -1)
144                       
145    def FFtestGetNumSim(self):
146        # TODO: need to get a numsim doc to use here
147        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.NUMSIM_DOC_TYPE,
148                                    tc.VALID_NUMSIM_DOC_ID, targetCollection = dc.NUMSIM_COLLECTION_PATH)
149        self.assertNotEquals(doc.find(tc.VALID_NUMSIM_DOC_ID), -1)
150                       
151    def testGetAtom(self):
152        utils = tu(tc.EXIST_DBCONFIG_FILE)
153        createdAtom = utils.createAtomInEXist(tc.xmlString)
154        self.createdAtoms.append(createdAtom.getFullPath())
155        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE, 
156                                    createdAtom.datasetID, 
157                                    targetCollection = dc.ATOM_COLLECTION_PATH)
158        self.assertNotEquals(doc.find(createdAtom.datasetID), -1)
159                       
160    def testGetInvalidAtom(self):
161        self.assertRaises(ValueError, self.client.getNDGDoc, tc.VALID_PROVIDER_ID, 
162                          no.ATOM_DOC_TYPE, tc.VALID_ATOM_DOC_ID + "blah", 
163                          targetCollection = dc.ATOM_COLLECTION_PATH)
164                       
165    def testGetAtomBackup(self):
166        utils = tu(tc.EXIST_DBCONFIG_FILE)
167        createdAtom = utils.createAtomInEXist(tc.xmlString)
168        createdAtom = utils.createAtomInEXist(tc.xmlString)
169        self.createdAtoms.append(createdAtom.getFullPath())
170        doc = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_BACKUP_DOC_TYPE,
171                                    createdAtom.datasetID, 
172                                    targetCollection = dc.BACKUP_COLLECTION_PATH)
173        self.assertNotEquals(doc.find(createdAtom.datasetID), -1)
174        doc1 = self.client.getNDGDoc(tc.VALID_PROVIDER_ID, no.ATOM_DOC_TYPE,
175                                    createdAtom.datasetID, 
176                                    targetCollection = dc.ATOM_COLLECTION_PATH)
177        self.assertNotEquals(doc1.find(createdAtom.datasetID), -1)
178        self.assertNotEquals(doc, doc1)
179
180
181       
182    def tearDown(self):
183        for path  in self.createdAtoms:
184            # delete the test file, in case it has been used in a test
185            self.utils.deleteDoc(path)
186
187           
188if __name__=="__main__":
189    unittest.main()
Note: See TracBrowser for help on using the repository browser.