6720056456

Committed 01 Nov 2023 01:06PM UTC coverage: 84.061% (+2.7%) from 81.332%

Build # 6720056456

Build Type

push

github

Committed by

web-flow

Commit Message

fix tests (#687)



* skip py37

Run Details

5374 of 6393 relevant lines covered (84.06%)

0.84 hits per line

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

90.1

/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()

    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')	1✔
80	gml_input.stream.close()	1✔
81
82	def test_json_validator(self):	1✔
83	"""Test GeoJSON validator
84	"""
85	json_input = self.get_input('json/point.geojson', None, FORMATS.JSON.mime_type)	1✔
86	self.assertTrue(validatejson(json_input, MODE.NONE), 'NONE validation')	1✔
87	self.assertTrue(validatejson(json_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
88	self.assertTrue(validatejson(json_input, MODE.STRICT), 'STRICT validation')	1✔
89	json_input.stream.close()	1✔
90
91	def test_geojson_validator(self):	1✔
92	"""Test GeoJSON validator
93	"""
94	geojson_input = self.get_input('json/point.geojson', 'json/schema/geojson.json',	1✔
95	FORMATS.GEOJSON.mime_type)
96	self.assertTrue(validategeojson(geojson_input, MODE.NONE), 'NONE validation')	1✔
97	self.assertTrue(validategeojson(geojson_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
98	self.assertTrue(validategeojson(geojson_input, MODE.STRICT), 'STRICT validation')	1✔
99	self.assertTrue(validategeojson(geojson_input, MODE.VERYSTRICT), 'VERYSTRICT validation')	1✔
100	geojson_input.stream.close()	1✔
101
102	def test_shapefile_validator(self):	1✔
103	"""Test ESRI Shapefile validator
104	"""
105	shapefile_input = self.get_input('shp/point.shp.zip', None,	1✔
106	FORMATS.SHP.mime_type)
107	self.assertTrue(validateshapefile(shapefile_input, MODE.NONE), 'NONE validation')	1✔
108	self.assertTrue(validateshapefile(shapefile_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
109	self.assertTrue(validateshapefile(shapefile_input, MODE.STRICT), 'STRICT validation')	1✔
110	shapefile_input.stream.close()	1✔
111
112	def test_geotiff_validator(self):	1✔
113	"""Test GeoTIFF validator
114	"""
115	geotiff_input = self.get_input('geotiff/dem.tiff', None,	1✔
116	FORMATS.GEOTIFF.mime_type)
117	self.assertTrue(validategeotiff(geotiff_input, MODE.NONE), 'NONE validation')	1✔
118	self.assertTrue(validategeotiff(geotiff_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
119	self.assertTrue(validategeotiff(geotiff_input, MODE.STRICT), 'STRICT validation')	1✔
120	geotiff_input.stream.close()	1✔
121
122	def test_netcdf_validator(self):	1✔
123	"""Test netCDF validator
124	"""
125	netcdf_input = self.get_input('netcdf/time.nc', None, FORMATS.NETCDF.mime_type)	1✔
126	self.assertTrue(validatenetcdf(netcdf_input, MODE.NONE), 'NONE validation')	1✔
127	self.assertTrue(validatenetcdf(netcdf_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
128	netcdf_input.stream.close()	1✔
129	if WITH_NC4:	1✔
130	self.assertTrue(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')	1✔
131	netcdf_input.file = 'grub.nc'	1✔
132	self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT))	1✔
133	else:
134	self.assertFalse(validatenetcdf(netcdf_input, MODE.STRICT), 'STRICT validation')	×
135
136	@pytest.mark.xfail(reason="test.opendap.org is offline")	1✔
137	def test_dods_validator(self):	1✔
138	opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,])	1✔
139	opendap_input.url = "http://test.opendap.org:80/opendap/netcdf/examples/sresa1b_ncar_ccsm3_0_run1_200001.nc"	1✔
140	self.assertTrue(validatedods(opendap_input, MODE.NONE), 'NONE validation')	1✔
141	self.assertTrue(validatedods(opendap_input, MODE.SIMPLE), 'SIMPLE validation')	1✔
142
143	if WITH_NC4:	1✔
144	self.assertTrue(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')	1✔
145	opendap_input.url = 'Faulty url'	1✔
146	self.assertFalse(validatedods(opendap_input, MODE.STRICT))	1✔
147	else:
148	self.assertFalse(validatedods(opendap_input, MODE.STRICT), 'STRICT validation')	×
149
150	def test_dods_default(self):	1✔
151	opendap_input = ComplexInput('dods', 'opendap test', [FORMATS.DODS,],	1✔
152	default='http://test.opendap.org',
153	default_type=SOURCE_TYPE.URL,
154	mode=MODE.SIMPLE)
155
156	def test_fail_validator(self):	1✔
157	fake_input = self.get_input('point.xsd', 'point.xsd', FORMATS.SHP.mime_type)	1✔
158	self.assertFalse(validategml(fake_input, MODE.SIMPLE), 'SIMPLE validation invalid')	1✔
159	fake_input.stream.close()	1✔
160
161
162	def load_tests(loader=None, tests=None, pattern=None):	1✔
163	import unittest	×
164
165	if not loader:	×
166	loader = unittest.TestLoader()	×
167	suite_list = [	×
168	loader.loadTestsFromTestCase(ValidateTest)
169	]
170	return unittest.TestSuite(suite_list)	×

geopython / pywps / 6720056456

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