def test__get_child_layers_info_without_scalehint(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
entry = Entry(request)
class Layer(object):
pass
child_layer_1 = Layer()
child_layer_1.name = 'layer_1'
child_layer_1.scaleHint = None
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = 'layer_2'
child_layer_2.scaleHint = None
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info(layer)
expected = [{
'name': 'layer_1'
}, {
'name': 'layer_2',
}]
self.assertEqual(child_layers_info, expected)
def test_permalink_theme(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.registry.settings = {"mapserv_url": mapserv_url, "external_mapserv_url": mapserv_url}
entry = Entry(request)
request.user = None
request.matchdict = {"themes": ["theme"]}
result = entry.permalinktheme()
self.assertEquals(
result.keys(), ["lang", "mobile_url", "permalink_themes", "no_redirect", "extra_params", "debug"]
)
self.assertEquals(result["extra_params"], "?lang=en&permalink_themes=theme")
self.assertEquals(result["permalink_themes"], "permalink_themes=theme")
request.matchdict = {"themes": ["theme1", "theme2"]}
result = entry.permalinktheme()
self.assertEquals(
result.keys(), ["lang", "mobile_url", "permalink_themes", "no_redirect", "extra_params", "debug"]
)
self.assertEquals(result["extra_params"], "?lang=en&permalink_themes=theme1,theme2")
self.assertEquals(result["permalink_themes"], "permalink_themes=theme1,theme2")
def test__get_child_layers_info_without_scalehint(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer(object):
pass
child_layer_1 = Layer()
child_layer_1.name = 'layer_1'
child_layer_1.scaleHint = None
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = 'layer_2'
child_layer_2.scaleHint = None
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info(layer)
expected = [{
'name': 'layer_1'
}, {
'name': 'layer_2',
}]
self.assertEqual(child_layers_info, expected)
def test_permalink_theme(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
entry = Entry(request)
request.matchdict = {
'themes': ['theme'],
}
result = entry.permalinktheme()
self.assertEquals(
result.keys(),
[
'lang', 'mobile_url', 'permalink_themes',
'no_redirect', 'extra_params', 'debug'
]
)
self.assertEquals(result['extra_params'], '?lang=fr&permalink_themes=theme')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme')
request.matchdict = {
'themes': ['theme1', 'theme2'],
}
result = entry.permalinktheme()
self.assertEquals(
result.keys(),
[
'lang', 'mobile_url', 'permalink_themes',
'no_redirect', 'extra_params', 'debug'
]
)
self.assertEquals(result['extra_params'], '?lang=fr&permalink_themes=theme1,theme2')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme1,theme2')
def test_theme(self):
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings['mapserv_url'] = ms_url
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals(len(themes), 0)
cache_region.invalidate()
themes, errors = entry._themes(None)
self.assertEquals(len(errors), 22)
self.assertEquals(
errors[0],
'The layer __test_layer is not defined in WMS capabilities')
self.assertEquals(
errors[11], 'Too many recursions with group "__test_layer_group"')
def test_permalink_theme(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.registry.settings = {
'mapserv_url': mapserv_url,
'external_mapserv_url': mapserv_url,
}
entry = Entry(request)
request.user = None
request.matchdict = {
'themes': ['theme'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(),
['lang', 'mobile_url', 'permalink_themes',
'no_redirect', 'extra_params', 'debug'])
self.assertEquals(result['extra_params'], '?lang=en&permalink_themes=theme')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme')
request.matchdict = {
'themes': ['theme1', 'theme2'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(),
['lang', 'mobile_url', 'permalink_themes',
'no_redirect', 'extra_params', 'debug'])
self.assertEquals(result['extra_params'], '?lang=en&permalink_themes=theme1,theme2')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme1,theme2')
def test__get_child_layers_info_with_scalehint(self):
import math
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer:
pass
child_layer_1 = Layer()
child_layer_1.name = "layer_1"
child_layer_1.scaleHint = {"min": 1 * math.sqrt(2), "max": 2 * math.sqrt(2)}
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = "layer_2"
child_layer_2.scaleHint = {"min": 3 * math.sqrt(2), "max": 4 * math.sqrt(2)}
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info_1(layer)
expected = [
{"name": "layer_1", "minResolutionHint": 1.0, "maxResolutionHint": 2.0},
{"name": "layer_2", "minResolutionHint": 3.0, "maxResolutionHint": 4.0},
]
self.assertEqual(child_layers_info, expected)
def test_WFS_types(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings = {
'mapserv_url': ms_url,
'external_mapserv_url': ms_url,
'functionalities': {
'available_in_templates': []
}
}
entry = Entry(request)
request.user = None
response = entry._getVars()
self.assertEquals(response['serverError'], '[]')
result = '["testpoint_unprotected", "testpoint_protected", "testpoint_protected_query_with_collect", "testpoint_substitution", "testpoint_column_restriction", "test_wmsfeatures"]'
self.assertEquals(response['WFSTypes'], result)
self.assertEquals(response['externalWFSTypes'], result)
def test_login(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj(
params={
'login': u'__test_user1',
'password': u'__test_user1',
'came_from': "/came_from",
})
response = Entry(request).login()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers['Location'], "/came_from")
request = self._create_request_obj(params={
'login': u'__test_user1',
'password': u'__test_user1',
})
response = Entry(request).login()
self.assertEquals(response.status_int, 200)
self.assertEquals(response.body, 'true')
request = self._create_request_obj(params={
'login': u'__test_user1',
'password': u'bad password',
})
response = Entry(request).login()
self.assertEquals(response.status_int, 401)
def test_WFS_types(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings = {
'mapserv_url': ms_url,
'external_mapserv_url': ms_url,
'functionalities': {
'available_in_templates': []
}
}
entry = Entry(request)
request.user = None
response = entry._getVars()
self.assertEquals(response['serverError'], '[]')
result = '["testpoint_unprotected", "testpoint_protected", "testpoint_protected_query_with_collect", "testpoint_substitution", "testpoint_column_restriction", "test_wmsfeatures"]'
self.assertEquals(response['WFSTypes'], result)
self.assertEquals(response['externalWFSTypes'], result)
def test_entry_points_noexternal(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.registry.settings.update({
'layers_enum': {
'layer_test': {
'attributes': {
'label': None
}
}
}
})
entry = Entry(request)
result = entry.home()
self.assertEquals(
set(result.keys()),
set(
[
'lang', 'debug', 'extra_params',
'mobile_url', 'no_redirect'
]
)
)
result = entry.viewer()
def test_login(self):
from c2cgeoportal import default_user_validator
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.params['login'] = u'__test_user1'
request.params['password'] = u'__test_user1'
request.params['came_from'] = "/came_from"
request.registry.validate_user = default_user_validator
request.user = None
response = Entry(request).login()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers['Location'], "/came_from")
request = testing.DummyRequest()
request.headers['Host'] = host
request.params['login'] = u'__test_user1'
request.params['password'] = u'__test_user1'
request.registry.validate_user = default_user_validator
request.user = None
response = Entry(request).login()
self.assertEquals(response.status_int, 200)
self.assertEquals(response.body, 'true')
request = testing.DummyRequest()
request.headers['Host'] = host
request.params['login'] = u'__test_user1'
request.params['password'] = u'bad password'
request.registry.validate_user = default_user_validator
request.user = None
response = Entry(request).login()
self.assertEquals(response.status_int, 401)
def test_entry_points_wfs(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
mapserv = request.registry.settings['mapserv_url']
request.registry.settings.update({
'external_mapserv_url': mapserv,
'mapserv_wfs_url': mapserv,
'external_mapserv_wfs_url': mapserv,
'layers_enum': {
'layer_test': {
'attributes': {
'label': None
}
}
}
})
entry = Entry(request)
result = entry.home()
self.assertEquals(
set(result.keys()),
set(['lang', 'debug', 'extra_params', 'mobile_url',
'no_redirect']))
result = entry.viewer()
def test_permalink_theme(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
entry = Entry(request)
request.matchdict = {
'themes': ['theme'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(), [
'lang', 'mobile_url', 'permalink_themes', 'no_redirect',
'extra_params', 'debug'
])
self.assertEquals(result['extra_params'],
'?lang=fr&permalink_themes=theme')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme')
request.matchdict = {
'themes': ['theme1', 'theme2'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(), [
'lang', 'mobile_url', 'permalink_themes', 'no_redirect',
'extra_params', 'debug'
])
self.assertEquals(result['extra_params'],
'?lang=fr&permalink_themes=theme1,theme2')
self.assertEquals(result['permalink_themes'],
'permalink_themes=theme1,theme2')
def test_theme(self):
from c2cgeoportal.models import DBSession, Theme
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings = {
'mapserv_url': ms_url,
}
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals(len(themes), 0)
cache_region.invalidate()
themes, errors = entry._themes(None)
self.assertEquals(len(errors), 11)
self.assertEquals(errors[0], 'Too many recursions with group "__test_layer_group"')
def test_logout_no_auth(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj(path='/',
params={'came_from': '/came_from'})
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 404)
def test_themev2_noauth_edit_permission(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
request.params = {"interface": "main", "version": "2"}
entry = Entry(request)
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set())
self.assertEqual([t["name"] for t in themes["themes"]], [])
def test_themev2_noauth_edit_permission(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
request.params = {"interface": "main", "version": "2"}
entry = Entry(request)
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set())
self.assertEqual([t["name"] for t in themes["themes"]], [])
def test_logout_no_auth(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj(path='/', params={
'came_from': '/came_from'
})
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 404)
def test_logout_no_auth(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest(path='/')
request.headers['Host'] = host
request.params['came_from'] = '/came_from'
request.user = None
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 404)
def test_logout_no_auth(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest(path='/')
request.headers['Host'] = host
request.params['came_from'] = '/came_from'
request.user = None
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 404)
def test_error(self):
from c2cgeoportal.views.entry import Entry
entry = Entry(self._create_request_obj(params={
"version": "2",
}))
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set([
"The WMS layer name 'testpoint_unprotected', can't be two times in the same block (first level group).",
]))
def test_error(self):
from c2cgeoportal.views.entry import Entry
entry = Entry(self._create_request_obj(params={
"version": "2",
}))
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set([
"The theme has an unsupported name '__test/theme'."
]))
def test_error(self):
from c2cgeoportal.views.entry import Entry
entry = Entry(self._create_request_obj(params={
"version": "2",
}))
themes = entry.themes()
self.assertEquals(
set(themes["errors"]),
set(["The theme has an unsupported name '__test/theme'."]))
def test_login(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.params = { 'lang': 'en' }
entry = Entry(request)
request.path = '/for_test'
expected = {
'lang': 'en',
'came_from': '/for_test',
}
self.assertEqual(entry.loginform403(), expected)
request.params = {
'came_from': '/for_a_second_test',
}
entry = Entry(request)
expected = {
'lang': 'en',
'came_from': '/for_a_second_test',
}
self.assertEqual(entry.loginform(), expected)
entry = Entry(request)
request.params = {}
expected = {
'lang': 'en',
'came_from': '/',
}
self.assertEqual(entry.loginform(), expected)
def test_web_client_functionalities(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.tests.functional import mapserv_url
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
request.user = None
request1 = DummyRequest()
request1.static_url = lambda url: 'http://example.com/dummy/static/url'
request1.route_url = lambda url: mapserv_url
request1.user = DBSession.query(User).filter(
User.username == '__test_user1').one()
request2 = DummyRequest()
request2.static_url = lambda url: 'http://example.com/dummy/static/url'
request2.route_url = lambda url: mapserv_url
request2.user = DBSession.query(User).filter(
User.username == '__test_user2').one()
settings = {
'functionalities': {
'anonymous': {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
'registered': {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
},
'available_in_templates': ['__test_s', '__test_a'],
},
'mapserv_url': mapserv_url,
}
request.registry.settings = settings
request1.registry.settings = settings
request2.registry.settings = settings
annon = Entry(request)._getVars()
u1 = Entry(request1)._getVars()
u2 = Entry(request2)._getVars()
self.assertEquals(annon['functionality'], {
"__test_s": ["anonymous"],
"__test_a": ["a1", "a2"]
})
self.assertEquals(u1['functionality'], {
"__test_s": ["registered"],
"__test_a": ["r1", "r2"]
})
self.assertEquals(u2['functionality'], {
"__test_s": ["db"],
"__test_a": ["db1", "db2"]
})
def test_error(self):
from c2cgeoportal.views.entry import Entry
entry = Entry(self._create_request_obj(params={
"version": "2",
}))
themes = entry.themes()
self.assertEquals(
set(themes["errors"]),
set([
"The WMS layer name 'testpoint_unprotected', can't be two times in the same block (first level group).",
]))
def test_web_client_functionalities(self):
from c2cgeoportal.models import DBSession, User
from tests.functional import create_dummy_request
from c2cgeoportal.views.entry import Entry
request = create_dummy_request()
request.static_url = lambda url: "http://example.com/dummy/static/url"
request1 = create_dummy_request()
request1.static_url = lambda url: "http://example.com/dummy/static/url"
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2 = create_dummy_request()
request2.static_url = lambda url: "http://example.com/dummy/static/url"
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
settings = {
"functionalities": {
"anonymous": {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
"registered": {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
},
"available_in_templates": ["__test_s", "__test_a"],
},
"admin_interface": {
"available_functionalities": ["__test_a", "__test_s"]
},
}
functionality.FUNCTIONALITIES_TYPES = None
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
annon = Entry(request).get_cgxp_viewer_vars()
u1 = Entry(request1).get_cgxp_viewer_vars()
u2 = Entry(request2).get_cgxp_viewer_vars()
self.assertEqual(annon["functionality"], {
"__test_s": ["anonymous"],
"__test_a": ["a1", "a2"]
})
self.assertEqual(u1["functionality"], {
"__test_s": ["registered"],
"__test_a": ["r1", "r2"]
})
self.assertEqual(u2["functionality"], {
"__test_s": ["db"],
"__test_a": ["db1", "db2"]
})
def test_permalink_themes(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
request.registry.settings['external_mapserv_url'] = \
request.registry.settings['mapserv_url']
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.params = {
'permalink_themes': 'my_themes',
}
entry = Entry(request)
response = entry._getVars()
self.assertEquals(response['permalink_themes'], '["my_themes"]')
def test_permalink_themes(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
request.registry.settings['external_mapserv_url'] = \
request.registry.settings['mapserv_url']
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.params = {
'permalink_themes': 'my_themes',
}
entry = Entry(request)
response = entry._getVars()
self.assertEquals(response['permalink_themes'], '["my_themes"]')
def test_permalink_themes(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv_url
request.registry.settings = {"mapserv_url": mapserv_url, "external_mapserv_url": mapserv_url}
request.params = {"permalink_themes": "my_themes"}
entry = Entry(request)
request.user = None
response = entry._getVars()
self.assertEquals(response["permalink_themes"], '["my_themes"]')
def test_themev2_auth_no_edit_permission(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj(username=u"__test_user1")
request.params = {"interface": "main", "version": "2"}
entry = Entry(request)
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set())
self.assertEqual([t["name"] for t in themes["themes"]], ["__test_theme"])
self.assertEqual([c["name"] for c in themes["themes"][0]["children"]], ["__test_layer_group"])
layers = themes["themes"][0]["children"][0]["children"]
self.assertEqual([l["name"] for l in layers], ["__test_private_layer"])
self.assertEqual("editable" in layers[0], False)
def test_theme(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings = {
'mapserv_url': ms_url,
}
request.user = None
entry = Entry(request)
# unautenticated
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertFalse(self._find_layer(themes[0], '__test_private_layer'))
# autenticated on parent
role_id = DBSession.query(User.role_id).filter_by(username=u'__test_user1').one()
request.params = { 'role_id': role_id }
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# autenticated
request.params = {}
request.user = DBSession.query(User).filter_by(username=u'__test_user1').one()
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# mapfile error
request.params = {}
request.registry.settings = {
'mapserv_url': mapserv_url + '?map=not_a_mapfile',
}
from c2cgeoportal import caching
caching.invalidate_region()
themes, errors = entry._themes(None)
self.assertEquals(len(themes), 0)
self.assertEquals(len(errors), 1)
def test_entry_points(self):
from c2cgeoportal.views.entry import Entry
mapfile = os.path.join(os.path.dirname(os.path.abspath(__file__)), "c2cgeoportal_test.map")
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv
request.registry.settings = {"mapserv_url": mapserv, "external_mapserv_url": mapserv}
entry = Entry(request)
request.user = None
all_params = set(
[
"lang",
"tilecache_url",
"tiles_url",
"debug",
"serverError",
"themes",
"external_themes",
"functionality",
"WFSTypes",
"externalWFSTypes",
"user",
]
)
result = entry.home()
self.assertEquals(set(result.keys()), set(["lang", "debug", "extra_params", "mobile_url", "no_redirect"]))
result = entry.viewer()
self.assertEquals(set(result.keys()), all_params)
result = entry.edit()
self.assertEquals(set(result.keys()), set(["lang", "debug", "extra_params"]))
result = entry.editjs()
self.assertEquals(set(result.keys()), all_params)
result = entry.mobile()
self.assertEquals(set(result.keys()), set(["lang"]))
result = entry.apijs()
self.assertEquals(set(result.keys()), set(["lang", "debug", "queryable_layers"]))
result = entry.xapijs()
self.assertEquals(set(result.keys()), set(["lang", "debug", "queryable_layers"]))
result = entry.apihelp()
self.assertEquals(set(result.keys()), set(["lang", "debug"]))
result = entry.xapihelp()
self.assertEquals(set(result.keys()), set(["lang", "debug"]))
def test_themev2_auth_no_edit_permission(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj(username=u"__test_user1")
request.params = {"interface": "main", "version": "2"}
entry = Entry(request)
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set())
self.assertEqual([t["name"] for t in themes["themes"]],
["__test_theme"])
self.assertEqual([c["name"] for c in themes["themes"][0]["children"]],
["__test_layer_group"])
layers = themes["themes"][0]["children"][0]["children"]
self.assertEqual([l["name"] for l in layers], ["__test_private_layer"])
self.assertEqual("editable" in layers[0], False)
def test_theme(self):
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv_url
request.client_addr = None
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals([t["name"] for t in themes], [u"__test_theme"])
cache_region.invalidate()
themes, errors = entry._themes(None, u"desktop")
self.assertEquals(len([e for e in errors if e == "Too many recursions with group '__test_layer_group'"]), 1)
def test_entry_points(self):
from c2cgeoportal.views.entry import Entry
mapfile = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'c2cgeoportal_test.map'
)
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv
request.registry.settings = {
'mapserv_url': mapserv,
'external_mapserv_url': mapserv,
}
entry = Entry(request)
request.user = None
all_params = set(['lang', 'tilecache_url', 'tiles_url', 'debug',
'serverError', 'themes', 'external_themes', 'functionality',
'WFSTypes', 'externalWFSTypes', 'user'])
result = entry.home()
self.assertEquals(
set(result.keys()),
set(['lang', 'debug', 'extra_params',
'mobile_url', 'no_redirect']))
result = entry.viewer()
self.assertEquals(set(result.keys()), all_params)
result = entry.edit()
self.assertEquals(set(result.keys()), set(['lang', 'debug', 'extra_params']))
result = entry.editjs()
self.assertEquals(set(result.keys()), all_params)
result = entry.mobile()
self.assertEquals(set(result.keys()), set(['lang']))
result = entry.apijs()
self.assertEquals(set(result.keys()), set(['lang', 'debug', 'queryable_layers']))
result = entry.xapijs()
self.assertEquals(set(result.keys()), set(['lang', 'debug', 'queryable_layers']))
result = entry.apihelp()
self.assertEquals(set(result.keys()), set(['lang', 'debug']))
result = entry.xapihelp()
self.assertEquals(set(result.keys()), set(['lang', 'debug']))
def test_permalink_themes(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
request.registry.settings = {
'mapserv_url': mapserv_url,
'external_mapserv_url': mapserv_url,
}
request.params = {
'permalink_themes': 'my_themes',
}
entry = Entry(request)
request.user = None
response = entry._getVars()
self.assertEquals(response['permalink_themes'], '["my_themes"]')
def test_permalink_themes(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
request.registry.settings = {
'mapserv_url': mapserv_url,
'external_mapserv_url': mapserv_url,
}
request.params = {
'permalink_themes': 'my_themes',
}
entry = Entry(request)
request.user = None
response = entry._getVars()
self.assertEquals(response['permalink_themes'], '["my_themes"]')
def _create_entry_obj(self, username=None, params={}, **kargs):
from c2cgeoportal.views.entry import Entry
request = create_dummy_request(**kargs)
request.static_url = lambda url: "/dummy/static/url"
request.route_url = lambda url, **kwargs: mapserv_url
request.params = params
return Entry(request)
def _create_entry_obj(self, **kwargs):
from c2cgeoportal.views.entry import Entry
kwargs["additional_settings"] = {
"admin_interface": {
"available_metadata": ["test"]
}
}
return Entry(self._create_request_obj(**kwargs))
def test__get_child_layers_info_with_scalehint(self):
import math
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer(object):
pass
child_layer_1 = Layer()
child_layer_1.name = 'layer_1'
child_layer_1.scaleHint = {
'min': 1 * math.sqrt(2),
'max': 2 * math.sqrt(2)
}
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = 'layer_2'
child_layer_2.scaleHint = {
'min': 3 * math.sqrt(2),
'max': 4 * math.sqrt(2)
}
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info(layer)
expected = [{
'name': 'layer_1',
'minResolutionHint': 1.0,
'maxResolutionHint': 2.0
}, {
'name': 'layer_2',
'minResolutionHint': 3.0,
'maxResolutionHint': 4.0
}]
self.assertEqual(child_layers_info, expected)
def test__get_child_layers_info_with_scalehint(self):
import math
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer:
pass
child_layer_1 = Layer()
child_layer_1.name = "layer_1"
child_layer_1.scaleHint = {
"min": 1 * math.sqrt(2),
"max": 2 * math.sqrt(2)
}
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = "layer_2"
child_layer_2.scaleHint = {
"min": 3 * math.sqrt(2),
"max": 4 * math.sqrt(2)
}
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info_1(layer)
expected = [{
"name": "layer_1",
"minResolutionHint": 1.0,
"maxResolutionHint": 2.0
}, {
"name": "layer_2",
"minResolutionHint": 3.0,
"maxResolutionHint": 4.0
}]
self.assertEqual(child_layers_info, expected)
def _create_entry_obj(self, username=None, params={}):
from c2cgeoportal.views.entry import Entry
request = createDummyRequest()
request.static_url = lambda url: '/dummy/static/url'
request.route_url = lambda url, **kwargs: \
request.registry.settings['mapserv_url']
request.params = params
return Entry(request)
def test__get_child_layers_info_with_scalehint(self):
import math
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer(object):
pass
child_layer_1 = Layer()
child_layer_1.name = 'layer_1'
child_layer_1.scaleHint = {
'min': 1 * math.sqrt(2),
'max': 2 * math.sqrt(2)
}
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = 'layer_2'
child_layer_2.scaleHint = {
'min': 3 * math.sqrt(2),
'max': 4 * math.sqrt(2)
}
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info(layer)
expected = [{
'name': 'layer_1',
'minResolutionHint': 1.0,
'maxResolutionHint': 2.0
}, {
'name': 'layer_2',
'minResolutionHint': 3.0,
'maxResolutionHint': 4.0
}]
self.assertEqual(child_layers_info, expected)
def test_logout(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest(path="/")
request.headers["Host"] = host
request.params["came_from"] = "/came_from"
request.user = DBSession.query(User).filter_by(username=u"__test_user1").one()
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers["Location"], "/came_from")
request = testing.DummyRequest(path="/")
request.headers["Host"] = host
request.route_url = lambda url: "/dummy/route/url"
request.user = DBSession.query(User).filter_by(username=u"__test_user1").one()
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers["Location"], "/dummy/route/url")
def test_login(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
request.path = "/for_test"
expected = {
"lang": "fr",
"came_from": "/for_test",
}
self.assertEqual(entry.loginform403(), expected)
request.params = {
"came_from": "/for_a_second_test",
}
entry = Entry(request)
expected = {
"lang": "fr",
"came_from": "/for_a_second_test",
}
self.assertEqual(entry.loginform(), expected)
entry = Entry(request)
request.params = {}
expected = {
"lang": "fr",
"came_from": "/",
}
self.assertEqual(entry.loginform(), expected)
def test_login(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
request.path = '/for_test'
expected = {
'lang': 'fr',
'came_from': '/for_test',
}
self.assertEqual(entry.loginform403(), expected)
request.params = {
'came_from': '/for_a_second_test',
}
entry = Entry(request)
expected = {
'lang': 'fr',
'came_from': '/for_a_second_test',
}
self.assertEqual(entry.loginform(), expected)
entry = Entry(request)
request.params = {}
expected = {
'lang': 'fr',
'came_from': '/',
}
self.assertEqual(entry.loginform(), expected)
def test_theme(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
entry = Entry(request)
# unautenticated
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertFalse(self._find_layer(themes[0], '__test_private_layer'))
# autenticated on parent
role_id = DBSession.query(User.role_id).filter_by(username=u'__test_user1').one()
request.params = {'role_id': role_id}
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# autenticated
request.params = {}
request.user = DBSession.query(User).filter_by(username=u'__test_user1').one()
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# mapfile error
request.params = {}
request.registry.settings['mapserv_url'] = mapserv_url + '?map=not_a_mapfile'
log.info(request.registry.settings['mapserv_url'])
from c2cgeoportal import caching
caching.invalidate_region()
log.info(type(request.registry.settings['mapserv_url']))
themes, errors = entry._themes(None)
self.assertEquals(len(themes), 0)
self.assertEquals(len(errors), 1)
def test_theme(self):
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv_url
request.client_addr = None
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, "c2cgeoportal_test.map")
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings["mapserverproxy"]["mapserv_url"] = ms_url
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals([t["name"] for t in themes], [u"__test_theme"])
cache_region.invalidate()
themes, errors = entry._themes(None, u"main")
self.assertEquals(len([e for e in errors if e == "Too many recursions with group '__test_layer_group'"]), 1)
def test_theme(self):
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv_url
request.client_addr = None
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals([t["name"] for t in themes], [u"__test_theme"])
cache_region.invalidate()
themes, errors = entry._themes(None, u"desktop")
self.assertEquals(
len([
e for e in errors
if e == "Too many recursions with group '__test_layer_group'"
]), 1)
def test_logout(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest(path='/')
request.headers['Host'] = host
request.params['came_from'] = '/came_from'
request.user = DBSession.query(User) \
.filter_by(username=u'__test_user1').one()
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers['Location'], "/came_from")
request = testing.DummyRequest(path='/')
request.headers['Host'] = host
request.route_url = lambda url: '/dummy/route/url'
request.user = DBSession.query(User) \
.filter_by(username=u'__test_user1').one()
entry = Entry(request)
response = entry.logout()
self.assertEquals(response.status_int, 302)
self.assertEquals(response.headers['Location'], '/dummy/route/url')
def test_WFS_types(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.registry.settings.update({
'external_mapserv_url': request.registry.settings['mapserv_url'],
})
entry = Entry(request)
response = entry._getVars()
self.assertEquals(
response['serverError'],
'["The layer __test_public_layer is not defined in WMS capabilities", '
'"The layer __test_layer_in_group is not defined in WMS capabilities"]'
)
result = '["testpoint_unprotected", "testpoint_protected", ' \
'"testpoint_protected_query_with_collect", ' \
'"testpoint_substitution", "testpoint_column_restriction", ' \
'"test_wmsfeatures", "test_wmstime", "test_wmstime2"]'
self.assertEquals(response['WFSTypes'], result)
self.assertEquals(response['externalWFSTypes'], result)
def test_theme(self):
from c2cgeoportal.views.entry import Entry, cache_region
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "http://example.com/dummy/static/url"
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, "c2cgeoportal_test.map")
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings["mapserv_url"] = ms_url
request.user = None
entry = Entry(request)
cache_region.invalidate()
themes = entry.themes()
self.assertEquals(len(themes), 0)
cache_region.invalidate()
themes, errors = entry._themes(None)
self.assertEquals(len(errors), 22)
self.assertEquals(errors[0], "The layer __test_layer is not defined in WMS capabilities")
self.assertEquals(errors[11], 'Too many recursions with group "__test_layer_group"')
def test_WFS_types(self):
from c2cgeoportal.views.entry import Entry
request = self._create_request_obj()
#request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.registry.settings.update({
'external_mapserv_url':
request.registry.settings['mapserv_url'],
})
entry = Entry(request)
response = entry._getVars()
self.assertEquals(
response['serverError'],
'["The layer __test_public_layer is not defined in WMS capabilities", '
'"The layer __test_layer_in_group is not defined in WMS capabilities"]'
)
result = '["testpoint_unprotected", "testpoint_protected", ' \
'"testpoint_protected_query_with_collect", ' \
'"testpoint_substitution", "testpoint_column_restriction", ' \
'"test_wmsfeatures", "test_wmstime", "test_wmstime2"]'
self.assertEquals(response['WFSTypes'], result)
self.assertEquals(response['externalWFSTypes'], result)
def test__get_child_layers_info_without_scalehint(self):
from pyramid.testing import DummyRequest
from c2cgeoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
class Layer:
pass
child_layer_1 = Layer()
child_layer_1.name = "layer_1"
child_layer_1.scaleHint = None
child_layer_1.layers = []
child_layer_2 = Layer()
child_layer_2.name = "layer_2"
child_layer_2.scaleHint = None
child_layer_2.layers = []
layer = Layer()
layer.layers = [child_layer_1, child_layer_2]
child_layers_info = entry._get_child_layers_info_1(layer)
expected = [{
"name": "layer_1",
"minResolutionHint": 0.0,
"maxResolutionHint": 999999999.0,
}, {
"name": "layer_2",
"minResolutionHint": 0.0,
"maxResolutionHint": 999999999.0,
}]
self.assertEqual(child_layers_info, expected)
def test_permalink_theme(self):
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.registry.settings = {
'mapserv_url': mapserv_url,
'external_mapserv_url': mapserv_url,
}
entry = Entry(request)
request.user = None
request.matchdict = {
'themes': ['theme'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(), [
'lang', 'mobile_url', 'permalink_themes', 'no_redirect',
'extra_params', 'debug'
])
self.assertEquals(result['extra_params'],
'?lang=en&permalink_themes=theme')
self.assertEquals(result['permalink_themes'], 'permalink_themes=theme')
request.matchdict = {
'themes': ['theme1', 'theme2'],
}
result = entry.permalinktheme()
self.assertEquals(result.keys(), [
'lang', 'mobile_url', 'permalink_themes', 'no_redirect',
'extra_params', 'debug'
])
self.assertEquals(result['extra_params'],
'?lang=en&permalink_themes=theme1,theme2')
self.assertEquals(result['permalink_themes'],
'permalink_themes=theme1,theme2')
def test_theme(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: 'http://example.com/dummy/static/url'
request.route_url = lambda url: mapserv_url
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
ms_url = "%s?map=%s&" % (mapserv_url, mapfile)
request.registry.settings = {
'mapserv_url': ms_url,
}
request.user = None
entry = Entry(request)
# unautenticated
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertFalse(self._find_layer(themes[0], '__test_private_layer'))
# autenticated on parent
role_id = DBSession.query(
User.role_id).filter_by(username=u'__test_user1').one()
request.params = {'role_id': role_id}
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# autenticated
request.params = {}
request.user = DBSession.query(User).filter_by(
username=u'__test_user1').one()
themes = entry.themes()
self.assertEquals(len(themes), 1)
self.assertTrue(self._find_layer(themes[0], '__test_public_layer'))
self.assertTrue(self._find_layer(themes[0], '__test_private_layer'))
# mapfile error
request.params = {}
request.registry.settings = {
'mapserv_url': mapserv_url + '?map=not_a_mapfile',
}
from c2cgeoportal import caching
caching.invalidate_region()
themes, errors = entry._themes(None)
self.assertEquals(len(themes), 0)
self.assertEquals(len(errors), 1)
def test_loginchange(self):
from c2cgeoportal.views.entry import Entry
from c2cgeoportal.models import User
from pyramid.httpexceptions import HTTPBadRequest, HTTPUnauthorized
try:
from hashlib import sha1
sha1 # suppress pyflakes warning
except ImportError: # pragma: nocover
from sha import new as sha1 # flake8: noqa
request = self._create_request_obj()
entry = Entry(request)
self.assertRaises(HTTPBadRequest, entry.loginchange)
request = self._create_request_obj(params={
'lang': 'en',
'newPassword': '******',
'confirmNewPassword': '******',
})
entry = Entry(request)
self.assertRaises(HTTPUnauthorized, entry.loginchange)
request.user = User()
self.assertEquals(request.user.is_password_changed, False)
self.assertEquals(request.user._password,
unicode(sha1('').hexdigest()))
self.assertRaises(HTTPBadRequest, entry.loginchange)
request = self._create_request_obj(params={
'lang': 'en',
'newPassword': '******',
'confirmNewPassword': '******'
})
request.user = User()
entry = Entry(request)
self.assertNotEqual(entry.loginchange(), None)
self.assertEqual(request.user.is_password_changed, True)
self.assertEqual(request.user._password,
unicode(sha1('1234').hexdigest()))
def _create_entry_obj(self, username=None, params={}):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.views.entry import Entry
mapfile = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'c2cgeoportal_test.map')
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
request = testing.DummyRequest()
request.headers['Host'] = host
request.registry.settings = {
'mapserv_url': mapserv,
}
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
request.static_url = lambda url: '/dummy/static/url'
request.route_url = lambda url: mapserv
request.params = params
if username:
request.user = DBSession.query(User) \
.filter_by(username=username).one()
else:
request.user = None
return Entry(request)
