def test_wfs_get_capabilities(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_getcap_request()
request.params.update(
dict(
service="wfs",
version="1.1.1",
request="getcapabilities",
))
response = MapservProxy(request).proxy()
self.assertFalse(
(response.body).find("<Name>testpoint_protected</Name>") > 0)
request = self._create_getcap_request(username=u"__test_user1")
request.params.update(
dict(
service="wfs",
version="1.1.1",
request="getcapabilities",
))
response = MapservProxy(request).proxy()
self.assertTrue(
response.body.find("<Name>testpoint_protected</Name>") > 0)
def test_wfs_get_capabilities(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_getcap_request()
request.params.update(
dict(
service="wfs",
version="1.1.1",
request="getcapabilities",
))
response = MapservProxy(request).proxy()
assert "<Name>testpoint_protected</Name>" not in response.body.decode(
"utf-8")
# testpoint_group is not public so even unprotected layers are hidden:
assert "<Name>testpoint_unprotected</Name>" not in response.body.decode(
"utf-8")
assert "<Name>testpoint_group</Name>" not in response.body.decode(
"utf-8")
request = self._create_getcap_request(username="******")
request.params.update(
dict(
service="wfs",
version="1.1.1",
request="getcapabilities",
))
response = MapservProxy(request).proxy()
assert "<Name>testpoint_protected</Name>" in response.body.decode(
"utf-8")
assert "<Name>testpoint_unprotected</Name>" in response.body.decode(
"utf-8")
assert "<Name>testpoint_group</Name>" not in response.body.decode(
"utf-8")
def test_wms_get_capabilities(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_getcap_request()
request.params.update(dict(
service="wms", version="1.1.1", request="getcapabilities",
))
response = MapservProxy(request).proxy()
self.assertFalse((response.body).find("<Name>testpoint_protected</Name>") > 0)
self.assertFalse((response.body).find("<Name>testpoint_protected_2</Name>") > 0)
# testpoint_group is not public so even unprotected layers are hidden:
self.assertFalse((response.body).find("<Name>testpoint_unprotected</Name>") > 0)
self.assertFalse((response.body).find("<Name>testpoint_group</Name>") > 0)
# testpoint_group_2 is a standard group containing only protected layers
self.assertFalse((response.body).find("<Name>testpoint_group_2</Name>") > 0)
request = self._create_getcap_request(username=u"__test_user1")
request.params.update(dict(
service="wms", version="1.1.1", request="getcapabilities",
))
response = MapservProxy(request).proxy()
self.assertTrue(response.body.find("<Name>testpoint_protected</Name>") > 0)
self.assertTrue(response.body.find("<Name>testpoint_protected_2</Name>") > 0)
self.assertTrue((response.body).find("<Name>testpoint_unprotected</Name>") > 0)
self.assertTrue((response.body).find("<Name>testpoint_group</Name>") > 0)
self.assertTrue((response.body).find("<Name>testpoint_group_2</Name>") > 0)
def _wms_get_capabilities_config(ogcserver, service="wms", username=None):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = create_dummy_request(
{
"admin_interface": {
"available_functionalities": [
"mapserver_substitution",
"print_template",
]
},
"servers": {
"srv": "http://example.com"
},
"mapserverproxy": {
"default_ogc_server": ogcserver,
},
},
user=username)
request.params.update(
dict(
service=service,
version="1.1.1",
request="getcapabilities",
))
return MapservProxy(request).proxy()
def test_get_feature_info_jsonp(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.params.update(
dict(service="wms",
version="1.1.1",
request="getfeatureinfo",
bbox="-90,-45,90,0",
layers="testpoint_unprotected",
query_layers="testpoint_unprotected",
srs="EPSG:21781",
format="image/png",
info_format="application/vnd.ogc.gml",
width="600",
height="400",
x="0",
y="400",
callback="cb"))
response = MapservProxy(request).proxy()
expected_response = """
<?xmlversion="1.0"encoding="UTF-8"?>
<msGMLOutput
xmlns:gml="http://www.opengis.net/gml"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<testpoint_unprotected_layer>
<gml:name>countries</gml:name>
<testpoint_unprotected_feature>
<gml:boundedBy>
<gml:Box srsName="EPSG:21781">
<gml:coordinates>-90.000000,-45.000000 -90.000000,-45.000000</gml:coordinates>
</gml:Box>
</gml:boundedBy>
<the_geom>
<gml:Point srsName="EPSG:21781">
<gml:coordinates>-90.000000,-45.000000</gml:coordinates>
</gml:Point>
</the_geom>
<name>foo</name>
<city>Lausanne</city>
<country>Swiss</country>
</testpoint_unprotected_feature>
</testpoint_unprotected_layer>
</msGMLOutput>
"""
import re
pattern = re.compile(r"\s+")
expected_response = "".join(
re.sub(pattern, "", l) for l in expected_response.splitlines())
expected_response = "%s('%s');" % ("cb", expected_response)
response_body = "".join(
re.sub(pattern, "", l) for l in response.body.splitlines())
self.assertEqual(response_body, expected_response)
self.assertFalse(response.cache_control.public)
self.assertEqual(str(response.cache_control), "no-cache")
def test_GetLegendGraphic(self):
request = self._create_dummy_request()
request.params.update(dict(service='wms', version='1.1.1',
request='getlegendgraphic',
layer='testpoint_unprotected',
srs='EPSG:21781',
format='image/png',
extraparam=u'with spéciàl chârs'))
response = MapservProxy(request).proxy()
self.assertTrue(response.cache_control.public)
self.assertEqual(response.cache_control.max_age, 1000)
def GetFeature_IsLike(self, value):
request = self._create_dummy_request()
request.method = 'POST'
request.body = (GETFEATURE_REQUEST % {
'feature': u'testpoint_unprotected',
'function': u'Like',
'arguments': u'wildCard="*" singleChar="." escapeChar="!"',
'property': u'name',
'value': value,
}).encode('utf-8')
return MapservProxy(request).proxy()
def GetFeature_IsNotEqualTo(self, value):
request = self._create_dummy_request()
request.method = 'POST'
request.body = (GETFEATURE_REQUEST % {
'feature': u'testpoint_unprotected',
'function': u'NotEqualTo',
'arguments': u'',
'property': u'name',
'value': value,
}).encode('utf-8')
return MapservProxy(request).proxy()
def test_GetFeatureInfo_JSONP(self):
request = self._create_dummy_request()
request.params.update(dict(
service='wms', version='1.1.1',
request='getfeatureinfo', bbox='-90,-45,90,0',
layers='testpoint_unprotected',
query_layers='testpoint_unprotected',
srs='EPSG:21781', format='image/png',
info_format='application/vnd.ogc.gml',
width='600', height='400', x='0', y='400',
callback='cb'
))
response = MapservProxy(request).proxy()
expected_response = """
<?xmlversion="1.0"encoding="UTF-8"?>
<msGMLOutput
xmlns:gml="http://www.opengis.net/gml"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<testpoint_unprotected_layer>
<gml:name>countries</gml:name>
<testpoint_unprotected_feature>
<gml:boundedBy>
<gml:Box srsName="EPSG:21781">
<gml:coordinates>-90.000000,-45.000000 -90.000000,-45.000000</gml:coordinates>
</gml:Box>
</gml:boundedBy>
<the_geom>
<gml:Point srsName="EPSG:21781">
<gml:coordinates>-90.000000,-45.000000</gml:coordinates>
</gml:Point>
</the_geom>
<name>foo</name>
<city>Lausanne</city>
<country>Swiss</country>
</testpoint_unprotected_feature>
</testpoint_unprotected_layer>
</msGMLOutput>
"""
import re
pattern = re.compile(r'\s+')
expected_response = ''.join(
re.sub(pattern, '', l) for l in expected_response.splitlines()
)
expected_response = '%s(\'%s\');' % ('cb', expected_response)
response_body = ''.join(
re.sub(pattern, '', l) for l in response.body.splitlines()
)
self.assertEqual(response_body, expected_response)
self.assertFalse(response.cache_control.public)
self.assertEqual(str(response.cache_control), "no-cache")
def test_GetMap_protected_layer_user2(self):
request = self._create_dummy_request(username=u'__test_user2')
request.params.update(dict(
service='wms', version='1.1.1', request='getmap',
bbox='-180,-90,180,90', layers='testpoint_protected',
width='600', height='400', srs='EPSG:21781', format='image/png'
))
response = MapservProxy(request).proxy()
self.assertEqual(str(response.cache_control), "no-cache")
# empty
md5sum = hashlib.md5(response.body).hexdigest()
self.assertEquals(md5sum, 'ef33223235b26c782736c88933b35331')
def test_geoserver(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_getcap_request(username="******", additional_settings={
"mapserverproxy": {
"default_ogc_server": "__test_ogc_server_geoserver",
}
})
request.params.update(dict(
service="wms", version="1.1.1", request="getcapabilities",
))
response = MapservProxy(request).proxy()
assert "<Name>testpoint_protected</Name>" in response.body.decode("utf-8")
def _get_feature_is_equal_to(self, value):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.method = "POST"
request.body = (GETFEATURE_REQUEST % {
"feature": u"testpoint_unprotected",
"function": u"EqualTo",
"arguments": u"",
"property": u"name",
"value": value,
}).encode("utf-8")
return MapservProxy(request).proxy()
def _get_feature_is_like(self, value):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.method = "POST"
request.body = (GETFEATURE_REQUEST % {
"feature": u"testpoint_unprotected",
"function": u"Like",
"arguments": u'wildCard="*" singleChar="." escapeChar="!"',
"property": u"name",
"value": value,
}).encode("utf-8")
return MapservProxy(request).proxy()
def test_GetMap_protected_layer_collect_query_user3(self):
request = self._create_dummy_request(username=u'__test_user3')
request.params.update(dict(
service='wms', version='1.1.1', request='getmap',
bbox='-180,-90,180,90', layers='testpoint_protected_query_with_collect',
width='600', height='400', srs='EPSG:21781', format='image/png'
))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertEqual(str(response.cache_control), "no-cache")
# two points
md5sum = hashlib.md5(response.body).hexdigest()
self.assertEquals(md5sum, '0a4fac2209d06c6fa36048c125b1679a')
def test_GetMap_unprotected_layer_user2(self):
request = self._create_dummy_request(username=u'__test_user2')
request.params.update(dict(
service='wms', version='1.1.1', request='getmap',
bbox='-180,-90,180,90', layers='testpoint_unprotected',
width='600', height='400', srs='EPSG:21781', format='image/png'
))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertEqual(str(response.cache_control), "no-cache")
# 4 points
md5sum = hashlib.md5(response.body).hexdigest()
self.assertEquals(md5sum, '61cbb0a6d18b72e4a28c1087019de245')
def test_get_map_protected_layer_user2(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request(username="******")
request.params.update(dict(
service="wms", version="1.1.1", request="getmap",
bbox="599820,199910,600180,200090", layers="testpoint_protected",
width="600", height="400", srs="EPSG:21781", format="image/png"
))
response = MapservProxy(request).proxy()
self.assertEqual(str(response.cache_control), "max-age=0, no-cache")
# empty
md5sum = hashlib.md5(response.body).hexdigest()
self.assertIn(md5sum, NO_POINT)
def _get_feature_is_not_equal_to(self, value):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.headers["Content-Type"] = "application/xml; charset=UTF-8"
request.method = "POST"
request.body = (GETFEATURE_REQUEST % {
"feature": "testpoint_unprotected",
"function": "NotEqualTo",
"arguments": "",
"property": "name",
"value": value,
}).encode("utf-8")
return MapservProxy(request).proxy()
def test_get_legend_graphic(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.params.update(
dict(service="wms",
version="1.1.1",
request="getlegendgraphic",
layer="testpoint_unprotected",
srs="EPSG:21781",
format="image/png",
extraparam=u"with spéciàl chârs"))
response = MapservProxy(request).proxy()
self.assertTrue(response.cache_control.public)
self.assertEqual(response.cache_control.max_age, 1000)
def test_GetFeature_FeatureId_GET_JSONP(self):
request = self._create_dummy_request()
featureid = '%(typename)s.%(fid1)s,%(typename)s.%(fid2)s' % {
'typename': 'testpoint_unprotected',
'fid1': self.id_lausanne,
'fid2': self.id_paris
}
request.params.update(dict(
service='wfs', version='1.0.0',
request='getfeature', typename='testpoint_unprotected',
featureid=featureid, callback='cb'
))
response = MapservProxy(request).proxy()
self.assertTrue('Lausanne' in response.body)
self.assertTrue('Paris' in response.body)
self.assertFalse('Londre' in response.body)
self.assertFalse('Chambéry' in response.body)
self.assertEqual(response.content_type, 'application/javascript')
def test_get_feature_external_wfs_url(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
featureid = "{typename!s}.{fid1!s},{typename!s}.{fid2!s}".format(
typename="testpoint_unprotected",
fid1=self.id_lausanne,
fid2=self.id_paris
)
request.params.update(dict(
service="wfs", version="1.0.0",
request="getfeature", typename="testpoint_unprotected",
featureid=featureid, callback="cb", EXTERNAL=1
))
response = MapservProxy(request).proxy()
self.assertTrue(response.body != "")
self.assertEqual(str(response.cache_control), "max-age=0, no-cache")
def test_GetFeature_external_wfs_url(self):
request = self._create_dummy_request()
request.registry.settings.update({
'external_mapserv_wfs_url': request.registry.settings['mapserv_url'],
})
featureid = '%(typename)s.%(fid1)s,%(typename)s.%(fid2)s' % {
'typename': 'testpoint_unprotected',
'fid1': self.id_lausanne,
'fid2': self.id_paris
}
request.params.update(dict(
service='wfs', version='1.0.0',
request='getfeature', typename='testpoint_unprotected',
featureid=featureid, callback='cb', EXTERNAL=1
))
response = MapservProxy(request).proxy()
self.assertTrue(response.body != '')
self.assertEqual(str(response.cache_control), "no-cache")
def test_get_feature_wfs_url(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
featureid = "%(typename)s.%(fid1)s,%(typename)s.%(fid2)s" % {
"typename": "testpoint_unprotected",
"fid1": self.id_lausanne,
"fid2": self.id_paris
}
request.params.update(
dict(service="wfs",
version="1.0.0",
request="getfeature",
typename="testpoint_unprotected",
featureid=featureid,
callback="cb"))
response = MapservProxy(request).proxy()
self.assertTrue(response.body != "")
self.assertEqual(str(response.cache_control), "no-cache")
def test_get_map_protected_layer_collect_query_user3(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request(username=u"__test_user3")
request.params.update(
dict(service="wms",
version="1.1.1",
request="getmap",
bbox="-180,-90,180,90",
layers="testpoint_protected_query_with_collect",
width="600",
height="400",
srs="EPSG:21781",
format="image/png"))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertEqual(str(response.cache_control), "no-cache")
# two points
md5sum = hashlib.md5(response.body).hexdigest()
self.assertIn(md5sum, TWO_POINTS)
def test_get_feature_feature_id_get_jsonp(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
featureid = "{typename!s}.{fid1!s},{typename!s}.{fid2!s}".format(
typename="testpoint_unprotected",
fid1=self.id_lausanne,
fid2=self.id_paris
)
request.params.update(dict(
service="wfs", version="1.0.0",
request="getfeature", typename="testpoint_unprotected",
featureid=featureid, callback="cb"
))
response = MapservProxy(request).proxy()
assert "Lausanne" in response.body.decode("utf-8")
assert "Paris" in response.body.decode("utf-8")
assert "Londre" not in response.body.decode("utf-8")
assert "Chambéry" not in response.body.decode("utf-8")
self.assertEqual(response.content_type, "application/javascript")
def test_get_feature_feature_id_get(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
featureid = "%(typename)s.%(fid1)s,%(typename)s.%(fid2)s" % {
"typename": "testpoint_unprotected",
"fid1": self.id_lausanne,
"fid2": self.id_paris
}
request.params.update(
dict(service="wfs",
version="1.0.0",
request="getfeature",
typename="testpoint_unprotected",
featureid=featureid))
response = MapservProxy(request).proxy()
self.assertTrue("Lausanne" in response.body)
self.assertTrue("Paris" in response.body)
self.assertFalse("Londre" in response.body)
self.assertFalse("Chambéry" in response.body)
self.assertEqual(response.content_type, "text/xml")
def test_getlegendgraphic_custom_nocache(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.registry.settings.update({
"headers": {
"mapserver": {
"cache_control_max_age": 0,
"access_control_allow_origin": "*"
}
}
})
request.params.update(
dict(service="wms",
version="1.1.1",
request="getlegendgraphic",
layer="testpoint_unprotected",
srs="EPSG:21781",
format="image/png",
extraparam=u"with spéciàl chârs"))
response = MapservProxy(request).proxy()
self.assertTrue(response.cache_control.public)
self.assertTrue(response.cache_control.no_cache)
def test_substitution(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
request.method = "POST"
request.headers["Content-Type"] = "application/xml; charset=UTF-8"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"foo") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"bar") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"éàè") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"123") < 0)
request.params.update(dict(s_name="bar"))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"foo") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"bar") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"éàè") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"123") < 0)
request = self._create_dummy_request()
request.method = "POST"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.params.update(dict(S_NAME="bar"))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"foo") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"bar") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"éàè") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"123") < 0)
request = self._create_dummy_request()
request.method = "POST"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution": ["name=bar"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"foo") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"bar") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"éàè") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"123") < 0)
request.body = COLUMN_RESTRICTION_GETFEATURE_REQUEST
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution":
["cols=name", "cols=city", "cols=country"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Lausanne") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Swiss") > 0)
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution": ["cols=name", "cols=city"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Lausanne") > 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Swiss") < 0)
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution": ["cols=name", "cols=country"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Lausanne") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Swiss") > 0)
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution": ["cols=name"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Lausanne") < 0)
self.assertTrue(
unicode(response.body.decode("utf-8")).find(u"Swiss") < 0)
request = self._create_dummy_request()
request.registry.settings["admin_interface"] = {
"available_functionalities": ["mapserver_substitution"]
}
request.method = "POST"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.registry.settings["functionalities"]["anonymous"] = {
"mapserver_substitution": ["foo_bar"]
}
request.params.update(
dict(s_test1="to be removed", S_TEST2="to be removed"))
# just pass in the log messagse
response = MapservProxy(request).proxy()
def test_substitution(self):
request = self._create_dummy_request()
request.method = 'POST'
request.body = SUBSTITUTION_GETFEATURE_REQUEST
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'foo') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'bar') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'éàè') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'123') < 0)
request.params.update(dict(s_name='bar'))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'foo') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'bar') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'éàè') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'123') < 0)
request = self._create_dummy_request()
request.method = 'POST'
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.params.update(dict(S_NAME='bar'))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'foo') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'bar') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'éàè') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'123') < 0)
request = self._create_dummy_request()
request.method = 'POST'
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["name=bar"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'foo') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'bar') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'éàè') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'123') < 0)
request.body = COLUMN_RESTRICTION_GETFEATURE_REQUEST
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["cols=name", "cols=city", "cols=country"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Lausanne') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Swiss') > 0)
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["cols=name", "cols=city"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Lausanne') > 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Swiss') < 0)
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["cols=name", "cols=country"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Lausanne') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Swiss') > 0)
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["cols=name"]
}
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Lausanne') < 0)
self.assertTrue(unicode(response.body.decode('utf-8')).find(u'Swiss') < 0)
request = self._create_dummy_request()
request.method = 'POST'
request.body = SUBSTITUTION_GETFEATURE_REQUEST
request.registry.settings['functionalities']['anonymous'] = {
"mapserver_substitution": ["foo_bar"]
}
request.params.update(dict(
s_test1='to be removed', S_TEST2='to be removed'
))
# just pass in the log messagse
response = MapservProxy(request).proxy()
def test_no_params(self):
from c2cgeoportal.views.mapserverproxy import MapservProxy
request = self._create_dummy_request()
response = MapservProxy(request).proxy()
self.assertEqual(response.status_code, 200)
