16372983163

Committed 18 Jul 2025 02:24PM UTC coverage: 84.089% (+0.03%) from 84.061%

Build # 16372983163

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #694 from geopython/fix-lint

fixed linting issues and test failures

Run Details

5 of 5 new or added lines in 2 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

5380 of 6398 relevant lines covered (84.09%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.52

/tests/validator/test_complexvalidators.py

##################################################################
# Copyright 2018 Open Source Geospatial Foundation and others    #
# licensed under MIT, Please consult LICENSE.txt for details     #
##################################################################

"""Unit tests for complex validator
"""

from basic import TestBase
import pytest
from pywps.validator.mode import MODE
from pywps.validator.complexvalidator import (
    validategml,
    # validategpx,
    # validatexml,
    validatejson,
    validategeojson,
    validateshapefile,
    validategeotiff,
    validatenetcdf,
    validatedods,
)
from pywps.inout.formats import FORMATS
from pywps import ComplexInput
from pywps.inout.basic import SOURCE_TYPE
import tempfile
import os


try:
    import netCDF4  # noqa
except ImportError:
    WITH_NC4 = False
else:
    WITH_NC4 = True


class ValidateTest(TestBase):
    """Complex validator test cases"""

    def get_input(self, name, schema, mime_type):

        class FakeFormat(object):
            mimetype = 'text/plain'
            schema = None
            units = None

            def validate(self, data):
                return True

        class FakeInput(object):
            tempdir = tempfile.mkdtemp(dir=self.tmpdir.name)
            file = os.path.join(
                os.path.abspath(os.path.dirname(__file__)),
                '..', 'data', name)
            format = FakeFormat()

        class data_format(object):
            file = os.path.join(
                os.path.abspath(os.path.dirname(__file__)),
                '..', 'data', str(schema))

        fake_input = FakeInput()
        fake_input.stream = open(fake_input.file)
        fake_input.data_format = data_format()
        if schema:
            fake_input.data_format.schema = 'file://' + fake_input.data_format.file
        fake_input.data_format.mime_type = mime_type

        return fake_input

    def test_gml_validator(self):
        """Test GML validator
        """
        gml_input = self.get_input('gml/point.gml', 'point.xsd', FORMATS.GML.mime_type)
        self.assertTrue(validategml(gml_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validategml(gml_input, MODE.SIMPLE), 'SIMPLE validation')
        self.assertTrue(validategml(gml_input, MODE.STRICT), 'STRICT validation')
        # self.assertTrue(validategml(gml_input, MODE.VERYSTRICT), 'VERYSTRICT validation')
        gml_input.stream.close()

    @pytest.mark.xfail(reason="gml verystrict validation fails")
    def test_gml_validator_verystrict(self):
        """Test GML validator
        """
        gml_input = self.get_input('gml/point.gml', 'point.xsd', FORMATS.GML.mime_type)
        self.assertTrue(validategml(gml_input, MODE.VERYSTRICT), 'VERYSTRICT validation')
        gml_input.stream.close()

    def test_json_validator(self):
        """Test GeoJSON validator
        """
        json_input = self.get_input('json/point.geojson', None, FORMATS.JSON.mime_type)
        self.assertTrue(validatejson(json_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validatejson(json_input, MODE.SIMPLE), 'SIMPLE validation')
        self.assertTrue(validatejson(json_input, MODE.STRICT), 'STRICT validation')
        json_input.stream.close()

    def test_geojson_validator(self):
        """Test GeoJSON validator
        """
        geojson_input = self.get_input('json/point.geojson', 'json/schema/geojson.json',
                                  FORMATS.GEOJSON.mime_type)
        self.assertTrue(validategeojson(geojson_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validategeojson(geojson_input, MODE.SIMPLE), 'SIMPLE validation')
        self.assertTrue(validategeojson(geojson_input, MODE.STRICT), 'STRICT validation')
        self.assertTrue(validategeojson(geojson_input, MODE.VERYSTRICT), 'VERYSTRICT validation')
        geojson_input.stream.close()

    def test_shapefile_validator(self):
        """Test ESRI Shapefile validator
        """
        shapefile_input = self.get_input('shp/point.shp.zip', None,
                FORMATS.SHP.mime_type)
        self.assertTrue(validateshapefile(shapefile_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validateshapefile(shapefile_input, MODE.SIMPLE), 'SIMPLE validation')
        self.assertTrue(validateshapefile(shapefile_input, MODE.STRICT), 'STRICT validation')
        shapefile_input.stream.close()

    def test_geotiff_validator(self):
        """Test GeoTIFF validator
        """
        geotiff_input = self.get_input('geotiff/dem.tiff', None,
                                  FORMATS.GEOTIFF.mime_type)
        self.assertTrue(validategeotiff(geotiff_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validategeotiff(geotiff_input, MODE.SIMPLE), 'SIMPLE validation')
        self.assertTrue(validategeotiff(geotiff_input, MODE.STRICT), 'STRICT validation')
        geotiff_input.stream.close()

    def test_netcdf_validator(self):
        """Test netCDF validator
        """
        netcdf_input = self.get_input('netcdf/time.nc', None, FORMATS.NETCDF.mime_type)
        self.assertTrue(validatenetcdf(netcdf_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validatenetcdf(netcdf_input, MODE.SIMPLE), 'SIMPLE validation')
        netcdf_input.stream.close()
        if WITH_NC4:
            self.assertTrue(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')
            netcdf_input.file = 'grub.nc'
            self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT))
        else:
            self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')

    @pytest.mark.xfail(reason="test.opendap.org is offline")
    def test_dods_validator(self):
        opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,])
        opendap_input.url = "http://test.opendap.org:80/opendap/netcdf/examples/sresa1b_ncar_ccsm3_0_run1_200001.nc"
        self.assertTrue(validatedods(opendap_input, MODE.NONE), 'NONE validation')
        self.assertTrue(validatedods(opendap_input, MODE.SIMPLE), 'SIMPLE validation')

        if WITH_NC4:
            self.assertTrue(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')
            opendap_input.url = 'Faulty url'
            self.assertFalse(validatedods(opendap_input, MODE.STRICT))
        else:
            self.assertFalse(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')

    def test_dods_default(self):
        opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,],
                                     default='http://test.opendap.org',
                                     default_type=SOURCE_TYPE.URL,
                                     mode=MODE.SIMPLE)

    def test_fail_validator(self):
        fake_input = self.get_input('point.xsd', 'point.xsd', FORMATS.SHP.mime_type)
        self.assertFalse(validategml(fake_input, MODE.SIMPLE), 'SIMPLE validation invalid')
        fake_input.stream.close()


def load_tests(loader=None, tests=None, pattern=None):
    import unittest

    if not loader:
        loader = unittest.TestLoader()
    suite_list = [
        loader.loadTestsFromTestCase(ValidateTest)
    ]
    return unittest.TestSuite(suite_list)

1	##################################################################
2	# Copyright 2018 Open Source Geospatial Foundation and others #
3	# licensed under MIT, Please consult LICENSE.txt for details #
4	##################################################################
5
6	"""Unit tests for complex validator	1✔
7	"""
8
9	from basic import TestBase	1✔
10	import pytest	1✔
11	from pywps.validator.mode import MODE	1✔
12	from pywps.validator.complexvalidator import (	1✔
13	validategml,
14	# validategpx,
15	# validatexml,
16	validatejson,
17	validategeojson,
18	validateshapefile,
19	validategeotiff,
20	validatenetcdf,
21	validatedods,
22	)
23	from pywps.inout.formats import FORMATS	1✔
24	from pywps import ComplexInput	1✔
25	from pywps.inout.basic import SOURCE_TYPE	1✔
26	import tempfile	1✔
27	import os	1✔
28
29
30	try:	1✔
31	import netCDF4 # noqa	1✔
32	except ImportError:	×
33	WITH_NC4 = False	×
34	else:
35	WITH_NC4 = True	1✔
36
37
38	class ValidateTest(TestBase):	1✔
39	"""Complex validator test cases"""
40
41	def get_input(self, name, schema, mime_type):	1✔
42
43	class FakeFormat(object):	1✔
44	mimetype = 'text/plain'	1✔
45	schema = None	1✔
46	units = None	1✔
47
48	def validate(self, data):	1✔
49	return True	×
50
51	class FakeInput(object):	1✔
52	tempdir = tempfile.mkdtemp(dir=self.tmpdir.name)	1✔
53	file = os.path.join(	1✔
54	os.path.abspath(os.path.dirname(__file__)),
55	'..', 'data', name)
56	format = FakeFormat()	1✔
57
58	class data_format(object):	1✔
59	file = os.path.join(	1✔
60	os.path.abspath(os.path.dirname(__file__)),
61	'..', 'data', str(schema))
62
63	fake_input = FakeInput()	1✔
64	fake_input.stream = open(fake_input.file)	1✔
65	fake_input.data_format = data_format()	1✔
66	if schema:	1✔
67	fake_input.data_format.schema = 'file://' + fake_input.data_format.file	1✔
68	fake_input.data_format.mime_type = mime_type	1✔
69
70	return fake_input	1✔
71
72	def test_gml_validator(self):	1✔
73	"""Test GML validator
74	"""
75	gml_input = self.get_input('gml/point.gml', 'point.xsd', FORMATS.GML.mime_type)	1✔
76	self.assertTrue(validategml(gml_input, MODE.NONE), 'NONE validation')	1✔
77	self.assertTrue(validategml(gml_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
78	self.assertTrue(validategml(gml_input, MODE.STRICT), 'STRICT validation')	1✔
79	# self.assertTrue(validategml(gml_input, MODE.VERYSTRICT), 'VERYSTRICT validation')
80	gml_input.stream.close()	1✔
81
82	@pytest.mark.xfail(reason="gml verystrict validation fails")	1✔
83	def test_gml_validator_verystrict(self):	1✔
84	"""Test GML validator
85	"""
86	gml_input = self.get_input('gml/point.gml', 'point.xsd', FORMATS.GML.mime_type)	1✔
87	self.assertTrue(validategml(gml_input, MODE.VERYSTRICT), 'VERYSTRICT validation')	1✔
UNCOV 88	gml_input.stream.close()	×
89
90	def test_json_validator(self):	1✔
91	"""Test GeoJSON validator
92	"""
93	json_input = self.get_input('json/point.geojson', None, FORMATS.JSON.mime_type)	1✔
94	self.assertTrue(validatejson(json_input, MODE.NONE), 'NONE validation')	1✔
95	self.assertTrue(validatejson(json_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
96	self.assertTrue(validatejson(json_input, MODE.STRICT), 'STRICT validation')	1✔
97	json_input.stream.close()	1✔
98
99	def test_geojson_validator(self):	1✔
100	"""Test GeoJSON validator
101	"""
102	geojson_input = self.get_input('json/point.geojson', 'json/schema/geojson.json',	1✔
103	FORMATS.GEOJSON.mime_type)
104	self.assertTrue(validategeojson(geojson_input, MODE.NONE), 'NONE validation')	1✔
105	self.assertTrue(validategeojson(geojson_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
106	self.assertTrue(validategeojson(geojson_input, MODE.STRICT), 'STRICT validation')	1✔
107	self.assertTrue(validategeojson(geojson_input, MODE.VERYSTRICT), 'VERYSTRICT validation')	1✔
108	geojson_input.stream.close()	1✔
109
110	def test_shapefile_validator(self):	1✔
111	"""Test ESRI Shapefile validator
112	"""
113	shapefile_input = self.get_input('shp/point.shp.zip', None,	1✔
114	FORMATS.SHP.mime_type)
115	self.assertTrue(validateshapefile(shapefile_input, MODE.NONE), 'NONE validation')	1✔
116	self.assertTrue(validateshapefile(shapefile_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
117	self.assertTrue(validateshapefile(shapefile_input, MODE.STRICT), 'STRICT validation')	1✔
118	shapefile_input.stream.close()	1✔
119
120	def test_geotiff_validator(self):	1✔
121	"""Test GeoTIFF validator
122	"""
123	geotiff_input = self.get_input('geotiff/dem.tiff', None,	1✔
124	FORMATS.GEOTIFF.mime_type)
125	self.assertTrue(validategeotiff(geotiff_input, MODE.NONE), 'NONE validation')	1✔
126	self.assertTrue(validategeotiff(geotiff_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
127	self.assertTrue(validategeotiff(geotiff_input, MODE.STRICT), 'STRICT validation')	1✔
128	geotiff_input.stream.close()	1✔
129
130	def test_netcdf_validator(self):	1✔
131	"""Test netCDF validator
132	"""
133	netcdf_input = self.get_input('netcdf/time.nc', None, FORMATS.NETCDF.mime_type)	1✔
134	self.assertTrue(validatenetcdf(netcdf_input, MODE.NONE), 'NONE validation')	1✔
135	self.assertTrue(validatenetcdf(netcdf_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
136	netcdf_input.stream.close()	1✔
137	if WITH_NC4:	1✔
138	self.assertTrue(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')	1✔
139	netcdf_input.file = 'grub.nc'	1✔
140	self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT))	1✔
141	else:
142	self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')	×
143
144	@pytest.mark.xfail(reason="test.opendap.org is offline")	1✔
145	def test_dods_validator(self):	1✔
146	opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,])	1✔
147	opendap_input.url = "http://test.opendap.org:80/opendap/netcdf/examples/sresa1b_ncar_ccsm3_0_run1_200001.nc"	1✔
148	self.assertTrue(validatedods(opendap_input, MODE.NONE), 'NONE validation')	1✔
149	self.assertTrue(validatedods(opendap_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
150
151	if WITH_NC4:	1✔
152	self.assertTrue(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')	1✔
153	opendap_input.url = 'Faulty url'	1✔
154	self.assertFalse(validatedods(opendap_input, MODE.STRICT))	1✔
155	else:
156	self.assertFalse(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')	×
157
158	def test_dods_default(self):	1✔
159	opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,],	1✔
160	default='http://test.opendap.org',
161	default_type=SOURCE_TYPE.URL,
162	mode=MODE.SIMPLE)
163
164	def test_fail_validator(self):	1✔
165	fake_input = self.get_input('point.xsd', 'point.xsd', FORMATS.SHP.mime_type)	1✔
166	self.assertFalse(validategml(fake_input, MODE.SIMPLE), 'SIMPLE validation invalid')	1✔
167	fake_input.stream.close()	1✔
168
169
170	def load_tests(loader=None, tests=None, pattern=None):	1✔
171	import unittest	×
172
173	if not loader:	×
174	loader = unittest.TestLoader()	×
175	suite_list = [	×
176	loader.loadTestsFromTestCase(ValidateTest)
177	]
178	return unittest.TestSuite(suite_list)	×

geopython / pywps / 16372983163

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous