Home       Trees       Indices       Help   
python-sld
Package sld :: Package test
[hide private]
[frames] | no frames]

Source Code for Package sld.test

  1  """ 
  2  Test suite for the StyledLayerDescriptor python library. 
  3   
  4  License 
  5  ======= 
  6  Copyright 2011 David Zwarg <U{dzwarg@azavea.com}> 
  7   
  8  Licensed under the Apache License, Version 2.0 (the "License"); 
  9  you may not use this file except in compliance with the License. 
 10  You may obtain a copy of the License at 
 11   
 12  U{http://www.apache.org/licenses/LICENSE-2.0} 
 13   
 14  Unless required by applicable law or agreed to in writing, software 
 15  distributed under the License is distributed on an "AS IS" BASIS, 
 16  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 17  See the License for the specific language governing permissions and 
 18  limitations under the License. 
 19   
 20  @author: David Zwarg 
 21  @contact: dzwarg@azavea.com 
 22  @copyright: 2011, Azavea 
 23  @license: Apache 2.0 
 24  @version: 1.0.6 
 25  """ 
 26  from sld import * 
 27  import unittest, copy 
 28  from lxml import etree 
 29   

 30 -class SLD_Test(unittest.TestCase): 

 31      """ 
 32      All tests for django-sld are contained in this TestCase class. 
 33      """ 
 34   
 35      _sld0 = None 
 36      """Store a parsed SLD, with known styles and structure""" 
 37   
 38      _sld1 = None 
 39      """Store a dynamically generated SLD""" 
 40   

 41 -    def setUp(self): 

 42          """ 
 43          Set up the test fixture. 
 44          """ 
 45          if SLD_Test._sld0 is None: 
 46              SLD_Test._sld0 = StyledLayerDescriptor('test/style.sld') 
 47              SLD_Test._sld1 = StyledLayerDescriptor() 

 48   
 49   

 50 -    def test_constructor1(self): 

 51          """ 
 52          Test an empty constructor, and make sure the SLD is valid. 
 53          """ 
 54          sld = StyledLayerDescriptor() 
 55   
 56          self.assertTrue( 'sld' in sld._nsmap ) 
 57   
 58          expected = """<sld:StyledLayerDescriptor xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc" version="1.0.0"/>""" 
 59          actual = etree.tostring(sld._node, with_tail=False) 
 60          self.assertEqual(actual, expected) 
 61   
 62          sld.normalize() 
 63   
 64          self.assertTrue(sld.validate()) 

 65           
 66   

 67 -    def test_constructor2(self): 

 68          """ 
 69          Test a constructor on a bogus file. 
 70          """ 
 71          try: 
 72              sld = StyledLayerDescriptor('junk') 
 73              self.fail("Error") 
 74          except: 
 75              # Good, failure on a junk file. 
 76              pass 

 77   

 78 -    def test_sld_version(self): 

 79          """ 
 80          Test the SLD version on the root element. 
 81          """ 
 82          self.assertEqual( self._sld0.version, "1.0.0" ) 

 83   

 84 -    def test_sld_ns(self): 

 85          """ 
 86          Test the namespace on the root element. 
 87          """ 
 88          self.assertEqual( self._sld0.xmlns, 'http://www.opengis.net/sld' ) 

 89   

 90 -    def test_sld_namedlayer1(self): 

 91          """ 
 92          Test the object type of the NamedLayer property. 
 93          """ 
 94          self.assertTrue( isinstance(self._sld0.NamedLayer, NamedLayer), "NamedLayer property is not the proper class.") 

 95   

 96 -    def test_sld_namedlayer2(self): 

 97          """ 
 98          Test the creation and construction of a NamedLayer element. 
 99          """ 
100          self.assertTrue( self._sld1.NamedLayer is None ) 
101   
102          sld = copy.deepcopy(self._sld1) 
103   
104          sld.create_namedlayer('test named layer') 
105          self.assertFalse( sld.NamedLayer is None ) 
106   
107          sld.normalize() 
108          self.assertTrue(sld.validate()) 

109   

110 -    def test_namedlayer_name(self): 

111          """ 
112          Test the proper parsing of the name of the NamedLayer. 
113          """ 
114          expected = 'poptot' 
115          self.assertEqual( self._sld0.NamedLayer.Name, expected, "NamedLayer was named '%s', not '%s'" % (self._sld0.NamedLayer.Name, expected,)) 

116   

118          """ 
119          Test the object type of the UserStyle property. 
120          """ 
121          self.assertTrue( isinstance(self._sld0.NamedLayer.UserStyle, UserStyle), "UserStyle property is not the proper class.") 

122   

124          """ 
125          Test the proper parsing of the UserStyle property. 
126          """ 
127          sld = copy.deepcopy(self._sld1) 
128   
129          sld.create_namedlayer('test named layer') 
130   
131          self.assertTrue( sld.NamedLayer.UserStyle is None) 
132   
133          sld.NamedLayer.create_userstyle() 
134   
135          self.assertFalse( sld.NamedLayer.UserStyle is None) 
136   
137          sld.normalize() 
138          self.assertFalse(sld.validate()) 

139   

140 -    def test_userstyle_title1(self): 

141          """ 
142          Test the parsing of the UserStyle Title, and proper rendering. 
143          """ 
144          sld = copy.deepcopy(self._sld0) 
145          us = sld.NamedLayer.UserStyle  
146          expected = 'Population' 
147          self.assertEqual( us.Title, expected, "UserStyle Title was '%s', not '%s'" % (us.Title, expected,)) 
148   
149          expected = 'Consternation' 
150          us.Title = expected 
151          self.assertEqual( us.Title, expected, "UserStyle Title was '%s', not '%s'" % (us.Title, expected,)) 
152   
153          us._node.remove(us._node[2]) 
154   
155          expected = """<UserStyle xmlns="http://www.opengis.net/sld" xmlns:ogc="http://www.opengis.net/ogc" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
156        <Title>%s</Title> 
157        <Abstract>A grayscale style showing the population numbers in a given geounit.</Abstract> 
158        </UserStyle>""" % expected 
159          actual = etree.tostring(us._node, with_tail=False) 
160          self.assertEqual( len(actual), len(expected)) 
161          self.assertEqual( actual, expected, "UserStyle was not serialized correctly.\n%s" % actual ) 
162   
163          sld.normalize() 
164          self.assertFalse(sld.validate()) 

165   

166 -    def test_userstyle_title2(self): 

167          """ 
168          Test the construction of the UserStyle Title, and proper rendering. 
169          """ 
170          sld = copy.deepcopy(self._sld1) 
171          sld.create_namedlayer('test named layer') 
172          sld.NamedLayer.create_userstyle() 
173   
174          us = sld.NamedLayer.UserStyle  
175          self.assertTrue( us.Title is None, "UserStyle Title was not None") 
176   
177          expected = 'Consternation' 
178          us.Title = expected 
179          self.assertEqual( us.Title, expected, "UserStyle Title was '%s', not '%s'" % (us.Title, expected,)) 
180   
181          expected = """<sld:UserStyle xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Title>%s</sld:Title></sld:UserStyle>""" % expected 
182          actual = etree.tostring(us._node, with_tail=False) 
183          self.assertEqual( len(actual), len(expected)) 
184          self.assertEqual( actual, expected, "UserStyle was not serialized correctly.\n%s" % actual ) 
185   
186          sld.normalize() 
187          self.assertFalse(sld.validate()) 

188   

189 -    def test_userstyle_abstract1(self): 

190          """ 
191          Test the parsing of the UserStyle Abstract, and proper rendering. 
192          """ 
193          sld = copy.deepcopy(self._sld0) 
194          us = sld.NamedLayer.UserStyle 
195          expected = 'A grayscale style showing the population numbers in a given geounit.' 
196          self.assertEqual( us.Abstract, expected, "UserStyle Abstract was '%s', not '%s'" % (us.Abstract, expected,)) 
197   
198          expected = 'Something completely different' 
199          us.Abstract = expected 
200          self.assertEqual( us.Abstract, expected, "UserStyle Abstract was '%s', not '%s'" % (us.Abstract, expected,)) 
201   
202          us._node.remove(us._node[2]) 
203   
204          expected = """<UserStyle xmlns="http://www.opengis.net/sld" xmlns:ogc="http://www.opengis.net/ogc" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
205        <Title>Population</Title> 
206        <Abstract>%s</Abstract> 
207        </UserStyle>""" % expected 
208          actual = etree.tostring(us._node, with_tail=False) 
209          self.assertEqual( len(actual), len(expected) ) 
210          self.assertEqual( actual, expected, "UserStyle was not serialized correctly.\n%s" % actual ) 
211   
212          sld.normalize() 
213          self.assertFalse(sld.validate()) 

214   

215 -    def test_userstyle_abstract2(self): 

216          """ 
217          Test the construction of the UserStyle Abstract, and proper rendering. 
218          """ 
219          sld = copy.deepcopy(self._sld1) 
220          sld.create_namedlayer('test named layer') 
221          sld.NamedLayer.create_userstyle() 
222   
223          us = sld.NamedLayer.UserStyle 
224          self.assertTrue( us.Abstract is None, "UserStyle Abstract was not None") 
225   
226          expected = 'Something completely different' 
227          us.Abstract = expected 
228          self.assertEqual( us.Abstract, expected, "UserStyle Abstract was '%s', not '%s'" % (us.Abstract, expected,)) 
229   
230          expected = """<sld:UserStyle xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Abstract>%s</sld:Abstract></sld:UserStyle>""" % expected 
231          actual = etree.tostring(us._node, with_tail=False) 
232          self.assertEqual( len(actual), len(expected) ) 
233          self.assertEqual( actual, expected, "UserStyle was not serialized correctly.\n%s" % actual ) 
234   
235          sld.normalize() 
236          self.assertFalse(sld.validate()) 

237   

239          """ 
240          Test the object type of the FeatureTypeStyle property. 
241          """ 
242          self.assertTrue( isinstance(self._sld0.NamedLayer.UserStyle.FeatureTypeStyle, FeatureTypeStyle), "FeatureTypeStyle property is not the proper class.") 

243   

245          """ 
246          Test the construction of a new FeatureTypeStyle property. 
247          """ 
248          sld = copy.deepcopy(self._sld1) 
249          sld.create_namedlayer('test named layer') 
250          sld.NamedLayer.create_userstyle() 
251   
252          self.assertTrue( sld.NamedLayer.UserStyle.FeatureTypeStyle is None ) 
253   
254          sld.NamedLayer.UserStyle.create_featuretypestyle() 
255   
256          self.assertFalse( sld.NamedLayer.UserStyle.FeatureTypeStyle is None ) 
257   
258          sld.normalize() 
259          self.assertFalse(sld.validate()) 

260   

262          """ 
263          Test the parsing of the Rules property. 
264          """ 
265          rules = self._sld0.NamedLayer.UserStyle.FeatureTypeStyle.Rules 
266          self.assertEqual( len(rules), 6 ) 
267          self.assertTrue( isinstance(rules[0], Rule), "Rule item in list is not the proper class." ) 

268   

270          """ 
271          Test the construction of the Rules property. 
272          """ 
273          sld = copy.deepcopy(self._sld1) 
274          sld.create_namedlayer('test named layer') 
275          sld.NamedLayer.create_userstyle() 
276          sld.NamedLayer.UserStyle.create_featuretypestyle() 
277   
278          rules = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules 
279          self.assertEqual( len(rules), 0 ) 
280   
281          sld.NamedLayer.UserStyle.FeatureTypeStyle.create_rule('test rule', PointSymbolizer) 
282          rules = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules 
283   
284          self.assertEqual( len(rules), 1 ) 
285   
286          sld.normalize() 
287          self.assertTrue(sld.validate()) 

288   

289 -    def test_rule_title1(self): 

290          """ 
291          Test the parsing of the individual Rule properties. 
292          """ 
293          sld = copy.deepcopy(self._sld0) 
294          rule = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0] 
295   
296          expected = "> 880" 
297          self.assertEqual( rule.Title, expected ) 
298   
299          expected = "> 999" 
300          rule.Title = expected 
301          self.assertEqual( rule.Title, expected ) 
302   
303          expected = """<Rule xmlns="http://www.opengis.net/sld" xmlns:ogc="http://www.opengis.net/ogc" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
304            <Title>&gt; 999</Title> 
305            <ogc:Filter> 
306              <ogc:PropertyIsGreaterThanOrEqualTo> 
307                <ogc:PropertyName>number</ogc:PropertyName> 
308                <ogc:Literal>880</ogc:Literal> 
309              </ogc:PropertyIsGreaterThanOrEqualTo> 
310            </ogc:Filter> 
311            <PolygonSymbolizer> 
312              <Fill> 
313                <CssParameter name="fill">#252525</CssParameter> 
314              </Fill> 
315            </PolygonSymbolizer> 
316          </Rule>""" 
317          actual = etree.tostring(rule._node, with_tail=False) 
318          self.assertEqual( actual, expected, actual ) 
319           
320          sld.normalize() 
321          self.assertTrue(sld.validate()) 

322   

323 -    def test_rule_title2(self): 

324          """ 
325          Test the construction of new Rule properties. 
326          """ 
327          sld = copy.deepcopy(self._sld1) 
328          sld.create_namedlayer('test named layer') 
329          sld.NamedLayer.create_userstyle() 
330          sld.NamedLayer.UserStyle.create_featuretypestyle() 
331          sld.NamedLayer.UserStyle.FeatureTypeStyle.create_rule('test rule', PointSymbolizer) 
332   
333          rule = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0] 
334   
335          expected = "> 999" 
336          rule.Title = expected 
337          self.assertEqual( rule.Title, expected ) 
338   
339          expected = """<sld:Rule xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Title>&gt; 999</sld:Title><sld:PointSymbolizer><sld:Graphic><sld:Mark><sld:WellKnownName>square</sld:WellKnownName><sld:Fill><sld:CssParameter name="fill">#ff0000</sld:CssParameter></sld:Fill></sld:Mark></sld:Graphic></sld:PointSymbolizer></sld:Rule>""" 
340          actual = etree.tostring(rule._node, with_tail=False) 
341          self.assertEqual( actual, expected, actual ) 
342           
343          sld.normalize() 
344          self.assertTrue(sld.validate()) 

345   

346 -    def test_rule_filter1(self): 

347          """ 
348          Test the parsing of the Filter property. 
349          """ 
350          sld = copy.deepcopy(self._sld0) 
351          rule = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0] 
352   
353          self.assertFalse( rule.Filter.PropertyIsGreaterThanOrEqualTo is None ) 
354   
355          self.assertEqual( rule.Filter.PropertyIsGreaterThanOrEqualTo.PropertyName, 'number' ) 
356          self.assertEqual( rule.Filter.PropertyIsGreaterThanOrEqualTo.Literal, '880' ) 
357           
358          sld.normalize() 
359          self.assertTrue(sld.validate()) 

360   

361 -    def test_rule_filter_none(self): 

362          """ 
363          Test the construction of the Filter property. 
364          """ 
365          sld = copy.deepcopy(self._sld1) 
366          namedlayer = sld.create_namedlayer('test named layer') 
367          userstyle = namedlayer.create_userstyle() 
368          featuretypestyle = userstyle.create_featuretypestyle() 
369          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
370          rfilter = rule.create_filter() 
371   
372          self.assertTrue( rfilter is None ) 
373          sld.normalize() 
374          self.assertTrue(sld.validate()) 

375   

376 -    def test_filter_eq(self): 

377          """ 
378          Test the construction of an equality filter. 
379          """ 
380          sld = copy.deepcopy(self._sld1) 
381          namedlayer = sld.create_namedlayer('test named layer') 
382          userstyle = namedlayer.create_userstyle() 
383          featuretypestyle = userstyle.create_featuretypestyle() 
384          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
385          rfilter = rule.create_filter('valueA', '==', '5000') 
386   
387          self.assertTrue( rfilter.PropertyIsNotEqualTo is None ) 
388          self.assertTrue( rfilter.PropertyIsLessThan is None ) 
389          self.assertTrue( rfilter.PropertyIsLessThanOrEqualTo is None ) 
390          self.assertTrue( rfilter.PropertyIsGreaterThan is None ) 
391          self.assertTrue( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
392          self.assertTrue( rfilter.PropertyIsLike is None ) 
393          self.assertFalse( rfilter.PropertyIsEqualTo is None ) 
394          self.assertEqual( rfilter.PropertyIsEqualTo.PropertyName, 'valueA' ) 
395          self.assertEqual( rfilter.PropertyIsEqualTo.Literal, '5000' ) 
396   
397          sld.normalize() 
398          self.assertTrue(sld.validate()) 

399   

400 -    def test_filter_lte(self): 

401          """ 
402          Test the construction of a less-than-or-equal Filter. 
403          """ 
404          sld = copy.deepcopy(self._sld1) 
405          namedlayer = sld.create_namedlayer('test named layer') 
406          userstyle = namedlayer.create_userstyle() 
407          featuretypestyle = userstyle.create_featuretypestyle() 
408          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
409          rfilter = rule.create_filter('valueB', '<=', '5000') 
410   
411          self.assertTrue( rfilter.PropertyIsEqualTo is None ) 
412          self.assertTrue( rfilter.PropertyIsNotEqualTo is None ) 
413          self.assertTrue( rfilter.PropertyIsLessThan is None ) 
414          self.assertTrue( rfilter.PropertyIsGreaterThan is None ) 
415          self.assertTrue( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
416          self.assertTrue( rfilter.PropertyIsLike is None ) 
417          self.assertFalse( rfilter.PropertyIsLessThanOrEqualTo is None ) 
418          self.assertEqual( rfilter.PropertyIsLessThanOrEqualTo.PropertyName, 'valueB' ) 
419          self.assertEqual( rfilter.PropertyIsLessThanOrEqualTo.Literal, '5000' ) 
420           
421          sld.normalize() 
422          self.assertTrue(sld.validate()) 

423   

424 -    def test_filter_lt(self): 

425          """ 
426          Test the construction of a less-than Filter. 
427          """ 
428          sld = copy.deepcopy(self._sld1) 
429          namedlayer = sld.create_namedlayer('test named layer') 
430          userstyle = namedlayer.create_userstyle() 
431          featuretypestyle = userstyle.create_featuretypestyle() 
432          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
433          rfilter = rule.create_filter('valueC', '<', '500') 
434   
435          self.assertTrue( rfilter.PropertyIsEqualTo is None ) 
436          self.assertTrue( rfilter.PropertyIsLessThanOrEqualTo is None ) 
437          self.assertTrue( rfilter.PropertyIsNotEqualTo is None ) 
438          self.assertTrue( rfilter.PropertyIsGreaterThan is None ) 
439          self.assertTrue( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
440          self.assertTrue( rfilter.PropertyIsLike is None ) 
441          self.assertFalse( rfilter.PropertyIsLessThan is None ) 
442          self.assertEqual( rfilter.PropertyIsLessThan.PropertyName, 'valueC' ) 
443          self.assertEqual( rfilter.PropertyIsLessThan.Literal, '500' ) 
444   
445          sld.normalize() 
446          self.assertTrue(sld.validate()) 

447   

448 -    def test_filter_gte(self): 

449          """ 
450          Test the construction of a greater-than-or-equal Filter. 
451          """ 
452          sld = copy.deepcopy(self._sld1) 
453          namedlayer = sld.create_namedlayer('test named layer') 
454          userstyle = namedlayer.create_userstyle() 
455          featuretypestyle = userstyle.create_featuretypestyle() 
456          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
457          rfilter = rule.create_filter('valueD', '>=', '100') 
458   
459          self.assertTrue( rfilter.PropertyIsEqualTo is None ) 
460          self.assertTrue( rfilter.PropertyIsLessThanOrEqualTo is None ) 
461          self.assertTrue( rfilter.PropertyIsLessThan is None ) 
462          self.assertTrue( rfilter.PropertyIsNotEqualTo is None ) 
463          self.assertTrue( rfilter.PropertyIsGreaterThan is None ) 
464          self.assertTrue( rfilter.PropertyIsLike is None ) 
465          self.assertFalse( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
466          self.assertEqual( rfilter.PropertyIsGreaterThanOrEqualTo.PropertyName, 'valueD' ) 
467          self.assertEqual( rfilter.PropertyIsGreaterThanOrEqualTo.Literal, '100' ) 
468           
469          sld.normalize() 
470          self.assertTrue(sld.validate()) 

471   

472 -    def test_filter_gt(self): 

473          """ 
474          Test the construction of a greater-than Filter. 
475          """ 
476          sld = copy.deepcopy(self._sld1) 
477          namedlayer = sld.create_namedlayer('test named layer') 
478          userstyle = namedlayer.create_userstyle() 
479          featuretypestyle = userstyle.create_featuretypestyle() 
480          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
481          rfilter = rule.create_filter('valueE', '>', '10') 
482   
483          self.assertTrue( rfilter.PropertyIsEqualTo is None ) 
484          self.assertTrue( rfilter.PropertyIsLessThanOrEqualTo is None ) 
485          self.assertTrue( rfilter.PropertyIsLessThan is None ) 
486          self.assertTrue( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
487          self.assertTrue( rfilter.PropertyIsNotEqualTo is None ) 
488          self.assertTrue( rfilter.PropertyIsLike is None ) 
489          self.assertFalse( rfilter.PropertyIsGreaterThan is None ) 
490          self.assertEqual( rfilter.PropertyIsGreaterThan.PropertyName, 'valueE' ) 
491          self.assertEqual( rfilter.PropertyIsGreaterThan.Literal, '10' ) 
492           
493          sld.normalize() 
494          self.assertTrue(sld.validate()) 

495   

496 -    def test_filter_neq(self): 

497          """ 
498          Test the construction of an inequality Filter. 
499          """ 
500          sld = copy.deepcopy(self._sld1) 
501          namedlayer = sld.create_namedlayer('test named layer') 
502          userstyle = namedlayer.create_userstyle() 
503          featuretypestyle = userstyle.create_featuretypestyle() 
504          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
505          rfilter = rule.create_filter('valueF', '!=', '0.01') 
506   
507          self.assertTrue( rfilter.PropertyIsEqualTo is None ) 
508          self.assertTrue( rfilter.PropertyIsLessThan is None ) 
509          self.assertTrue( rfilter.PropertyIsLessThanOrEqualTo is None ) 
510          self.assertTrue( rfilter.PropertyIsGreaterThan is None ) 
511          self.assertTrue( rfilter.PropertyIsGreaterThanOrEqualTo is None ) 
512          self.assertTrue( rfilter.PropertyIsLike is None ) 
513          self.assertFalse( rfilter.PropertyIsNotEqualTo is None ) 
514          self.assertEqual( rfilter.PropertyIsNotEqualTo.PropertyName, 'valueF' ) 
515          self.assertEqual( rfilter.PropertyIsNotEqualTo.Literal, '0.01' ) 
516           
517          sld.normalize() 
518          self.assertTrue(sld.validate()) 

519   

520 -    def test_filter_and(self): 

521          """ 
522          Test the construction of a logical-and Filter. 
523          """ 
524          sld = copy.deepcopy(self._sld1) 
525          namedlayer = sld.create_namedlayer('test named layer') 
526          userstyle = namedlayer.create_userstyle() 
527          featuretypestyle = userstyle.create_featuretypestyle() 
528          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
529           
530          filter1 = Filter(rule) 
531          filter1.PropertyIsGreaterThan = PropertyCriterion(filter1, 'PropertyIsGreaterThan') 
532          filter1.PropertyIsGreaterThan.PropertyName = 'number' 
533          filter1.PropertyIsGreaterThan.Literal = '-10' 
534   
535          filter2 = Filter(rule) 
536          filter2.PropertyIsLessThanOrEqualTo = PropertyCriterion(filter2, 'PropertyIsLessThanOrEqualTo') 
537          filter2.PropertyIsLessThanOrEqualTo.PropertyName = 'number' 
538          filter2.PropertyIsLessThanOrEqualTo.Literal = '10' 
539   
540          rule.Filter = filter1 + filter2 
541   
542          expected = """<sld:Rule xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Title>test rule</sld:Title><sld:PointSymbolizer><sld:Graphic><sld:Mark><sld:WellKnownName>square</sld:WellKnownName><sld:Fill><sld:CssParameter name="fill">#ff0000</sld:CssParameter></sld:Fill></sld:Mark></sld:Graphic></sld:PointSymbolizer><ogc:Filter><ogc:And><ogc:PropertyIsGreaterThan><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>-10</ogc:Literal></ogc:PropertyIsGreaterThan><ogc:PropertyIsLessThanOrEqualTo><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>10</ogc:Literal></ogc:PropertyIsLessThanOrEqualTo></ogc:And></ogc:Filter></sld:Rule>""" 
543          actual = etree.tostring(rule._node, with_tail=False) 
544          self.assertEqual(actual, expected) 
545           
546          sld.normalize() 
547          self.assertTrue(sld.validate()) 

548   

549 -    def test_filter_or(self): 

550          """ 
551          Test the construction of a logical-or Filter. 
552          """ 
553          sld = copy.deepcopy(self._sld1) 
554          namedlayer = sld.create_namedlayer('test named layer') 
555          userstyle = namedlayer.create_userstyle() 
556          featuretypestyle = userstyle.create_featuretypestyle() 
557          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
558           
559          filter1 = Filter(rule) 
560          filter1.PropertyIsGreaterThan = PropertyCriterion(filter1, 'PropertyIsGreaterThan') 
561          filter1.PropertyIsGreaterThan.PropertyName = 'number' 
562          filter1.PropertyIsGreaterThan.Literal = '10' 
563   
564          filter2 = Filter(rule) 
565          filter2.PropertyIsLessThan= PropertyCriterion(filter2, 'PropertyIsLessThan') 
566          filter2.PropertyIsLessThan.PropertyName = 'number' 
567          filter2.PropertyIsLessThan.Literal = '-10' 
568   
569          rule.Filter = filter1 | filter2 
570   
571          expected = """<sld:Rule xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Title>test rule</sld:Title><sld:PointSymbolizer><sld:Graphic><sld:Mark><sld:WellKnownName>square</sld:WellKnownName><sld:Fill><sld:CssParameter name="fill">#ff0000</sld:CssParameter></sld:Fill></sld:Mark></sld:Graphic></sld:PointSymbolizer><ogc:Filter><ogc:Or><ogc:PropertyIsGreaterThan><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>10</ogc:Literal></ogc:PropertyIsGreaterThan><ogc:PropertyIsLessThan><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>-10</ogc:Literal></ogc:PropertyIsLessThan></ogc:Or></ogc:Filter></sld:Rule>""" 
572          actual = etree.tostring(rule._node, with_tail=False) 
573          self.assertEqual(actual, expected) 
574           
575          sld.normalize() 
576          self.assertTrue(sld.validate()) 

577   

578 -    def test_filter_and_or(self): 

579          """ 
580          Test the construction of a logical-and combined with a logical-or Filter. 
581          """ 
582          sld = copy.deepcopy(self._sld1) 
583          namedlayer = sld.create_namedlayer('test named layer') 
584          userstyle = namedlayer.create_userstyle() 
585          featuretypestyle = userstyle.create_featuretypestyle() 
586          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
587           
588          filter1 = Filter(rule) 
589          filter1.PropertyIsGreaterThan = PropertyCriterion(filter1, 'PropertyIsGreaterThan') 
590          filter1.PropertyIsGreaterThan.PropertyName = 'number' 
591          filter1.PropertyIsGreaterThan.Literal = '10' 
592   
593          filter2 = Filter(rule) 
594          filter2.PropertyIsLessThan = PropertyCriterion(filter2, 'PropertyIsLessThan') 
595          filter2.PropertyIsLessThan.PropertyName = 'number' 
596          filter2.PropertyIsLessThan.Literal = '-10' 
597   
598          filter3 = Filter(rule) 
599          filter3.PropertyIsEqualTo = PropertyCriterion(filter3, 'PropertyIsEqualTo') 
600          filter3.PropertyIsEqualTo.PropertyName = 'value' 
601          filter3.PropertyIsEqualTo.Literal = 'yes' 
602   
603          rule.Filter = filter1 + (filter2 | filter3) 
604   
605          expected = """<sld:Rule xmlns:sld="http://www.opengis.net/sld" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ogc="http://www.opengis.net/ogc"><sld:Title>test rule</sld:Title><sld:PointSymbolizer><sld:Graphic><sld:Mark><sld:WellKnownName>square</sld:WellKnownName><sld:Fill><sld:CssParameter name="fill">#ff0000</sld:CssParameter></sld:Fill></sld:Mark></sld:Graphic></sld:PointSymbolizer><ogc:Filter><ogc:And><ogc:PropertyIsGreaterThan><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>10</ogc:Literal></ogc:PropertyIsGreaterThan><ogc:Or><ogc:PropertyIsLessThan><ogc:PropertyName>number</ogc:PropertyName><ogc:Literal>-10</ogc:Literal></ogc:PropertyIsLessThan><ogc:PropertyIsEqualTo><ogc:PropertyName>value</ogc:PropertyName><ogc:Literal>yes</ogc:Literal></ogc:PropertyIsEqualTo></ogc:Or></ogc:And></ogc:Filter></sld:Rule>""" 
606          actual = etree.tostring(rule._node, with_tail=False, pretty_print=False) 
607          self.assertEqual(actual, expected) 
608           
609          sld.normalize() 
610          self.assertTrue(sld.validate()) 

611   

613          """ 
614          Test the parsing of the PolygonSymbolizer property. 
615          """ 
616          sld = copy.deepcopy(self._sld0) 
617          rule = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0] 
618   
619          self.assertFalse( rule.PolygonSymbolizer is None ) 
620   
621          sld.normalize() 
622          self.assertTrue(sld.validate()) 

623   

625          """ 
626          Test the construction of a PolygonSymbolizer property. 
627          """ 
628          sld = copy.deepcopy(self._sld1) 
629          namedlayer = sld.create_namedlayer('test named layer') 
630          userstyle = namedlayer.create_userstyle() 
631          featuretypestyle = userstyle.create_featuretypestyle() 
632          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
633          symbolizer = rule.create_symbolizer('Polygon') 
634   
635          self.assertTrue( symbolizer.Fill is None ) 
636          self.assertTrue( symbolizer.Stroke is None ) 
637          self.assertTrue( symbolizer.Font is None ) 
638           
639          sld.normalize() 
640          self.assertTrue(sld.validate()) 

641           

643          """ 
644          Test the parsing of a Fill property. 
645          """ 
646          sld = copy.deepcopy(self._sld0) 
647          rule = sld.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0] 
648   
649          self.assertFalse( rule.PolygonSymbolizer.Fill is None ) 
650   
651          del rule.PolygonSymbolizer.Fill 
652   
653          self.assertTrue( rule.PolygonSymbolizer.Fill is None ) 
654           
655          sld.normalize() 
656          self.assertTrue(sld.validate()) 

657   

659          """ 
660          Test the construction of a Fill property. 
661          """ 
662          sld = copy.deepcopy(self._sld1) 
663          namedlayer = sld.create_namedlayer('test named layer') 
664          userstyle = namedlayer.create_userstyle() 
665          featuretypestyle = userstyle.create_featuretypestyle() 
666          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
667          symbolizer = rule.create_symbolizer('Polygon') 
668          fill = symbolizer.create_fill() 
669   
670          self.assertFalse( fill.CssParameters is None ) 
671          self.assertEqual( len(fill.CssParameters), 0 ) 
672          
673          sld.normalize() 
674          self.assertTrue(sld.validate()) 

675           

676 -    def test_fill_cssparameter1(self): 

677          """ 
678          Test the parsing of the CssParameter property. 
679          """ 
680          fill = self._sld0.NamedLayer.UserStyle.FeatureTypeStyle.Rules[0].PolygonSymbolizer.Fill 
681   
682          self.assertFalse( fill.CssParameters is None ) 
683          self.assertEqual( len(fill.CssParameters), 1 ) 
684   
685          fill = self._sld0.NamedLayer.UserStyle.FeatureTypeStyle.Rules[5].LineSymbolizer.Stroke 
686   
687          self.assertFalse( fill.CssParameters is None ) 
688          self.assertEqual( len(fill.CssParameters), 2 ) 

689   

690 -    def test_fill_cssparameter2(self): 

691          """ 
692          Test the construction of the CssParameter property. 
693          """ 
694          sld = copy.deepcopy(self._sld1) 
695          namedlayer = sld.create_namedlayer('test named layer') 
696          userstyle = namedlayer.create_userstyle() 
697          featuretypestyle = userstyle.create_featuretypestyle() 
698          rule = featuretypestyle.create_rule('test rule', PointSymbolizer) 
699          symbolizer = rule.create_symbolizer('Polygon') 
700          fill = symbolizer.create_fill() 
701          parameter = fill.create_cssparameter('fill', '#ffffff') 
702   
703          self.assertEqual( len(fill.CssParameters), 1 ) 
704          self.assertEqual( fill.CssParameters[0].Name, 'fill' ) 
705          self.assertEqual( fill.CssParameters[0].Value, '#ffffff' ) 
706           
707          sld.normalize() 
708          self.assertTrue(sld.validate()) 

709   
710  if __name__ == '__main__': 
711      unittest.main() 
712

   Home       Trees       Indices       Help   
python-sld
Generated by Epydoc 3.0.1 on Tue Jan 3 14:45:15 2012 http://epydoc.sourceforge.net