def test_layer_delete_from_geoserver(self):
"""Verify that layer is correctly deleted from GeoServer
"""
# Layer.delete() calls the pre_delete hook which uses cascading_delete()
# Should we explicitly test that the styles and store are
# deleted as well as the resource itself?
# There is already an explicit test for cascading delete
gs_cat = gs_catalog
# Test Uploading then Deleting a Shapefile from GeoServer
shp_file = os.path.join(
gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file, overwrite=True)
shp_store = gs_cat.get_store(shp_layer.name)
shp_layer.delete()
self.assertRaises(
FailedRequestError,
lambda: gs_cat.get_resource(
shp_layer.name,
store=shp_store))
# Test Uploading then Deleting a TIFF file from GeoServer
tif_file = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
tif_layer = file_upload(tif_file)
tif_store = gs_cat.get_store(tif_layer.name)
tif_layer.delete()
self.assertRaises(
FailedRequestError,
lambda: gs_cat.get_resource(
shp_layer.name,
store=tif_store))
def test_unpublished(self):
"""Test permissions on an unpublished layer
"""
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)
# we need some time to have the service up and running
time.sleep(20)
# request getCapabilities: layer must be there as it is published and
# advertised: we need to check if in response there is
# <Name>geonode:san_andres_y_providencia_water</Name>
url = "http://localhost:8080/geoserver/ows?" "service=wms&version=1.3.0&request=GetCapabilities"
str_to_check = "<Name>geonode:san_andres_y_providencia_poi</Name>"
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertTrue(any(str_to_check in s for s in response.readlines()))
# by default the uploaded layer is
self.assertTrue(layer.is_published, True)
# Clean up and completely delete the layer
layer.delete()
# with settings disabled
with self.settings(RESOURCE_PUBLISHING=True):
thefile = os.path.join(gisdata.VECTOR_DATA, "san_andres_y_providencia_administrative.shp")
layer = file_upload(thefile, overwrite=True)
layer.set_default_permissions()
check_layer(layer)
# we need some time to have the service up and running
time.sleep(20)
str_to_check = "<Name>san_andres_y_providencia_administrative</Name>"
# by default the uploaded layer must be unpublished
self.assertEqual(layer.is_published, False)
# check the layer is not in GetCapabilities
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertFalse(any(str_to_check in s for s in response.readlines()))
# now test with published layer
resource = layer.get_self_resource()
resource.is_published = True
resource.save()
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertTrue(any(str_to_check in s for s in response.readlines()))
# Clean up and completely delete the layer
layer.delete()
def test_extension_not_implemented(self):
"""Verify a GeoNodeException is returned for not compatible extensions
"""
sampletxt = os.path.join(gisdata.VECTOR_DATA, "points_epsg2249_no_prj.dbf")
try:
file_upload(sampletxt)
except GeoNodeException, e:
pass
def save_shape(self, shape_in_memory=None, user=None):
if shape_in_memory is None:
shape_in_memory = self.shp
shape_in_memory.save(self.path_file)
self.__create_projection()
file = self.path_file + ".shp"
file_upload(file, user=user)
command_remove_shape = "rm -f " + self.path_file + ".*"
call(command_remove_shape, shell=True)
def test_bad_shapefile(self):
"""Verifying GeoNode complains about a shapefile without .prj
"""
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
def test_map_json(self):
# 2 layers to be added to the map
filename = os.path.join(
gisdata.GOOD_DATA, 'raster/relief_san_andres.tif')
layer1 = file_upload(filename)
filename = os.path.join(
gisdata.GOOD_DATA,
'vector/san_andres_y_providencia_administrative.shp')
layer2 = file_upload(filename)
json_payload = InitialSetup.generate_initial_map(layer1, layer2)
# First, create a map with two layers
# Need to log in for saving a map
self.client.login(username='******', password='******')
result_new_map = self.client.post(
reverse('new_map_json'),
json.dumps(json_payload),
content_type='application/json')
# the new map is successfully saved
self.assertEqual(result_new_map.status_code, 200)
map_id = json.loads(result_new_map.content).get('id')
# try to remove one layer
layers = json_payload['map']['layers']
before_remove = len(layers)
after_remove = before_remove - 1
layer = layers[0]
layers.remove(layer)
# check if the layer is eliminated from the map
result_update_map = self.client.post(
reverse('map_json', kwargs={'mapid': map_id}),
data=json.dumps(json_payload),
content_type='application/json')
# successfully updated
self.assertEqual(result_update_map.status_code, 200)
# the number of layers on the map decrease by 1
self.assertEqual(
len(result_update_map.context_data['map'].layers),
after_remove)
# clean up
map = Map.objects.get(id=map_id)
map.delete()
layer1.delete()
layer2.delete()
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'base.change_resourcebase',_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
return render_to_response(template,
RequestContext(request, {'layer': layer,
'is_featuretype': layer.is_vector()}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(base_file, name=layer.name,
user=request.user, overwrite=True)
except Exception, e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse('layer_detail', args=[saved_layer.service_typename])
finally:
def test_unpublished(self):
"""Test permissions on an unpublished layer
"""
thefile = os.path.join(
gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
layer = file_upload(thefile, overwrite=True)
check_layer(layer)
# we need some time to have the service up and running
time.sleep(20)
# request getCapabilities: layer must be there as it is published and
# advertised: we need to check if in response there is
# <Name>geonode:san_andres_y_providencia_water</Name>
url = 'http://localhost:8080/geoserver/ows?' \
'service=wms&version=1.3.0&request=GetCapabilities'
str_to_check = '<Name>geonode:san_andres_y_providencia_poi</Name>'
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertTrue(any(str_to_check in s for s in response.readlines()))
# now test with unpublished layer
resource = layer.get_self_resource()
resource.is_published = False
resource.save()
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertFalse(any(str_to_check in s for s in response.readlines()))
# Clean up and completely delete the layer
layer.delete()
def test_list_style(self):
"""Test querying list of styles from QGIS Server."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
layer = file_upload(filename)
""":type: geonode.layers.models.Layer"""
actual_list_style = style_list(layer, internal=False)
expected_list_style = ['default']
# There will be a default style
self.assertEqual(
set(expected_list_style),
set([style.name for style in actual_list_style]))
style_list_url = reverse(
'qgis_server:download-qml',
kwargs={
'layername': layer.name
})
response = self.client.get(style_list_url)
self.assertEqual(response.status_code, 200)
actual_list_style = json.loads(response.content)
# There will be a default style
self.assertEqual(
set(expected_list_style),
set([style['name'] for style in actual_list_style]))
layer.delete()
def test_getcapabilities_filters_by_site(self):
thefile1 = os.path.join(gisdata.VECTOR_DATA, "san_andres_y_providencia_poi.shp")
thefile2 = os.path.join(gisdata.VECTOR_DATA, "san_andres_y_providencia_administrative.shp")
file_upload(thefile1, overwrite=True)
file_upload(thefile2, overwrite=True)
# remove one layer from the site resources
SiteResources.objects.get(site=self.slave_site).resources.remove(Layer.objects.all()[0])
self.assertEqual(SiteResources.objects.get(site=self.slave_site).resources.count(), 1)
self.client.login(username="******", password="******")
resp = self.client.get(self.getcaps_url)
xml = minidom.parseString(resp.content)
getcaps_layer = xml.getElementsByTagName("Layer")[0]
self.assertEqual(len(getcaps_layer.getElementsByTagName("Layer")), 1)
def test_set_attributes(self):
"""Test attributes syncronization
"""
# upload a shapefile
shp_file = os.path.join(
gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
layer = file_upload(shp_file)
# set attributes for resource
for attribute in layer.attribute_set.all():
attribute.attribute_label = '%s_label' % attribute.attribute
attribute.description = '%s_description' % attribute.attribute
attribute.save()
# sync the attributes with GeoServer
set_attributes(layer)
# tests if everything is synced properly
for attribute in layer.attribute_set.all():
self.assertEquals(
attribute.attribute_label,
'%s_label' % attribute.attribute
)
self.assertEquals(
attribute.description,
'%s_description' % attribute.attribute
)
def test_empty_bbox(self):
"""Regression-test for failures caused by zero-width bounding boxes"""
thefile = os.path.join(gisdata.VECTOR_DATA, 'single_point.shp')
uploaded = file_upload(thefile, overwrite=True)
self.client.login(username='******', password='******')
resp = self.client.get(uploaded.get_absolute_url())
self.assertEquals(resp.status_code, 200)
def test_cascading_delete(self):
"""Verify that the helpers.cascading_delete() method is working properly
"""
gs_cat = gs_catalog
# Upload a Shapefile
shp_file = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file)
# Save the names of the Resource/Store/Styles
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 = gs_cat.get_layer(resource_name)
styles = layer.styles + [layer.default_style]
# Delete the Layer using cascading_delete()
cascading_delete(gs_cat, shp_layer.typename)
# Verify that the styles were deleted
for style in styles:
s = gs_cat.get_style(style.name)
assert s == None
# Verify that the resource was deleted
self.assertRaises(FailedRequestError, lambda: gs_cat.get_resource(resource_name, store=store))
# Verify that the store was deleted
self.assertRaises(FailedRequestError, lambda: gs_cat.get_store(store_name))
# Clean up by deleting the layer from GeoNode's DB and GeoNetwork
shp_layer.delete()
def test_map_thumbnail(self):
"""Test the map save method generates a thumbnail link
"""
# TODO: Would be nice to ensure the name is available before
# running the test...
norman = get_user_model().objects.get(username="******")
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,
)
try:
self.client.login(username='******', password='******')
saved_layer.set_default_permissions()
map_obj = Map(owner=norman, zoom=0,
center_x=0, center_y=0)
map_obj.create_from_layer_list(norman, [saved_layer], 'title', '')
thumbnail_url = map_obj.get_thumbnail_url()
self.assertNotEqual(thumbnail_url, staticfiles.static(settings.MISSING_THUMBNAIL))
finally:
# Cleanup
saved_layer.delete()
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'layer': layer,
'is_featuretype': layer.is_vector(),
'is_layer': True,
}
return render_to_response(template,
RequestContext(request, ctx))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
except Exception as e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 500
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
def test_layer_delete_from_geoserver(self):
"""Verify that layer is correctly deleted from GeoServer
"""
# Layer.delete() calls the pre_delete hook which uses cascading_delete()
# Should we explicitly test that the styles and store are
# deleted as well as the resource itself?
# There is already an explicit test for cascading delete
gs_cat = gs_catalog
# Test Uploading then Deleting a Shapefile from GeoServer
shp_file = os.path.join(
gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
shp_layer = file_upload(shp_file, overwrite=True)
# we need some time to have the service up and running
time.sleep(20)
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.delete()
# Verify that it no longer exists in GeoServer
self.assertRaises(
FailedRequestError,
lambda: gs_cat.get_resource(
shp_layer.name,
store=shp_store))
# Verify that the store was deleted
ds = gs_cat.get_store(shp_store_name)
self.assertIsNone(ds)
# Test Uploading then Deleting a TIFF file from GeoServer
tif_file = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
tif_layer = file_upload(tif_file)
ws = gs_cat.get_workspace(tif_layer.workspace)
tif_store = gs_cat.get_store(tif_layer.store, ws)
tif_layer.delete()
self.assertRaises(
FailedRequestError,
lambda: gs_cat.get_resource(
shp_layer.name,
store=tif_store))
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_permissions',
_PERMISSION_MSG_MODIFY)
try:
if "permission_denied" in layer:
return HttpResponse('You are not allowed to replace this layer',
mimetype="text/plain",
status=401)
except:
pass
if request.method == 'GET':
return render_to_response(
template, RequestContext(
request, {
'layer': layer, 'is_featuretype': layer.is_vector()}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(base_file, name=layer.name,
user=request.user, overwrite=True)
except Exception as e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 500
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
def test_download_map_qlr(self):
"""Test download QLR file for a map"""
# 2 layers to be added to the map
filename = os.path.join(
gisdata.GOOD_DATA, 'raster/relief_san_andres.tif')
layer1 = file_upload(filename)
filename = os.path.join(
gisdata.GOOD_DATA,
'vector/san_andres_y_providencia_administrative.shp')
layer2 = file_upload(filename)
# construct json request for new map
json_payload = InitialSetup.generate_initial_map(layer1, layer2)
self.client.login(username='******', password='******')
response = self.client.post(
reverse('new_map_json'),
json.dumps(json_payload),
content_type='application/json')
# map is successfull saved
self.assertEqual(response.status_code, 200)
map_id = json.loads(response.content).get('id')
map = Map.objects.get(id=map_id)
# check that QLR is added to the links
links = map.link_set.download()
map_qlr_link = links.get(name='Download QLR Layer file')
self.assertIn('qlr', map_qlr_link.url)
# QLR
response = self.client.get(
reverse('map_download_qlr', kwargs={'mapid': map_id}))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.get('Content-Type'),
'application/x-qgis-layer-definition')
# cleanup
map.delete()
layer1.delete()
layer2.delete()
def setUp(self):
super(NewMapConfigTest, self).setUp()
from geonode.layers.utils import file_upload
self.layer = file_upload(
os.path.join(TESTDIR, 'test_point.shp'),
name='testlayer'
)
self.url = '/layers/geonode:testlayer'
self.service_name = 'data-test'
def test_shapefile(self):
"""Test Uploading a good shapefile
"""
thefile = os.path.join(gisdata.VECTOR_DATA, 'san_andres_y_providencia_poi.shp')
uploaded = file_upload(thefile, overwrite=True)
check_layer(uploaded)
# Clean up and completely delete the layer
uploaded.delete()
def test_tiff(self):
"""Uploading a good .tiff
"""
thefile = os.path.join(gisdata.RASTER_DATA, 'test_grid.tif')
uploaded = file_upload(thefile, overwrite=True)
check_layer(uploaded)
# Clean up and completely delete the layer
uploaded.delete()
def test_raster_upload(self):
"""Test that the wcs links are correctly created for a raster"""
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 == 'GeoTIFF':
wcs_link = True
self.assertTrue(wcs_link)
def test_bad_shapefile(self):
"""Verifying GeoNode complains about a shapefile without .prj
"""
thefile = os.path.join(gisdata.BAD_DATA, "points_epsg2249_no_prj.shp")
try:
uploaded = file_upload(thefile, overwrite=True)
except GeoNodeException, e:
pass
def test_zipped_files(self):
"""Test that the zipped files is created for raster."""
filename = os.path.join(gisdata.GOOD_DATA, 'raster/test_grid.tif')
uploaded = file_upload(filename)
zip_link = False
for link in uploaded.link_set.all():
if link.mime == 'ZIP':
zip_link = True
self.assertTrue(zip_link)
def setUp(self):
super(LayerMetadataDetailTest, self).setUp()
from geonode.layers.utils import file_upload
self.layer = file_upload(
os.path.join(TESTDIR, 'test_point.shp'),
name='testlayer'
)
self.url = '/layers/geonode:testlayer/metadata_detail'
def test_keywords_upload(self):
"""Check that keywords can be passed to file_upload
"""
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
assert 'foo' in uploaded.keyword_list(), 'Could not find "foo" in %s' % keywords
assert 'bar' in uploaded.keyword_list(), 'Could not find "bar" in %s' % keywords
def create_layer(number):
""" Creates a new layer """
file_list = glob.glob('%s*.shp' % shp_path)
random_index = randint(0, len(file_list) -1)
file_uri = file_list[random_index]
layer = file_upload(file_uri)
# keywords
assign_keywords(layer)
# other stuff
resource = layer.get_self_resource()
set_resource(resource)
def setUp(self):
super(LayerPublishTest, self).setUp()
from geonode.layers.utils import file_upload
self.layer = file_upload(
os.path.join(TESTDIR, 'test_point.shp'),
name='testlayer'
)
self.url = '/layers/geonode:testlayer/publish'
# We expect to be redirected
self.expected_status = 302
def layer_replace(request, layername, template="layers/layer_replace.html"):
layer = _resolve_layer(request, layername, "base.change_resourcebase", _PERMISSION_MSG_MODIFY)
if request.method == "GET":
ctx = {"charsets": CHARSETS, "layer": layer, "is_featuretype": layer.is_vector(), "is_layer": True}
return render_to_response(template, RequestContext(request, ctx))
elif request.method == "POST":
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
if layer.is_vector() and is_raster(base_file):
out["success"] = False
out["errors"] = _("You are attempting to replace a vector layer with a raster.")
elif (not layer.is_vector()) and is_vector(base_file):
out["success"] = False
out["errors"] = _("You are attempting to replace a raster layer with a vector.")
else:
# delete geoserver's store before upload
cat = gs_catalog
cascading_delete(cat, layer.typename)
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
out["success"] = True
out["url"] = reverse("layer_detail", args=[saved_layer.service_typename])
except Exception as e:
out["success"] = False
out["errors"] = str(e)
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out["errors"] = form.errors
out["errormsgs"] = errormsgs
if out["success"]:
status_code = 200
else:
status_code = 400
return HttpResponse(json.dumps(out), mimetype="application/json", status=status_code)
def test_repeated_upload(self):
"""Upload the same file more than once
"""
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 = ('Expected %s but got %s' % (uploaded1.name, uploaded2.name))
assert uploaded1.name == uploaded2.name, msg
msg = ('Expected a different name when uploading %s using '
'overwrite=False but got %s' % (thefile, uploaded3.name))
assert uploaded1.name != uploaded3.name, msg
# Clean up and completely delete the layers
# uploaded1 is overwritten by uploaded2 ... no need to delete it
uploaded2.delete()
uploaded3.delete()
