def addZippedShapefile2Geoserver(geosvr_url_base, uname, upwd, ws_name, store_name, zippedTif_full_path, res_url):
try:
geosvr_url_full = geosvr_url_base+"/geoserver/rest/"
print "GeoServer REST Full URL: "+geosvr_url_full
coverage_file = zippedTif_full_path
print "Connect to Geoserver"
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geosvr_url_full, username=uname, password=upwd)
print "Connected"
response = None
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri=res_url)
if result['success']:
print "Create workspace " + ws_name + " successfully"
else:
print "Create workspace " + ws_name + " failed"
print result
store_id = ws_name + ":" + store_name
result = None
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_zip=coverage_file)
if result['success']:
print "Create store " + store_name + " successfully"
else:
print "Create store " + store_name + " failed"
print result
spatial_dataset_engine.list_layers(debug=True)
return True
except:
print ("addZippedTif2Geoserver() error")
return False
def addZippedShp2Geoserver(geosvr_url_base, uname, upwd, ws_name, store_name, zippedTif_full_path, res_url):
try:
# Specifying the full REST url
geosvr_url_full = geosvr_url_base+"/geoserver/rest/"
print "GeoServer REST Full URL: "+ geosvr_url_full
print "Connect to Geoserver"
# First get the engine
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geosvr_url_full, username=uname, password=upwd)
print "Connected"
response = None
# Creating the workspace
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri=res_url)
if result['success']:
print "Create workspace " + ws_name + " successfully"
else:
print "Create workspace " + ws_name + " failed"
print result
store_id = ws_name+":"+store_name
# Path to the shapefile base
coverage_file = zippedTif_full_path
print zippedTif_full_path
# Creating a workspace for registering a shapefile in the geoserver
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_base=coverage_file)
# Check if it was successful
if result['success']:
print "Create store " + store_name + " successfully"
else:
print "Create store " + store_name + " failed"
print result
# Debugging
spatial_dataset_engine.list_layers(debug=True)
return True
except:
print ("addZippedShp2Geoserver() error")
raise Exception("addZippedShp2Geoserver() error")
def addZippedShapefile2Geoserver(geosvr_url_base, uname, upwd, ws_name,
store_name, zippedTif_full_path, res_url):
try:
geosvr_url_full = geosvr_url_base + "/geoserver/rest/"
logger.debug("GeoServer REST Full URL: " + geosvr_url_full)
coverage_file = zippedTif_full_path
logger.debug("Connect to Geoserver")
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geosvr_url_full, username=uname, password=upwd)
logger.debug("Connected")
response = None
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name,
uri=res_url)
if result['success']:
logger.debug("Create workspace " + ws_name + " successfully")
else:
logger.debug("Create workspace " + ws_name + " failed")
logger.debug(result)
store_id = ws_name + ":" + store_name
result = None
result = spatial_dataset_engine.create_shapefile_resource(
store_id=store_id, shapefile_zip=coverage_file)
if result['success']:
logger.debug("Create store " + store_name + " successfully")
else:
logger.debug("Create store " + store_name + " failed")
logger.debug(result)
spatial_dataset_engine.list_layers(debug=True)
return True
except:
logger.exception("addZippedTif2Geoserver() error")
return False
def genShapeFile(input,title,geo_url,username,password,hs_url):
try:
file_name = 'hs_sites'
temp_dir = tempfile.mkdtemp()
file_location = temp_dir+"/"+file_name
w = sf.Writer(sf.POINT)
w.field('sitename')
w.field('sitecode')
w.field('network')
w.field('service')
w.field('url','C',200)
# w.field('elevation')
for item in input:
w.point(float(item['longitude']),float(item['latitude']))
site_name = item['sitename']
site_name.decode("utf-8")
w.record(item['sitename'],item['sitecode'],item['network'],item['service'],hs_url, 'Point')
w.save(file_location)
prj = open("%s.prj" % file_location, "w")
epsg = 'GEOGCS["WGS84",DATUM["WGS_1984",SPHEROID["WGS84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]'
prj.write(epsg)
prj.close()
file_list = os.listdir(temp_dir)
zip_file_full_path = temp_dir + "/" + "shapefile.zip"
with zipfile.ZipFile(zip_file_full_path, 'a') as myzip:
for fn in file_list:
shapefile_fp = temp_dir + "/"+ fn # tif full path
new_file_name = title + os.path.splitext(fn)[1]
myzip.write(shapefile_fp, arcname=new_file_name)
#Connecting to geoserver
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geo_url, username=username, password=password)
layer_metadata = {}
response = None
ws_name = "catalog"
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri="www.servir.org")
if result['success']:
print "Created workspace " + ws_name + " successfully"
else:
print "Creating workspace " + ws_name + " failed"
#print result
store_id = ws_name + ":" + title
result = None
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_zip=zip_file_full_path)
if result['success']:
print "Created store " + title + " successfully"
else:
print "Creating store " + title + " failed"
#find the bbox area
wms_rest_url = '{}workspaces/{}/datastores/{}/featuretypes/{}.json'.format(geo_url,ws_name,title,title)
print wms_rest_url
r = requests.get(wms_rest_url, auth=(username,password))
if r.status_code != 200:
print 'The Geoserver appears to be down.'
else:
json = r.json()
extents = json['featureType']['latLonBoundingBox']
# wms_response = urllib2.urlopen(wms_rest_url)
# wms_data = wms_response.read()
# print wms_data
layer_metadata["layer"] = store_id
layer_metadata["extents"] = extents
return layer_metadata
except:
return False
finally:
if temp_dir is not None:
if os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
class GeoServerDatasetEngineEnd2EndTests(unittest.TestCase):
def setUp(self):
# Files
self.tests_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.files_root = os.path.join(self.tests_root, 'files')
# GeoServer
self.gs_endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.gs_username = TEST_GEOSERVER_DATASET_SERVICE['USERNAME']
self.gs_password = TEST_GEOSERVER_DATASET_SERVICE['PASSWORD']
self.catalog = GeoServerCatalog(self.gs_endpoint, username=self.gs_username, password=self.gs_password)
# Postgis
self.pg_username = TEST_POSTGIS_SERVICE['USERNAME']
self.pg_password = TEST_POSTGIS_SERVICE['PASSWORD']
self.pg_database = TEST_POSTGIS_SERVICE['DATABASE']
self.pg_table_name = 'points'
self.pg_host = TEST_POSTGIS_SERVICE['HOST']
self.pg_port = TEST_POSTGIS_SERVICE['PORT']
self.pg_url = TEST_POSTGIS_SERVICE['URL']
self.pg_public_url = TEST_POSTGIS_SERVICE['PUBLIC_URL']
# Setup a testing workspace
self.workspace_name = random_string_generator(10)
self.workspace_uri = 'http://www.tethysplatform.org/{}'.format(self.workspace_name)
retries = 5
while retries > 0:
try:
self.catalog.create_workspace(self.workspace_name, self.workspace_uri)
break
except AssertionError as e:
if 'Error persisting' in str(e) and retries > 0:
print("WARNING: FAILED TO PERSIST WORKSPACE.")
retries -= 1
else:
raise
# Setup Postgis database connection
self.public_engine = create_engine(self.pg_public_url)
self.connection = self.public_engine.connect()
self.transaction = self.connection.begin()
# Create GeoServer Engine
self.endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.geoserver_engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
self.geometry_column = 'geometry'
self.geometry_type = 'Point'
self.srid = 4326
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def tearDown(self):
# Clean up GeoServer
workspace = self.catalog.get_workspace(self.workspace_name)
self.catalog.delete(workspace, recurse=True, purge=True)
# Clean up Postgis database
self.transaction.rollback()
self.connection.close()
self.public_engine.dispose()
def setup_postgis_table(self):
"""
Creates table in the database named "points" with two entries. The table has three columns:
"id", "name", and "geometry." Use this table for the tests that require a database.
"""
# Clean up
delete_sql = "DROP TABLE IF EXISTS {table}".\
format(table=self.pg_table_name)
self.connection.execute(delete_sql)
# Create table
geom_table_sql = "CREATE TABLE IF NOT EXISTS {table} (" \
"id integer CONSTRAINT points_primary_key PRIMARY KEY, " \
"name varchar(20)" \
"); " \
"SELECT AddGeometryColumn('public', '{table}', 'geometry', 4326, 'POINT', 2);". \
format(table=self.pg_table_name)
self.connection.execute(geom_table_sql)
insert_sql = "INSERT INTO {table} VALUES ({id}, '{name}', ST_GeomFromText('POINT({lon} {lat})', 4326));"
rows = [
{"id": 1, "name": "Aquaveo", "lat": 40.276039, "lon": -111.651120},
{"id": 2, "name": "BYU", "lat": 40.252335, "lon": -111.649326},
]
for r in rows:
sql = insert_sql.format(
table=self.pg_table_name,
id=r['id'],
name=r['name'],
lat=r['lat'],
lon=r['lon']
)
self.connection.execute(sql)
self.transaction.commit()
def test_create_shapefile_resource_base(self):
# call methods: create_shapefile_resource, list_resources, get_resource, delete_resource
# TEST create shapefile
# Setup
filename = 'test'
shapefile_name = os.path.join(self.files_root, 'shapefile', filename)
workspace = self.workspace_name
store_id = random_string_generator(10)
store_id_name = '{}:{}'.format(workspace, store_id)
# store_id_name = store_id
# Execute
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id_name,
shapefile_base=shapefile_name,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_id, r['name'])
self.assertIn(store_id, r['store'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(store_id, result)
# TEST get_resources
# Execute
# Geoserver uses the store_id as the layer/resource name (not the filename)
resource_id_name = '{}:{}'.format(workspace, store_id)
response = self.geoserver_engine.get_resource(resource_id=resource_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(store_id, r['name'])
self.assertIn(store_id, r['wfs']['shapefile'])
# TEST delete_resource
# Execute
# This case the resource id is the same as the store id.
response = self.geoserver_engine.delete_resource(resource_id=resource_id_name,
store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
# TODO: delete_resource is returning a 403 error: not authorized.
# self.assertTrue(response['success'])
def test_create_shapefile_resource_zip(self):
# call methods: create_shapefile_resource, list_layers, get_layer, delete_layer
# TEST create_shapefile_resource
# Test1.zip
# Setup
shapefile_zip = os.path.join(self.files_root, 'shapefile', "test1.zip")
shapefile = "test1"
workspace = self.workspace_name
store_id = random_string_generator(10)
store_id_name = '{}:{}'.format(workspace, store_id)
# Execute
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id_name,
shapefile_zip=shapefile_zip,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
filename = os.path.splitext(os.path.basename(shapefile_zip))[0]
self.assertIsInstance(r, dict)
self.assertIn(filename, r['name'])
self.assertIn(store_id, r['store'])
# TEST list_layers test
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Get the last item from result
layer_id = '{}:{}'.format(workspace, shapefile)
# TEST get layers test
# Execute
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(filename, r['name'])
self.assertIn(self.workspace_name, r['name'])
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=layer_id,
store_id=store_id)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_shapefile_resource_upload(self):
# call methods: create_shapefile_resource, list_stores, get_store, delete_store
# TEST create_shapefile_resource
# Use in memory file list: test.shp and friends
# Setup
shapefile_cst = os.path.join(self.files_root, 'shapefile', 'test.cst')
shapefile_dbf = os.path.join(self.files_root, 'shapefile', 'test.dbf')
shapefile_prj = os.path.join(self.files_root, 'shapefile', 'test.prj')
shapefile_shp = os.path.join(self.files_root, 'shapefile', 'test.shp')
shapefile_shx = os.path.join(self.files_root, 'shapefile', 'test.shx')
# Workspace is given
store_rand = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_rand)
with open(shapefile_cst, 'rb') as cst_upload,\
open(shapefile_dbf, 'rb') as dbf_upload,\
open(shapefile_prj, 'rb') as prj_upload,\
open(shapefile_shp, 'rb') as shp_upload,\
open(shapefile_shx, 'rb') as shx_upload:
upload_list = [cst_upload, dbf_upload, prj_upload, shp_upload, shx_upload]
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id,
shapefile_upload=upload_list,
overwrite=True)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_rand, r['name'])
self.assertIn(store_rand, r['store'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_rand, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], store_rand)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_arcgrid(self):
# call methods: create_coverage_resource, list_resources, get_resource, delete_resource
# TEST create_coverage_resource
# precip30min.zip
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'arcgrid'
coverage_file_name = 'precip30min.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "arc_sample", coverage_file_name)
with open(coverage_file, 'rb') as coverage_upload:
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=coverage_upload,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(coverage_name, result)
# TEST get_resource
# Execute
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
self.assertIn('ArcGrid', r['keywords'])
self.assertEqual(coverage_name, r['title'])
self.assertEqual('coverage', r['resource_type'])
# delete_resource
# TODO: delete_resource is returning a 403 error: not authorized.
# Execute
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.delete_resource(resource_id=resource_id,
store_id=store_name)
# # Validate response object
self.assert_valid_response_object(response)
# # Success
# self.assertTrue(response['success'])
def test_create_coverage_resource_grassgrid(self):
# call methods: create_coverage_resource, list_layers, get_layer, delete_layer
# TEST create_coverage resource
# my_grass.zip
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'grassgrid'
coverage_file_name = 'my_grass.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "grass_ascii", coverage_file_name)
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_file=coverage_file,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Tests
self.assertIn(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_layers
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Check if layer is in list
self.assertIn(coverage_name, result)
# TEST get_layer
# Execute
layer_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_name, r['store'])
self.assertIn(self.workspace_name, r['name'])
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=layer_id,
store_id=store_name)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_geotiff(self):
# adem.tif
# call methods: create_coverage_resource, list_stores, get_store, delete_store
# TEST create_coverage_resource
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'geotiff'
coverage_file_name = 'adem.tif'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, coverage_file_name)
with open(coverage_file, 'rb') as coverage_upload:
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=coverage_upload,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# TEST layer group listed
self.assertIn(store_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=expected_store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], store_name)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=expected_store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_world_file_tif(self):
# pk50095.zip
# call methods: create_coverage_resource, list_layers, get_layer, delete_layer
# TEST create_coverage resource
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'worldimage'
coverage_file_name = 'Pk50095.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "img_sample", coverage_file_name)
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_file=coverage_file,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Tests
self.assertIn(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_layers
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Check if layer is in list
self.assertIn(coverage_name, result)
# TEST get_layer
# Execute
layer_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_name, r['store'])
self.assertIn(self.workspace_name, self.workspace_name)
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=coverage_name,
store_id=store_name)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_upload(self):
# DO NOT MOCK
# Use in memory file list: precip30min.prj & precip30min.asc
# call methods: create_coverage_resource, list_resources, get_resource, delete_resource
store_id_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_id_name)
expected_coverage_type = 'arcgrid'
coverage_file_name = 'precip30min.asc'
prj_file_name = 'precip30min.prj'
coverage_name = coverage_file_name.split('.')[0]
arc_sample = os.path.join(self.files_root, "arc_sample")
coverage_file = os.path.join(arc_sample, coverage_file_name)
prj_file = os.path.join(arc_sample, prj_file_name)
with open(coverage_file, 'rb') as coverage_upload:
with open(prj_file, 'rb') as prj_upload:
upload_list = [coverage_upload, prj_upload]
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=upload_list,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(coverage_name, result)
# TEST get_resources
# Execute
resource_id = "{}:{}".format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(coverage_name, r['name'])
self.assertIn(coverage_name, r['wcs']['arcgrid'])
# TEST delete_resource
# TODO: delete_resource is returning a 403 error: not authorized.
# Execute
# This case the resource id is the same as the filename.
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.delete_resource(resource_id=resource_id,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
# self.assertTrue(response['success'])
def test_create_layer_group(self):
# call methods: create_layer_group, list_layer_groups, get_layer_group, delete_layer_group
# create_layer_group
# Use existing layers and styles in geoserver:
# layers: sf:roads, sf:bugsites, sf:streams;
# styles: simple_roads, capitals, simple_streams
# TEST create_layer_group
# Do create
# expected_layer_group_id = '{}:{}'.format(self.workspace_name, random_string_generator(10))
expected_layer_group_id = random_string_generator(10)
expected_layers = ['roads', 'bugsites', 'streams']
expected_styles = ['simple_roads', 'capitals', 'simple_streams']
# TODO: create_layer_group: fails on catalog.save() when workspace is given.
response = self.geoserver_engine.create_layer_group(layer_group_id=expected_layer_group_id,
layers=expected_layers,
styles=expected_styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEquals(result['name'], expected_layer_group_id)
self.assertEquals(result['layers'], expected_layers)
self.assertEquals(result['styles'], expected_styles)
# TEST list_layer_groups
# Execute
response = self.geoserver_engine.list_layer_groups()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(expected_layer_group_id, result)
# TEST get layer_group
# Execute
response = self.geoserver_engine.get_layer_group(layer_group_id=expected_layer_group_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# List of dictionaries
self.assertIn('workspace', r)
self.assertEqual(None, r['workspace'])
self.assertIn('layers', r)
self.assertEqual(expected_layers, r['layers'])
self.assertIn('styles', r)
self.assertEqual(expected_styles, r['styles'])
self.assertNotIn('dom', r)
# TEST delete layer group
# Clean up
self.geoserver_engine.delete_layer_group(layer_group_id=expected_layer_group_id)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# self.assertIsNone(response['result'])
def test_create_workspace(self):
# call methods: create_workspace, list_workspaces, get_workspace, delete_workspace
# TEST create workspace
expected_workspace_id = random_string_generator(10)
expected_uri = 'http://www.tethysplatform.org/{}'.format(expected_workspace_id)
# create workspace test
response = self.geoserver_engine.create_workspace(workspace_id=expected_workspace_id, uri=expected_uri)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn('name', r)
self.assertEqual(expected_workspace_id, r['name'])
# TEST list workspace
# Execute
response = self.geoserver_engine.list_workspaces()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# TEST layer group listed
self.assertIn(expected_workspace_id, result)
# TEST get_workspace
# Execute
response = self.geoserver_engine.get_workspace(workspace_id=expected_workspace_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], expected_workspace_id)
# TEST delete work_space
# Do delete
response = self.geoserver_engine.delete_workspace(workspace_id=expected_workspace_id)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_create_style(self):
# call methods: create_style, list_styles, get_style, delete_style
# TEST create_style
expected_style_id_name = random_string_generator(10)
expected_style_id = '{}:{}'.format(self.workspace_name, expected_style_id_name)
style_file_name = 'point.sld'
expected_sld = os.path.join(self.files_root, style_file_name)
# Execute
with open(expected_sld, 'r') as sld_file:
sld_string = sld_file.read()
# TODO: create_style: Fails on when overwrite is False.
response = self.geoserver_engine.create_style(style_id=expected_style_id, sld=sld_string, overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# TEST list_styles
# Execute
response = self.geoserver_engine.list_styles(workspace=self.workspace_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# TEST layer listed
self.assertIn(expected_style_id_name, result)
# TEST get_style
# Execute
response = self.geoserver_engine.get_style(style_id=expected_style_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], expected_style_id)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_style
# Do delete
response = self.geoserver_engine.delete_style(style_id=expected_style_id)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_link_and_add_table(self):
# call methods: link_sqlalchemy_db_to_geoserver, add_table_to_postgis_store, list_stores, get_store,
# delete_store
self.setup_postgis_table()
# TEST link_sqlalchemy_db_to_geoserver
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
sqlalchemy_engine = create_engine(self.pg_url)
response = self.geoserver_engine.link_sqlalchemy_db_to_geoserver(store_id=store_id,
sqlalchemy_engine=sqlalchemy_engine,
docker=True)
# Check for success response
self.assertTrue(response['success'])
sqlalchemy_engine.dispose()
# TEST add_table_to_postgis_store
# Execute
response = self.geoserver_engine.add_table_to_postgis_store(store_id=store_id,
table=self.pg_table_name)
# Check for success response
self.assertTrue(response['success'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_id_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(store_id_name, r['name'])
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_postgis_feature_resource(self):
# call methods: create_postgis_feature_resource (with table), list_stores, get_store, delete_store
self.setup_postgis_table()
# TEST create_postgis_feature_resource (with table)
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
response = self.geoserver_engine.create_postgis_feature_resource(store_id=store_id,
host=self.pg_host,
port=self.pg_port,
database=self.pg_database,
user=self.pg_username,
password=self.pg_password,
table=self.pg_table_name)
self.assertTrue(response['success'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_id_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(store_id_name, r['name'])
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_sql_view(self):
# call methods: create_sql_view, list_resources, list_stores, list_layers
self.setup_postgis_table()
# TEST create_postgis_feature_resource (with table)
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
response = self.geoserver_engine.create_postgis_feature_resource(store_id=store_id,
host=self.pg_host,
port=self.pg_port,
database=self.pg_database,
user=self.pg_username,
password=self.pg_password,
table=self.pg_table_name)
self.assertTrue(response['success'])
feature_type_name = random_string_generator(10)
postgis_store_id = '{}:{}'.format(self.workspace_name, store_id_name)
sql = "SELECT * FROM {}".format(self.pg_table_name)
geometry_column = self.geometry_column
geometry_type = self.geometry_type
response = self.geoserver_engine.create_sql_view(feature_type_name=feature_type_name,
postgis_store_id=postgis_store_id,
sql=sql,
geometry_column=geometry_column,
geometry_type=geometry_type)
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn('name', r)
self.assertIn(feature_type_name, r['name'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(feature_type_name, result)
# TEST get_resources
# Execute
# Geoserver uses the store_id as the layer/resource name (not the filename)
resource_id_name = '{}:{}'.format(self.workspace_name, feature_type_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(feature_type_name, r['name'])
self.assertIn(feature_type_name, r['wfs']['shapefile'])
# TEST delete_resource
# Execute
# This case the resource id is the same as the store id.
response = self.geoserver_engine.delete_resource(resource_id=resource_id_name,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
class TestGeoServerDatasetEngine(unittest.TestCase):
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile',
self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(
endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace,
uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(
self.test_store_identifier,
shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(
layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name, ),
styles=(self.test_style_name, ))
# Pause
pause(10)
def tearDown(self):
# Delete test layer groups
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Delete test resources & layers
self.engine.delete_resource(self.test_resource_identifier,
recurse=True)
# Delete stores
self.engine.delete_store(self.test_store_identifier)
# Delete test workspace
self.engine.delete_workspace(self.test_resource_workspace)
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def test_list_resources(self):
pause(10)
# Execute
response = self.engine.list_resources(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_resource_name, result)
def test_list_resources_with_properties(self):
# Execute
response = self.engine.list_resources(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_resource_in = False
for r in result:
if r['name'] == self.test_resource_name:
test_resource_in = True
break
self.assertTrue(test_resource_in)
def test_list_layers(self):
# Execute
response = self.engine.list_layers(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_layer_name, result)
def test_list_layers_with_properties(self):
# Execute
response = self.engine.list_layers(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_in = False
for r in result:
if r['name'] == self.test_layer_name:
test_layer_in = True
break
self.assertTrue(test_layer_in)
def test_list_layer_groups(self):
# Execute
response = self.engine.list_layer_groups(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer group listed
self.assertIn(self.test_layer_group_name, result)
def test_list_layer_groups_with_properties(self):
# Execute
response = self.engine.list_layer_groups(with_properties=True,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_group_in = False
for r in result:
if r['name'] == self.test_layer_group_name:
test_layer_group_in = True
break
self.assertTrue(test_layer_group_in)
def test_list_workspaces(self):
pass
def test_list_stores(self):
pass
def test_list_styles(self):
pass
def test_get_resource(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('workspace', result)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_workspace(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_identifier, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('workspace', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_store(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('store', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['store'], self.test_resource_store)
def test_get_resource_multiple_with_name(self):
pass
def test_get_layer(self):
# Execute
response = self.engine.get_layer(layer_id=self.test_layer_name,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_name)
def test_get_layer_group(self):
# Execute
response = self.engine.get_layer_group(
layer_group_id=self.test_layer_group_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_group_name)
def test_get_store(self):
pass
def test_get_workspace(self):
pass
def test_get_style(self):
pass
def test_update_resource(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_name,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_name, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_workspace(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_identifier,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_identifier, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_store(self):
pause(10)
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_layer(self):
# Get original
old_response = self.engine.get_layer(layer_id=self.test_layer_name)
# Update
new_default_style = self.test_style_name
response = self.engine.update_layer(layer_id=self.test_layer_name,
default_style=new_default_style,
debug=self.debug)
# Update should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
old_result = old_response['result']
result = response['result']
self.assertEqual(result['default_style'], new_default_style)
self.assertNotEqual(old_result['default_style'],
result['default_style'])
def test_update_layer_group(self):
pass
def test_delete_resource(self):
# Must delete layer group and layer first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
self.engine.delete_layer(layer_id=self.test_layer_name)
# Do delete
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_belongs_to_layer(self):
# Do delete without deleting layer group and layer
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_resource_recurse(self):
# Force delete with recurse
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_does_not_exist(self):
# Do delete
response = self.engine.delete_resource(resource_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer(self):
# Delete layer group first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_belongs_to_group(self):
# Do delete without deleting layer group
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_recurse(self):
# Force delete with recurse
response = self.engine.delete_layer(layer_id=self.test_layer_name,
recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_does_not_exist(self):
# Delete layer group first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_group(self):
# Do delete
response = self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_group_does_not_exist(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_workspace(self):
pass
def test_delete_store(self):
pass
def test_delete_style(self):
pass
def test_create_layer_group(self):
# Do create
name = random_string_generator(10)
layers = (self.test_layer_name, )
styles = (self.test_style_name, )
response = self.engine.create_layer_group(layer_group_id=name,
layers=layers,
styles=styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEqual(result['name'], name)
self.assertEqual(result['layers'], layers)
self.assertEqual(result['styles'], [])
# Clean up
self.engine.delete_layer_group(layer_group_id=name)
def test_create_layer_group_mismatch_layers_styles(self):
# Do create with differing number of styles and layers
name = random_string_generator(10)
layers = (self.test_layer_name, )
styles = (self.test_style_name, self.test_style_name)
response = self.engine.create_layer_group(layer_group_id=name,
layers=layers,
styles=styles)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_create_shapefile_resource(self):
self.assertTrue(False)
def test_create_coverage_resource(self):
self.assertTrue(False)
def test_create_workspace(self):
self.assertTrue(False)
def test_create_style(self):
self.assertTrue(False)
def test_create_sql_view(self):
self.assertTrue(False)
class TestGeoServerDatasetEngine(unittest.TestCase):
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile', self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace, uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(self.test_store_identifier, shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name,),
styles=(self.test_style_name,))
# Pause
pause(10)
def tearDown(self):
# Delete test layer groups
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Delete test resources & layers
self.engine.delete_resource(self.test_resource_identifier, recurse=True)
# Delete stores
self.engine.delete_store(self.test_store_identifier)
# Delete test workspace
self.engine.delete_workspace(self.test_resource_workspace)
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def test_list_resources(self):
pause(10)
# Execute
response = self.engine.list_resources(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_resource_name, result)
def test_list_resources_with_properties(self):
# Execute
response = self.engine.list_resources(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_resource_in = False
for r in result:
if r['name'] == self.test_resource_name:
test_resource_in = True
break
self.assertTrue(test_resource_in)
def test_list_layers(self):
# Execute
response = self.engine.list_layers(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_layer_name, result)
def test_list_layers_with_properties(self):
# Execute
response = self.engine.list_layers(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_in = False
for r in result:
if r['name'] == self.test_layer_name:
test_layer_in = True
break
self.assertTrue(test_layer_in)
def test_list_layer_groups(self):
# Execute
response = self.engine.list_layer_groups(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer group listed
self.assertIn(self.test_layer_group_name, result)
def test_list_layer_groups_with_properties(self):
# Execute
response = self.engine.list_layer_groups(with_properties=True, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_group_in = False
for r in result:
if r['name'] == self.test_layer_group_name:
test_layer_group_in = True
break
self.assertTrue(test_layer_group_in)
def test_list_workspaces(self):
pass
def test_list_stores(self):
pass
def test_list_styles(self):
pass
def test_get_resource(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('workspace', result)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_workspace(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_identifier,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('workspace', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_store(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('store', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['store'], self.test_resource_store)
def test_get_resource_multiple_with_name(self):
pass
def test_get_layer(self):
# Execute
response = self.engine.get_layer(layer_id=self.test_layer_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_name)
def test_get_layer_group(self):
# Execute
response = self.engine.get_layer_group(layer_group_id=self.test_layer_group_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_group_name)
def test_get_store(self):
pass
def test_get_workspace(self):
pass
def test_get_style(self):
pass
def test_update_resource(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_name,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_name, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_workspace(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_identifier,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_identifier,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_store(self):
pause(10)
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_layer(self):
# Get original
old_response = self.engine.get_layer(layer_id=self.test_layer_name)
# Update
new_default_style = self.test_style_name
response = self.engine.update_layer(layer_id=self.test_layer_name,
default_style=new_default_style,
debug=self.debug)
# Update should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
old_result = old_response['result']
result = response['result']
self.assertEqual(result['default_style'], new_default_style)
self.assertNotEqual(old_result['default_style'], result['default_style'])
def test_update_layer_group(self):
pass
def test_delete_resource(self):
# Must delete layer group and layer first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
self.engine.delete_layer(layer_id=self.test_layer_name)
# Do delete
response = self.engine.delete_resource(resource_id=self.test_resource_identifier)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_belongs_to_layer(self):
# Do delete without deleting layer group and layer
response = self.engine.delete_resource(resource_id=self.test_resource_identifier)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_resource_recurse(self):
# Force delete with recurse
response = self.engine.delete_resource(resource_id=self.test_resource_identifier, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_does_not_exist(self):
# Do delete
response = self.engine.delete_resource(resource_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer(self):
# Delete layer group first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_belongs_to_group(self):
# Do delete without deleting layer group
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_recurse(self):
# Force delete with recurse
response = self.engine.delete_layer(layer_id=self.test_layer_name, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_does_not_exist(self):
# Delete layer group first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_group(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_group_does_not_exist(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_workspace(self):
pass
def test_delete_store(self):
pass
def test_delete_style(self):
pass
def test_create_layer_group(self):
# Do create
name = random_string_generator(10)
layers = (self.test_layer_name,)
styles = (self.test_style_name,)
response = self.engine.create_layer_group(layer_group_id=name, layers=layers, styles=styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEqual(result['name'], name)
self.assertEqual(result['layers'], layers)
self.assertEqual(result['styles'], [])
# Clean up
self.engine.delete_layer_group(layer_group_id=name)
def test_create_layer_group_mismatch_layers_styles(self):
# Do create with differing number of styles and layers
name = random_string_generator(10)
layers = (self.test_layer_name,)
styles = (self.test_style_name, self.test_style_name)
response = self.engine.create_layer_group(layer_group_id=name, layers=layers, styles=styles)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_create_shapefile_resource(self):
self.assertTrue(False)
def test_create_coverage_resource(self):
self.assertTrue(False)
def test_create_workspace(self):
self.assertTrue(False)
def test_create_style(self):
self.assertTrue(False)
def test_create_sql_view(self):
self.assertTrue(False)
