[sextante] more tests

python/plugins/sextante/algs/AutoincrementalField.py

@@ -45,7 +45,7 @@ class AutoincrementalField(GeoAlgorithm):
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
         vprovider = vlayer.dataProvider()
         fields = vprovider.fields()
-        fields[len(fields)] = QgsField("AUTO", QVariant.Int)
+        fields.append(QgsField("AUTO", QVariant.Int))
         writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
@@ -58,10 +58,10 @@ class AutoincrementalField(GeoAlgorithm):
             nElement += 1
             inGeom = inFeat.geometry()
             outFeat.setGeometry( inGeom )
-            atMap = inFeat.attributeMap()
+            attrs = inFeat.attributes()
-            atMap.append(QVariant(nElement))
+            attrs.append(QVariant(nElement))
-            outFeat.setAttributeMap( atMap )
+            outFeat.setAttributes(attrs)
-            writer.addFeature( outFeat )
+            writer.addFeature(outFeat)
         del writer
 
     def defineCharacteristics(self):

python/plugins/sextante/algs/ftools/Dissolve.py

@@ -56,7 +56,6 @@ class Dissolve(GeoAlgorithm):
         vproviderA = vlayerA.dataProvider()
         fields = vproviderA.fields()
         writer = self.getOutputFromName(Dissolve.OUTPUT).getVectorWriter(fields, vproviderA.geometryType(), vproviderA.crs() )
-        #inFeat = QgsFeature()
         outFeat = QgsFeature()
         nElement = 0
         nFeat = vproviderA.featureCount()

python/plugins/sextante/script/ScriptAlgorithm.py

@@ -204,12 +204,10 @@ class ScriptAlgorithm(GeoAlgorithm):
         ns['progress'] = progress
 
         for param in self.parameters:
-            #script += param.name + "=" + param.getValueAsCommandLineParameter() + "\n"
             ns[param.name] = param.value
 
         for out in self.outputs:
             ns[out.name] = out.value
-            #script += out.name + "=" + out.getValueAsCommandLineParameter() + "\n"
 
         script+=self.script
         exec(script) in ns

python/plugins/sextante/tests/QgisAlgsTest.py

@@ -4,7 +4,7 @@ from sextante.tests.TestData import points, points2, polygons, polygons2, lines,
     table
 from sextante.core.QGisLayers import QGisLayers
 
-class AlgTests(unittest.TestCase):
+class QgisAlgsTest(unittest.TestCase):
     
     def test_qgiscountpointsinpolygon(self):
         outputs=sextante.runalg("qgis:countpointsinpolygon",polygons(),points(),"NUMPOINTS",None)
@@ -660,26 +660,26 @@ class AlgTests(unittest.TestCase):
         wkt='POLYGON((270818.44773413 4458997.23886624,270833.27466046 4458983.16267036,270830.83478651 4458975.28000067,270822.38906898 4458967.20964836,270823.32748204 4458959.70234389,270822.7644342 4458958.01320039,270818.44773413 4458997.23886624))'
         self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
                 
-def test_qgisunion(self):
+    def test_qgisunion(self):
-    outputs=sextante.runalg("qgis:union",polygons(),polygons2(),None)
+        outputs=sextante.runalg("qgis:union",polygons(),polygons2(),None)
-    output=outputs['OUTPUT']
+        output=outputs['OUTPUT']
-    layer=QGisLayers.getObjectFromUri(output, True)
+        layer=QGisLayers.getObjectFromUri(output, True)
-    fields=layer.pendingFields()
+        fields=layer.pendingFields()
-    expectednames=['ID','POLY_NUM_A','POLY_ST_A','id_2','POLY_NUM_B','POLY_ST_B']
+        expectednames=['ID','POLY_NUM_A','POLY_ST_A','id_2','POLY_NUM_B','POLY_ST_B']
-    expectedtypes=['Integer','Real','String','Integer','Real','String']
+        expectedtypes=['Integer','Real','String','Integer','Real','String']
-    names=[str(f.name()) for f in fields]
+        names=[str(f.name()) for f in fields]
-    types=[str(f.typeName()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
-    self.assertEqual(expectednames, names)
+        self.assertEqual(expectednames, names)
-    self.assertEqual(expectedtypes, types)
+        self.assertEqual(expectedtypes, types)
-    features=sextante.getfeatures(layer)
+        features=sextante.getfeatures(layer)
-    self.assertEqual(8, len(features))
+        self.assertEqual(8, len(features))
-    feature=features.next()
+        feature=features.next()
-    attrs=feature.attributes()
+        attrs=feature.attributes()
-    expectedvalues=["1","1.1","string a","2","1","string a"]
+        expectedvalues=["1","1.1","string a","2","1","string a"]
-    values=[str(attr.toString()) for attr in attrs]
+        values=[str(attr.toString()) for attr in attrs]
-    self.assertEqual(expectedvalues, values)
+        self.assertEqual(expectedvalues, values)
-    wkt='POLYGON((270807.08580285 4458940.1594565,270798.42294527 4458914.62661676,270780.81854858 4458914.21983449,270763.52289518 4458920.715993,270760.3449542 4458926.6570575,270763.78234766 4458958.22561242,270794.30290024 4458942.16424502,270807.08580285 4458940.1594565))'
+        wkt='POLYGON((270807.08580285 4458940.1594565,270798.42294527 4458914.62661676,270780.81854858 4458914.21983449,270763.52289518 4458920.715993,270760.3449542 4458926.6570575,270763.78234766 4458958.22561242,270794.30290024 4458942.16424502,270807.08580285 4458940.1594565))'
-    self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
     
     def test_qgisclip(self):
         outputs=sextante.runalg("qgis:clip",polygons(),polygons2(),None)
@@ -745,8 +745,175 @@ def test_qgisunion(self):
         wkt='POLYGON((270807.08580285 4458940.1594565,270798.42294527 4458914.62661676,270780.81854858 4458914.21983449,270763.52289518 4458920.715993,270760.3449542 4458926.6570575,270763.78234766 4458958.22561242,270794.30290024 4458942.16424502,270807.08580285 4458940.1594565))'
         self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
         
+    def test_qgisaddautoincrementalfield(self):
+        outputs=sextante.runalg("qgis:addautoincrementalfield",points(),None)
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','PT_NUM_A','PT_ST_A','AUTO']
+        expectedtypes=['Integer','Real','String','Integer']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(12, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","a","1"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POINT(270839.65586926 4458983.16267036)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))        
+                 
+    def test_qgisaddfieldtoattributestable(self):
+        outputs=sextante.runalg("qgis:addfieldtoattributestable",points(),"newfield",1,None)
+        output=outputs['OUTPUT_LAYER']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','PT_NUM_A','PT_ST_A','newfield']
+        expectedtypes=['Integer','Real','String','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(12, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","a",""]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POINT(270839.65586926 4458983.16267036)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        
+    def test_qgiscreateequivalentnumericalfield(self):
+        outputs=sextante.runalg("qgis:createequivalentnumericalfield",points2(),"POLY_ST_A",None)
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','POLY_NUM_A','POLY_ST_A','ID_2','POLY_NUM_B','POLY_ST_B','NUM_FIELD']
+        expectedtypes=['Integer','Real','String','Integer','Real','String','Integer']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(8, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","string a","2","1","string a","0"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POINT(270781.07973944 4458932.92171896)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        
+    def test_qgisdeletecolumn(self):
+        outputs=sextante.runalg("qgis:deletecolumn",points(),"PT_NUM_A",None)
+        output=outputs['SAVENAME']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','PT_ST_A']
+        expectedtypes=['Integer','String']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(12, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","a"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POINT(270839.65586926 4458983.16267036)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        
+    def test_qgisexportaddgeometrycolumnspoints(self):
+        outputs=sextante.runalg("qgis:exportaddgeometrycolumns",points(),0,None)
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','PT_NUM_A','PT_ST_A','xcoord','ycoord']
+        expectedtypes=['Integer','Real','String','Real','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(12, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","a","270839.655869","4458983.16267"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POINT(270839.65586926 4458983.16267036)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        
+        
+    def test_qgisexportaddgeometrycolumnslines(self):
+        outputs=sextante.runalg("qgis:exportaddgeometrycolumns",lines(),0,None)
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','LINE_NUM_A','LINE_ST_A','length']
+        expectedtypes=['Integer','Real','String','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(3, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","11.1","string a","49.724003"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='LINESTRING(270818.44773413 4458997.23886624, 270833.27466046 4458983.16267036, 270830.83478651 4458975.28000067, 270822.38906898 4458967.20964836, 270823.32748204 4458959.70234389, 270822.7644342 4458958.01320039)'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+        
+    def test_qgisexportaddgeometrycolumnspolygons(self):
+        outputs=sextante.runalg("qgis:exportaddgeometrycolumns",polygons(),0,None)
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','POLY_NUM_A','POLY_ST_A','area','perimeter']
+        expectedtypes=['Integer','Real','String','Real','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(2, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","string a","3543.718994","232.686821"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POLYGON((270771.63330111 4458992.35349302,270791.33997534 4458993.47958869,270799.03496242 4458993.10422346,270799.03496242 4458993.10422346,270815.36334964 4458986.91069727,270818.55395404 4458973.96059707,270798.42294527 4458914.62661676,270780.81854858 4458914.21983449,270759.84833131 4458922.09614031,270766.19050537 4458980.34180587,270771.63330111 4458992.35349302))'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))    
+        
+    def test_qgisstatisticsbycategories(self):
+        outputs=sextante.runalg("qgis:statisticsbycategories",points2(),"POLY_NUM_A","POLY_ST_B",None)
+        output=outputs['OUTPUT']    
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['Category','min','max','mean','stddev']
+        expectedtypes=['String','Real','Real','Real','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(3, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["NULL","1.1","2.2","1.925","0.55"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+                
 def suite():
-    suite = unittest.makeSuite(AlgTests, 'test')
+    suite = unittest.makeSuite(QgisAlgsTest, 'test')    
     return suite
 
 def runtests():
@@ -754,3 +921,4 @@ def runtests():
     testsuite = suite()
     testsuite.run(result)
     return result
+    

python/plugins/sextante/tests/RunAlgTest.py

@@ -0,0 +1,64 @@
+import sextante
+import unittest
+from sextante.tests.TestData import points, points2, polygons, polygons2, lines, union,\
+    table
+from sextante.core.QGisLayers import QGisLayers
+from sextante.core.SextanteUtils import SextanteUtils
+
+class ParametrizedTestCase(unittest.TestCase):
+
+    def __init__(self, methodName='runTest', useTempFiles=False):
+        super(ParametrizedTestCase, self).__init__(methodName)
+        self.useTempFiles = useTempFiles
+
+    @staticmethod
+    def parametrize(testcase_klass, useTempFiles):
+        testloader = unittest.TestLoader()
+        testnames = testloader.getTestCaseNames(testcase_klass)
+        suite = unittest.TestSuite()
+        for name in testnames:
+            suite.addTest(testcase_klass(name, useTempFiles=useTempFiles))
+        return suite
+    
+class RunAlgTest(ParametrizedTestCase):
+    '''This test takes a reduced set of algorithms and executes them in different ways, changing 
+    parameters such as whether to use thread or not, the output file format, etc. 
+    Basically, it uses some algorithms to test other parts of SEXTANTE, not the algorithms themselves'''
+           
+    def getOutputFile(self):
+        if self.useTempFiles:
+            return None
+        else:
+            return SextanteUtils.getTempFilename('shp')
+    
+    def test_qgiscountpointsinpolygon(self):
+        outputs=sextante.runalg("qgis:countpointsinpolygon",polygons(),points(),"NUMPOINTS", self.getOutputFile())
+        output=outputs['OUTPUT']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['ID','POLY_NUM_A','POLY_ST_A','NUMPOINTS']
+        expectedtypes=['Integer','Real','String','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(2, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["1","1.1","string a","6"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+                
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(ParametrizedTestCase.parametrize(RunAlgTest, False))
+    suite.addTest(ParametrizedTestCase.parametrize(RunAlgTest, True))    
+    return suite
+
+def runtests():
+    result = unittest.TestResult()    
+    testsuite = suite()
+    testsuite.run(result)
+    return result
+    

python/plugins/sextante/tests/ScriptTest.py

@@ -0,0 +1,59 @@
+import sextante
+import unittest
+from sextante.tests.TestData import points, points2, polygons, polygons2, lines, union,\
+    table
+from sextante.core.QGisLayers import QGisLayers
+
+class ScriptTest(unittest.TestCase):
+    
+    def test_scriptcreatetilingfromvectorlayer(self):
+        outputs=sextante.runalg("script:createtilingfromvectorlayer",union(),10,None)
+        output=outputs['polygons']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['longitude','latitude']
+        expectedtypes=['Real','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(10, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["270761.415396242","4458948.29588823"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POLYGON((270755.54427424 4458901.23378639,270755.54427424 4458995.35799007,270767.28651824 4458995.35799007,270767.28651824 4458901.23378639,270755.54427424 4458901.23378639))'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+            
+    def test_scripthexgridfromlayerbounds(self):
+        outputs=sextante.runalg("script:hexgridfromlayerbounds",polygons(),10,None)
+        output=outputs['grid']
+        layer=QGisLayers.getObjectFromUri(output, True)
+        fields=layer.pendingFields()
+        expectednames=['longitude','latitude']
+        expectedtypes=['Real','Real']
+        names=[str(f.name()) for f in fields]
+        types=[str(f.typeName()) for f in fields]
+        self.assertEqual(expectednames, names)
+        self.assertEqual(expectedtypes, types)
+        features=sextante.getfeatures(layer)
+        self.assertEqual(117, len(features))
+        feature=features.next()
+        attrs=feature.attributes()
+        expectedvalues=["270765.621834001","4458907.27146471"]
+        values=[str(attr.toString()) for attr in attrs]
+        self.assertEqual(expectedvalues, values)
+        wkt='POLYGON((270771.39533669 4458907.27146471,270768.50858535 4458902.27146471,270762.73508265 4458902.27146471,270759.84833131 4458907.27146471,270762.73508265 4458912.27146471,270768.50858535 4458912.27146471,270771.39533669 4458907.27146471))'
+        self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
+            
+def suite():
+    suite = unittest.makeSuite(ScriptTest, 'test')    
+    return suite
+
+def runtests():
+    result = unittest.TestResult()    
+    testsuite = suite()
+    testsuite.run(result)
+    return result