Changeset 4469 for MILK


Ignore:
Timestamp:
20/11/08 15:36:44 (11 years ago)
Author:
cbyrom
Message:

Strip out code not relevant to MILK - mainly WCS and WMS stuff - also including the CSML server code + trackback code
Also tidy up structure of 'public' dir - setting up new 'style' dir and
centralising icons in icons dir + remove all unused icons, javascript and stylesheets.
Also strip out testcase code and populate new test directory structure.

Location:
MILK/trunk/milk_server/milk_server
Files:
17 deleted
15 edited
1 copied
2 moved

Legend:

Unmodified
Added
Removed
  • MILK/trunk/milk_server/milk_server/lib/Date.py

    r2672 r4469  
    4949       'JUL':7,'AUG':8,'SEP':9,'OCT':10,'NOV':11,'DEC':12} 
    5050    return d[s.upper()] 
    51  
    52 import unittest 
    53  
    54 class TestCase(unittest.TestCase): 
    55     def test_julday(self): 
    56         # Date checked from http://aa.usno.navy.mil/data/docs/JulianDate.html 
    57         self.assertEqual(JulDay((1,12,2001)),2452245) 
    58         self.assertEqual(JulDay((28,2,2004)),2453064) 
    59     def test_LeapYear(self): 
    60         self.assertEqual(LeapYear(1900),0) 
    61         self.assertEqual(LeapYear(2000),1) 
    62         self.assertEqual(LeapYear(2001),0) 
    63         self.assertEqual(LeapYear(2004),1) 
    64     def test_ValidDate(self): 
    65         self.assertEqual(ValidDate((1,1,2004)),1) 
    66         self.assertEqual(ValidDate((29,2,2003)),0) 
    67         self.assertEqual(ValidDate((29,2,2004)),1) 
    68         self.assertEqual(ValidDate((31,4,2003)),0) 
    69      
    70  
    71      
    72 if __name__=="__main__": 
    73     unittest.main()     
  • MILK/trunk/milk_server/milk_server/lib/Utilities.py

    r3842 r4469  
    211211    """ 
    212212    return [urllib.unquote(x) for x in string.split('|')] 
    213  
    214      
    215          
    216 import unittest 
    217  
    218 class TestCase(unittest.TestCase): 
    219     """ Tests as required """ 
    220  
    221     configFile='examples/example.config' 
    222     difFile='examples/neodc.eg1.dif' 
    223      
    224     def setUp(self): 
    225         # If pkg_resources is available assume the module is eggified and 
    226         # get a stream to the input data from the egg. 
    227         #try: 
    228         #    import pkg_resources 
    229         #    f = pkg_resources.resource_stream(__name__, self.configFile) 
    230         #except ImportError: 
    231             # Else take the input file from __file__ 
    232             #import os 
    233         self.config=myConfig(self.configFile) 
    234         f=file(self.difFile,'r') 
    235         self.difxml=f.read() 
    236             #f=file(os.path.join(os.path.basepath(__file__), self.configFile)) 
    237  
    238         #self.config=myConfig(f) 
    239  
    240     def testConfig(self): 
    241         print 'Discovery Icon [%s]'%self.config.get('DISCOVERY','icon') 
    242          
    243     def testidget(self): 
    244         self.assertEqual(idget(self.difxml),'NOCSDAT192') 
    245  
    246  
    247 if __name__=="__main__": 
    248     unittest.main() 
    249  
    250  
    251  
  • MILK/trunk/milk_server/milk_server/lib/base.py

    r4066 r4469  
    1414from pylons.i18n import N_, _, ungettext 
    1515from paste.request import construct_url 
    16 import ows_server.models as model 
    17 import ows_server.lib.helpers as h 
    18 from ows_common import exceptions as OWS_E 
    19 from ows_common.operations_metadata import OperationsMetadata, Operation, RequestMethod 
    20 from ows_common.get_capabilities import ServiceMetadata 
    21 import ows_common.xml 
     16import milk_server.models as model 
     17import milk_server.lib.helpers as h 
    2218 
    2319# NDG Security import enables Single Sign On capability but note this is not 
     
    4541 
    4642# Configure 
    47 EXCEPTION_TYPE = request.environ['ndgConfig'].get('OWS_SERVER', 'exception_type', 'ogc').lower() 
     43EXCEPTION_TYPE = request.environ['ndgConfig'].get('MILK_SERVER', 'exception_type', 'ogc').lower() 
    4844 
    4945class BaseController(_BaseController): 
     
    6965         
    7066        return _BaseController.__call__(self, environ, start_response) 
    71      
    72 class OwsController(BaseController): 
    73     def __call__(self, environ, start_response): 
    74  
    75         # All OWS parameter names are case insensitive. 
    76         req = request._current_obj() 
    77         self.ows_params = {} 
    78         for k in req.params: 
    79             self.ows_params[k.lower()] = req.params[k]         
    80  
    81         # If the EXCEPTION_TYPE is 'pylons' let Pylons catch any exceptions. 
    82         # Otherwise send an OGC exception report for any OWS_E.OwsError 
    83         if 'pylons' in EXCEPTION_TYPE: 
    84             self._fixOwsAction(environ) 
    85             return super(OwsController, self).__call__(environ, start_response) 
    86         else: 
    87             try: 
    88                 self._fixOwsAction(environ) 
    89                 return super(OwsController, self).__call__(environ, start_response) 
    90             except OWS_E.OwsError, e: 
    91                 logger.exception(e) 
    92                 start_response('400 Bad Request',[('Content-type','text/xml')]) 
    93 #                response.headers['content-type'] = 'text/xml' 
    94                 return render('exception_report', report=e.report, format='xml') 
    95  
    96  
    97     def _fixOwsAction(self, environ): 
    98         # Override the Routes action from the request query parameter 
    99         try: 
    100             action = self.ows_params['request'] 
    101         except KeyError: 
    102             raise OWS_E.MissingParameterValue('REQUEST parameter not specified', 'REQUEST') 
    103  
    104         # Check action is a method in self 
    105         if not getattr(self, action): 
    106             raise OWS_E.InvalidParameterValue('request=%s not supported' % action, 'REQUEST') 
    107  
    108         # override routes action with request 
    109         environ['pylons.routes_dict']['action'] = action 
    110         del self.ows_params['request'] 
    111  
    112     def _loadCapabilities(self): 
    113         """ 
    114         creates an ows_common.get_capabilities.ServiceMetadata object 
    115         by consulting the paste configuration and annotations in the 
    116         controller definition. 
    117  
    118         """ 
    119         # Deduce ows_endpoint from routes 
    120         ows_endpoint = h.url_for(controller=request.environ['pylons.routes_dict']['controller']) 
    121          
    122         #Deduce base_url from config 
    123         base_url =request.environ['ndgConfig'].get('DEFAULT','server') 
    124  
    125          
    126         # Get the server-level configuration data from an XML file 
    127         config = request.environ['paste.config'] 
    128         sm_tree = ET.parse(config['ows_common_config']) 
    129         sm = ows_common.xml.service_metadata(sm_tree.getroot()) 
    130          
    131         # Extract service-level parameters and constraint 
    132         parameters = getattr(self, '_ows_parameters', {}) 
    133         constraints = getattr(self, '_ows_constraints', {}) 
    134         versions = getattr(self, '_ows_versions', []) 
    135          
    136         # Extract operation-level parameters and constraints 
    137         od = {} 
    138         for attr in dir(self): 
    139             op = getattr(self, attr) 
    140             if hasattr(op, '_ows_name'): 
    141                 p = getattr(op, '_ows_parameters', {}) 
    142                 c = getattr(op, '_ows_constraints', {}) 
    143                 od[op._ows_name] = Operation(get=RequestMethod(href=base_url+ows_endpoint), 
    144                                              post=None, 
    145                                              parameters=p, 
    146                                              constraints=c, 
    147                                              name=op._ows_name) 
    148          
    149         sm.operationsMetadata = OperationsMetadata(od, constraints, parameters) 
    150         sm.serviceIdentification.serviceTypeVersions = versions 
    151         return sm 
    152  
    153     def _renderCapabilities(self, template='ows/get_capabilities'): 
    154         """ 
    155         The standard way of returning a Capabilities document. 
    156  
    157         Each subclass should implement self._load_capabilities() and call 
    158         this method to return a response object. 
    159  
    160         """ 
    161         c.service_metadata = self._loadCapabilities()         
    162         response.headers['content-type'] = 'text/xml' 
    163         return render(template, format='xml') 
    16467 
    16568 
  • MILK/trunk/milk_server/milk_server/lib/csml_cache.py

    r2631 r4469  
    1212 
    1313from cache import Cache 
    14 import os, tempfile 
    15 import cdms 
    16 from ows_server.lib.csml_util import get_csml_doc 
    17  
    18 import logging 
    19 logger = logging.getLogger('csml_cache') 
     14import os, tempfile, logging 
     15try: 
     16    import cdms2 as cdms 
     17except: 
     18    import cdms 
    2019 
    2120class CDMSEntry(object): 
     
    3332     
    3433    def __init__(self, filename, varname): 
    35         logger.info('Caching file variable %s in %s' % (varname, filename)) 
     34        logging.info('Caching file variable %s in %s' % (varname, filename)) 
    3635        self._f = cdms.open(filename) 
    3736        self.var = self._f[varname] 
    3837    def __del__(self): 
    3938        filename = self._f.id 
    40         logger.info('Removing file %s' % filename) 
     39        logging.info('Removing file %s' % filename) 
    4140        self._f.close() 
    4241        os.remove(filename) 
     
    8483        """ 
    8584        return super(CSMLExtractCache, self).__getitem__(name).var 
    86  
    87  
    88 class CSMLDocumentCache(Cache): 
    89     """ 
    90     There is considerable overhead for parsing CSML documents. 
    91     This cache stores the csml.parser.Dataset objects in memory. 
    92  
    93     """ 
    94     def build(self, key, name, opened, entry): 
    95         return get_csml_doc(name) 
    96  
    97 #--------------------------------------------------------------------------- 
    98  
    99 from pylons import request 
    100 extractCache = CSMLExtractCache(request.environ['paste.config']['app_conf']['tmp_dir'], max_size=3) 
    101 csmlCache = CSMLDocumentCache(max_size=5) 
  • MILK/trunk/milk_server/milk_server/lib/geoUtilities.py

    r3093 r4469  
    6565    def __str__(self): 
    6666        return '%s,%s'%(self.nboxes,self.boxes) 
    67  
    68      
    69 import unittest 
    70  
    71 class TestCase(unittest.TestCase): 
    72      
    73     def testMoveBox(self): 
    74         w,e=1,359 
    75         w,e=moveBox(w,e) 
    76         self.assertEqual((w,e),(-179.,179.)) 
    77         w,e=190,200 
    78         w,e=moveBox(w,e) 
    79         self.assertEqual((w,e),(-170.,-160.)) 
    80         w,e=10,20 
    81         w,e=moveBox(w,e) 
    82         self.assertEqual((w,e),(10.,20.)) 
    83      
    84 if __name__=="__main__": 
    85  
    86     unittest.main() 
    8767         
  • MILK/trunk/milk_server/milk_server/lib/mailer.py

    r2868 r4469  
    5353    except Exception,e: 
    5454        return 0, 'Error sending mail [%s]'%e 
    55          
    56          
    57 if __name__=="__main__": 
    58      
    59     server='outbox.rl.ac.uk' 
    60     recipients=['s.j.pepler@rl.ac.uk',] 
    61      
    62     import unittest 
    63      
    64     class TestCase(unittest.TestCase): 
    65          
    66         def testNormal(self): 
    67             ''' test sending a normal email message ''' 
    68             body='test body' 
    69             subject='mailer test' 
    70             status,message=mailHandler(recipients,subject,body,server=server) 
    71             self.assertEqual(message,'ok') 
    72              
    73         def testMime(self): 
    74             '''test sending an xml attachment ''' 
    75             body='test body' 
    76             subject='mailer mime test' 
    77             a=('<xml><something>blah</something></blah>','trackback.xml') 
    78             att=[a,] 
    79             status,message=mailHandler(recipients,subject,body,xmlAttachments=att,server=server) 
    80             self.assertEqual(message,'ok') 
    81              
    82          
    83     unittest.main() 
    84          
  • MILK/trunk/milk_server/milk_server/lib/ndgInterface.py

    r4237 r4469  
    88 
    99from cache import Cache 
    10 import os, tempfile 
     10from csml_cache import CSMLExtractCache 
     11import os, tempfile, logging 
    1112import csml 
    1213try: 
     
    1617from ndgUtils import ndgRetrieve, ndgObject, xmlHandler2 
    1718from pylons import request,session 
    18 import logging 
    1919 
    20 #from ows_server.models.ndgSecurity import HandleSecurity 
    2120from pylons import g # for handle to access control PEP interface 
    2221try: 
     
    2625    from warnings import warn 
    2726    warn(__name__ + ": access control is disabled: %s" % e, RuntimeWarning) 
    28      
    29      
    30 class CDMSEntry(object): 
    31     """ 
    32     A reference to a CDMS file that will delete the file when it is 
    33     garbage collected. 
    34  
    35     Instances of this class are used as Cache entry values.  When entries are 
    36     automatically removed from the cache the CDMSEntry object will be 
    37     garbage collected unless it is being accessed by another thread. 
    38  
    39     """ 
    40  
    41     __slots__ = ['_f', 'var'] 
    42      
    43     def __init__(self, filename, varname): 
    44         logging.info('Caching file variable %s in %s' % (varname, filename)) 
    45         self._f = cdms.open(filename) 
    46         self.var = self._f[varname] 
    47     def __del__(self): 
    48         filename = self._f.id 
    49         logging.info('Removing file %s' % filename) 
    50         self._f.close() 
    51         os.remove(filename) 
    52   
    53  
    54 class CSMLExtractCache(Cache): 
    55      
    56     def __init__(self, cache_dir, max_size=0): 
    57         super(CSMLExtractCache, self).__init__(max_size) 
    58         self._cache_dir = cache_dir 
    59  
    60     def _extract(self, feature, sel): 
    61         (fd, filename) = tempfile.mkstemp('.nc', 'csml_wxs_', self._cache_dir) 
    62         os.close(fd) 
    63         (outputdir, ncname) = os.path.split(filename) 
    64  
    65         # Workarround until ticket:778 (TestExtractAll) is fixed 
    66         sel.update(longitude=(-180, 180), latitude=(-90, 90)) 
    67  
    68         feature.subsetToGridSeries(ncname=ncname, outputdir=outputdir, **sel) 
    69  
    70         return filename 
    71      
    72     def key(self, name): 
    73         """ 
    74         Cache provides this method to map externally visible entry names 
    75         to internal keys.  We use it here to turn selectors into hashable 
    76         values. 
    77  
    78         """ 
    79         (feature, sel) = name 
    80          
    81         return (feature.id, tuple(sorted(sel.items()))) 
    82  
    83     def build(self, key, name, opened, entry): 
    84         (feature, sel) = name 
    85         filename = self._extract(feature, sel) 
    86  
    87         return CDMSEntry(filename, feature.name.CONTENT) 
    88  
    89     def __getitem__(self, name): 
    90         """ 
    91         Returns the opened CDMS object. 
    92  
    93         """ 
    94         return super(CSMLExtractCache, self).__getitem__(name).var 
    9527 
    9628class ndgInterface: 
     
    181113        return status,xmlh 
    182114             
    183     def GetParsedCSML(self,uri): 
    184          
    185         ''' This method gets a parsed CSML object corresponding to the URI ''' 
    186          
    187         # do we need an xml handler instance to test the security? 
    188         if 'ndgCleared' not in session: 
    189             status,xmlh=self.GetXML(uri) 
    190         else:  
    191             if uri not in session['ndgCleared']:  
    192                 status,xmlh=self.GetXML(uri) 
    193             else: status=1 
    194         if not status: return status,xmlh 
    195          
    196         try: 
    197             d=self.CSMLDocCache[uri] 
    198             logging.info('CSML Cache hit for [%s]'%uri) 
    199         except: 
    200             logging.info('CSML Cache miss for [%s]'%uri) 
    201             status,xmlh=self.GetXML(uri) 
    202             if not status: return status,xmlh     
    203             d=csml.parser.Dataset() 
    204             d.parseElemTree(xmlh.tree) 
    205             self.CSMLDocCache[uri]=d 
    206         status=1 
    207         return status,d 
    208          
     115 
    209116    def __gatekeep(self,uri,x): 
    210117        ''' This is the NDG gatekeeper ''' 
     
    231138            # Caught a known access control condition 
    232139            return False, 'Access Denied for %s %s' % (uri, e) 
     140 
    233141                 
    234142    def __getLocal(self,uri): 
  • MILK/trunk/milk_server/milk_server/models/AccessControl.py

    r2643 r4469  
    1 from Utilities import wrapGetText 
     1from milk_server.lib.Utilities import wrapGetText 
    22class AccessControl: 
    33         
  • MILK/trunk/milk_server/milk_server/models/DIF.py

    r3842 r4469  
    22# renderEntity etc ... 
    33# 
    4 from Utilities import * 
    5 from geoUtilities import * 
     4from milk_server.lib.Utilities import * 
     5from milk_server.lib.geoUtilities import * 
    66from People2 import * 
    77from AccessControl import AccessControl 
     
    217217           f.close() 
    218218 
    219  
    220 import unittest 
    221  
    222 class TestCase(unittest.TestCase): 
    223     """ 
    224     """ 
    225  
    226     inputFile = 'examples/neodc.eg1.dif' 
    227     inputFile2= 'examples/bodc.eg2.edmed.dif' 
    228     inputFile2= 'examples/bodc.eg3.difChange.dif' 
    229     inputFile2= 'examples/ndg.noc.soton.ac.uk__DIF__NOCSDAT162.xml' 
    230     configFile= 'config/ndgDiscovery.config' 
    231      
    232     def setUp(self): 
    233         ''' Load example config and DIF files for testing ''' 
    234         from ndgUtils.xmlHandler2 import xmlHandler 
    235         x=xmlHandler(self.inputFile2) 
    236         self.dif=DIF(x.tree,et=1) 
    237         self.config=myConfig(self.configFile) 
    238  
    239     def testEntries(self): 
    240         ''' Testing the DIF object can be loaded and some key entries extracted ''' 
    241         print 'Entry ID [%s]'%self.dif.entryID 
    242         print 'Author [%s]'%self.dif.authors 
    243         print 'Abstract [%s]'%self.dif.abstract 
    244         print 'BBox [%s]'%self.dif.bbox.boxes 
    245      
    246     def testParameters(self): 
    247         ''' Testing obtaining parameters from an edmed dif in original format ''' 
    248         print 'Parameters %s'%self.dif.parameters 
    249          
    250     def testDifficult(self): 
    251         ''' Grab a test example from the internet and load it ''' 
    252         from ndgUtils import ndgRetrieve, xmlHandler2 
    253         #testURI='grid.bodc.nerc.ac.uk__DIF__EDMED1048008' 
    254         testURI='neodc.nerc.ac.uk__DIF__NEODC_NEXTMAP' 
    255         uri=ndgObject(testURI,config=self.config) 
    256         status,xml=ndgRetrieve(uri,self.config) 
    257         self.assertEqual(status,1) 
    258         xml=xmlHandler2.xmlHandler(xml,string=1) 
    259         d=DIF(xml.tree,et=1) 
    260         print d.entryID,[str(i) for i in d.services] 
    261  
    262  
    263 if __name__=="__main__": 
    264     unittest.main() 
    265  
    266          
    267          
     219         
  • MILK/trunk/milk_server/milk_server/models/DiscoveryState.py

    r3093 r4469  
    108108======================== 
    109109'''%(self.searchString,self.constraints,self.sessID,self.hits,self.offset,self.stride,self.environ) 
    110          
    111 if __name__=="__main__": 
    112      
    113     import unittest 
    114     DummyEnviron={'QUERY_STRING':'start=10&howmany=10','HTTP_HOST':'example.ndg', 
    115                       'PATH_INFO':'/discovery','wsgi.url_scheme':'http','SERVER_PORT':'80'} 
    116  
    117     class TestCase(unittest.TestCase): 
    118          
    119         def testDiscoveryState(self): 
    120             ''' Test creation of a discovery state variable ''' 
    121             d=DiscoveryState('123','blah',DummyEnviron,12,'(none)') 
    122             self.assertEqual(d.geturl(offset='11',stride='20'), 
    123                             'http://example.ndg/discovery?start=11&amp;howmany=20') 
    124             print d 
    125      
    126         def testStrideself(self): 
    127             ''' Test striding through a dataset ''' 
    128              
    129             s=DiscoveryState('123','blah',DummyEnviron,15,'(none)',1,10) 
    130             res=s.getNext() 
    131             self.assertEqual([[11,5],[]],res) 
    132              
    133             s=DiscoveryState('123','blah',DummyEnviron,15,'(none)',11,5) 
    134             res=s.getNext() 
    135             self.assertEqual([[],[1,10]],res) 
    136              
    137             s=DiscoveryState('123','blah',DummyEnviron,50,'(none)',11,10) 
    138             res=s.getNext() 
    139             self.assertEqual([[21,10],[1,10]],res)  
    140  
    141                 
    142     unittest.main() 
    143                        
    144          
  • MILK/trunk/milk_server/milk_server/models/People.py

    r3501 r4469  
    1 from Utilities import wrapGetText 
     1from milk_server.lib.Utilities import wrapGetText 
    22from ndgUtils.ETxmlView import nsdumb 
    3 from htmlUtilities import * 
     3from milk_server.lib.htmlUtilities import * 
    44 
    55class Name: 
  • MILK/trunk/milk_server/milk_server/models/People2.py

    r3501 r4469  
    1 from Utilities import wrapGetText 
    21from ndgUtils.ETxmlView import nsdumb 
    3 from htmlUtilities import * 
    4 from xmlHandler import xmlHandler 
    5  
     2from milk_server.lib.htmlUtilities import * 
    63 
    74def tr(x):return '<tr>%s</tr>'%x 
     
    201198</Personnel> 
    202199</Data_Center>''' 
    203  
    204  
    205 class TestCase(unittest.TestCase): 
    206      
    207     def testDIFContact(self): 
    208         '''Test instantiating a DIFContact''' 
    209         w='<DIF xmlns="http://gcmd.gsfc.nasa.gov/Aboutus/xml/dif/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">%s</DIF>'%Example2 
    210         #w='<wrap>%s</wrap>'%Example2 
    211         y=xmlHandler(w,string=1) 
    212         h=nsdumb(y.tree) 
    213         e=h.find(y.tree,'Data_Center') 
    214         d=DIFcontact(h,e) 
    215         print d.toHTML() 
    216      
    217     def testDIFname(self): 
    218         '''Make sure we can create a contact, with just a name ''' 
    219         x=DIFcontact(0,0,name='Bryan Lawrence') 
    220         print x.toHTML() 
    221     
    222 if __name__=="__main__": 
    223     unittest.main()          
  • MILK/trunk/milk_server/milk_server/models/ServiceBinding.py

    r3501 r4469  
    1313# This module provides classes to support these activities. 
    1414 
    15 from htmlUtilities import hyperlink,image 
     15from milk_server.lib.htmlUtilities import hyperlink,image 
    1616from ndgUtils.ETxmlView import nsdumb,et2text 
    1717 
  • MILK/trunk/milk_server/milk_server/models/__init__.py

    r2476 r4469  
    1 ## NOTE 
    2 ##   If you plan on using SQLObject, the following should be un-commented and provides 
    3 ##   a starting point for setting up your schema 
    4  
    5 #from sqlobject import * 
    6 #from pylons.database import PackageHub 
    7 #hub = PackageHub("ows_server") 
    8 #__connection__ = hub 
    9  
    10 # You should then import your SQLObject classes 
    11 # from myclass import MyDataClass 
  • MILK/trunk/milk_server/milk_server/models/ndgSecurity.py

    r3893 r4469  
    33import socket 
    44 
    5 from ows_server.lib.base import * 
     5from milk_server.lib.base import * 
    66from pylons import request 
    77import logging 
     
    99 
    1010from ows_common.exception_report import OwsError 
    11 from ows_server.lib.security_util import SecuritySession 
     11from milk_server.lib.security_util import SecuritySession 
    1212 
    1313try:  
  • MILK/trunk/milk_server/milk_server/models/selectedItem.py

    r3842 r4469  
    1010""" 
    1111 
    12 from ows_server.models import Utilities 
     12from milk_server.lib import Utilities 
    1313import logging 
    1414 
  • MILK/trunk/milk_server/milk_server/models/stubB.py

    r4259 r4469  
    88#  
    99 
    10 from Utilities import * 
     10from milk_server.lib.Utilities import * 
    1111from ndgUtils.BeautifulSoup import BeautifulSoup 
    1212from AccessControl import AccessControl 
    13 from geoUtilities import Bounding 
     13from milk_server.lib.geoUtilities import Bounding 
    1414from People import * 
    1515from ndgUtils import ndgObject 
    16 from ows_server.models import Utilities 
    1716import logging 
    1817 
    19 #from DeploymentHandling import * 
    2018try: #python 2.5 
    2119    from xml.etree import ElementTree as ET 
     
    311309                # now go get all the related links 
    312310                self.related=Deployments(helper.find(elem,'DeploymentSummary'),helper,self.config) 
    313  
    314  
    315 if __name__=="__main__": 
    316     import unittest 
    317     import os.path 
    318     from ndgUtils import ndgRetrieve, xmlHandler2 
    319          
    320      
    321     class TestCase(unittest.TestCase): 
    322      
    323             def testDE(self): 
    324                 ''' Test rendering a DataEntity stubB ''' 
    325                 doc='badc.nerc.ac.uk__NDG-B1__dataent_COAPEC' 
    326                 xml=self.getit(doc)      
    327                 self.doit(xml.tree) 
    328                  
    329             def getit(self,doc): 
    330                 self.c=myConfig('../../ndgDiscovery.config') 
    331                 uri=ndgObject(doc) 
    332                 status,xml=ndgRetrieve(uri,self.c) 
    333                 self.assertEqual(status,1) 
    334                 xml=xmlHandler2.xmlHandler(xml,string=1) 
    335                 return xml 
    336            
    337             def doit(self,xml): 
    338                 x=stubB(xml,self.c) 
    339                  
    340           
    341     unittest.main() 
    342              
    343              
Note: See TracChangeset for help on using the changeset viewer.