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_web_client_functionalities(self): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User from tests.functional import create_dummy_request from c2cgeoportal_geoportal.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_ogcserver(self): from c2cgeoportal_commons.models.main import OGCServer from c2cgeoportal_geoportal.views.ogcproxy import OGCProxy request = create_dummy_request() request.params.update({"ogcserver": "MixedCaseOGCServer"}) proxy = OGCProxy(request) assert isinstance(proxy.ogc_server, OGCServer) assert proxy.ogc_server.name == "MixedCaseOGCServer" request = create_dummy_request() request.params.update({"OGCSERVER": "MixedCaseOGCServer"}) proxy = OGCProxy(request) assert isinstance(proxy.ogc_server, OGCServer) assert proxy.ogc_server.name == "MixedCaseOGCServer"
def test_password_change_2fa(self): from c2cgeoportal_geoportal.views.login import Login url = None request = create_dummy_request() request.POST = {"login": "******", "password": "******"} request.GET = { "client_id": "qgis", "client_secret": "1234", "redirect_uri": "http://127.0.0.1:7070/", "response_type": "code", "type": "oauth2", } request.method = "POST" request.body = "" pyramid.testing.setUp(request=request, registry=init_registry()) request.registry.settings["authentication"] = {"two_factor": True} try: response = Login(request).login() LOG.error(response.text) assert False except HTTPFound as http_exception: url = http_exception.headers["Location"] assert url == "http://example.com/notlogin/view?"
def _wms_get_capabilities_config(ogcserver, service="wms", username=None): from c2cgeoportal_geoportal.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 _create_getcap_request(username=None): from c2cgeoportal.models import DBSession, User request = create_dummy_request() request.user = None if username is None else \ DBSession.query(User).filter_by(username=username).one() return request
def test_it(self): from c2cgeoportal_geoportal.resources import defaultgroupsfinder request = create_dummy_request(authentication=False, user="******") roles = defaultgroupsfinder("__test_user", request) self.assertEqual(roles, ["__test_role"])
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(**kwargs) request.route_url = lambda url, **kwargs: mapserv_url request.params = params return request
def _create_getcap_request(username=None): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request() request.user = None if username is None else \ DBSession.query(User).filter_by(username=username).one() return request
def test_request_wrong_auth(self): request = create_dummy_request(headers={ "Authorization": "Basic " + base64.b64encode( "__test_user:__wrong_pass".encode("utf-8") ).decode("utf-8").replace("\n", "") }) self.assertEqual(request.user, None)
def _get_request(layerid, username=None): from c2cgeoportal.models import DBSession, User request = create_dummy_request() request.matchdict = {"layer_id": str(layerid)} if username is not None: request.user = DBSession.query(User).filter_by( username=username).one() return request
def test_wrong_key(self): token = create_token("foobar1234567890", "__test_user1", "__test_user1", 1) request = create_dummy_request(params={"auth": token}) policy = UrlAuthenticationPolicy("foobar1234567891", defaultgroupsfinder) userid = policy.unauthenticated_userid(request) self.assertIsNone(userid)
def _get_request(layerid, username=None, params=None): if params is None: params = {} request = create_dummy_request(user=username) request.route_url = lambda name, _query: f"http://server/{name}?{urlencode(_query)}" request.matchdict = {"layer_id": str(layerid)} request.params = params return request
def _create_getcap_request(username=None, additional_settings=None): if additional_settings is None: additional_settings = {} from c2cgeoportal.models import DBSession, User request = create_dummy_request(additional_settings) request.user = None if username is None else \ DBSession.query(User).filter_by(username=username).one() return request
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(**kwargs) request.static_url = lambda url: "/dummy/static/url" request.route_url = lambda url, **kwargs: mapserv_url request.params = params return request
def _create_getcap_request(username=None): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request() request.user = None if username is None else DBSession.query( User).filter_by(username=username).one() request.params.update({"ogcserver": "__test_ogc_server"}) return request
def _get_request(layerid, username=None, params=None): if params is None: params = {} request = create_dummy_request(user=username) request.static_url = lambda url: "/dummy/static/url" request.route_url = lambda name, _query: "http://server/{}?{}".format(name, urlencode(_query)) request.matchdict = {"layer_id": str(layerid)} request.params = params return request
def test_request_right_auth(self): request = create_dummy_request( {'basicauth': 'true'}, headers={ "Authorization": "Basic " + base64.b64encode("__test_user:__test_user".encode( "utf-8")).decode("utf-8").replace("\n", "") }) self.assertEqual(request.user.username, "__test_user")
def _create_dummy_request(username=None): request = create_dummy_request({ "admin_interface": { "available_functionalities": [ "mapserver_substitution", "print_template", ] } }, user=username) return request
def get_user(self, aeskey, user, password, valid): token = create_token(aeskey, user, password, valid) request = create_dummy_request({"urllogin": { "aes_key": aeskey }}, params={"auth": token}) get_user_from_request = create_get_user_from_request( request.registry.settings) get_user_from_request(request) return self.user
def test_wrong_key(self): token = create_token("foobar1234567890", "__test_user1", "__test_user1", 1) request = create_dummy_request({ "urllogin": { "aes_key": "foobar1234567891" } }, params={"auth": token}) get_user_from_request = create_get_user_from_request(request.registry.settings) get_user_from_request(request) self.assertIsNone(self.user)
def get_user(self, aeskey, user, password, valid): token = create_token(aeskey, user, password, valid) request = create_dummy_request({ "urllogin": { "aes_key": aeskey } }, params={"auth": token}) get_user_from_request = create_get_user_from_request(request.registry.settings) get_user_from_request(request) return self.user
def _create_entry_obj(params=None, **kargs): if params is None: params = {} from c2cgeoportal_geoportal.views.entry import Entry request = create_dummy_request(**kargs) request.route_url = lambda url, **kwargs: mapserv_url request.params = params return Entry(request)
def get_user(self, aeskey, user, password, valid, remember_mock): token = create_token(aeskey, user, password, valid) request = create_dummy_request(params={"auth": token}) policy = UrlAuthenticationPolicy(aeskey, defaultgroupsfinder) userid = policy.unauthenticated_userid(request) if userid is not None: remember_mock.assert_called_once_with(request, userid) else: remember_mock.assert_not_called() return userid
def test_web_client_functionalities(self): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User from tests.functional import create_dummy_request from c2cgeoportal_geoportal.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_wrong_key(self): token = create_token("foobar1234567890", "__test_user1", "__test_user1", 1) request = create_dummy_request( {"urllogin": { "aes_key": "foobar1234567891" }}, params={"auth": token}) get_user_from_request = create_get_user_from_request( request.registry.settings) get_user_from_request(request) self.assertIsNone(self.user)
def _get_request(layerid, username=None, params=None): if params is None: params = {} request = create_dummy_request(user=username) request.static_url = lambda url: "/dummy/static/url" request.route_url = lambda name, _query: "http://server/{}?{}".format( name, urlencode(_query)) request.matchdict = {"layer_id": str(layerid)} request.params = params from c2cgeoportal_geoportal.lib import functionality functionality.FUNCTIONALITIES_TYPES = None return request
def _create_dummy_request(username=None, params=None): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request( {"fulltextsearch": {"languages": {"fr": "french", "en": "english", "de": "german"}}}, params=params, ) request.response = Response() request.user = None if username: request.user = DBSession.query(User).filter_by(username=username).one() return request
def test_difference(self): from shapely.geometry import Polygon from c2cgeoportal_geoportal.views.geometry_processing import GeometryProcessing request = create_dummy_request() request.method = "POST" request.body = '{ "geometries": [{ "type": "Polygon", "coordinates": [[[0, 0], [0, 4], [4, 4], [4, 0], [0, 0]]] }, ' \ '{ "type": "Polygon", "coordinates": [[[2, 1], [2, 3], [6, 3], [6, 1], [2, 1]]] }]}' geom_ops = GeometryProcessing(request) geom = geom_ops.difference() self.assertEqual( geom, Polygon([(0, 0), (0, 4), (4, 4), (4, 3), (2, 3), (2, 1), (4, 1), (4, 0), (0, 0)]))
def _create_dummy_request(username=None): request = create_dummy_request( { "admin_interface": { "available_functionalities": [{ "name": "mapserver_substitution" }, { "name": "print_template" }] } }, user=username) request.params.update({"ogcserver": "__test_ogc_server"}) return request
def _create_dummy_request(username=None): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request({ "tinyowsproxy": { "tinyows_url": "http://localhost/tinyows", "ogc_server": "__test_ogc_server", # "online_resource": "http://domain.com/tinyows_proxy", # "proxy_online_resource": "http://domain.com/tinyows" } }) request.user = None if username is None else DBSession.query( User).filter_by(username=username).one() return request
def _create_request_obj(username=None, params=None, **kwargs): if params is None: params = {} from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request(**kwargs) request.route_url = lambda url, **kwargs: mapserv_url request.interface_name = "main" request.params = params if username is not None: request.user = DBSession.query(User).filter_by(username=username).one() return request
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(**kwargs) request.static_url = lambda url: "/dummy/static/url" def route_url(name, _query=None, **kwargs): if _query is None: return "http://localhost/travis/mapserv" else: return "http://localhost/travis/mapserv?" + "&".join(["=".join(i) for i in list(_query.items())]) request.route_url = route_url request.params = params return request
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(**kwargs) def route_url(name, _query=None, **kwargs): del name # Unused del kwargs # Unused if _query is None: return "http://localhost/ci/mapserv" else: return "http://localhost/ci/mapserv?" + "&".join(["=".join(i) for i in list(_query.items())]) request.route_url = route_url request.params = params return request
def _create_request_obj(username=None, **kwargs): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request(**kwargs) request.registry.settings.update({ "authentication": { "two_factor": True, "two_factor_issuer_name": "CI" } }) if username is not None: request.user = DBSession.query(User).filter_by( username=username).one() return request
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(**kwargs) request.static_url = lambda url: "/dummy/static/url" def route_url(name, _query=None, **kwargs): if _query is None: return "http://localhost/travis/mapserv" else: return "http://localhost/travis/mapserv?" + "&".join( ["=".join(i) for i in list(_query.items())]) request.route_url = route_url request.params = params return request
def test_request_auth_overwritten_property(self): def setter(request): class User: pass class Role: pass u = User() u.username = "******" u.role = Role() u.role.name = "__bar" return u request = create_dummy_request(authentication=False, user="******") request.set_property(setter, name="user", reify=True) self.assertEqual(request.user.username, "__foo") self.assertEqual(request.user.role.name, "__bar")
def _create_dummy_request(username=None, params=None): from c2cgeoportal_commons.models import DBSession from c2cgeoportal_commons.models.static import User request = create_dummy_request({ "fulltextsearch": { "languages": { "fr": "french", "en": "english", "de": "german", } } }, params=params) request.response = Response() request.user = None if username: request.user = DBSession.query(User) \ .filter_by(username=username).one() return request
def _create_request_obj(params=None, **kwargs): if params is None: params = {} request = create_dummy_request(additional_settings={ "admin_interface": { "available_metadata": [ { "name": "minResolution", "type": "float" }, { "name": "maxResolution", "type": "float" } ] } }, **kwargs) request.static_url = lambda url: "/dummy/static/url" request.route_url = lambda url, **kwargs: mapserv_url request.params = params return request
def _wms_get_capabilities(ogcserver, service="wms", username=None): from c2cgeoportal_geoportal.views.mapserverproxy import MapservProxy request = create_dummy_request({ "admin_interface": { "available_functionalities": [ "mapserver_substitution", "print_template", ] }, "servers": { "srv": "http://example.com" } }, user=username) request.params.update(dict( service=service, version="1.1.1", request="getcapabilities", ogcserver=ogcserver )) return MapservProxy(request).proxy()
def test_request_no_auth(self): request = create_dummy_request() self.assertEqual(request.user, None)
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() settings = { "functionalities": { "anonymous": {}, "registered": {}, }, "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) self.assertEqual(get_functionality("__test_s", request), []) self.assertEqual(get_functionality("__test_a", request), []) self.assertEqual(get_functionality("__test_s", request1), []) self.assertEqual(get_functionality("__test_a", request1), []) self.assertEqual(get_functionality("__test_s", request2), ["db"]) self.assertEqual(get_functionality("__test_a", request2), ["db1", "db2"]) settings = { "functionalities": { "anonymous": {}, "registered": { "__test_s": "registered", "__test_a": ["r1", "r2"] } }, "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) self.assertEqual(get_functionality("__test_s", request), []) self.assertEqual(get_functionality("__test_a", request), []) self.assertEqual(get_functionality("__test_s", request1), ["registered"]) self.assertEqual(get_functionality("__test_a", request1), ["r1", "r2"]) self.assertEqual(get_functionality("__test_s", request2), ["db"]) self.assertEqual(get_functionality("__test_a", request2), ["db1", "db2"]) settings = { "functionalities": { "anonymous": { "__test_s": "anonymous", "__test_a": ["a1", "a2"] }, "registered": {} }, "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) self.assertEqual(get_functionality("__test_s", request), ["anonymous"]) self.assertEqual(get_functionality("__test_a", request), ["a1", "a2"]) self.assertEqual(get_functionality("__test_s", request1), ["anonymous"]) self.assertEqual(get_functionality("__test_a", request1), ["a1", "a2"]) self.assertEqual(get_functionality("__test_s", request2), ["db"]) self.assertEqual(get_functionality("__test_a", request2), ["db1", "db2"]) settings = { "functionalities": { "anonymous": { "__test_s": "anonymous", "__test_a": ["a1", "a2"] }, "registered": { "__test_s": "registered", "__test_a": ["r1", "r2"] } }, "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) self.assertEqual(get_functionality("__test_s", request), ["anonymous"]) self.assertEqual(get_functionality("__test_a", request), ["a1", "a2"]) self.assertEqual(get_functionality("__test_s", request1), ["registered"]) self.assertEqual(get_functionality("__test_a", request1), ["r1", "r2"]) self.assertEqual(get_functionality("__test_s", request2), ["db"]) self.assertEqual(get_functionality("__test_a", request2), ["db1", "db2"])
def test_request_auth(self): request = create_dummy_request(authentication=False, user="******") self.assertEqual(request.user.username, "__test_user") self.assertEqual(request.user.role.name, "__test_role")
def test_metadata(self): from c2cgeoportal_geoportal.views.entry import Entry types = [ {"name": "string", "type": "string"}, {"name": "list", "type": "list"}, {"name": "boolean", "type": "boolean"}, {"name": "boolean2", "type": "boolean"}, {"name": "boolean3", "type": "boolean"}, {"name": "integer", "type": "integer"}, {"name": "float", "type": "float"}, {"name": "json", "type": "json"}, {"name": "json_wrong", "type": "json"}, {"name": "date", "type": "date"}, {"name": "time", "type": "time"}, {"name": "datetime", "type": "datetime"}, {"name": "date2", "type": "date"}, {"name": "time2", "type": "time"}, {"name": "datetime2", "type": "datetime"}, {"name": "unknown", "type": "unknown"}, ] types += [{"name": "url{}".format(n), "type": "url"} for n in range(1, 21)] request = create_dummy_request(additional_settings={ "package": "tests", "servers": { "server": "http://example.com/test" }, "admin_interface": {"available_metadata": types} }) def route_url(url, **kargs): return "http://mapserver.org/" request.route_url = route_url def static_url(url, **kargs): return "http://dummy.org/{}".format(url) request.static_url = static_url request.params = { "version": "2", "interface": "desktop", } entry = Entry(request) themes = entry.themes() self.assertEqual(self._get_filtered_errors(themes), set([ "The boolean attribute 'boolean3'='hello' is not in [yes, y, on, 1, true, no, n, off, 0, false].", "Unable to parse the attribute 'json_wrong'='{\"test\": 123' with the type 'json', error:\n'set' object has no attribute 'append'", "The date attribute 'date2'='Sep 25 10:36:28 BRST 2003' should not have any time", "The time attribute 'time2'='Sep 25 10:36:28 BRST 2003' should not have any date", "Unable to parse the attribute 'datetime2'='Hello' with the type 'datetime', error:\nUnknown string format", "The attribute 'url11'='https:///static/icon.png' is not a valid URL.", "The attribute 'url12'='static://test' cannot have an empty path.", "The attribute 'url13'='static://test/' cannot have an empty path.", "The attribute 'url14'='config:///static/icon.png' cannot have an empty netloc.", "The server 'unknown_server' is not found in the config", "The attribute 'url16'='https://' is not a valid URL.", "The attribute 'url17'='https:///' is not a valid URL.", "The attribute 'url18'='https:///static' is not a valid URL.", "The attribute 'url19'='' is not an URL.", "The attribute 'url20'='/' is not an URL.", "Unknown type 'unknown'.", ])) self.assertEqual( [self._only_name(t, "metadata") for t in themes["themes"]], [{ "metadata": {}, "children": [{ "metadata": {}, "children": [{ "metadata": { "string": "string", "list": ["1", "2", "a"], "boolean": True, "boolean2": False, "integer": 1, "float": 5.5, "json": {"test": 123}, "date": "2003-09-25", "time": "10:36:28", "datetime": "2003-09-25T10:36:28", "url1": "http://example.com/hi?a=b#c", "url2": "http://dummy.org/tests_geoportal:static/path/icon.png", "url3": "http://dummy.org/tests:static/path/icon.png", "url4": "http://dummy.org/tests:cgxp/path/icon.png", "url5": "http://dummy.org/project:static/path/icon.png", "url6": "http://dummy.org/project:cgxp/path/icon.png", "url7": "http://example.com/test", "url8": "http://example.com/test/index.html", "url9": "/dummy/static/icon.png", "url10": "dummy/static/icon.png", } }] }] }] )