def test_web_client_functionalities(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.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.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 _create_getcap_request(self, username=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(self, params={}, **kwargs):
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_request_obj(self, params={}, **kwargs):
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.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 _create_getcap_request(self, username=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(self, params={}, **kwargs):
request = create_dummy_request(**kwargs)
request.static_url = lambda url: "/dummy/static/url"
request.route_url = lambda url, **kwargs: \
request.registry.settings["mapserverproxy"]["mapserv_url"]
request.params = params
return request
def _get_request(self, 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_web_client_functionalities(self):
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.tests.functional import mapserv_url, 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"]
},
"mapserverproxy": {
"mapserv_url": mapserv_url,
"geoserver": False,
},
}
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.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 _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 _get_request(self, 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 _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_entry_obj(self, username=None, params={}):
from c2cgeoportal.views.entry import Entry
request = create_dummy_request()
request.static_url = lambda url: "/dummy/static/url"
request.route_url = lambda url, **kwargs: \
request.registry.settings["mapserverproxy"]["mapserv_url"]
request.params = params
return Entry(request)
def _create_dummy_request(self, username=None, params=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request(params=params)
request.response = Response()
request.user = None
if username:
request.user = DBSession.query(User) \
.filter_by(username=username).one()
return request
def _create_getcap_request(self, username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"mapserverproxy": {"mapserv_url": "%s?map=%s" % (mapserv_url, os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"c2cgeoportal_test.map"
))}
})
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def _create_request_obj(self, username=None, params={}, **kwargs):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request(**kwargs)
request.static_url = lambda url: "/dummy/static/url"
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_dummy_request(username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"tinyowsproxy": {
"tinyows_url": "http://localhost/tinyows",
"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_dummy_request(username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"tinyowsproxy": {
"tinyows_url": "http://localhost/tinyows",
"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(self, username=None, params={}, **kwargs):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request(**kwargs)
request.static_url = lambda url: "/dummy/static/url"
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 test_difference(self):
from shapely.geometry import Polygon
from c2cgeoportal.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.assertEquals(
geom,
Polygon([(0, 0), (0, 4), (4, 4), (4, 3), (2, 3), (2, 1), (4, 1), (4, 0), (0, 0)])
)
def _create_request_obj(self, params={}, **kwargs):
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 _query.items()])
request.route_url = route_url
request.params = params
return request
def _create_dummy_request(username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"admin_interface": {
"available_functionalities": [
"mapserver_substitution",
"print_template",
]
}
})
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def test_difference(self):
from shapely.geometry import Polygon
from c2cgeoportal.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.assertEquals(
geom,
Polygon([(0, 0), (0, 4), (4, 4), (4, 3), (2, 3), (2, 1), (4, 1), (4, 0), (0, 0)])
)
def _create_request_obj(self, params={}, **kwargs):
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 _query.items()])
request.route_url = route_url
request.params = params
return request
def _create_dummy_request(self, username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"mapserverproxy": {
"mapserv_url": mapserv_url,
"geoserver": False,
},
})
request.params = {"map": os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"c2cgeoportal_test.map"
)}
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def _create_dummy_request(self, username=None, params=None):
from c2cgeoportal.models import DBSession, 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_dummy_request(self, username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"admin_interface": {
"available_functionalities": [
"mapserver_substitution",
"print_template",
]
}
})
request.params = {"map": os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"c2cgeoportal_test.map"
)}
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def _create_dummy_request(username=None, params=None):
from c2cgeoportal.models import DBSession, 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_dummy_request(self, username=None):
from c2cgeoportal.models import DBSession, User
request = create_dummy_request({
"admin_interface": {
"available_functionalities": [
"mapserver_substitution",
"print_template",
]
}
})
request.params = {
"map":
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"c2cgeoportal_test.map")
}
request.user = None if username is None else \
DBSession.query(User).filter_by(username=username).one()
return request
def test_functionalities(self):
from c2cgeoportal.tests.functional import create_dummy_request
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.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.assertEquals(get_functionality("__test_s", request), [])
self.assertEquals(get_functionality("__test_a", request), [])
self.assertEquals(get_functionality("__test_s", request1), [])
self.assertEquals(get_functionality("__test_a", request1), [])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request), [])
self.assertEquals(get_functionality("__test_a", request), [])
self.assertEquals(get_functionality("__test_s", request1),
["registered"])
self.assertEquals(get_functionality("__test_a", request1),
["r1", "r2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request),
["anonymous"])
self.assertEquals(get_functionality("__test_a", request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request1),
["anonymous"])
self.assertEquals(get_functionality("__test_a", request1),
["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request),
["anonymous"])
self.assertEquals(get_functionality("__test_a", request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request1),
["registered"])
self.assertEquals(get_functionality("__test_a", request1),
["r1", "r2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(get_functionality("__test_a", request2),
["db1", "db2"])
def test_functionalities(self):
from c2cgeoportal.tests.functional import create_dummy_request
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.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.assertEquals(get_functionality("__test_s", request), [])
self.assertEquals(get_functionality("__test_a", request), [])
self.assertEquals(get_functionality("__test_s", request1), [])
self.assertEquals(get_functionality("__test_a", request1), [])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request), [])
self.assertEquals(get_functionality("__test_a", request), [])
self.assertEquals(get_functionality("__test_s", request1), ["registered"])
self.assertEquals(get_functionality("__test_a", request1), ["r1", "r2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request), ["anonymous"])
self.assertEquals(get_functionality("__test_a", request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request1), ["anonymous"])
self.assertEquals(get_functionality("__test_a", request1), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(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.assertEquals(get_functionality("__test_s", request), ["anonymous"])
self.assertEquals(get_functionality("__test_a", request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", request1), ["registered"])
self.assertEquals(get_functionality("__test_a", request1), ["r1", "r2"])
self.assertEquals(get_functionality("__test_s", request2), ["db"])
self.assertEquals(get_functionality("__test_a", request2), ["db1", "db2"])
def test_metadata(self):
from c2cgeoportal.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": "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}
})
request.static_url = lambda url: "http://dummy.org/{}".format(url)
request.params = {
"version": "2",
"interface": "desktop",
}
entry = Entry(request)
themes = entry.themes()
self.assertEquals(set(themes["errors"]), set([
"The boolean attribute 'boolean3'='hello' is not in [yes, y, on, 1, true, no, n, off, 0, false].",
"The date attribute '{}'='{}' shouldn't have any time",
"The time attribute '{}'='{}' shouldn't 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' isn't a valid URL.",
"The attribute 'url12'='static://test' can't have an empty path.",
"The attribute 'url13'='static://test/' can't have an empty path.",
"The attribute 'url14'='config:///static/icon.png' can't have an empty netloc.",
"The server 'unknown_server' isn't found in the config",
"The attribute 'url16'='https://' isn't a valid URL.",
"The attribute 'url17'='https:///' isn't a valid URL.",
"The attribute 'url18'='https:///static' isn't a valid URL.",
"The attribute 'url19'='' isn't an URL.",
"The attribute 'url20'='/' isn't an URL.",
"Unknown type 'unknown'.",
]))
self.assertEquals(
[self._only_name(t, "metadata") for t in themes["themes"]],
[{
"metadata": {},
"children": [{
"metadata": {},
"children": [{
"metadata": {
u"string": u"string",
u"list": [u"1", u"2", u"a"],
u"boolean": True,
u"boolean2": False,
u"integer": 1,
u"float": 5.5,
u"date": "2003-09-25",
u"time": "10:36:28",
u"datetime": "2003-09-25T10:36:28",
u"url1": u"http://example.com/hi?a=b#c",
u"url2": "http://dummy.org/tests:static/path/icon.png",
u"url3": "http://dummy.org/tests:static/path/icon.png",
u"url4": "http://dummy.org/tests:cgxp/path/icon.png",
u"url5": "http://dummy.org/project:static/path/icon.png",
u"url6": "http://dummy.org/project:cgxp/path/icon.png",
u"url7": u"http://example.com/test?",
u"url8": u"http://example.com/test/index.html?",
u"url9": u"/dummy/static/icon.png",
u"url10": u"dummy/static/icon.png",
}
}]
}]
}]
)
def test_functionalities(self):
from c2cgeoportal.tests.functional import create_dummy_request
from c2cgeoportal.models import DBSession, User
from c2cgeoportal.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": {},
}
}
self.assertEquals(get_functionality("__test_s", settings, request), [])
self.assertEquals(get_functionality("__test_a", settings, request), [])
self.assertEquals(get_functionality("__test_s", settings, request1), [])
self.assertEquals(get_functionality("__test_a", settings, request1), [])
self.assertEquals(get_functionality("__test_s", settings, request2), ["db"])
self.assertEquals(get_functionality("__test_a", settings, request2), ["db1", "db2"])
settings = {
"functionalities": {
"anonymous": {},
"registered": {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
}
}
}
self.assertEquals(get_functionality("__test_s", settings, request), [])
self.assertEquals(get_functionality("__test_a", settings, request), [])
self.assertEquals(get_functionality("__test_s", settings, request1), ["registered"])
self.assertEquals(get_functionality("__test_a", settings, request1), ["r1", "r2"])
self.assertEquals(get_functionality("__test_s", settings, request2), ["db"])
self.assertEquals(get_functionality("__test_a", settings, request2), ["db1", "db2"])
settings = {
"functionalities": {
"anonymous": {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
"registered": {}
}
}
self.assertEquals(get_functionality("__test_s", settings, request), ["anonymous"])
self.assertEquals(get_functionality("__test_a", settings, request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", settings, request1), ["anonymous"])
self.assertEquals(get_functionality("__test_a", settings, request1), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", settings, request2), ["db"])
self.assertEquals(get_functionality("__test_a", settings, request2), ["db1", "db2"])
settings = {
"functionalities": {
"anonymous": {
"__test_s": "anonymous",
"__test_a": ["a1", "a2"]
},
"registered": {
"__test_s": "registered",
"__test_a": ["r1", "r2"]
}
}
}
self.assertEquals(get_functionality("__test_s", settings, request), ["anonymous"])
self.assertEquals(get_functionality("__test_a", settings, request), ["a1", "a2"])
self.assertEquals(get_functionality("__test_s", settings, request1), ["registered"])
self.assertEquals(get_functionality("__test_a", settings, request1), ["r1", "r2"])
self.assertEquals(get_functionality("__test_s", settings, request2), ["db"])
self.assertEquals(get_functionality("__test_a", settings, request2), ["db1", "db2"])
