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()