def setUpClass(cls):
super().setUpClass()
cls.user_admin = get_user_model().objects.get(username="******")
admin, _ = get_user_model().objects.get_or_create(username="******")
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
cls.layer_coast_line = create_single_layer(
'san_andres_y_providencia_coastline')
cls.layer_highway = create_single_layer(
'san_andres_y_providencia_highway')
# create a map from loaded layers
cls.map_composition = Map()
admin_user = get_user_model().objects.get(username="******")
cls.map_composition.create_from_layer_list(
admin_user, [cls.layer_coast_line, cls.layer_highway],
"composition", "abstract")
# update MapLayers to correctly show layers' location
with DisableDjangoSignals():
for maplayer in cls.map_composition.layers:
if maplayer.name in [
cls.layer_coast_line.alternate,
cls.layer_highway.alternate
]:
maplayer.local = True
maplayer.save(force_update=True)
maplayer.refresh_from_db()
cls.map_composition.refresh_from_db()
def setUp(self):
self.keyword = [
{
"keywords": ["features", "test_layer"],
"thesaurus": {"date": None, "datetype": None, "title": None},
"type": "theme",
},
{
"keywords": ["no conditions to access and use"],
"thesaurus": {
"date": "2020-10-30T16:58:34",
"datetype": "publication",
"title": "Test for ordering",
},
"type": None,
},
{
"keywords": ["ad", "af"],
"thesaurus": {
"date": "2008-06-01",
"datetype": "publication",
"title": "GEMET - INSPIRE themes, version 1.0",
},
"type": None,
},
{"keywords": ["Global"], "thesaurus": {"date": None, "datetype": None, "title": None}, "type": "place"},
]
self.layer = create_single_layer('keyword-handler')
self.sut = utils.KeywordHandler(
instance=self.layer,
keywords=self.keyword
)
def setUp(self):
self.layer = create_single_layer('metadata-storer')
self.uuid = self.layer.uuid
self.abstract = self.layer.abstract
self.custom = {
"processes": {"uuid": "abc123cfde", "abstract": "updated abstract"},
"second-stage": {"title": "Updated Title", "abstract": "another update"},
}
def setUp(self):
self.resource = create_single_layer('foo_layer')
r = RequestFactory()
self.url = urljoin(settings.SITEURL,
reverse("download", args={self.resource.id}))
r.get(self.url)
admin = get_user_model().objects.get(username='******')
r.user = admin
self.context = {'request': r}
def setUpClass(cls):
super().setUpClass()
create_models(type=cls.get_type, integration=cls.get_integration)
all_public()
cls.user_admin = get_user_model().objects.get(username="******")
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
cls.layer_coast_line = create_single_layer(
'san_andres_y_providencia_coastline')
def setUp(self):
self.files = os.path.join(gisdata.GOOD_DATA, "vector/san_andres_y_providencia_water.shp")
self.files_as_dict, self.tmpdir = get_files(self.files)
self.cat = gs_catalog
self.user = get_user_model().objects.get(username="******")
self.sut = create_single_layer("san_andres_y_providencia_water.shp")
self.sut.name = 'san_andres_y_providencia_water'
self.sut.save()
self.geoserver_url = settings.GEOSERVER_LOCATION
self.geoserver_manager = GeoServerResourceManager()
def test_given_resource_base_object_will_assign_subtype_as_content_type(
self):
test_user = get_user_model().objects.first()
'''
If the input object is a ResourceBase, in favorite content type, should be saved he
subtype content type (Doc, Layer, Map or GeoApp)
'''
create_single_layer('foo_layer')
resource = ResourceBase.objects.get(title='foo_layer')
created_fav = Favorite.objects.create_favorite(resource, test_user)
self.assertEqual('layer', created_fav.content_type.model)
'''
If the input object is a subtype, should save the relative content type
'''
test_document_1 = Document.objects.first()
Favorite.objects.create_favorite(test_document_1, test_user)
fav = Favorite.objects.last()
ct = ContentType.objects.get_for_model(test_document_1)
self.assertEqual(fav.content_type, ct)
def test_storage_manager_replace_single_file(self, path, strg):
'''
Will test that the function returns the expected result
and that the StorageManager function as been called with the expected parameters
'''
path.return_value = '/opt/full/path/to/file'
strg.return_value = '/opt/full/path/to/file'
expected = '/opt/full/path/to/file'
layer = create_single_layer('storage_manager')
layer.files = ['/opt/full/path/to/file2']
layer.save()
with open('geonode/base/fixtures/test_sld.sld') as new_file:
output = self.sut().replace(layer, new_file)
self.assertListEqual([expected], output['files'])
def test_storage_manager_replace_files_list(self): # , path, strg):
'''
Will test that the function returns the expected result
and that the StorageManager function as been called with the expected parameters
'''
# path.return_value = '/opt/full/path/to/file'
# strg.return_value = '/opt/full/path/to/file'
old_files = ['/opt/full/path/to/file', '/opt/full/path/to/file']
new_files = [
os.path.join(f"{self.project_root}", "tests/data/test_sld.sld"),
os.path.join(f"{self.project_root}", "tests/data/test_data.json")
]
layer = create_single_layer('storage_manager')
layer.files = old_files
layer.save()
output = self.sut().replace(layer, new_files)
self.assertEqual(2, len(output['files']))
self.assertTrue('file.sld' in output['files'][0])
self.assertTrue('file.json' in output['files'][1])
def test_revise_resource_value_in_replace_should_return_none_for_not_existing_layer(self):
layer = create_single_layer('fake_layer')
_gs_import_session_info = self.geoserver_manager._revise_resource_value(layer, list(self.files_as_dict.values()), self.user, action_type="replace")
self.assertEqual(_gs_import_session_info.import_session.state, enumerations.STATE_PENDING)
def test_ogc_server_defaults(self):
"""
Tests that OGC_SERVER_SETTINGS are built if they do not exist in the settings.
"""
from django.urls import reverse, resolve
from ..ows import _wcs_get_capabilities, _wfs_get_capabilities, _wms_get_capabilities
OGC_SERVER = {'default': dict()}
defaults = self.OGC_DEFAULT_SETTINGS.get('default')
ogc_settings = OGC_Servers_Handler(OGC_SERVER)['default']
self.assertEqual(ogc_settings.server, defaults)
self.assertEqual(ogc_settings.rest, f"{defaults['LOCATION']}rest")
self.assertEqual(ogc_settings.ows, f"{defaults['LOCATION']}ows")
# Make sure we get None vs a KeyError when the key does not exist
self.assertIsNone(ogc_settings.SFDSDFDSF)
# Testing REST endpoints
route = resolve('/gs/rest/layers').route
self.assertEqual(route, '^gs/rest/layers')
route = resolve('/gs/rest/imports').route
self.assertEqual(route, '^gs/rest/imports')
route = resolve('/gs/rest/sldservice').route
self.assertEqual(route, '^gs/rest/sldservice')
store_resolver = resolve('/gs/rest/stores/geonode_data/')
self.assertEqual(store_resolver.url_name, 'stores')
self.assertEqual(store_resolver.kwargs['store_type'], 'geonode_data')
self.assertEqual(store_resolver.route,
'^gs/rest/stores/(?P<store_type>\\w+)/$')
sld_resolver = resolve('/gs/rest/styles')
self.assertIsNone(sld_resolver.url_name)
self.assertTrue('workspace' not in sld_resolver.kwargs)
self.assertEqual(sld_resolver.kwargs['proxy_path'], '/gs/rest/styles')
self.assertEqual(sld_resolver.kwargs['downstream_path'], 'rest/styles')
self.assertEqual(sld_resolver.route, '^gs/rest/styles')
sld_resolver = resolve('/gs/rest/workspaces/geonode/styles')
self.assertIsNone(sld_resolver.url_name)
self.assertEqual(sld_resolver.kwargs['workspace'], 'geonode')
self.assertEqual(sld_resolver.kwargs['proxy_path'],
'/gs/rest/workspaces')
self.assertEqual(sld_resolver.kwargs['downstream_path'],
'rest/workspaces')
self.assertEqual(sld_resolver.route,
'^gs/rest/workspaces/(?P<workspace>\\w+)')
# Testing OWS endpoints
wcs = _wcs_get_capabilities()
logger.debug(wcs)
self.assertIsNotNone(wcs)
try:
wcs_url = urljoin(settings.SITEURL, reverse('ows_endpoint'))
except Exception:
wcs_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'ows')
self.assertTrue(wcs.startswith(wcs_url))
self.assertIn("service=WCS", wcs)
self.assertIn("request=GetCapabilities", wcs)
self.assertIn("version=2.0.1", wcs)
wfs = _wfs_get_capabilities()
logger.debug(wfs)
self.assertIsNotNone(wfs)
try:
wfs_url = urljoin(settings.SITEURL, reverse('ows_endpoint'))
except Exception:
wfs_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'ows')
self.assertTrue(wfs.startswith(wfs_url))
self.assertIn("service=WFS", wfs)
self.assertIn("request=GetCapabilities", wfs)
self.assertIn("version=1.1.0", wfs)
wms = _wms_get_capabilities()
logger.debug(wms)
self.assertIsNotNone(wms)
try:
wms_url = urljoin(settings.SITEURL, reverse('ows_endpoint'))
except Exception:
wms_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'ows')
self.assertTrue(wms.startswith(wms_url))
self.assertIn("service=WMS", wms)
self.assertIn("request=GetCapabilities", wms)
self.assertIn("version=1.3.0", wms)
# Test OWS Download Links
from geonode.geoserver.ows import wcs_links, wfs_links, wms_links
instance = create_single_layer("san_andres_y_providencia_water")
instance.name = 'san_andres_y_providencia_water'
instance.save()
bbox = instance.bbox
srid = instance.srid
height = 512
width = 512
# Default Style (expect exception since we are offline)
style = get_sld_for(gs_catalog, instance)
logger.error(
f" style -------------------------------------------> {style}")
if isinstance(style, str):
style = gs_catalog.get_style(instance.name,
workspace=instance.workspace)
self.assertIsNotNone(style)
self.assertFalse(isinstance(style, str))
instance.default_style, _ = Style.objects.get_or_create(
name=style.name,
defaults=dict(sld_title=style.sld_title, sld_body=style.sld_body))
self.assertIsNotNone(instance.default_style)
self.assertIsNotNone(instance.default_style.name)
# WMS Links
wms_links = wms_links(f"{ogc_settings.public_url}wms?",
instance.alternate, bbox, srid, height, width)
self.assertIsNotNone(wms_links)
self.assertEqual(len(wms_links), 3)
wms_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'wms')
identifier = urlencode({'layers': instance.alternate})
for _link in wms_links:
logger.debug(f'{wms_url} --> {_link[3]}')
self.assertTrue(wms_url in _link[3])
logger.debug(f'{identifier} --> {_link[3]}')
self.assertTrue(identifier in _link[3])
# WFS Links
wfs_links = wfs_links(f"{ogc_settings.public_url}wfs?",
instance.alternate, bbox, srid)
self.assertIsNotNone(wfs_links)
self.assertEqual(len(wfs_links), 6)
wfs_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'wfs')
identifier = urlencode({'typename': instance.alternate})
for _link in wfs_links:
logger.debug(f'{wfs_url} --> {_link[3]}')
self.assertTrue(wfs_url in _link[3])
logger.debug(f'{identifier} --> {_link[3]}')
self.assertTrue(identifier in _link[3])
# WCS Links
wcs_links = wcs_links(f"{ogc_settings.public_url}wcs?",
instance.alternate, bbox, srid)
self.assertIsNotNone(wcs_links)
self.assertEqual(len(wcs_links), 2)
wcs_url = urljoin(ogc_settings.PUBLIC_LOCATION, 'wcs')
identifier = urlencode(
{'coverageid': instance.alternate.replace(':', '__', 1)})
for _link in wcs_links:
logger.debug(f'{wcs_url} --> {_link[3]}')
self.assertTrue(wcs_url in _link[3])
logger.debug(f'{identifier} --> {_link[3]}')
self.assertTrue(identifier in _link[3])
def test_group_activity_pages_render(self):
"""
Verify Activity List pages
"""
self.assertTrue(self.client.login(username="******", password="******"))
response = self.client.get("/groups/")
self.assertEqual(200, response.status_code)
response = self.client.get("/groups/group/bar/activity/")
self.assertEqual(200, response.status_code)
logger.error(response.content)
self.assertContains(response,
'Layers',
count=1,
status_code=200,
msg_prefix='',
html=False)
self.assertContains(response,
'Maps',
count=5,
status_code=200,
msg_prefix='',
html=False)
self.assertContains(response,
'Documents',
count=3,
status_code=200,
msg_prefix='',
html=False)
self.assertContains(response,
'<a href="/layers/:geonode:CA">CA</a>',
count=0,
status_code=200,
msg_prefix='',
html=False)
self.assertContains(response,
'uploaded',
count=0,
status_code=200,
msg_prefix='',
html=False)
layer = create_single_layer('single_point.shp')
try:
# Add test to test perms being sent to the front end.
layer.set_default_permissions()
perms_info = layer.get_all_level_info()
# Ensure there is only one group 'anonymous' by default
self.assertEqual(len(perms_info['groups'].keys()), 1)
# Add the foo group to the layer object groups
layer.set_permissions({'groups': {'bar': ['view_resourcebase']}})
perms_info = _perms_info_json(layer)
# Ensure foo is in the perms_info output
self.assertCountEqual(
json.loads(perms_info)['groups'], {
'bar': ['view_resourcebase']})
layer.group = self.bar.group
layer.save()
response = self.client.get("/groups/group/bar/activity/")
self.assertEqual(200, response.status_code)
_log(response)
self.assertContains(
response,
'<a href="/layers/:geonode:single_point.shp">geonode:single_point.shp</a>',
count=2,
status_code=200,
msg_prefix='',
html=False)
self.assertContains(
response,
'uploaded',
count=2,
status_code=200,
msg_prefix='',
html=False)
finally:
layer.set_default_permissions()
layer.group = None
layer.save()