desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Test uploading a zipped shapefile with xml sidecar'
| def test_zipped_upload_xml_sidecar(self):
| (fd, abspath) = self.temp_file('.zip')
fp = os.fdopen(fd, 'wb')
zf = ZipFile(fp, 'w')
fpath = os.path.join(GOOD_DATA, 'vector', 'Air_Runways.*')
for f in glob.glob(fpath):
zf.write(f, os.path.basename(f))
zf.close()
self.upload_file(abspath, self.complete_upload, check_name='Air_Runw... |
'Tests the layers that are invalid and should not be uploaded'
| def test_invalid_layer_upload(self):
| invalid_path = os.path.join(BAD_DATA)
self.upload_folder_of_files(invalid_path, self.check_invalid_projection)
|
'Tests that the upload computes correctly next session IDs'
| def test_coherent_importer_session(self):
| session_ids = []
fname = os.path.join(GOOD_DATA, 'raster', 'relief_san_andres.tif')
self.upload_file(fname, self.complete_raster_upload, session_ids=session_ids)
invalid_path = os.path.join(BAD_DATA)
self.upload_folder_of_files(invalid_path, self.check_invalid_projection, session_ids=session_ids)
... |
'Verify a error message is return when an unsupported layer is
uploaded'
| def test_extension_not_implemented(self):
| unsupported_path = __file__
if unsupported_path.endswith('.pyc'):
unsupported_path = unsupported_path.rstrip('c')
with self.assertRaises(HTTPError):
self.client.upload_file(unsupported_path)
|
'make sure a csv upload fails gracefully/normally when not activated'
| def test_csv(self):
| csv_file = self.make_csv(['lat', 'lon', 'thing'], ['-100', '-40', 'foo'])
(layer_name, ext) = os.path.splitext(os.path.basename(csv_file))
(resp, data) = self.client.upload_file(csv_file)
self.assertTrue(('success' in data))
self.assertTrue(data['success'])
self.assertTrue(data['redirect_to'], '... |
'Override the baseclass test and verify a correct CSV upload'
| def test_csv(self):
| csv_file = self.make_csv(['lat', 'lon', 'thing'], ['-100', '-40', 'foo'])
(layer_name, ext) = os.path.splitext(os.path.basename(csv_file))
(resp, form_data) = self.client.upload_file(csv_file)
self.check_save_step(resp, form_data)
csv_step = form_data['redirect_to']
self.assertEquals(csv_step, u... |
'Verify that uploading time based shapefile works properly'
| def test_time(self):
| cascading_delete(self.catalog, 'boxes_with_date')
timedir = os.path.join(GOOD_DATA, 'time')
layer_name = 'boxes_with_date'
shp = os.path.join(timedir, ('%s.shp' % layer_name))
(resp, data) = self.client.upload_file(shp)
self.wait_for_progress(data.get('progress'))
self.assertEquals(resp.code... |
'Test formation of REST call to geoserver\'s geogig API'
| def test_payload_creation(self):
| author_name = 'test'
author_email = 'testuser@geonode.org'
settings.OGC_SERVER['default']['PG_GEOGIG'] = False
fb_message = {'authorName': author_name, 'authorEmail': author_email, 'parentDirectory': settings.OGC_SERVER['default']['GEOGIG_DATASTORE_DIR']}
fb_payload = make_geogig_rest_payload(author... |
'Tests the scan_file function.'
| def test_scan_file(self):
| exts = ('.shp', '.shx', '.sld', '.xml', '.prj', '.dbf')
with create_files(map((lambda s: 'san_andres_y_providencia_location{0}'.format(s)), exts)) as tests:
shp = filter((lambda s: s.endswith('.shp')), tests)[0]
spatial_files = scan_file(shp)
self.assertTrue(isinstance(spatial_files, Spa... |
'This does not actually delete the file, only the database record. But
that is easy to implement.'
| def delete(self, request, *args, **kwargs):
| self.object = self.get_object()
self.object.delete()
if request.is_ajax():
response = JSONResponse(True, {}, response_content_type(self.request))
response['Content-Disposition'] = 'inline; filename=files.json'
return response
else:
return HttpResponseRedirect(reverse('... |
'Convert this map to a nested dictionary structure matching the JSON
configuration for GXP Viewers.
The ``added_layers`` parameter list allows a list of extra MapLayer
instances to append to the Map\'s layer list when generating the
configuration. These are not persisted; if you want to add layers you
should use ``.lay... | def viewer_json(self, user, access_token, *added_layers):
| if (self.id and (len(added_layers) == 0)):
cfg = cache.get(((('viewer_json_' + str(self.id)) + '_') + str((0 if (user is None) else user.id))))
if (cfg is not None):
return cfg
layers = list(self.layers)
layers.extend(added_layers)
server_lookup = {}
sources = {}
def ... |
'Generate a dict that can be serialized to a GXP layer source
configuration suitable for loading this layer.'
| def source_config(self, access_token):
| try:
cfg = json.loads(self.source_params)
except Exception:
cfg = dict(ptype='gxp_wmscsource', restUrl='/gs/rest')
if self.ows_url:
'\n This limits the access token we add to only the OGC servers decal... |
'Generate a dict that can be serialized to a GXP layer configuration
suitable for loading this layer.
The "source" property will be left unset; the layer is not aware of the
name assigned to its source plugin. See
geonode.maps.models.Map.viewer_json for an example of
generating a full map configuration.'
| def layer_config(self, user=None):
| try:
cfg = json.loads(self.layer_params)
except Exception:
cfg = dict()
if self.format:
cfg['format'] = self.format
if self.name:
cfg['name'] = self.name
if self.opacity:
cfg['opacity'] = self.opacity
if self.styles:
cfg['styles'] = self.styles
... |
'Remove record from the catalogue'
| def remove_record(self, uuid):
| raise NotImplementedError()
|
'Create record in the catalogue'
| def create_record(self, item):
| raise NotImplementedError()
|
'Get record from the catalogue'
| def get_record(self, uuid):
| raise NotImplementedError()
|
'Search for records from the catalogue'
| def search_records(self, keywords, start, limit, bbox):
| raise NotImplementedError()
|
'initialize pycsw HTTP CSW backend'
| def __init__(self, *args, **kwargs):
| super(CatalogueBackend, self).__init__(*args, **kwargs)
self.catalogue.formats = ['Atom', 'DIF', 'Dublin Core', 'ebRIM', 'FGDC', 'ISO']
|
'returns list of valid GetRecordById URLs for a given record'
| def urls_for_uuid(self, uuid):
| urls = []
for mformat in self.formats:
urls.append(('text/xml', mformat, self.url_for_uuid(uuid, METADATA_FORMATS[mformat][1])))
return urls
|
'get all element data from an XML document'
| def csw_gen_anytext(self, xml):
| xml = etree.fromstring(xml)
return ' '.join([value.strip() for value in xml.xpath('//text()')])
|
'set the full set of geonetwork privileges on the item with the
specified uuid based on the dictionary given of the form:
\'group_name1\': {\'operation1\': True, \'operation2\': True, ...},
\'group_name2\': ...
all unspecified operations and operations for unspecified groups
are set to False.'
| def set_metadata_privs(self, uuid, privileges):
| if (self.type == 'geonetwork'):
get_dbid_url = ('%sgeonetwork/srv/en/portal.search.present?%s' % (self.base, urllib.urlencode({'uuid': uuid})))
request = urllib2.Request(get_dbid_url)
response = self.urlopen(request)
doc = etree.fromstring(response.read())
data_dbid = doc.fin... |
'helper to fetch the set of geonetwork
groups.'
| def _geonetwork_get_group_ids(self):
| get_groups_url = ('%sgeonetwork/srv/en/xml.info?%s' % (self.base, urllib.urlencode({'type': 'groups'})))
request = urllib2.Request(get_groups_url)
response = self.urlopen(request)
doc = etree.fromstring(response.read())
groups = {}
for gp in doc.findall('groups/group'):
groups[gp.find('n... |
'helper to fetch the set of geonetwork
\'operations\' (privileges)'
| def _geonetwork_get_operation_ids(self):
| get_ops_url = ('%sgeonetwork/srv/en/xml.info?%s' % (self.base, urllib.urlencode({'type': 'operations'})))
request = urllib2.Request(get_ops_url)
response = self.urlopen(request)
doc = etree.fromstring(response.read())
ops = {}
for op in doc.findall('operations/operation'):
ops[op.find('n... |
'CSW search wrapper'
| def search(self, keywords, startposition, maxrecords, bbox):
| formats = []
for f in self.formats:
formats.append(METADATA_FORMATS[f][0])
return self.getrecords(typenames=' '.join(formats), keywords=keywords, startposition=startposition, maxrecords=maxrecords, bbox=bbox, outputschema='http://www.isotc211.org/2005/gmd', esn='full')
|
'fix bbox axis order
GeoNetwork accepts x/y
pycsw accepts y/x'
| def normalize_bbox(self, bbox):
| if (self.type == 'geonetwork'):
return bbox
else:
return [bbox[1], bbox[0], bbox[3], bbox[2]]
|
'accepts a node representing a catalogue result
record and builds a POD structure representing
the search result.'
| def metadatarecord2dict(self, rec):
| if (rec is None):
return None
result = {}
result['uuid'] = rec.identifier
result['title'] = rec.identification.title
result['abstract'] = rec.identification.abstract
keywords = []
for kw in rec.identification.keywords:
keywords.extend(kw['keywords'])
result['keywords'] = ... |
'HTTP-less CSW'
| def _csw_local_dispatch(self, keywords=None, start=0, limit=10, bbox=None, identifier=None):
| mdict = dict(settings.PYCSW['CONFIGURATION'], **CONFIGURATION)
if ('server' in settings.PYCSW['CONFIGURATION']):
mdict['server'].update(settings.PYCSW['CONFIGURATION']['server'])
config = SafeConfigParser()
for (section, options) in mdict.iteritems():
config.add_section(section)
... |
'Tests the get_catalogue function works.'
| def test_get_catalog(self):
| c = get_catalogue()
|
'Test that the data.json representation behaves correctly'
| def test_data_json(self):
| response = self.client.get(reverse('data_json')).content
data_json = json.loads(response)
len1 = len(ResourceBase.objects.all())
len2 = len(data_json)
self.assertEquals(len1, len2, 'Expected equality of json and repository lengths')
record_keys = ['accessLevel', 'contactPoint',... |
'Returns a tuple of the server\'s credentials.'
| @property
def credentials(self):
| creds = namedtuple('OGC_SERVER_CREDENTIALS', ['username', 'password'])
return creds(username=self.USER, password=self.PASSWORD)
|
'Returns the server\'s datastore dict or None.'
| @property
def datastore_db(self):
| if (self.DATASTORE and settings.DATABASES.get(self.DATASTORE, None)):
return settings.DATABASES.get(self.DATASTORE, dict())
else:
return dict()
|
'The Open Web Service url for the server.'
| @property
def ows(self):
| location = (self.PUBLIC_LOCATION if self.PUBLIC_LOCATION else self.LOCATION)
return (self.OWS_LOCATION if self.OWS_LOCATION else (location + 'ows'))
|
'The REST endpoint for the server.'
| @property
def rest(self):
| return ((self.LOCATION + 'rest') if (not self.REST_LOCATION) else self.REST_LOCATION)
|
'The global public endpoint for the server.'
| @property
def public_url(self):
| return (self.LOCATION if (not self.PUBLIC_LOCATION) else self.PUBLIC_LOCATION)
|
'The Open Web Service url for the server used by GeoNode internally.'
| @property
def internal_ows(self):
| location = self.LOCATION
return (location + 'ows')
|
'The internal REST endpoint for the server.'
| @property
def internal_rest(self):
| return (self.LOCATION + 'rest')
|
'Ensures the settings are valid.'
| def ensure_valid_configuration(self, alias):
| try:
server = self.servers[alias]
except KeyError:
raise ServerDoesNotExist(("The server %s doesn't exist" % alias))
datastore = server.get('DATASTORE')
uploader_backend = getattr(settings, 'UPLOADER', dict()).get('BACKEND', 'geonode.rest')
if ((uploader_backend == 'geono... |
'Puts the defaults into the settings dictionary for a given connection where no settings is provided.'
| def ensure_defaults(self, alias):
| try:
server = self.servers[alias]
except KeyError:
raise ServerDoesNotExist(("The server %s doesn't exist" % alias))
server.setdefault('BACKEND', 'geonode.geoserver')
server.setdefault('LOCATION', 'http://localhost:8080/geoserver/')
server.setdefault('USER', 'admin')
... |
'Ensures the layer_style_manage route returns a 200.'
| def test_style_manager(self):
| layer = Layer.objects.all()[0]
bob = get_user_model().objects.get(username='bobby')
assign_perm('change_layer_style', bob, layer)
logged_in = self.client.login(username='bobby', password='bob')
self.assertEquals(logged_in, True)
response = self.client.get(reverse('layer_style_manage', args=(laye... |
'Verify that the feature_edit_check view is behaving as expected'
| def test_feature_edit_check(self):
| valid_layer_typename = Layer.objects.all()[0].alternate
Layer.objects.all()[0].set_default_permissions()
invalid_layer_typename = 'n0ch@nc3'
response = self.client.post(reverse('feature_edit_check', args=(invalid_layer_typename,)))
self.assertEquals(response.status_code, 404)
response = self.cli... |
'Verify that the layer_acls view is behaving as expected'
| def test_layer_acls(self):
| valid_uname_pw = ('%s:%s' % ('bobby', 'bob'))
invalid_uname_pw = ('%s:%s' % ('n0t', 'v@l1d'))
valid_auth_headers = {'HTTP_AUTHORIZATION': ('basic ' + base64.b64encode(valid_uname_pw))}
invalid_auth_headers = {'HTTP_AUTHORIZATION': ('basic ' + base64.b64encode(invalid_uname_pw))}
bob = get_user... |
'Verify that the resolve_user view is behaving as expected'
| def test_resolve_user(self):
| valid_uname_pw = ('%s:%s' % ('admin', 'admin'))
invalid_uname_pw = ('%s:%s' % ('n0t', 'v@l1d'))
valid_auth_headers = {'HTTP_AUTHORIZATION': ('basic ' + base64.b64encode(valid_uname_pw))}
invalid_auth_headers = {'HTTP_AUTHORIZATION': ('basic ' + base64.b64encode(invalid_uname_pw))}
response = s... |
'Tests the OGC Servers Handler class.'
| def test_ogc_server_settings(self):
| with override_settings(OGC_SERVER=self.OGC_DEFAULT_SETTINGS, UPLOADER=self.UPLOADER_DEFAULT_SETTINGS):
OGC_SERVER = self.OGC_DEFAULT_SETTINGS.copy()
OGC_SERVER.update({'PUBLIC_LOCATION': 'http://localhost:8080/geoserver/'})
ogc_settings = OGC_Servers_Handler(OGC_SERVER)['default']
de... |
'Tests that OGC_SERVER_SETTINGS are built if they do not exist in the settings.'
| def test_ogc_server_defaults(self):
| 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, (defaults['LOCATION'] + 'rest'))
self.assertEqual(ogc_settings.ows, (... |
'Tests that the OGC_Servers_Handler throws an ImproperlyConfigured exception when using the importer
backend without a vector database and a datastore configured.'
| def test_importer_configuration(self):
| database_settings = self.DATABASE_DEFAULT_SETTINGS.copy()
ogc_server_settings = self.OGC_DEFAULT_SETTINGS.copy()
uploader_settings = self.UPLOADER_DEFAULT_SETTINGS.copy()
uploader_settings['BACKEND'] = 'geonode.importer'
self.assertTrue([('geonode_imports' not in database_settings.keys())])
with... |
'Tests the Geonode login required authentication middleware.'
| def test_login_middleware(self):
| from geonode.security.middleware import LoginRequiredMiddleware
middleware = LoginRequiredMiddleware()
white_list = [reverse('account_ajax_login'), reverse('account_confirm_email', kwargs=dict(key='test')), reverse('account_login'), reverse('account_password_reset'), reverse('forgot_username'), reverse('lay... |
'Try uploading a layer and verify that the user can administrate
his own layer despite not being a site administrator.'
| def test_layer_upload(self):
| self.client.login(username='norman', password='norman')
norman = get_user_model().objects.get(username='norman')
saved_layer = file_upload(os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp'), name='san_andres_y_providencia_poi_by_norman', user=norman, overwrite=True)
saved_layer.set_de... |
'Test that the wcs links are correctly created for a raster'
| def test_raster_upload(self):
| filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
wcs_link = False
for link in uploaded.link_set.all():
if (link.mime == 'image/tiff'):
wcs_link = True
self.assertTrue(wcs_link)
|
'Test that layers can be uploaded to running GeoNode/GeoServer'
| def test_layer_upload(self):
| layers = {}
expected_layers = []
not_expected_layers = []
for filename in os.listdir(gisdata.GOOD_DATA):
(basename, extension) = os.path.splitext(filename)
if (extension.lower() in ['.tif', '.shp', '.zip']):
expected_layers.append(os.path.join(gisdata.GOOD_DATA, filename))
... |
'Verify a GeoNodeException is returned for not compatible extensions'
| def test_extension_not_implemented(self):
| sampletxt = os.path.join(gisdata.VECTOR_DATA, 'points_epsg2249_no_prj.dbf')
try:
file_upload(sampletxt)
except GeoNodeException:
pass
except Exception:
raise
|
'Test uploading a layer with XML metadata'
| def test_layer_upload_metadata(self):
| thelayer = os.path.join(gisdata.PROJECT_ROOT, 'both', 'good', 'sangis.org', 'Airport', 'Air_Runways.shp')
self.assertTrue(('%s.xml' % thelayer), 'Expected layer XML metadata to exist')
uploaded = file_upload(thelayer, overwrite=True)
self.assertEqual(uploaded.title, 'Air Runways', 'Exp... |
'Test Uploading a good shapefile'
| def test_shapefile(self):
| thefile = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
uploaded = file_upload(thefile, overwrite=True)
check_layer(uploaded)
uploaded.delete()
|
'Verifying GeoNode complains about a shapefile without .prj'
| def test_bad_shapefile(self):
| thefile = os.path.join(gisdata.BAD_DATA, 'points_epsg2249_no_prj.shp')
try:
file_upload(thefile, overwrite=True)
except UploadError:
pass
except GeoNodeException:
pass
except Exception:
raise
|
'Uploading a good .tiff'
| def test_tiff(self):
| thefile = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
uploaded = file_upload(thefile, overwrite=True)
check_layer(uploaded)
uploaded.delete()
|
'Upload the same file more than once'
| def test_repeated_upload(self):
| thefile = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
uploaded1 = file_upload(thefile, overwrite=True)
check_layer(uploaded1)
uploaded2 = file_upload(thefile, overwrite=True)
check_layer(uploaded2)
uploaded3 = file_upload(thefile, overwrite=False)
check_layer(uploaded3)
msg = ('Ex... |
'Verify that layer is correctly deleted from GeoServer'
| def test_layer_delete_from_geoserver(self):
| gs_cat = gs_catalog
shp_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file, overwrite=True)
ws = gs_cat.get_workspace(shp_layer.workspace)
shp_store = gs_cat.get_store(shp_layer.store, ws)
shp_store_name = shp_store.name
shp_layer.de... |
'Verify that the \'delete_layer\' pre_delete hook is functioning'
| def test_delete_layer(self):
| gs_cat = gs_catalog
shp_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file)
shp_layer_id = shp_layer.pk
ws = gs_cat.get_workspace(shp_layer.workspace)
shp_store = gs_cat.get_store(shp_layer.store, ws)
shp_store_name = shp_store.name
... |
'Verify that the helpers.cascading_delete() method is working properly'
| def test_cascading_delete(self):
| gs_cat = gs_catalog
shp_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file)
resource_name = shp_layer.name
ws = gs_cat.get_workspace(shp_layer.workspace)
store = gs_cat.get_store(shp_layer.store, ws)
store_name = store.name
layer... |
'Check that keywords can be passed to file_upload'
| def test_keywords_upload(self):
| thefile = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
uploaded = file_upload(thefile, keywords=['foo', 'bar'], overwrite=True)
keywords = uploaded.keyword_list()
msg = ('No keywords found in layer %s' % uploaded.name)
assert (len(keywords) > 0), msg
asser... |
'Regression-test for failures caused by zero-width bounding boxes'
| def test_empty_bbox(self):
| thefile = os.path.join(gisdata.VECTOR_DATA, 'single_point.shp')
uploaded = file_upload(thefile, overwrite=True)
uploaded.set_default_permissions()
self.client.login(username='norman', password='norman')
resp = self.client.get(uploaded.get_absolute_url())
self.assertEquals(resp.status_code, 200)
|
'Test layer replace functionality'
| def test_layer_replace(self):
| vector_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_administrative.shp')
vector_layer = file_upload(vector_file, overwrite=True)
raster_file = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
raster_layer = file_upload(raster_file, overwrite=True)
self.client.login(username='... |
'Test layer import management command'
| def test_importlayer_mgmt_command(self):
| vector_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_administrative.shp')
call_command('importlayers', vector_file, overwrite=True, keywords='test, import, san andreas', title='Test San Andres y Providencia Administrative', verbosity=1)
lyr = Layer.objects.get(ti... |
'Test permissions on an unpublished layer'
| def test_unpublished(self):
| thefile = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
layer = file_upload(thefile, overwrite=True)
layer.set_default_permissions()
check_layer(layer)
time.sleep(20)
url = 'http://localhost:8080/geoserver/ows?service=wms&version=1.3.0&request=GetCapabilities'
str_to_... |
'Test the layer save method generates a thumbnail link'
| def test_layer_thumbnail(self):
| self.client.login(username='norman', password='norman')
norman = get_user_model().objects.get(username='norman')
saved_layer = file_upload(os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp'), name='san_andres_y_providencia_poi_by_norman', user=norman, overwrite=True)
thumbnail_url = sa... |
'Test the map save method generates a thumbnail link'
| def test_map_thumbnail(self):
| self.client.login(username='norman', password='norman')
norman = get_user_model().objects.get(username='norman')
saved_layer = file_upload(os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp'), name='san_andres_y_providencia_poi_by_norman', user=norman, overwrite=True)
saved_layer.set_de... |
'Test the PrintProxyMiddleware if activated.
It should respect the permissions on private layers.'
| def testPrintProxy(self):
| if ('geonode.middleware.PrintProxyMiddleware' in settings.MIDDLEWARE_CLASSES):
from geonode.maps.models import Map
self.client.login(username='norman', password='norman')
norman = get_user_model().objects.get(username='norman')
saved_layer = file_upload(os.path.join(gisdata.VECTOR_DA... |
'Test attributes syncronization'
| def test_set_attributes_from_geoserver(self):
| shp_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
layer = file_upload(shp_file)
for attribute in layer.attribute_set.all():
attribute.attribute_label = ('%s_label' % attribute.attribute)
attribute.description = ('%s_description' % attribute.attribute)
a... |
'Test utility function set_attributes() which creates Attribute instances attached
to a Layer instance.'
| def test_set_attributes_creates_attributes(self):
| self.client.login(username='norman', password='norman')
disconnected_post_save = signals.post_save.disconnect(geoserver_post_save, sender=Layer)
l = Layer.objects.create(name='dummy_layer')
if disconnected_post_save:
signals.post_save.connect(geoserver_post_save, sender=Layer)
attribute_map ... |
'Verify that GeoNode works against any CSW'
| def test_csw_base(self):
| csw = get_catalogue(skip_caps=False)
for op in csw.catalogue.operations:
for method in op.methods:
self.assertEqual(csw.catalogue.url, method['url'], 'Expected GeoNode URL to be equal to all CSW URLs')
self.assertEqual(csw.catalogue.version, '2.0.2', 'Expected ... |
'Verify that GeoNode CSW can handle search counting'
| def test_csw_search_count(self):
| csw = get_catalogue(skip_caps=False)
csw.catalogue.getrecords(typenames='csw:Record')
self.assertEqual(csw.catalogue.results['matches'], 16, 'Expected 16 records')
csw.catalogue.getrecords(typenames='gmd:MD_Metadata')
self.assertEqual(csw.catalogue.results['matches'], 16, 'Expected 16 re... |
'Verify that GeoNode CSW can handle ISO metadata with Dublin Core outputSchema'
| def test_csw_outputschema_dc(self):
| csw = get_catalogue()
csw.catalogue.getrecords(typenames='gmd:MD_Metadata', keywords=['%san_andres_y_providencia_location%'], outputschema='http://www.opengis.net/cat/csw/2.0.2', esn='full')
record = csw.catalogue.records.values()[0]
self.assertEqual(record.title, 'San Andres Y Providencia L... |
'Verify that GeoNode CSW can handle ISO metadata with ISO outputSchema'
| def test_csw_outputschema_iso(self):
| csw = get_catalogue()
csw.catalogue.getrecords(typenames='gmd:MD_Metadata', keywords=['%san_andres_y_providencia_location%'], outputschema='http://www.isotc211.org/2005/gmd', esn='full')
record = csw.catalogue.records.values()[0]
self.assertEqual(record.identification.title, 'San Andres Y Provi... |
'Verify that GeoNode CSW can handle ISO metadata BBOX model with Dublin Core outputSchema'
| def test_csw_outputschema_dc_bbox(self):
| csw = get_catalogue()
if (csw.catalogue.type != 'geonetwork'):
csw.catalogue.getrecords(typenames='gmd:MD_Metadata', keywords=['san_andres_y_providencia_location'], outputschema='http://www.opengis.net/cat/csw/2.0.2', esn='full')
record = csw.catalogue.records.values()[0]
self.assertEqua... |
'Verify that GeoNode CSW can handle ISO metadata with FGDC outputSchema'
| def test_csw_outputschema_fgdc(self):
| csw = get_catalogue()
if (csw.catalogue.type in ['pycsw_http', 'pycsw_local']):
csw.catalogue.getrecords(typenames='gmd:MD_Metadata', keywords=['san_andres_y_providencia_location'], outputschema='http://www.opengis.net/cat/csw/csdgm')
record = csw.catalogue.records.values()[0]
self.asser... |
'Verify that GeoNode CSW can handle bbox queries'
| def test_csw_query_bbox(self):
| csw = get_catalogue()
csw.catalogue.getrecords(bbox=[(-140), (-70), 80, 70])
self.assertEqual(csw.catalogue.results, {'matches': 7, 'nextrecord': 0, 'returned': 7}, 'Expected a specific bbox query result set')
|
'Verify that GeoNode CSW can handle FGDC metadata upload'
| def test_csw_upload_fgdc(self):
| csw = get_catalogue()
if (csw.catalogue.type == 'pycsw_http'):
md_doc = etree.tostring(etree.fromstring(open(os.path.join(gisdata.GOOD_METADATA, 'sangis.org', 'Census', 'Census_Blockgroup_Pop_Housing.shp.xml')).read()))
csw.catalogue.transaction(ttype='insert', typename='fgdc:metadata', record=m... |
'Verify that GeoNode CSW can handle bulk upload of ISO and FGDC metadata'
| def test_csw_bulk_upload(self):
| csw = get_catalogue()
if (csw.catalogue.type == 'pycsw_http'):
identifiers = []
for (root, dirs, files) in os.walk(os.path.join(gisdata.GOOD_METADATA, 'sangis.org')):
for mfile in files:
if mfile.endswith('.xml'):
md_doc = etree.tostring(etree.from... |
'Test if the homepage renders.'
| def test_home_page(self):
| response = self.client.get(reverse('home'))
self.failUnlessEqual(response.status_code, 200)
|
'Test help page renders.'
| def test_help_page(self):
| response = self.client.get(reverse('help'))
self.failUnlessEqual(response.status_code, 200)
|
'Test help page renders.'
| def test_developer_page(self):
| response = self.client.get(reverse('help'))
self.failUnlessEqual(response.status_code, 200)
|
'Test if the data home page renders.'
| def test_layer_page(self):
| response = self.client.get(reverse('layer_browse'))
self.failUnlessEqual(response.status_code, 200)
|
'Test if the data/acls endpoint renders.'
| def test_layer_acls(self):
| response = self.client.get(reverse('layer_acls'))
self.failUnlessEqual(response.status_code, 200)
|
'Test Maps page renders.'
| def test_maps_page(self):
| response = self.client.get(reverse('maps_browse'))
self.failUnlessEqual(response.status_code, 200)
|
'Test New Map page renders.'
| def test_new_map_page(self):
| response = self.client.get(reverse('new_map'))
self.failUnlessEqual(response.status_code, 200)
|
'Test the profiles page renders.'
| def test_profile_list(self):
| response = self.client.get(reverse('profile_browse'))
self.failUnlessEqual(response.status_code, 200)
|
'Test that user profile pages render.'
| def test_profiles(self):
| response = self.client.get(reverse('profile_detail', args=['admin']))
self.failUnlessEqual(response.status_code, 200)
response = self.client.get(reverse('profile_detail', args=['norman']))
self.failUnlessEqual(response.status_code, 200)
|
'Test that the CSW endpoint is correctly configured.'
| def test_csw_endpoint(self):
| response = self.client.get(reverse('csw_global_dispatch'))
self.failUnlessEqual(response.status_code, 200)
|
'Test that the local OpenSearch endpoint is correctly configured.'
| def test_opensearch_description(self):
| response = self.client.get(reverse('opensearch_dispatch'))
self.failUnlessEqual(response.status_code, 200)
|
'Get the related service object dynamically'
| @property
def service(self):
| service_layers = self.servicelayer_set.all()
if (len(service_layers) == 0):
return None
else:
return service_layers[0].service
|
'Get the shp or geotiff file for this layer.'
| def get_base_file(self):
| if (self.upload_session is None):
return (None, None)
base_exts = [x.replace('.', '') for x in (cov_exts + vec_exts)]
base_files = self.upload_session.layerfile_set.filter(name__in=base_exts)
base_files_count = base_files.count()
if (base_files_count == 0):
return (None, None)
ms... |
'/data/ -> Test accessing the data page'
| def test_data(self):
| response = self.client.get(reverse('layer_browse'))
self.failUnlessEqual(response.status_code, 200)
|
'/data/geonode:CA/metadata -> Test accessing the description of a layer'
| def test_describe_data_2(self):
| self.assertEqual(8, get_user_model().objects.all().count())
response = self.client.get(reverse('layer_metadata', args=('geonode:CA',)))
self.failUnlessEqual(response.status_code, 302)
self.client.login(username='admin', password='admin')
response = self.client.get(reverse('layer_metadata', args=('ge... |
'/data/geonode:CA/metadata -> Test accessing the description of a layer'
| def test_describe_data(self):
| self.assertEqual(8, get_user_model().objects.all().count())
response = self.client.get(reverse('layer_metadata', args=('geonode:CA',)))
self.failUnlessEqual(response.status_code, 302)
self.client.login(username='admin', password='admin')
response = self.client.get(reverse('layer_metadata', args=('ge... |
'Test layer feature catalogue functionality'
| def test_layer_attributes_feature_catalogue(self):
| url = reverse('layer_feature_catalogue', args=('bad_layer',))
response = self.client.get(url)
self.assertEquals(response.status_code, 404)
layer = Layer.objects.get(pk=3)
url = reverse('layer_feature_catalogue', args=(layer.alternate,))
response = self.client.get(url)
self.assertEquals(respo... |
'Test layer rating is removed on layer remove'
| def test_rating_layer_remove(self):
| layer = Layer.objects.get(pk=3)
layer.default_style = Style.objects.get(pk=layer.pk)
layer.save()
url = reverse('layer_remove', args=(layer.alternate,))
layer_id = layer.id
ctype = ContentType.objects.get(model='layer')
OverallRating.objects.create(category=2, object_id=layer_id, content_typ... |
'Test layer remove functionality'
| def test_layer_remove(self):
| layer = Layer.objects.get(pk=1)
url = reverse('layer_remove', args=(layer.alternate,))
layer.default_style = Style.objects.get(pk=layer.pk)
layer.save()
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
self.client.login(username='norman', password='norman')
re... |
'Tests that deleting a layer with a shared default style will not cascade and
delete multiple layers.'
| def test_non_cascading(self):
| layer1 = Layer.objects.get(pk=1)
layer2 = Layer.objects.get(pk=2)
url = reverse('layer_remove', args=(layer1.alternate,))
layer1.default_style = Style.objects.get(pk=layer1.pk)
layer1.save()
layer2.default_style = Style.objects.get(pk=layer1.pk)
layer2.save()
self.assertEquals(layer1.def... |
'Ensure set_permissions supports the change_layer_data permission.'
| def test_assign_change_layer_data_perm(self):
| layer = Layer.objects.first()
user = get_anonymous_user()
layer.set_permissions({'users': {user.username: ['change_layer_data']}})
perms = layer.get_all_level_info()
self.assertIn('change_layer_data', perms['users'][user])
|
'Test unpublished layer behaviour'
| def test_unpublished_layer(self):
| user = get_user_model().objects.get(username='bobby')
self.client.login(username='bobby', password='bob')
response = self.client.get(reverse('layer_detail', args=('geonode:CA',)))
self.failUnlessEqual(response.status_code, 200)
layer = Layer.objects.filter(title='CA')[0]
layer.is_published = Fal... |
'Test if moderation flag works'
| def test_moderated_upload(self):
| with self.settings(ADMIN_MODERATE_UPLOADS=False):
layer_upload_url = reverse('layer_upload')
self.client.login(username=self.user, password=self.passwd)
(input_paths, suffixes) = self._get_input_paths()
input_files = [open(fp, 'rb') for fp in input_paths]
files = dict(zip(['{... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.