def test_validate_model_returns_status_code_0_when_no_errors_detected(
self):
"""
Test validate_model returns a 0 status code when no errors are detected.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 0)
def test_missing_hru_id_field_detected(self):
"""
Test that the appropriate error is thrown when the
hru1 shapefile is missing a field named "HRU_ID".
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model_Missing_HRU_ID_Field.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 1)
self.assertFalse(model.errors["hru_id"])
def test_handles_missing_root_folder(self):
"""
Test that a missing root folder does not cause an error
as long as the Watershed and Scenarios folders are found.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model_No_Root_Folder.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 0)
self.assertTrue(os.path.exists(model.swat_model_directory))
def test_that_number_of_hrus_in_hru1_match_hru_files(self):
"""
Test that the number of unique hrus in the hru1 shapefile
match the number of .hru files in the TxtInOut directory.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 0)
self.assertEqual(len(validation_results["errors"]), 0)
self.assertTrue(model.errors["matching_hrus"])
def test_validate_model_returns_folders_error_when_required_swat_folders_missing(
self):
"""
Test that the "folders" error is returned by validate_model when the
"Watershed" and/or "Scenarios" folders are missing.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model_Missing_SWAT_Folders.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 1)
self.assertFalse(model.errors["folders"])
def test_validate_model_returns_status_code_1_when_errors_detected(self):
"""
Test validate_model returns a 1 status code when errors are found.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model_Missing_Reqs.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 1)
self.assertFalse(model.errors["raster"])
self.assertFalse(model.errors["shapefile"])
self.assertFalse(model.errors["hrus"])
def test_missing_keys(self):
"""
Test that missing keys in the upload dictionary are detected.
"""
# Missing "workspace" key
upload = {"local": UploadedFile(name="test_file.zip"), "aws": {}}
with self.assertRaises(KeyError):
SWATModelZip(upload)
def test_validate_model_detects_missing_swatoutput_database(self):
"""
Test that validate model checks for SWATOutput.mdb and toggles
the appropriate error flag if it is not found.
"""
upload = {
"workspace":
self.workspace,
"local":
UploadedFile(name="SWAT_Model_Missing_SWATOutput_database.zip"),
"aws": {}
}
model = SWATModelZip(upload, "field")
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 1)
self.assertFalse(model.errors["swatmdb"])
def test_validate_model_detects_mismatching_number_of_hrus_in_hru1_and_txtinout(
self):
"""
Test that the correct errors is thrown when the number of hrus in
hru1 shapefile and the number .hru files in the TxtInOut directory
do not match.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model_Mismatching_HRUs.zip"),
"aws": {}
}
model = SWATModelZip(upload)
validation_results = model.validate_model()
self.assertEqual(validation_results["status"], 1)
self.assertEqual(len(validation_results["errors"]), 1)
self.assertFalse(model.errors["matching_hrus"])
def test_file_is_not_a_zip(self):
"""
Test that the uploaded file has the .zip extension.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model.tar.gz"),
"aws": {}
}
with self.assertRaises(NotAZipError):
SWATModelZip(upload)
def test_file_does_not_exist(self):
"""
Test that the uploaded file exists.
"""
# "workspace" key points to file that does not exist
upload = {
"workspace": os.path.join(self.workspace),
"local": UploadedFile(name="SWAT_Model_Does_Not_Exist.zip"),
"aws": {}
}
with self.assertRaises(FileNotFoundError):
SWATModelZip(upload)
def upload_swat_model_zip(request):
""" This view uploads the SWAT model zip in to the input directory. """
# Clear any previous progress or error messages
request.session['progress_complete'] = []
request.session['progress_message'] = []
request.session['error'] = []
# If user is submitting a zipped SWAT Model
if request.method == 'POST':
upload = {
'workspace': request.session.get('directory'),
'local': request.FILES.get('swat_model_zip', None),
'aws': None
}
# Check if the uploaded zip is on the aws s3 server
task_id = request.session.get('unique_directory_name')
if task_id in request.session.get('on_s3').keys():
file_name, file_size = request.session.get('on_s3')[task_id]
upload['aws'] = S3Upload.objects.filter(email=request.user.email,
file_name=file_name,
file_size=file_size)
try:
swat_model = SWATModelZip(upload)
except Exception as e:
logger.error(str(e))
error_msg = 'An unexpected error has occurred, ' \
'please try again. If the issue persists ' \
'please use the Contact Us form to request ' \
'further assistance from the site admins.'
request.session['error'] = error_msg
request.session['error_swat_model'] = error_msg
return render(request, 'fieldswat/index.html')
validation_results = swat_model.validate_model()
if validation_results["status"] == 1:
request.session['error'] = validation_results['errors']
request.session['error_swat_model'] = validation_results['errors']
return render(request, 'fieldswat/index.html')
try:
# fetch data from SWATOutput.mdb
swatoutput_mdb_data = get_unique_years_from_mdb(
swat_model.get_directory())
request.session['swatoutput_years'] = swatoutput_mdb_data['years']
request.session['swatoutput_runoff'] = swatoutput_mdb_data[
'runoff']
request.session['swatoutput_sediment'] = swatoutput_mdb_data[
'sediment']
# get unique_years
unique_years = list(set(swatoutput_mdb_data['years']))
unique_years.sort()
except Exception as e:
logger.error(str(e))
logger.error(
"{0}: Missing .hru file or unique year in database.".format(
request.session.get('unique_directory_name')))
error_msg = 'You are either missing a .hru file or unique ' \
'year in your database. Please compare your ' \
'database with the example data to assess ' \
'its compatibility with the Field_SWAT tool. ' \
'If the issue persists then use the ' \
'"Contact Us" option to report your issue to ' \
'the Site Administrator.'
request.session['error'] = error_msg
request.session['error_swat_model'] = error_msg
return render(request, 'fieldswat/index.html')
request.session['swatoutput_unique_years'] = unique_years
# add unique years to context
context = {'fieldswat_unique_years': [year for year in unique_years]}
# Update relevant session variables
request.session[
'fieldswat_swat_model_filename'] = swat_model.get_filename()
request.session['fieldswat_swat_model_dir'] = swat_model.get_directory(
)
request.session['progress_message'].append(
'Swat Model zip folder uploaded.')
# Render the main page
return render(request, 'fieldswat/index.html', context)
else:
# Nothing was posted, reload main page
return render(request, 'fieldswat/index.html')