def test_web_client_functionalities(self):
from tests.functional import create_dummy_request
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.static import User
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()
fill_tech_user_functionality(
"registered", (("__test_s", "registered"), ("__test_a", "r1"), ("__test_a", "r2"))
)
fill_tech_user_functionality(
"anonymous", (("__test_s", "anonymous"), ("__test_a", "a1"), ("__test_a", "a2"))
)
settings = {
"functionalities": {"available_in_templates": ["__test_s", "__test_a"]},
"admin_interface": {"available_functionalities": [{"name": "__test_a"}, {"name": "__test_s"}]},
}
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
def test_functionalities(self):
from tests.functional import create_dummy_request
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.static import User
from c2cgeoportal_geoportal.lib.functionality import get_functionality
request = create_dummy_request()
request.user = None
request1 = create_dummy_request()
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2 = create_dummy_request()
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
request3 = create_dummy_request()
request3.user = DBSession.query(User).filter(
User.username == "__test_user3").one()
settings = {
"admin_interface": {
"available_functionalities": [
{
"name": "__test_a"
},
{
"name": "__test_b",
"single": True
},
{
"name": "__test_s",
"single": True
},
]
}
}
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
request3.registry.settings.update(settings)
self.assertEqual(get_functionality("__test_s", request, False), [])
self.assertEqual(get_functionality("__test_a", request, False), [])
self.assertEqual(get_functionality("__test_s", request1, False), [])
self.assertEqual(get_functionality("__test_a", request1, False), [])
self.assertEqual(get_functionality("__test_s", request2, False),
["db"])
self.assertEqual(set(get_functionality("__test_a", request2, False)),
{"db1", "db2"})
self.assertEqual(get_functionality("__test_s", request3, False),
["db"])
self.assertEqual(set(get_functionality("__test_a", request3, False)),
{"db1", "db2"})
self.assertEqual(get_functionality("__test_b", request3, False), [])
fill_tech_user_functionality("registered",
(("__test_s", "registered"),
("__test_a", "r1"), ("__test_a", "r2")))
settings = {
"admin_interface": {
"available_functionalities": [{
"name": "__test_a"
}, {
"name": "__test_s"
}]
}
}
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
request3.user = DBSession.query(User).filter(
User.username == "__test_user3").one()
self.assertEqual(get_functionality("__test_s", request, False), [])
self.assertEqual(get_functionality("__test_a", request, False), [])
self.assertEqual(get_functionality("__test_s", request1, False),
["registered"])
self.assertEqual(set(get_functionality("__test_a", request1, False)),
{"r1", "r2"})
self.assertEqual(get_functionality("__test_s", request2, False),
["db"])
self.assertEqual(set(get_functionality("__test_a", request2, False)),
{"db1", "db2"})
fill_tech_user_functionality("registered", [])
fill_tech_user_functionality("anonymous",
(("__test_s", "anonymous"),
("__test_a", "a1"), ("__test_a", "a2")))
settings = {
"admin_interface": {
"available_functionalities": [{
"name": "__test_a"
}, {
"name": "__test_s"
}]
}
}
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
request3.user = DBSession.query(User).filter(
User.username == "__test_user3").one()
self.assertEqual(get_functionality("__test_s", request, False),
["anonymous"])
self.assertEqual(set(get_functionality("__test_a", request, False)),
{"a1", "a2"})
self.assertEqual(get_functionality("__test_s", request1, False),
["anonymous"])
self.assertEqual(set(get_functionality("__test_a", request1, False)),
{"a1", "a2"})
self.assertEqual(get_functionality("__test_s", request2, False),
["db"])
self.assertEqual(set(get_functionality("__test_a", request2, False)),
{"db1", "db2"})
fill_tech_user_functionality("registered",
(("__test_s", "registered"),
("__test_a", "r1"), ("__test_a", "r2")))
fill_tech_user_functionality("anonymous",
(("__test_s", "anonymous"),
("__test_a", "a1"), ("__test_a", "a2")))
settings = {
"admin_interface": {
"available_functionalities": [{
"name": "__test_a"
}, {
"name": "__test_s"
}]
}
}
request.registry.settings.update(settings)
request1.registry.settings.update(settings)
request2.registry.settings.update(settings)
request1.user = DBSession.query(User).filter(
User.username == "__test_user1").one()
request2.user = DBSession.query(User).filter(
User.username == "__test_user2").one()
request3.user = DBSession.query(User).filter(
User.username == "__test_user3").one()
self.assertEqual(get_functionality("__test_s", request, False),
["anonymous"])
self.assertEqual(set(get_functionality("__test_a", request, False)),
{"a1", "a2"})
self.assertEqual(get_functionality("__test_s", request1, False),
["registered"])
self.assertEqual(set(get_functionality("__test_a", request1, False)),
{"r1", "r2"})
self.assertEqual(get_functionality("__test_s", request2, False),
["db"])
self.assertEqual(set(get_functionality("__test_a", request2, False)),
{"db1", "db2"})
def test_substitution(self):
from c2cgeoportal_geoportal.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)
assert "foo" in response.body.decode("utf-8")
assert "bar" not in response.body.decode("utf-8")
assert "éàè" not in response.body.decode("utf-8")
assert "123" not in response.body.decode("utf-8")
request.params.update(dict(s_name="bar"))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "foo" in response.body.decode("utf-8")
assert "bar" not in response.body.decode("utf-8")
assert "éàè" not in response.body.decode("utf-8")
assert "123" not in response.body.decode("utf-8")
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)
assert "foo" in response.body.decode("utf-8")
assert "bar" not in response.body.decode("utf-8")
assert "éàè" not in response.body.decode("utf-8")
assert "123" not in response.body.decode("utf-8")
request = self._create_dummy_request()
request.method = "POST"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
fill_tech_user_functionality(
"anonymous", (("mapserver_substitution", "name=bar"), ))
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "foo" not in response.body.decode("utf-8")
assert "bar" in response.body.decode("utf-8")
assert "éàè" not in response.body.decode("utf-8")
assert "123" not in response.body.decode("utf-8")
request.body = COLUMN_RESTRICTION_GETFEATURE_REQUEST
fill_tech_user_functionality(
"anonymous", [("mapserver_substitution", e)
for e in ["cols=name", "cols=city", "cols=country"]])
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "Lausanne" in response.body.decode("utf-8")
assert "Swiss" in response.body.decode("utf-8")
fill_tech_user_functionality("anonymous",
[("mapserver_substitution", e)
for e in ["cols=name", "cols=city"]])
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "Lausanne" in response.body.decode("utf-8")
assert "Swiss" not in response.body.decode("utf-8")
fill_tech_user_functionality("anonymous",
[("mapserver_substitution", e)
for e in ["cols=name", "cols=country"]])
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "Lausanne" not in response.body.decode("utf-8")
assert "Swiss" in response.body.decode("utf-8")
fill_tech_user_functionality("anonymous",
[("mapserver_substitution", e)
for e in ["cols=name"]])
response = MapservProxy(request).proxy()
self.assertTrue(response.status_int, 200)
assert "Lausanne" not in response.body.decode("utf-8")
assert "Swiss" not in response.body.decode("utf-8")
request = self._create_dummy_request()
request.registry.settings["admin_interface"] = {
"available_functionalities": [{
"name": "mapserver_substitution"
}]
}
request.method = "POST"
request.body = SUBSTITUTION_GETFEATURE_REQUEST
fill_tech_user_functionality("anonymous",
(("mapserver_substitution", "foo_bar"), ))
request.params.update(
dict(s_test1="to be removed", S_TEST2="to be removed"))
# just pass in the log message
response = MapservProxy(request).proxy()
def test_login_0(self):
from tests import DummyRequest
from c2cgeoportal_geoportal.views.login import Login
request = DummyRequest()
request.is_valid_referer = True
request.user = None
login = Login(request)
request.path = "/for_test"
responce = login.loginform403()
assert responce["came_from"] == "/for_test"
request.params = {"came_from": "/for_a_second_test"}
login = Login(request)
responce = login.loginform()
assert responce["came_from"] == "/for_a_second_test"
login = Login(request)
request.params = {}
responce = login.loginform()
assert responce["came_from"] == "/"
request.registry.settings = {
"functionalities": {
"available_in_templates": ["func"]
},
"admin_interface": {
"available_functionalities": [{
"name": "func"
}]
},
}
fill_tech_user_functionality("anonymous", (("func", "anon"),
("toto", "anon_value2")))
fill_tech_user_functionality("registered", (("func", "reg"), ))
login = Login(request)
self.assertEqual(login.loginuser()["functionalities"],
{"func": ["anon"]})
class R:
id = 123
def __init__(self, name, functionalities):
self.name = name
self.functionalities = functionalities
class U:
username = "******"
is_password_changed = True
email = "*****@*****.**"
settings_role = None
def __init__(self, role="__test_role", functionalities=None):
if functionalities is None:
functionalities = []
self.roles = [R(role, functionalities)]
request.user = U()
login = Login(request)
expected = {
"username": "******",
"email": "*****@*****.**",
"is_intranet": False,
"two_factor_enable": False,
"roles": [{
"name": "__test_role",
"id": 123
}],
"functionalities": {
"func": ["reg"]
},
}
self.assertEqual(login.loginuser(), expected)
class F:
name = "func"
value = "value"
request.user = U("__test_role2", [F()])
login = Login(request)
expected = {
"username": "******",
"email": "*****@*****.**",
"is_intranet": False,
"two_factor_enable": False,
"roles": [{
"name": "__test_role2",
"id": 123
}],
"functionalities": {
"func": ["value"]
},
}
self.assertEqual(login.loginuser(), expected)
