def delete_test_shapefile(self):
#-----------------------------------------------------------
msgt("--- Delete Test Shapefile used for Classification Test ---")
#-----------------------------------------------------------
api_prep_form = CheckForExistingLayerForm(self.dataverse_test_info)
self.assertTrue(api_prep_form.is_valid()\
, "Error. Validation failed. (CheckForExistingLayerForm):\n%s" % api_prep_form.errors)
data_params = api_prep_form.cleaned_data
msgt('Delete params {0}'.format(data_params))
try:
r = requests.post(self.delete_dataverse_layer_url,
data=data_params,
auth=self.get_creds_for_http_basic_auth(),
timeout=5)
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
return
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
return
msg(r.text)
msg(r.status_code)
self.assertEqual(
r.status_code, 200,
"Expected status code 200 but received '%s'" % r.status_code)
def test_workflow_04(self):
msgt('(4) Try with HttpRequest - GET')
msg('(a) Try form with HttpRequest object')
h = HttpRequest()
h.GET = self.expected_params
f1 = CheckForExistingLayerForm(h.GET)
self.assertEqual(f1.is_valid(), True)
msg('(b) Try signature validity check - break assertion by sending dict, not HttpRequest')
self.assertRaises(AssertionError, f1.is_signature_valid_check_get, h.GET)
msg('(c) Try signature check with invalid data--no signature key')
h_bad_data = HttpRequest()
h_bad_data.GET = self.test_data
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data), False)
msg('(d) Try signature check with invalid data--bad signature key')
h_bad_data2 = HttpRequest()
h_bad_data2.GET = self.expected_params_bad_signature
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data2), False)
msg('(e) Try signature check with valid data')
self.assertEqual(f1.is_signature_valid_check_get(h), True)
msg('(f) cleaned data.')
self.assertEqual(f1.cleaned_data, self.expected_clean_data)
def test_workflow_02(self):
msgt('(2) Generate params for API call')
f1 = CheckForExistingLayerForm(self.test_data)
self.assertEqual(f1.is_valid(), True)
msg('(a) Generate API call params')
self.assertEqual(f1.get_api_params_with_signature(), self.expected_params)
msg('(b) Validate params in fresh form')
f2 = CheckForExistingLayerForm(self.expected_params)
self.assertEqual(f2.is_valid(), True)
msg('(c) Check signature validity. Signature length too short')
self.assertEqual(f2.is_signature_valid_check_val('signature - not long - enough')\
, False)
msg('(d) Check signature validity. Break assertion: signature is None')
self.assertRaises(AssertionError, f2.is_signature_valid_check_val, None)
msg('(e) Check signature validity. Wrong signature')
signature_str = '12345' * 11
self.assertEqual(f2.is_signature_valid_check_val(signature_str), False)
msg('(f) Correct signature.')
signature_str = '12345' * 11
self.assertEqual(f2.is_signature_valid_check_val(f1.get_api_signature()), True)
msg('(g) cleaned data.')
self.assertEqual(f2.cleaned_data, self.expected_clean_data)
def get_params_to_check_for_existing_layer_metadata(self):
"""Return dict of params used to check WorldMap
for existing layer metadata"""
gis_data_info = self.get_gis_data_info()
assert gis_data_info is not None, "gis_data_info cannot be None"
f = CheckForExistingLayerForm(gis_data_info.__dict__)
if not f.is_valid():
raise forms.ValidationError(\
'CheckForExistingLayerForm params did not validate: %s'\
% f.errors)
return f.cleaned_data
def test_06_good_delete_geotiff_from_worldmap(self):
#-----------------------------------------------------------
msgn("(6a) Send GeoTIFF delete request - Good parameters")
#-----------------------------------------------------------
api_prep_form = CheckForExistingLayerForm(self.geotiff_test_info)
self.assertTrue(api_prep_form.is_valid()\
, "Error. Validation failed. (CheckForExistingLayerForm):\n%s" % api_prep_form.errors)
data_params = api_prep_form.cleaned_data
try:
r = requests.post(self.delete_dataverse_layer_url,
data=data_params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
self.assertEqual(
r.status_code, 200,
"Expected status code 200 but received '%s'" % r.status_code)
msg(r.status_code)
msg(r.text)
#-----------------------------------------------------------
msgn("(6b) Examine JSON result from WorldMap GeoTIFF delete API")
#-----------------------------------------------------------
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response to JSON. Received: %s" % r.text)
msg(r.status_code)
# Expect 'success' key to be True
#
self.assertTrue(
json_resp.has_key('success'),
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
self.assertEqual(json_resp.get('success'), True,
"'success' value should be 'True'")
expected_msg = "Layer deleted"
self.assertEqual(json_resp.get('message'), expected_msg,
'Message should be "%s"' % expected_msg)
def get_params_to_check_for_existing_layer_metadata(self):
"""Return dict of params used to check WorldMap
for existing layer metadata"""
gis_data_info = self.get_gis_data_info()
assert gis_data_info is not None, "gis_data_info cannot be None"
f = CheckForExistingLayerForm(gis_data_info.__dict__)
if not f.is_valid():
raise forms.ValidationError(\
'CheckForExistingLayerForm params did not validate: %s'\
% f.errors)
return f.cleaned_data
def test_workflow_01(self):
msgt('(1) geoconnect, prepare initial data')
f1 = CheckForExistingLayerForm(self.test_data)
msg('(a) Is data valid')
self.assertEqual(f1.is_valid(), True)
msg('(b) check validation field names')
#msg(f.get_validation_field_names())
self.assertEqual(f1.get_validation_field_names(),
('datafile_id', 'dataverse_installation_name'))
msg('(c) check signature generated with fake key')
valid_signature = f1.get_api_signature()
self.assertEqual(
valid_signature,
'0068e42806f42ed64ca1ba3e9f3f1549c9bef3fcd84dacaf79ea18e7')
msg('(d) check valid signature against data used to generate it')
self.assertEqual(f1.is_signature_valid_check_val(valid_signature),
True)
msg('(e) cleaned data')
self.assertEqual(f1.cleaned_data, self.expected_clean_data)
msg('(f) cleaned data with signature key')
self.assertEqual(f1.get_api_params_with_signature(),
self.expected_params)
def test_workflow_04(self):
msgt('(4) Try with HttpRequest - GET')
msg('(a) Try form with HttpRequest object')
h = HttpRequest()
h.GET = self.expected_params
f1 = CheckForExistingLayerForm(h.GET)
self.assertEqual(f1.is_valid(), True)
msg('(b) Try signature validity check - break assertion by sending dict, not HttpRequest'
)
self.assertRaises(AssertionError, f1.is_signature_valid_check_get,
h.GET)
msg('(c) Try signature check with invalid data--no signature key')
h_bad_data = HttpRequest()
h_bad_data.GET = self.test_data
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data), False)
msg('(d) Try signature check with invalid data--bad signature key')
h_bad_data2 = HttpRequest()
h_bad_data2.GET = self.expected_params_bad_signature
self.assertEqual(f1.is_signature_valid_check_get(h_bad_data2), False)
msg('(e) Try signature check with valid data')
self.assertEqual(f1.is_signature_valid_check_get(h), True)
msg('(f) cleaned data.')
self.assertEqual(f1.cleaned_data, self.expected_clean_data)
def test_workflow_01(self):
msgt('(1) geoconnect, prepare initial data')
f1 = CheckForExistingLayerForm(self.test_data)
msg('(a) Is data valid')
self.assertEqual(f1.is_valid(), True)
msg('(b) check validation field names')
#msg(f.get_validation_field_names())
self.assertEqual(f1.get_validation_field_names(), ('datafile_id', 'dataverse_installation_name'))
msg('(c) check signature generated with fake key')
valid_signature = f1.get_api_signature()
self.assertEqual(valid_signature, '0068e42806f42ed64ca1ba3e9f3f1549c9bef3fcd84dacaf79ea18e7')
msg('(d) check valid signature against data used to generate it')
self.assertEqual(f1.is_signature_valid_check_val(valid_signature), True)
msg('(e) cleaned data')
self.assertEqual(f1.cleaned_data, self.expected_clean_data)
msg('(f) cleaned data with signature key')
self.assertEqual(f1.get_api_params_with_signature(), self.expected_params)
def test02_good_shapefile_import(self):
#-----------------------------------------------------------
msgt("--- Shapefile import (good) ---")
#-----------------------------------------------------------
api_url = self.add_shapefile_url
#-----------------------------------------------------------
msgn("(2a) Test WorldMap shapefile import API -- with GOOD data/file")
#-----------------------------------------------------------
# Get basic shapefile info
shapefile_api_form = ShapefileImportDataForm(self.shapefile_test_info)
self.assertTrue(shapefile_api_form.is_valid())
test_shapefile_info = shapefile_api_form.cleaned_data
# add dv info
test_shapefile_info.update(self.dataverse_test_info)
# prep file
files = {'file': open(self.test_shapefile_name, 'rb')}
# Test WorldMap shapefile import API
#
msg('api url: %s' % api_url)
#r = requests.post(api_url\
# , data=test_shapefile_info\
# , files=files)
try:
r = requests.post(api_url,
data=test_shapefile_info,
files=files,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
return
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
return
msg(r.status_code)
msg(r.text)
#open('/Users/rmp553/Desktop/page_out.html', 'w').write(r.text)
#return
# Expect HTTP 200 - success
#
self.assertEqual(
r.status_code, 200,
"Should receive 200 message. Received: %s\n%s" %
(r.status_code, r.text))
#-----------------------------------------------------------
msgn("(2b) Examine JSON result from WorldMap shapefile import API")
#-----------------------------------------------------------
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response to JSON. Received: %s" % r.text)
# Expect 'success' key to be True
#
self.assertTrue(
'success' in json_resp,
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
self.assertEqual(json_resp.get('success'), True,
"'success' value should be 'true'")
# Expect data key in JSON
#
self.assertTrue(
'data' in json_resp,
'JSON should have key "data". But found keys: %s' %
json_resp.keys())
#-----------------------------------------------------------
msgn(
"(2c) Use MapLayerMetadataValidationForm to validate JSON result from WorldMap shapefile import API"
)
#-----------------------------------------------------------
# Validate JSON data using MapLayerMetadataValidationForm
#
map_layer_metadata_data = json_resp.get('data')
f3_dataverse_info = MapLayerMetadataValidationForm(
map_layer_metadata_data)
self.assertTrue(f3_dataverse_info.is_valid(),
"Failed to validate JSON data using MapLayerMetadataValidationForm. Found errors: %s" \
% f3_dataverse_info.errors
)
#-----------------------------------------------------------
msgn("(2d) Retrieve layer details - successfully")
#-----------------------------------------------------------
# Validate JSON data using MapLayerMetadataValidationForm
#
existing_layer_form = CheckForExistingLayerForm(
self.dataverse_test_info)
self.assertTrue(existing_layer_form.is_valid()\
, "Error. Validation failed:\n%s" % existing_layer_form.errors)
data_params = existing_layer_form.cleaned_data
try:
r = requests.post(self.dataverse_map_layer_detail,
data=data_params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
return
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
return
msg(r.text)
self.assertEqual(
r.status_code, 200,
"Expected status code 200 but received '%s'" % r.status_code)
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response to JSON. Received: %s" % r.text)
self.assertTrue(
'success' in json_resp,
'JSON should include key "success". But found keys: %s' %
json_resp.keys())
self.assertTrue(
json_resp.get('success', False) is True,
"'success' value should be 'True'")
self.assertTrue(
'data' in json_resp,
'JSON should include key "data". But found keys: %s' %
json_resp.keys())
def test01_good_classification(self):
# Note: This has to be imported AFTER WorldMapBaseTest setUp creates a test table
#
#-----------------------------------------------------------
msgn(
"(1a) Retrieve layer information based on datafile_id and dv_user_id"
)
#-----------------------------------------------------------
msg('api_layer_info_url: %s' % self.api_layer_info_url)
f = CheckForExistingLayerForm(self.dataverse_test_info)
self.assertTrue(f.is_valid(),
'Validation failed using CheckForExistingLayerForm')
# Retrieve Layer metata using datafile_id and dv_user_id
# e.g. {'datafile_id': 1388, 'dv_user_id': 1}
params = f.cleaned_data #()
msgn('PARAMS: %s' % params)
try:
r = requests.post(self.api_layer_info_url,
data=params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msg('Connection error: %s' % e.message)
self.assertTrue(False, 'Connection error: %s' % e.message)
except:
msg("Unexpected error: %s" % sys.exc_info()[0])
self.assertTrue(False, "Unexpected error: %s" % sys.exc_info()[0])
print r.text
print r.status_code
self.assertEquals(
r.status_code, 200,
"Expected status code of 200 but received '%s'" % r.status_code)
#-----------------------------------------------------------
msgn("(1b) Convert response to JSON")
#-----------------------------------------------------------
try:
rjson = r.json()
except:
self.assertTrue(
False,
"Failed to convert response text to JSON. Text:\n%s" % r.text)
#-----------------------------------------------------------
msgn("(1c) Check for key fields in JSON")
#-----------------------------------------------------------
#msg(rjson)
self.assertTrue(
rjson.has_key('success'),
"JSON did not have key 'success'. Keys found:\n %s" % rjson.keys())
self.assertTrue(
rjson.has_key('data'),
"JSON did not have key 'data'. Keys found:\n %s" % rjson.keys())
self.assertEquals(
rjson.get('success'), True,
"Expected 'success' value to be 'True'. Found: '%s'" %
rjson.get('success'))
#-----------------------------------------------------------
msgn(
"(1d) Validate returned data using WorldMapToGeoconnectMapLayerMetadataValidationForm\n(includes layer name)"
)
#-----------------------------------------------------------
f = WorldMapToGeoconnectMapLayerMetadataValidationForm(
rjson.get('data', {}))
self.assertTrue(
f.is_valid(),
'Validation failed using WorldMapToGeoconnectMapLayerMetadataValidationForm. Errors: %s'
% f.errors)
#-----------------------------------------------------------
msgn(
"(1e) Get layer name from data (confirmed by previous validation)")
#-----------------------------------------------------------
self.existing_layer_name = rjson.get('data',
{}).get('layer_name', None)
self.assertTrue(self.existing_layer_name is not None,
'self.existing_layer_name cannot be None')
self.assertTrue(
len(self.existing_layer_name) > 0,
'self.existing_layer_name cannot be length 0')
#-----------------------------------------------------------
msgn("(1f) Prepare classification call")
#-----------------------------------------------------------
msg('existing_layer_name: %s' % self.existing_layer_name)
#self.dataverse_test_info
classify_params = self.dataverse_test_info
classify_params.update({
'reverse': False,
'attribute': u'SocStrif_2',
'ramp': 'Blue',
'endColor': '#08306b',
'intervals': 5,
'layer_name': self.existing_layer_name,
'startColor': '#f7fbff',
'method': u'equalInterval'
})
"""
import requests
classify_params = {'reverse': False,
'attribute': u'SocStrife1',
'dataverse_installation_name': u'http://localhost:8000',
'ramp': u'Custom', 'endColor': u'#f16913',
'datafile_id': 7775,
'intervals': 5,
'layer_name': u'social_disorder_hy4',
'startColor': u'#fff5eb',
'method': u'jenks'}
r = requests.post('http://127.0.0.1:8000/dataverse/classify-layer/',data=classify_params, auth=('rp','123'))
print r.text
print r.status_code
"""
f_classify = ClassifyRequestDataForm(classify_params)
self.assertTrue(
f_classify.is_valid(),
'ClassifyRequestDataForm did not validate. Errors:\n %s' %
f_classify.errors)
formatted_classify_params = f_classify.cleaned_data #get_api_params_with_signature()
msgt('classify_params: %s' % formatted_classify_params)
#self.assertTrue(classify_params.has_key(SIGNATURE_KEY)\
# , 'classify_params did not have SIGNATURE_KEY: "%s"' % SIGNATURE_KEY)
#-----------------------------------------------------------
msgn("(1g) Make classification request")
#-----------------------------------------------------------
msg('classify url: %s' % self.classify_layer_url)
msg('creds: {0}'.format(self.get_creds_for_http_basic_auth()))
try:
r = requests.post(self.classify_layer_url,
data=formatted_classify_params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
print r.text
print r.status_code
self.assertEquals(
r.status_code, 200,
"Expected status code of 200 but received '%s'" % r.status_code)
#-----------------------------------------------------------
msgn("(1h) Convert response to JSON")
#-----------------------------------------------------------
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response text to JSON. Text:\n%s" % r.text)
print 'json_resp: %s' % json_resp
self.assertTrue(
json_resp.has_key('success'),
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
self.assertEqual(json_resp.get('success'), True,
"'success' value should be 'True'")
f_metadata_check = WorldMapToGeoconnectMapLayerMetadataValidationForm(
json_resp.get('data', None))
self.assertTrue(
f_metadata_check.is_valid(),
"Validation failed for WorldMapToGeoconnectMapLayerMetadataValidationForm. Errors: %s"
% f_metadata_check.errors)
#-----------------------------------------------------------
msgn("(1i) Retrieve classification params")
#-----------------------------------------------------------
params_for_attr_request = self.dataverse_test_info
params_for_attr_request['layer_name'] = self.existing_layer_name
f_attrs = LayerAttributeRequestForm(params_for_attr_request)
self.assertTrue(
f_attrs.is_valid(),
'ClassifyRequestDataForm did not validate. Errors:\n %s' %
f_attrs.errors)
retrieve_attribute_params = f_attrs.cleaned_data #get_api_params_with_signature()
#msgt('retrieve_attribute_params: %s' % retrieve_attribute_params)
#self.assertTrue(retrieve_attribute_params.has_key(SIGNATURE_KEY)\
# , 'classify_params did not have SIGNATURE_KEY: "%s"' % SIGNATURE_KEY)
#-----------------------------------------------------------
msgn("(1i) Make classification param request")
#-----------------------------------------------------------
GET_CLASSIFY_ATTRIBUTES_API_PATH = reverse(
'view_layer_classification_attributes', args=())
try:
r = requests.post(GET_CLASSIFY_ATTRIBUTES_API_PATH,\
data=retrieve_attribute_params,\
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
print r.status_code
self.assertEquals(
r.status_code, 200,
"Expected status code of 200 but received '%s'" % r.status_code)
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response text to JSON. Text:\n%s" % r.text)
self.assertTrue(
json_resp.has_key('success'),
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
self.assertEqual(json_resp.get('success'), True,
"'success' value should be 'True'")
self.assertTrue(
json_resp.has_key('data'),
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
attribute_info = json_resp['data'].get('attribute_info', None)
self.assertTrue(attribute_info is not None, "attribute_info was None")
attribute_info = eval(attribute_info)
msgt('attribute_info')
msg(attribute_info)
self.assertEqual(len(attribute_info), 53,\
"Should be 54 attributes but found %s" % len(attribute_info))
def get_existing_layer_data(request):
"""
Given a POST with a 'dataverse_installation_name' and 'datafile_id'
Check if a DataverseLayerMetadata record exists for this information.
returns JSON
"""
# Is it a POST?
#
if not request.POST:
json_msg = MessageHelperJSON.get_json_msg(success=False, msg="The request must be a POST, not GET")
return HttpResponse(status=401, content=json_msg, content_type="application/json")
# Does the request contain the correct params?
#
f = CheckForExistingLayerForm(request.POST)
if not f.is_valid():
logger.error("Unexpected form validation error in CheckForExistingLayerFormWorldmap. Errors: %s" % f.errors)
json_msg = MessageHelperJSON.get_json_msg(success=False\
, msg="Invalid data for retrieving an existing layer.")
return HttpResponse(status=400, content=json_msg, content_type="application/json")
# Does a DataverseLayerMetadata object exist for the given params?
#
dataverse_layer_metadata = retrieve_dataverse_layer_metadata_by_kwargs_installation_and_file_id(**request.POST.dict())
# Nope, we are mapping a new file to the WorldMap
#
if dataverse_layer_metadata is None:
json_msg = MessageHelperJSON.get_json_msg(success=False, msg="This layer does not exist")
return HttpResponse(status=200, content=json_msg, content_type="application/json")
# Prepare a JSON response
#
map_layer = dataverse_layer_metadata.map_layer
layer_metadata_obj = LayerMetadata(map_layer)
data_dict = layer_metadata_obj.get_metadata_dict()
# Is this a TableJoin, if so, add more data
if map_layer.join_layer.count() > 0:
join_layer = map_layer.join_layer.all()[0]
#data_dict.update(join_layer.as_json())
data_dict.update(\
TableJoinResultForm.get_cleaned_data_from_table_join(join_layer)\
)
# Was this a Datatable mapped by Lat/Lng
if LatLngTableMappingRecord.objects.filter(layer=map_layer).count() > 0:
latlng_record = LatLngTableMappingRecord.objects.filter(layer=map_layer).all()[0]
data_dict.update(latlng_record.as_json())
# Return the response!
json_msg = MessageHelperJSON.get_json_msg(success=True,\
msg='worked',\
data_dict=data_dict)
return HttpResponse(status=200, content=json_msg, content_type="application/json")
def get_layer_info_using_dv_info(params_dict):
"""
Retrieve WorldMap layer information via API
params_dict needs to include:
- dataverse_installation_name
- datafile_id
Fail: (False, error message)
Success: (True, python dict)
"""
f = CheckForExistingLayerForm(params_dict)
if not f.is_valid():
err_msg = """Sorry! Failed to validate the request to retrieve WorldMap layer metadata."""
LOGGER.error(err_msg + \
" Validation failure for CheckForExistingLayerForm. Errors: %s" % f.errors)
return False, err_msg
#--------------------------------------
# Prepare the data
#--------------------------------------
data_params = f.cleaned_data
#--------------------------------------
# Make the request
#--------------------------------------
try:
resp = requests.post(GET_LAYER_INFO_BY_DATAVERSE_INSTALLATION_AND_FILE_API_PATH\
, data=data_params\
, auth=settings.WORLDMAP_ACCOUNT_AUTH\
, timeout=settings.WORLDMAP_SHORT_TIMEOUT)
except requests.exceptions.ConnectionError as exception_obj:
err_msg = """Sorry! Failed to retrieve data from the WorldMap.
<p><b>Details for administrator:</b> Could not contact the
WorldMap server: %s</p>"""\
% (GET_LAYER_INFO_BY_DATAVERSE_INSTALLATION_AND_FILE_API_PATH)
LOGGER.error(err_msg)
LOGGER.error('ConnectionError: %s', exception_obj.error)
return False, err_msg
except:
# Error with request
#
err_msg = "Unexpected error: %s" % sys.exc_info()[0]
LOGGER.error(err_msg)
return False, err_msg
print(resp.text)
print(resp.status_code)
#--------------------------------------
# Response looks good
#--------------------------------------
if resp.status_code == 200:
try:
response_dict = resp.json()
except ValueError:
err_msg = "Failed to convert response to JSON."
LOGGER.error(err_msg +
"Status code: 200.\nResponse text: %s" % resp.text)
return False, err_msg
return response_dict.get('success', False), response_dict
#--------------------------------------
# Response doesn't look good
#--------------------------------------
err_msg = "Status code: %s\nError: %s" % (resp.status_code, resp.text)
return False, err_msg
def delete_map_layer(gis_data_info, worldmap_layer_info):
"""
Delete a Layer from the WorldMap, using the WorldMap API
returns (True, None)
or (False, 'error message of some type')
"""
assert isinstance(
gis_data_info,
GISDataFile), "gis_data_file must be a GISDataFile object"
#assert isinstance(worldmap_layer_info, WorldMapLayerInfo),\
# "worldmap_layer_info must be a WorldMapLayerInfo object"
#--------------------------------------
# Does the GISDataFile object correspond
# to the WorldMapLayerInfo object?
#--------------------------------------
if worldmap_layer_info.get_gis_data_info() != gis_data_info:
err_msg = ('Error the GISDataFile does not correspond'
' to the WorldMapLayerInfo object.')
LOGGER.error(err_msg)
return (False, err_msg)
# For join layers, remove the TableJoin object
#
if worldmap_layer_info.is_join_layer():
return delete_worldmap_tablejoin(worldmap_layer_info)
#--------------------------------------
# Prepare params for WorldMAP API call
#--------------------------------------
data_params = get_dataverse_info_dict(gis_data_info)
existing_layer_form = CheckForExistingLayerForm(data_params)
if not existing_layer_form.is_valid():
err_msg = """Error. Validation failed. (CheckForExistingLayerForm)"""
LOGGER.error(err_msg)
return (False, err_msg)
#
data_params = existing_layer_form.cleaned_data
#data_params[settings.WORLDMAP_TOKEN_NAME_FOR_DV] = settings.WORLDMAP_TOKEN_FOR_DATAVERSE
print('DELETE_LAYER_API_PATH: %s' % DELETE_LAYER_API_PATH)
print("data_params: %s" % data_params)
try:
r = requests.post(DELETE_LAYER_API_PATH\
, data=data_params\
, auth=settings.WORLDMAP_ACCOUNT_AUTH\
, timeout=settings.WORLDMAP_SHORT_TIMEOUT)
except requests.exceptions.ConnectionError as exception_obj:
err_msg = ('Failed to retrieve data from the WorldMap.'
'<p><b>Details for administrator:</b>'
' Could not contact the WorldMap'
' server: {0}</p>').format(DELETE_LAYER_API_PATH)
LOGGER.error(err_msg + '\nConnectionError:' + exception_obj.message)
return (False, err_msg)
print(r.text)
print(r.status_code)
#--------------------------------------
# Check Response
#--------------------------------------
if r.status_code == 200:
#response_dict = r.json()
return (True, None)
#--------------------------------------
# Response doesn't look good
#--------------------------------------
err_msg = "Status code: %s\nError: %s" % (r.status_code, r.text)
LOGGER.error(err_msg)
return (False, err_msg)
def test_workflow_02(self):
msgt('(2) Generate params for API call')
f1 = CheckForExistingLayerForm(self.test_data)
self.assertEqual(f1.is_valid(), True)
msg('(a) Generate API call params')
self.assertEqual(f1.get_api_params_with_signature(),
self.expected_params)
msg('(b) Validate params in fresh form')
f2 = CheckForExistingLayerForm(self.expected_params)
self.assertEqual(f2.is_valid(), True)
msg('(c) Check signature validity. Signature length too short')
self.assertEqual(f2.is_signature_valid_check_val('signature - not long - enough')\
, False)
msg('(d) Check signature validity. Break assertion: signature is None'
)
self.assertRaises(AssertionError, f2.is_signature_valid_check_val,
None)
msg('(e) Check signature validity. Wrong signature')
signature_str = '12345' * 11
self.assertEqual(f2.is_signature_valid_check_val(signature_str), False)
msg('(f) Correct signature.')
signature_str = '12345' * 11
self.assertEqual(
f2.is_signature_valid_check_val(f1.get_api_signature()), True)
msg('(g) cleaned data.')
self.assertEqual(f2.cleaned_data, self.expected_clean_data)
def get_layer_info_using_dv_info(params_dict):
"""
Retrieve WorldMap layer information via API
params_dict needs to include:
- dataverse_installation_name
- datafile_id
Fail: (False, error message)
Success: (True, python dict)
"""
f = CheckForExistingLayerForm(params_dict)
if not f.is_valid():
err_msg = """Sorry! Failed to validate the request to retrieve WorldMap layer metadata."""
LOGGER.error(err_msg + \
" Validation failure for CheckForExistingLayerForm. Errors: %s" % f.errors)
return False, err_msg
#--------------------------------------
# Prepare the data
#--------------------------------------
data_params = f.cleaned_data
#--------------------------------------
# Make the request
#--------------------------------------
try:
resp = requests.post(GET_LAYER_INFO_BY_DATAVERSE_INSTALLATION_AND_FILE_API_PATH\
, data=data_params\
, auth=settings.WORLDMAP_ACCOUNT_AUTH\
, timeout=settings.WORLDMAP_SHORT_TIMEOUT)
except requests.exceptions.ConnectionError as exception_obj:
err_msg = """Sorry! Failed to retrieve data from the WorldMap.
<p><b>Details for administrator:</b> Could not contact the
WorldMap server: %s</p>"""\
% (GET_LAYER_INFO_BY_DATAVERSE_INSTALLATION_AND_FILE_API_PATH)
LOGGER.error(err_msg)
LOGGER.error('ConnectionError: %s', exception_obj)
return False, err_msg
except:
# Error with request
#
err_msg = "Unexpected error: %s" % sys.exc_info()[0]
LOGGER.error(err_msg)
return False, err_msg
print (resp.text)
print (resp.status_code)
#--------------------------------------
# Response looks good
#--------------------------------------
if resp.status_code == 200:
try:
response_dict = resp.json()
except ValueError:
err_msg = "Failed to convert response to JSON."
LOGGER.error(err_msg + "Status code: 200.\nResponse text: %s" % resp.text)
return False, err_msg
return response_dict.get('success', False), response_dict
#--------------------------------------
# Response doesn't look good
#--------------------------------------
err_msg = "Status code: %s\nError: %s" % (resp.status_code, resp.text)
return False, err_msg
def test03_bad_delete_shapefile_from_worldmap(self):
#-----------------------------------------------------------
msgt("--- Delete shapefile ---")
#-----------------------------------------------------------
#-----------------------------------------------------------
msgn("(3a) Send delete request - Missing parameter")
#-----------------------------------------------------------
existing_layer_form = CheckForExistingLayerForm(
self.dataverse_test_info)
self.assertTrue(existing_layer_form.is_valid()\
, "Error. Validation failed. (CheckForExistingLayerForm):\n%s" % existing_layer_form.errors)
data_params = existing_layer_form.cleaned_data
data_params.pop('datafile_id')
try:
r = requests.post(self.delete_dataverse_layer_url,
data=data_params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
return
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
return
self.assertEqual(
r.status_code, 400,
"Expected status code 400 but received '%s'" % r.status_code)
try:
json_resp = r.json()
except:
self.assertTrue(
False,
"Failed to convert response to JSON. Received: %s" % r.text)
# Expect 'success' key to be False
#
self.assertTrue(
json_resp.has_key('success'),
'JSON should have key "success". But found keys: %s' %
json_resp.keys())
self.assertEqual(json_resp.get('success'), False,
"'success' value should be 'False'")
expected_msg = 'Invalid data for delete request.'
self.assertEqual(json_resp.get('message'), expected_msg,
'Message should be "%s"' % expected_msg)
#-----------------------------------------------------------
msgn("(3b) Send delete request - Bad dataverse_installation_name")
#-----------------------------------------------------------
api_prep_form = CheckForExistingLayerForm(self.dataverse_test_info)
self.assertTrue(api_prep_form.is_valid()\
, "Error. Validation failed. (CheckForExistingLayerForm):\n%s" % api_prep_form.errors)
data_params = api_prep_form.cleaned_data
# Chnange key used to search for map layer
#
data_params['dataverse_installation_name'] = 'bah bah black sheep'
try:
r = requests.post(self.delete_dataverse_layer_url,
data=data_params,
auth=self.get_creds_for_http_basic_auth())
except requests.exceptions.ConnectionError as e:
msgx('Connection error: %s' % e.message)
return
except:
msgx("Unexpected error: %s" % sys.exc_info()[0])
return
self.assertEqual(
r.status_code, 404,
"Expected status code 404 but received '%s'" % r.status_code)
def delete_map_layer(gis_data_info, worldmap_layer_info):
"""
Delete a Layer from the WorldMap, using the WorldMap API
returns (True, None)
or (False, 'error message of some type')
"""
assert isinstance(gis_data_info, GISDataFile), "gis_data_file must be a GISDataFile object"
#assert isinstance(worldmap_layer_info, WorldMapLayerInfo),\
# "worldmap_layer_info must be a WorldMapLayerInfo object"
#--------------------------------------
# Does the GISDataFile object correspond
# to the WorldMapLayerInfo object?
#--------------------------------------
if worldmap_layer_info.get_gis_data_info() != gis_data_info:
err_msg = ('Error the GISDataFile does not correspond'
' to the WorldMapLayerInfo object.')
LOGGER.error(err_msg)
return (False, err_msg)
#--------------------------------------
# Prepare params for WorldMAP API call
#--------------------------------------
data_params = get_dataverse_info_dict(gis_data_info)
existing_layer_form = CheckForExistingLayerForm(data_params)
if not existing_layer_form.is_valid():
err_msg = """Error. Validation failed. (CheckForExistingLayerForm)"""
LOGGER.error(err_msg)
return (False, err_msg)
#
data_params = existing_layer_form.cleaned_data
LOGGER.info('make delete request: %s', DELETE_LAYER_API_PATH)
try:
r = requests.post(DELETE_LAYER_API_PATH\
, data=data_params\
, auth=settings.WORLDMAP_ACCOUNT_AUTH\
, timeout=settings.WORLDMAP_SHORT_TIMEOUT)
except requests.exceptions.ConnectionError as exception_obj:
err_msg = ('Failed to retrieve data from the WorldMap.'
'<p><b>Details for administrator:</b>'
' Could not contact the WorldMap'
' server: {0}</p>').format(DELETE_LAYER_API_PATH)
LOGGER.error(err_msg + '\nConnectionError:' + exception_obj.message)
return (False, err_msg)
LOGGER.debug(r.text)
LOGGER.debug(r.status_code)
#--------------------------------------
# Check Response
#--------------------------------------
if r.status_code == 200:
#response_dict = r.json()
return (True, None)
#--------------------------------------
# Response doesn't look good
#--------------------------------------
err_msg = "Status code: %s\nError: %s" % (r.status_code, r.text)
LOGGER.error(err_msg)
return (False, err_msg)
