def setUp(self):
from c2cgeoportal.models import DBSession, User, Role, Layer, \
RestrictionArea, Theme, LayerGroup
role1 = Role(name=u'__test_role1')
user1 = User(username=u'__test_user1',
password=u'__test_user1',
role=role1)
role2 = Role(name=u'__test_role2',
extent=WKTSpatialElement(
"POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))", srid=21781))
user2 = User(username=u'__test_user2',
password=u'__test_user2',
role=role2)
public_layer = Layer(name=u'__test_public_layer',
order=40,
public=True)
public_layer.isChecked = False
private_layer = Layer(name=u'__test_private_layer',
order=40,
public=False)
private_layer.geoTable = 'a_schema.a_geo_table'
layer_in_group = Layer(name=u'__test_layer_in_group')
layer_group = LayerGroup(name=u'__test_layer_group')
layer_group.children = [layer_in_group]
layer_wmsgroup = Layer(name=u'test_wmsfeaturesgroup')
layer_wmsgroup.isChecked = False
theme = Theme(name=u'__test_theme')
theme.children = [
public_layer, private_layer, layer_group, layer_wmsgroup
]
poly = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTSpatialElement(poly, srid=21781)
RestrictionArea(name=u'__test_ra1',
description=u'',
layers=[private_layer],
roles=[role1],
area=area)
area = WKTSpatialElement(poly, srid=21781)
RestrictionArea(name=u'__test_ra2',
description=u'',
layers=[private_layer],
roles=[role2],
area=area,
readwrite=True)
DBSession.add_all([user1, user2, public_layer, private_layer])
transaction.commit()
def setUp(self):
from c2cgeoportal.models import DBSession, User, Role, Layer, \
RestrictionArea, Theme, LayerGroup
role1 = Role(name=u'__test_role1')
user1 = User(username=u'__test_user1', password=u'__test_user1', role=role1)
role2 = Role(name=u'__test_role2', extent=WKTSpatialElement(
"POLYGON((1 2, 1 4, 3 4, 3 2, 1 2))", srid=21781
))
user2 = User(username=u'__test_user2', password=u'__test_user2', role=role2)
public_layer = Layer(name=u'__test_public_layer', order=40, public=True)
public_layer.isChecked = False
private_layer = Layer(name=u'__test_private_layer', order=40, public=False)
private_layer.geoTable = 'a_schema.a_geo_table'
layer_in_group = Layer(name=u'__test_layer_in_group')
layer_group = LayerGroup(name=u'__test_layer_group')
layer_group.children = [layer_in_group]
layer_wmsgroup = Layer(name=u'test_wmsfeaturesgroup')
layer_wmsgroup.isChecked = False
theme = Theme(name=u'__test_theme')
theme.children = [public_layer, private_layer, layer_group,
layer_wmsgroup]
poly = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTSpatialElement(poly, srid=21781)
RestrictionArea(name=u'__test_ra1', description=u'',
layers=[private_layer],
roles=[role1], area=area)
area = WKTSpatialElement(poly, srid=21781)
RestrictionArea(
name=u'__test_ra2', description=u'',
layers=[private_layer],
roles=[role2], area=area, readwrite=True
)
DBSession.add_all([user1, user2, public_layer, private_layer])
transaction.commit()
def setUp(self):
self.config = testing.setUp()
from c2cgeoportal.models import DBSession, User, Role, Layer, RestrictionArea, Theme, LayerGroup
role1 = Role(name=u"__test_role1")
user1 = User(username=u"__test_user1", password=u"__test_user1", role=role1)
role2 = Role(name=u"__test_role2")
user2 = User(username=u"__test_user2", password=u"__test_user2", role=role2)
public_layer = Layer(name=u"__test_public_layer", order=40, public=True)
public_layer.isChecked = False
private_layer = Layer(name=u"__test_private_layer", order=40, public=False)
private_layer.geoTable = "a_schema.a_geo_table"
layer_in_group = Layer(name=u"__test_layer_in_group")
layer_group = LayerGroup(name=u"__test_layer_group")
layer_group.children = [layer_in_group]
theme = Theme(name=u"__test_theme")
theme.children = [public_layer, private_layer, layer_group]
poly = "POLYGON((-100 0, -100 20, 100 20, 100 0, -100 0))"
area = WKTSpatialElement(poly, srid=21781)
ra = RestrictionArea(name=u"__test_ra1", description=u"", layers=[private_layer], roles=[role1], area=area)
area = WKTSpatialElement(poly, srid=21781)
ra = RestrictionArea(
name=u"__test_ra2", description=u"", layers=[private_layer], roles=[role2], area=area, readwrite=True
)
DBSession.add_all([user1, user2, public_layer, private_layer])
transaction.commit()
def test_layer(self):
import httplib2
from c2cgeoportal.views.entry import Entry
from c2cgeoportal.models import Layer, LayerGroup
from c2cgeoportal.lib.wmstparsing import TimeInformation
request = self._create_request_obj()
request.static_url = lambda name: '/dummy/static/' + name
request.route_url = lambda name: '/dummy/route/' + name
request.registry.settings['project'] = 'test_layer'
entry = Entry(request)
self.assertEqual(
entry._group(LayerGroup(), [], [], None, TimeInformation()),
(None, [], False))
layer = Layer()
layer.id = 20
layer.name = 'test internal WMS'
layer.metadataURL = "http://example.com/tiwms"
layer.isChecked = True
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.style = "my-style"
layer.kml = "tiwms.kml"
layer.legend = True
layer.legendRule = "rule"
layer.legendImage = "legend:static/tiwms-legend.png"
layer.isLegendExpanded = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.disclaimer = "Camptocamp"
layer.identifierAttributeField = "name"
layer.geoTable = "tiwms"
layer.public = True
self.assertEqual(entry._layer(layer, [], None, TimeInformation(
)), ({
'id': 20,
'name': 'test internal WMS',
'metadataURL': 'http://example.com/tiwms',
'isChecked': True,
'icon': '/dummy/route/mapserverproxy?SERVICE=WMS&VERSION=1.1.1&'
'REQUEST=GetLegendGraphic&LAYER=test internal WMS&FORMAT=image/png&TRANSPARENT=TRUE&RULE=rule',
'type': u'internal WMS',
'imageType': 'image/png',
'style': 'my-style',
'kml': '/dummy/static/test_layer:static/tiwms.kml',
'legend': True,
'legendImage': '/dummy/static/legend:static/tiwms-legend.png',
'isLegendExpanded': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'disclaimer': 'Camptocamp',
'identifierAttribute': 'name',
'editable': True,
'public': True,
}, ['The layer test internal WMS is not defined in WMS capabilities']))
layer = Layer()
layer.id = 20
layer.name = 'test external WMS'
layer.isChecked = False
layer.icon = "tewms.png"
layer.layerType = "external WMS"
layer.url = "http://example.com"
layer.imageType = "image/jpeg"
layer.isSingleTile = True
layer.legend = False
layer.isLegendExpanded = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(
layer, [], None, TimeInformation), ({
'id': 20,
'name': 'test external WMS',
'icon': '/dummy/static/test_layer:static/tewms.png',
'isChecked': False,
'type': u'external WMS',
'url': 'http://example.com',
'imageType': 'image/jpeg',
'isSingleTile': True,
'legend': False,
'isLegendExpanded': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.style = 'wmts-style'
layer.dimensions = '{"DATE": "1012"}'
layer.matrixSet = "swissgrid"
layer.wmsUrl = 'http://example.com/'
layer.wmsLayers = 'test'
layer.legend = False
layer.isLegendExpanded = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None, TimeInformation()),
({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'style': 'wmts-style',
'dimensions': {
u'DATE': u'1012'
},
'matrixSet': 'swissgrid',
'wmsUrl': 'http://example.com/',
'wmsLayers': 'test',
'legend': False,
'isLegendExpanded': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsUrl = 'http://example.com/'
layer.legend = False
layer.isLegendExpanded = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None, TimeInformation()),
({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': 'http://example.com/',
'wmsLayers': 'test WMTS',
'legend': False,
'isLegendExpanded': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'test'
layer.legend = False
layer.isLegendExpanded = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None, TimeInformation()),
({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': '/dummy/route/mapserverproxy',
'wmsLayers': 'test',
'queryLayers': [],
'legend': False,
'isLegendExpanded': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test no 2D'
layer.isChecked = False
layer.layerType = "no 2D"
layer.legend = False
layer.isLegendExpanded = False
layer.metadataURL = 'http://example.com/wmsfeatures.metadata'
layer.public = True
self.assertEqual(entry._layer(
layer, [], None, TimeInformation()), ({
'id': 20,
'name': u'test no 2D',
'isChecked': False,
'type': u'no 2D',
'legend': False,
'isLegendExpanded': False,
'metadataURL': u'http://example.com/wmsfeatures.metadata',
'public': True,
}, []))
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
mapfile = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'c2cgeoportal_test.map')
params = (
('map', mapfile),
('SERVICE', 'WMS'),
('VERSION', '1.1.1'),
('REQUEST', 'GetCapabilities'),
)
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
url = mapserv + '&'.join(['='.join(p) for p in params])
http = httplib2.Http()
h = {'Host': host}
resp, xml = http.request(url, method='GET', headers=h)
wms = WebMapService(None, xml=xml)
wms_layers = list(wms.contents)
layer = Layer()
layer.id = 20
layer.name = 'test_wmsfeaturesgroup'
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.isChecked = False
layer.legend = False
layer.isLegendExpanded = False
layer.public = True
self.assertEqual(
entry._layer(layer, wms_layers, wms, TimeInformation()), ({
'id':
20,
'name':
u'test_wmsfeaturesgroup',
'type':
u'internal WMS',
'isChecked':
False,
'legend':
False,
'isLegendExpanded':
False,
'imageType':
u'image/png',
'minResolutionHint':
1.76,
'maxResolutionHint':
8.8200000000000003,
'public':
True,
'queryable':
0,
'metadataUrls': [{
'url': 'http://example.com/wmsfeatures.metadata',
'type': 'TC211',
'format': 'text/plain',
}],
'childLayers': [{
'name': u'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003,
'queryable': 1,
}],
}, []))
layer_t1 = Layer()
layer_t1.id = 20
layer_t1.name = 'test_wmstime'
layer_t1.layerType = "internal WMS"
layer_t1.imageType = "image/png"
layer_t1.isChecked = False
layer_t1.legend = False
layer_t1.isLegendExpanded = False
layer_t1.public = True
layer_t1.timeMode = 'single'
time = TimeInformation()
entry._layer(layer_t1, wms_layers, wms, time)
self.assertEqual(
time.to_dict(), {
'resolution': 'year',
'interval': (1, 0, 0, 0),
'maxValue': '2010-01-01T00:00:00Z',
'minValue': '2000-01-01T00:00:00Z',
'mode': 'single',
})
layer_t2 = Layer()
layer_t2.id = 30
layer_t2.name = 'test_wmstime2'
layer_t2.layerType = "internal WMS"
layer_t2.imageType = "image/png"
layer_t2.isChecked = False
layer_t2.legend = False
layer_t2.isLegendExpanded = False
layer_t2.public = True
layer_t2.timeMode = 'single'
time = TimeInformation()
entry._layer(layer_t2, wms_layers, wms, time)
self.assertEqual(
time.to_dict(), {
'resolution': 'year',
'interval': (1, 0, 0, 0),
'maxValue': '2020-01-01T00:00:00Z',
'minValue': '2015-01-01T00:00:00Z',
'mode': 'single',
})
group = LayerGroup()
group.name = 'time'
group.children = [layer_t1, layer_t2]
time = TimeInformation()
entry._group(group, [layer_t1, layer_t2], wms_layers, wms, time)
self.assertEqual(
time.to_dict(), {
'resolution': 'year',
'interval': (1, 0, 0, 0),
'maxValue': '2020-01-01T00:00:00Z',
'minValue': '2000-01-01T00:00:00Z',
'mode': 'single',
})
layer = Layer()
layer.id = 20
layer.name = 'test_wmstimegroup'
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.isChecked = False
layer.legend = False
layer.isLegendExpanded = False
layer.public = True
layer.timeMode = 'single'
time = TimeInformation()
entry._layer(layer, wms_layers, wms, time)
self.assertEqual(
time.to_dict(), {
'resolution': 'year',
'interval': (1, 0, 0, 0),
'maxValue': '2020-01-01T00:00:00Z',
'minValue': '2000-01-01T00:00:00Z',
'mode': 'single',
})
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'test_wmsfeatures'
layer.legend = False
layer.isLegendExpanded = False
layer.public = True
self.assertEqual(
entry._layer(layer, wms_layers, wms, TimeInformation()), ({
'id':
20,
'name':
'test WMTS',
'isChecked':
False,
'type':
'WMTS',
'url':
'http://example.com/WMTS-Capabilities.xml',
'wmsUrl':
'/dummy/route/mapserverproxy',
'wmsLayers':
'test_wmsfeatures',
'queryLayers': [{
'name': 'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003
}],
'legend':
False,
'isLegendExpanded':
False,
'public':
True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'foo'
layer.queryLayers = 'test_wmsfeatures'
layer.legend = False
layer.isLegendExpanded = False
layer.public = True
self.assertEqual(
entry._layer(layer, wms_layers, wms, TimeInformation()), ({
'id':
20,
'name':
'test WMTS',
'isChecked':
False,
'type':
'WMTS',
'url':
'http://example.com/WMTS-Capabilities.xml',
'wmsUrl':
'/dummy/route/mapserverproxy',
'wmsLayers':
'foo',
'queryLayers': [{
'name': 'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003
}],
'legend':
False,
'isLegendExpanded':
False,
'public':
True,
}, []))
group1 = LayerGroup()
group1.name = 'block'
group2 = LayerGroup()
group2.name = 'node'
group2.metadataURL = 'http://example.com/group.metadata'
layer = Layer()
layer.id = 20
layer.name = 'test layer in group'
layer.isChecked = False
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.legend = False
layer.isLegendExpanded = False
layer.public = True
group1.children = [group2]
group2.children = [layer]
self.assertEqual(
entry._group(group1, [layer], [], None, TimeInformation()), ({
'isExpanded':
False,
'isInternalWMS':
True,
'name':
u'block',
'isBaseLayer':
False,
'children': [{
'isExpanded':
False,
'isInternalWMS':
True,
'name':
u'node',
'isBaseLayer':
False,
'metadataURL':
'http://example.com/group.metadata',
'children': [{
'name': u'test layer in group',
'id': 20,
'isChecked': False,
'type': u'internal WMS',
'legend': False,
'isLegendExpanded': False,
'imageType': u'image/png',
'public': True,
}]
}]
}, [
'The layer test layer in group is not defined in WMS capabilities'
], False))
group1 = LayerGroup()
group1.isInternalWMS = True
group2 = LayerGroup()
group2.isInternalWMS = False
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None, TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group1 = LayerGroup()
group1.isInternalWMS = False
group2 = LayerGroup()
group2.isInternalWMS = True
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None, TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'internal WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0],
"The layer is not defined in WMS capabilities")
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'external WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'WMTS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'no 2D'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'internal WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'external WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'WMTS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'no 2D'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None,
TimeInformation())
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
def test_layer(self):
import httplib2
from c2cgeoportal.views.entry import Entry
from c2cgeoportal.models import Layer, LayerGroup, Theme
request = testing.DummyRequest()
request.headers['Host'] = host
request.static_url = lambda url: '/dummy/static/' + url
request.route_url = lambda url: '/dummy/route/' + url
request.registry.settings = {
'project': 'test_layer',
}
entry = Entry(request)
self.assertEqual(entry._group(LayerGroup(), [], [], None), (None, [], False))
layer = Layer()
layer.id = 20
layer.name = 'test internal WMS'
layer.metadataURL = "http://example.com/tiwms"
layer.isChecked = True
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.style = "my-style"
layer.kml = "tiwms.kml"
layer.legend = True
layer.legendRule = "rule"
layer.legendImage = "legend:static/tiwms-legend.png"
layer.minResolution = 10
layer.maxResolution = 1000
layer.disclaimer = "Camptocamp"
layer.identifierAttributeField = "name"
layer.geoTable = "tiwms"
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': 'test internal WMS',
'metadataURL': 'http://example.com/tiwms',
'isChecked': True,
'icon': '/dummy/route/mapserverproxy?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetLegendGraphic&LAYER=test internal WMS&FORMAT=image/png&TRANSPARENT=TRUE&RULE=rule',
'type': u'internal WMS',
'imageType': 'image/png',
'style': 'my-style',
'kml': '/dummy/static/test_layer:static/tiwms.kml',
'legend': True,
'legendImage': '/dummy/static/legend:static/tiwms-legend.png',
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'disclaimer': 'Camptocamp',
'identifierAttribute': 'name',
'editable': True,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test external WMS'
layer.isChecked = False
layer.icon = "tewms.png"
layer.layerType = "external WMS"
layer.url = "http://example.com"
layer.imageType = "image/jpeg"
layer.isSingleTile = True
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': 'test external WMS',
'icon': '/dummy/static/test_layer:static/tewms.png',
'isChecked': False,
'type': u'external WMS',
'url': 'http://example.com',
'imageType': 'image/jpeg',
'isSingleTile': True,
'legend': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.style = 'wmts-style'
layer.dimensions = '{"DATE": "1012"}'
layer.matrixSet = "swissgrid"
layer.wmsUrl = 'http://example.com/'
layer.wmsLayers = 'test'
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'style': 'wmts-style',
'dimensions': {u'DATE': u'1012'},
'matrixSet': 'swissgrid',
'wmsUrl': 'http://example.com/',
'wmsLayers': 'test',
'legend': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsUrl = 'http://example.com/'
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': 'http://example.com/',
'wmsLayers': 'test WMTS',
'legend': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'test'
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': '/dummy/route/mapserverproxy',
'wmsLayers': 'test',
'queryLayers': [],
'legend': False,
'minResolutionHint': 10,
'maxResolutionHint': 1000,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test no 2D'
layer.isChecked = False
layer.layerType = "no 2D"
layer.legend = False
layer.metadataURL = 'http://example.com/wmsfeatures.metadata'
layer.public = True
self.assertEqual(entry._layer(layer, [], None), ({
'id': 20,
'name': u'test no 2D',
'isChecked': False,
'type': u'no 2D',
'legend': False,
'metadataURL': u'http://example.com/wmsfeatures.metadata',
'public': True,
}, []))
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, 'c2cgeoportal_test.map')
mapfile = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'c2cgeoportal_test.map'
)
params = (
('map', mapfile),
('SERVICE', 'WMS'),
('VERSION', '1.1.1'),
('REQUEST', 'GetCapabilities'),
)
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
url = mapserv + '&'.join(['='.join(p) for p in params])
http = httplib2.Http()
h = {'Host': host}
resp, xml =http.request(url, method='GET', headers=h)
wms = WebMapService(None, xml=xml)
wms_layers = list(wms.contents)
layer = Layer()
layer.id = 20
layer.name = 'test_wmsfeaturesgroup'
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.isChecked = False
layer.legend = False
layer.public = True
self.assertEqual(entry._layer(layer, wms_layers, wms), ({
'id': 20,
'name': u'test_wmsfeaturesgroup',
'type': u'internal WMS',
'isChecked': False,
'legend': False,
'imageType': u'image/png',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003,
'public': True,
'queryable': 0,
'metadataUrls': [{
'url': 'http://example.com/wmsfeatures.metadata',
'type': 'TC211',
'format': 'text/plain',
}],
'childLayers': [{
'name': u'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003,
'queryable': 1,
}],
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'test_wmsfeatures'
layer.legend = False
layer.public = True
self.assertEqual(entry._layer(layer, wms_layers, wms), ({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': '/dummy/route/mapserverproxy',
'wmsLayers': 'test_wmsfeatures',
'queryLayers': [{
'name': 'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003
}],
'legend': False,
'public': True,
}, []))
layer = Layer()
layer.id = 20
layer.name = 'test WMTS'
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = 'foo'
layer.queryLayers = 'test_wmsfeatures'
layer.legend = False
layer.public = True
self.assertEqual(entry._layer(layer, wms_layers, wms), ({
'id': 20,
'name': 'test WMTS',
'isChecked': False,
'type': 'WMTS',
'url': 'http://example.com/WMTS-Capabilities.xml',
'wmsUrl': '/dummy/route/mapserverproxy',
'wmsLayers': 'foo',
'queryLayers': [{
'name': 'test_wmsfeatures',
'minResolutionHint': 1.76,
'maxResolutionHint': 8.8200000000000003
}],
'legend': False,
'public': True,
}, []))
group1 = LayerGroup()
group1.name = 'block'
group2 = LayerGroup()
group2.name = 'node'
group2.metadataURL = 'http://example.com/group.metadata'
layer = Layer()
layer.id = 20
layer.name = 'test layer in group'
layer.isChecked = False
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.legend = False
layer.public = True
group1.children = [group2]
group2.children = [layer]
self.assertEqual(entry._group(group1, [layer], [], None), ({
'isExpanded': False,
'isInternalWMS': True,
'name': u'block',
'isBaseLayer': False,
'children': [{
'isExpanded': False,
'isInternalWMS': True,
'name': u'node',
'isBaseLayer': False,
'metadataURL': 'http://example.com/group.metadata',
'children': [{
'name': u'test layer in group',
'id': 20,
'isChecked': False,
'type': u'internal WMS',
'legend': False,
'imageType': u'image/png',
'public': True,
}]
}]
}, [], False))
group1 = LayerGroup()
group1.isInternalWMS = True
group2 = LayerGroup()
group2.isInternalWMS = False
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group1 = LayerGroup()
group1.isInternalWMS = False
group2 = LayerGroup()
group2.isInternalWMS = True
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'internal WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'external WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'WMTS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = 'no 2D'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'internal WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'external WMS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'WMTS'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = 'no 2D'
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
def _create_layer(self, public=False, none_area=False, attr_list=False,
exclude_properties=False):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
import sqlahelper
from sqlalchemy import func
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy import (GeometryDDL, GeometryExtensionColumn,
Point, WKTSpatialElement)
from c2cgeoportal.models import DBSession, Layer, RestrictionArea
self.__class__._table_index = self.__class__._table_index + 1
id = self.__class__._table_index
engine = sqlahelper.get_engine()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table = Table('%s_child' % tablename, self.metadata,
Column('id', types.Integer, primary_key=True),
Column('name', types.Unicode),
schema='public'
)
table.create()
ins = table.insert().values(name=u'c1é')
c1_id = engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(name=u'c2é')
c2_id = engine.connect().execute(ins).inserted_primary_key[0]
table = Table(
tablename, self.metadata,
Column('id', types.Integer, primary_key=True),
Column('child_id', types.Integer,
ForeignKey('public.%s_child.id' % tablename)),
Column('name', types.Unicode),
GeometryExtensionColumn('geom', Point(srid=21781)),
schema='public'
)
GeometryDDL(table)
table.create()
ins = table.insert().values(
child_id=c1_id,
name='foo',
geom=func.ST_GeomFromText('POINT(5 45)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(
child_id=c2_id,
name='bar',
geom=func.ST_GeomFromText('POINT(6 46)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
if attr_list:
ins = table.insert().values(
child_id=c2_id,
name='aaa,bbb,foo',
geom=func.ST_GeomFromText('POINT(6 46)', 21781)
)
engine.connect().execute(ins).inserted_primary_key[0]
layer = Layer()
layer.id = id
layer.geoTable = tablename
layer.public = public
if exclude_properties:
layer.excludeProperties = 'name'
DBSession.add(layer)
if not public:
ra = RestrictionArea()
ra.name = u'__test_ra'
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
if not none_area:
poly = 'POLYGON((4 44, 4 46, 6 46, 6 44, 4 44))'
ra.area = WKTSpatialElement(poly, srid=21781)
DBSession.add(ra)
self.layer_ids.append(self.__class__._table_index)
transaction.commit()
return id
def _create_layer(self,
public=False,
none_area=False,
attr_list=False,
exclude_properties=False):
""" This function is central for this test class. It creates
a layer with two features, and associates a restriction area
to it. """
import transaction
import sqlahelper
from sqlalchemy import func
from sqlalchemy import Column, Table, types, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from geoalchemy import (GeometryDDL, GeometryExtensionColumn, Point,
WKTSpatialElement)
from c2cgeoportal.models import DBSession, Layer, RestrictionArea
self.__class__._table_index = self.__class__._table_index + 1
id = self.__class__._table_index
engine = sqlahelper.get_engine()
if not self.metadata:
self.metadata = declarative_base(bind=engine).metadata
tablename = "table_%d" % id
table = Table('%s_child' % tablename,
self.metadata,
Column('id', types.Integer, primary_key=True),
Column('name', types.Unicode),
schema='public')
table.create()
ins = table.insert().values(name=u'c1é')
c1_id = engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(name=u'c2é')
c2_id = engine.connect().execute(ins).inserted_primary_key[0]
table = Table(tablename,
self.metadata,
Column('id', types.Integer, primary_key=True),
Column('child_id', types.Integer,
ForeignKey('public.%s_child.id' % tablename)),
Column('name', types.Unicode),
GeometryExtensionColumn('geom', Point(srid=21781)),
schema='public')
GeometryDDL(table)
table.create()
ins = table.insert().values(child_id=c1_id,
name='foo',
geom=func.ST_GeomFromText(
'POINT(5 45)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
ins = table.insert().values(child_id=c2_id,
name='bar',
geom=func.ST_GeomFromText(
'POINT(6 46)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
if attr_list:
ins = table.insert().values(child_id=c2_id,
name='aaa,bbb,foo',
geom=func.ST_GeomFromText(
'POINT(6 46)', 21781))
engine.connect().execute(ins).inserted_primary_key[0]
layer = Layer()
layer.id = id
layer.geoTable = tablename
layer.public = public
if exclude_properties:
layer.excludeProperties = 'name'
DBSession.add(layer)
if not public:
ra = RestrictionArea()
ra.name = u'__test_ra'
ra.layers = [layer]
ra.roles = [self.role]
ra.readwrite = True
if not none_area:
poly = 'POLYGON((4 44, 4 46, 6 46, 6 44, 4 44))'
ra.area = WKTSpatialElement(poly, srid=21781)
DBSession.add(ra)
self.layer_ids.append(self.__class__._table_index)
transaction.commit()
return id
def test_layer(self):
import httplib2
from c2cgeoportal.views.entry import Entry
from c2cgeoportal.models import Layer, LayerGroup, Theme
request = testing.DummyRequest()
request.headers["Host"] = host
request.static_url = lambda url: "/dummy/static/" + url
request.route_url = lambda url: "/dummy/route/" + url
request.registry.settings = {"project": "test_layer"}
entry = Entry(request)
self.assertEqual(entry._group(LayerGroup(), [], [], None), (None, [], False))
layer = Layer()
layer.id = 20
layer.name = "test internal WMS"
layer.metadataURL = "http://example.com/tiwms"
layer.isChecked = True
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.style = "my-style"
layer.kml = "tiwms.kml"
layer.legend = True
layer.legendRule = "rule"
layer.legendImage = "legend:static/tiwms-legend.png"
layer.minResolution = 10
layer.maxResolution = 1000
layer.disclaimer = "Camptocamp"
layer.identifierAttributeField = "name"
layer.geoTable = "tiwms"
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": "test internal WMS",
"metadataURL": "http://example.com/tiwms",
"isChecked": True,
"icon": "/dummy/route/mapserverproxy?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetLegendGraphic&LAYER=test internal WMS&FORMAT=image/png&TRANSPARENT=TRUE&RULE=rule",
"type": u"internal WMS",
"imageType": "image/png",
"style": "my-style",
"kml": "/dummy/static/test_layer:static/tiwms.kml",
"legend": True,
"legendImage": "/dummy/static/legend:static/tiwms-legend.png",
"minResolutionHint": 10,
"maxResolutionHint": 1000,
"disclaimer": "Camptocamp",
"identifierAttribute": "name",
"editable": True,
"public": True,
},
[],
),
)
layer = Layer()
layer.id = 20
layer.name = "test external WMS"
layer.isChecked = False
layer.icon = "tewms.png"
layer.layerType = "external WMS"
layer.url = "http://example.com"
layer.imageType = "image/jpeg"
layer.isSingleTile = True
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": "test external WMS",
"icon": "/dummy/static/test_layer:static/tewms.png",
"isChecked": False,
"type": u"external WMS",
"url": "http://example.com",
"imageType": "image/jpeg",
"isSingleTile": True,
"legend": False,
"minResolutionHint": 10,
"maxResolutionHint": 1000,
"public": True,
},
[],
),
)
layer = Layer()
layer.id = 20
layer.name = "test WMTS"
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.style = "wmts-style"
layer.dimensions = '{"DATE": "1012"}'
layer.matrixSet = "swissgrid"
layer.wmsUrl = "http://example.com/"
layer.wmsLayers = "test"
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": "test WMTS",
"isChecked": False,
"type": "WMTS",
"url": "http://example.com/WMTS-Capabilities.xml",
"style": "wmts-style",
"dimensions": {u"DATE": u"1012"},
"matrixSet": "swissgrid",
"wmsUrl": "http://example.com/",
"wmsLayers": "test",
"legend": False,
"minResolutionHint": 10,
"maxResolutionHint": 1000,
"public": True,
},
[],
),
)
layer = Layer()
layer.id = 20
layer.name = "test WMTS"
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsUrl = "http://example.com/"
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": "test WMTS",
"isChecked": False,
"type": "WMTS",
"url": "http://example.com/WMTS-Capabilities.xml",
"wmsUrl": "http://example.com/",
"wmsLayers": "test WMTS",
"legend": False,
"minResolutionHint": 10,
"maxResolutionHint": 1000,
"public": True,
},
[],
),
)
layer = Layer()
layer.id = 20
layer.name = "test WMTS"
layer.isChecked = False
layer.layerType = "WMTS"
layer.url = "http://example.com/WMTS-Capabilities.xml"
layer.wmsLayers = "test"
layer.legend = False
layer.minResolution = 10
layer.maxResolution = 1000
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": "test WMTS",
"isChecked": False,
"type": "WMTS",
"url": "http://example.com/WMTS-Capabilities.xml",
"wmsUrl": "/dummy/route/mapserverproxy",
"wmsLayers": "test",
"legend": False,
"minResolutionHint": 10,
"maxResolutionHint": 1000,
"public": True,
},
[],
),
)
layer = Layer()
layer.id = 20
layer.name = "test no 2D"
layer.isChecked = False
layer.layerType = "no 2D"
layer.legend = False
layer.metadataURL = "http://example.com/wmsfeatures.metadata"
layer.public = True
self.assertEqual(
entry._layer(layer, [], None),
(
{
"id": 20,
"name": u"test no 2D",
"isChecked": False,
"type": u"no 2D",
"legend": False,
"metadataURL": u"http://example.com/wmsfeatures.metadata",
"public": True,
},
[],
),
)
curdir = os.path.dirname(os.path.abspath(__file__))
mapfile = os.path.join(curdir, "c2cgeoportal_test.map")
mapfile = os.path.join(os.path.dirname(os.path.abspath(__file__)), "c2cgeoportal_test.map")
params = (("map", mapfile), ("SERVICE", "WMS"), ("VERSION", "1.1.1"), ("REQUEST", "GetCapabilities"))
mapserv = "%s?map=%s&" % (mapserv_url, mapfile)
url = mapserv + "&".join(["=".join(p) for p in params])
http = httplib2.Http()
h = {"Host": host}
resp, xml = http.request(url, method="GET", headers=h)
wms = WebMapService(None, xml=xml)
wms_layers = list(wms.contents)
layer = Layer()
layer.id = 20
layer.name = "test_wmsfeaturesgroup"
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.isChecked = False
layer.legend = False
layer.public = True
self.assertEqual(
entry._layer(layer, wms_layers, wms),
(
{
"id": 20,
"name": u"test_wmsfeaturesgroup",
"type": u"internal WMS",
"isChecked": False,
"legend": False,
"imageType": u"image/png",
"minResolutionHint": 1.76,
"maxResolutionHint": 8.8200000000000003,
"public": True,
"queryable": 0,
"metadataUrls": [
{"url": "http://example.com/wmsfeatures.metadata", "type": "TC211", "format": "text/plain"}
],
"childLayers": [
{
"name": u"test_wmsfeatures",
"minResolutionHint": 1.76,
"maxResolutionHint": 8.8200000000000003,
"queryable": 1,
}
],
},
[],
),
)
group1 = LayerGroup()
group1.name = "block"
group2 = LayerGroup()
group2.name = "node"
group2.metadataURL = "http://example.com/group.metadata"
layer = Layer()
layer.id = 20
layer.name = "test layer in group"
layer.isChecked = False
layer.layerType = "internal WMS"
layer.imageType = "image/png"
layer.legend = False
layer.public = True
group1.children = [group2]
group2.children = [layer]
self.assertEqual(
entry._group(group1, [layer], [], None),
(
{
"isExpanded": False,
"isInternalWMS": True,
"name": u"block",
"isBaseLayer": False,
"children": [
{
"isExpanded": False,
"isInternalWMS": True,
"name": u"node",
"isBaseLayer": False,
"metadataURL": "http://example.com/group.metadata",
"children": [
{
"name": u"test layer in group",
"id": 20,
"isChecked": False,
"type": u"internal WMS",
"legend": False,
"imageType": u"image/png",
"public": True,
}
],
}
],
},
[],
False,
),
)
group1 = LayerGroup()
group1.isInternalWMS = True
group2 = LayerGroup()
group2.isInternalWMS = False
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group1 = LayerGroup()
group1.isInternalWMS = False
group2 = LayerGroup()
group2.isInternalWMS = True
group1.children = [group2]
_, errors, stop = entry._group(group1, [], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = "internal WMS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = "external WMS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = "WMTS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = True
layer = Layer()
layer.layerType = "no 2D"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = "internal WMS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertTrue(len(errors) > 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = "external WMS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = "WMTS"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)
group = LayerGroup()
group.isInternalWMS = False
layer = Layer()
layer.layerType = "no 2D"
group.children = [layer]
_, errors, stop = entry._group(group, [layer], [], None)
self.assertEqual(len(errors), 0)
self.assertFalse(stop)