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_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 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 _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_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 _create_dummy_request(username=None):
request = create_dummy_request({
"admin_interface": {
"available_functionalities": [
"mapserver_substitution",
"print_template",
]
}
}, user=username)
return request
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_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 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",
}
}]
}]
}]
)
