def test_is_complete(self):
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['variables']
m = DispersalModel(fn)
self.assertFalse(m.is_complete())
fn = models['variables_complete']
m = DispersalModel(fn)
self.assertTrue(m.is_complete())
def test_run_command_once(self, po_mock):
# expect return value from function of 0
po_mock.return_value.close.return_value = 0
model_fn = self.repo.get_models()['lifestage_test']
model = DispersalModel(model_fn, setup=False)
i = model.get_instances()[0]
ac = AnalysisCommand("test")
# test normal
ac.times = [1990, 1991, 1992]
t_strings = [str(x) for x in ac.times]
maps = ['map1', 'map2', 'map3']
maps = dict(zip(t_strings, maps))
return_val = ac.run_command_once(1990, maps, "testcommand")
self.assertEqual(return_val, 0)
# test with map_name replacements, but too early
self.assertRaises(IndexError, ac.run_command_once, 1991, maps,
"testcommand %1 %2")
# test with map_name replacements
return_val = ac.run_command_once(1991, maps, "testcommand %1")
self.assertEqual(po_mock.call_args[0][0], "testcommand map1")
return_val = ac.run_command_once(1990, maps, "testcommand %0")
self.assertEqual(po_mock.call_args[0][0], "testcommand map1")
return_val = ac.run_command_once(1992, maps, "testcommand %0")
self.assertEqual(po_mock.call_args[0][0], "testcommand map3")
mdig_config = config.get_config()
mdig_config.analysis_print_time = True
self.__do_run_command_once(model, ac, maps)
def test_no_split_instances(self, m_remove_map, m_copy_map):
m_fn = self.models['variables']
dm = DispersalModel(m_fn)
g = grass.get_g()
split_instances_into_own_mapsets(dm)
self.assertEqual(m_remove_map.call_count, 0)
self.assertEqual(m_copy_map.call_count, 0)
def test_add_lifestage_model(self, get_g, m_ls):
self.make_grass_mock(get_g.return_value)
# Assume no appropriate files in tmp
c = config.get_config()
m = ModelRepository(self.temp_dir)
m2 = ModelRepository()
a_file = m2.get_models()['lifestage_test']
self.create_mock_location(self.temp_dir)
self.assertEqual(len(m.get_models()), 0)
# add location to model, save as new
dm = DispersalModel(a_file)
dm.set_location('grass_location')
temp_model_fn = os.path.join(os.path.dirname(a_file),
"with_location_model.xml")
dm.save_model(filename=temp_model_fn)
get_g.return_value.get_range.return_value = ['xxxxxx10'] * 10
get_g.return_value.raster_value_freq.return_value = [[1], [2], [3]]
m_ls.return_value = {}
# and then try to add
m.add_model(temp_model_fn)
self.assertEqual(len(m.get_models()), 1)
# more tests about lifestage resources?
self.remove_mock_location(self.temp_dir)
def do_me(self, mdig_model):
from textwrap import TextWrapper
import re
models = mdig.repository.get_models()
title_str = "Models in MDiG GRASS db @ " + mdig.repository.db
print "-" * len(title_str)
print title_str
print "model_name [location]"
print " description"
print "-" * len(title_str)
ms = models.keys()[:]
ms.sort()
for m in ms:
try:
dm = DispersalModel(models[m], setup=False)
tw = TextWrapper(expand_tabs=False, replace_whitespace=True)
tw.initial_indent = " " * 4
tw.subsequent_indent = " " * 4
desc = dm.get_description()
desc = re.sub("[\\s\\t]+", " ", desc)
desc = tw.fill(desc)
loc = dm.get_location()
if not loc:
loc = dm.infer_location()
if not loc:
loc = "unknown"
print "%s [%s]:\n%s" % (m, loc, desc)
except mdig.model.ValidationError:
print "%s [ERROR]" % (m, )
sys.exit(0)
def test_set_times(self):
model_fn = self.repo.get_models()['lifestage_test']
model = DispersalModel(model_fn, setup=False)
i = model.get_instances()[0]
ac = AnalysisCommand("test")
o_times = range(1990, 2000)
# Test running on all available times
ac.set_times((1990, 1999), o_times)
self.assertEquals(ac.times, o_times)
# Test with a single time in range
ac.set_times((1990, 1999), o_times, [1990])
self.assertEquals(ac.times, [1990])
# Test with a single time out of range
self.assertRaises(ValueError, ac.set_times, (1990, 1999), o_times,
[11990])
# Test with a single negative index
ac.set_times((1990, 1999), o_times, [-1])
self.assertEquals(ac.times, [1999])
# Test with time not in original times
del o_times[2] # delete 1992
self.assertRaises(ValueError, ac.set_times, (1990, 1999), o_times,
[1992])
# Test earliest time and not enough past maps to fulfill command line
ac = AnalysisCommand("test %19")
self.assertRaises(NotEnoughHistoryException, ac.set_times,
(1990, 1999), o_times, [-1])
def test_get_resources(self, m_xml):
m_xml.return_value = {}
mdig.repository = self.repo = ModelRepository()
models = mdig.repository.get_models()
# in other test
del models['test_weird_map_resource']
###
fn = models['lifestage_test']
m = DispersalModel(fn)
res = m.get_resources()
self.assertEqual(len(res), 7)
self.assertEqual(len([i[0] for i in res if i[0] == 'popmod']), 1)
self.assertEqual(len([i[0] for i in res if i[0] == 'coda']), 6)
del models['lifestage_test']
m.remove_log_handler()
fn = models['test_named_region']
m = DispersalModel(fn)
res = m.get_resources()
self.assertEqual(len(res), 5)
self.assertEqual(len([i[0] for i in res if i[0] == 'region']), 1)
self.assertEqual(len([i[0] for i in res if i[0] == 'map']), 4)
self.assertEqual(len([i[0] for i in res if i[2] == 'PERMANENT']), 2)
self.assertEqual(
len([i[0] for i in res if i[2] == 'test_named_region']), 2)
self.assertEqual(len([i[0] for i in res if i[2] is None]), 1)
del models['test_named_region']
m.remove_log_handler()
fn = models['management_use_maps']
m = DispersalModel(fn)
res = m.get_resources()
self.assertEqual(len(res), 3)
self.assertEqual(len([i[0] for i in res if i[0] == 'map']), 3)
self.assertEqual(len([i[0] for i in res if i[2] == 'PERMANENT']), 1)
self.assertEqual(len([i[0] for i in res if i[2] is None]), 2)
del models['management_use_maps']
m.remove_log_handler()
# check the others don't erroneously report resources
for k in models:
fn = models[k]
m = DispersalModel(fn)
res = m.get_resources()
self.assertEqual(len(res), 0)
m.remove_log_handler()
def test_get_weird_resources(self):
mdig.repository = self.repo = ModelRepository()
models = mdig.repository.get_models()
# this model has a comment that messed up initial map creation
fn = models['test_weird_map_resource']
m = DispersalModel(fn)
res = m.get_resources()
self.assertEqual(len(res), 0)
m.remove_log_handler()
def test_get_instances(self):
# this functionally generally well tested, but
# test removing deprecated baseDir attrib...
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['lifestage_test']
m = DispersalModel(fn)
completed_node = m.xml_model.xpath("/model/instances")
self.assertTrue(len(completed_node) > 0)
completed_node[0].attrib['baseDir'] = 'flibble'
instances = m.get_instances()
def setUp(self):
mdig.repository = self.repo = ModelRepository()
#logging.getLogger('mdig').setLevel(logging.CRITICAL)
models = mdig.repository.get_models()
fn = models['lifestage_test']
self.m_lifestage = DispersalModel(fn)
# Model initialise with variables
fn = models['variables']
self.m_variables = DispersalModel(fn)
fn = models['variables_complete']
self.m_variables_complete = DispersalModel(fn)
# management
fn = models['management_alter_variable']
self.m_management = DispersalModel(fn)
#analysis
fn = models['analysis_example']
self.m_analysis = DispersalModel(fn)
def test_run(self):
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['lifestage_test']
m = DispersalModel(fn)
m._get_instance_w_smallest_reps_remaining = Mock()
m._get_instance_w_smallest_reps_remaining.return_value = None
m.run()
self.assertEqual(m.active, False)
# These are less than or equal because of VM clock being weird
self.assertTrue(m.start_time <= datetime.datetime.now())
self.assertTrue(m.start_time <= m.end_time)
def setUp(self):
mdig.repository = self.repo = ModelRepository()
#logging.getLogger('mdig').setLevel(logging.CRITICAL)
models = mdig.repository.get_models()
fn = models['lifestage_test']
self.m_lifestage = DispersalModel(fn)
# Model initialise with management strategy
fn = models['management_area_combine']
self.m_strategy = DispersalModel(fn)
# Model initialise with variables
fn = models['variables']
self.m_variables = DispersalModel(fn)
#logging.getLogger('mdig').setLevel(logging.WARNING)
fn = models['variables_complete']
self.m_variables_complete = DispersalModel(fn)
c = config.get_config()
self.gisdb = c['GRASS']['GISDBASE']
def test_hard_reset(self, m_rm):
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['lifestage_test']
m = DispersalModel(fn)
# init the mapsets so we have something to remove
for i in m.get_instances():
i.init_mapset()
m.hard_reset()
self.assertEqual(m_rm.call_count, 1)
self.assertEqual(len(m.xml_model.xpath('/model/instances/completed')),
0)
m.remove_log_handler()
def test_submit_model_missing_files(self):
import tempfile
fn = self.repo.get_models()['lifestage_test']
dm = DispersalModel(fn)
temp_fn = tempfile.mktemp(suffix='.xml')
dm.set_name('lifestage_test2')
dm.set_location('grass_location')
dm.save_model(temp_fn)
f= open(temp_fn)
import os.path
r = self.postmultipart('/models/',fields={},files=[('new_model',temp_fn,f.read())])
f.close()
os.remove(temp_fn)
self.assertTrue('error' in r['body'])
self.assertTrue('lifestage_test2' not in self.repo.get_models())
def test_submit_model_already_exists(self):
import tempfile
fn = self.repo.get_models()['variables']
dm = DispersalModel(fn)
temp_fn = tempfile.mktemp(suffix='.xml')
dm.set_location('grass_location')
dm.save_model(temp_fn)
f= open(temp_fn)
import os.path
count=len(self.repo.get_models())
self.postmultipart('/models/',fields={},files=[('new_model',temp_fn,f.read())])
f.close()
os.remove(temp_fn)
self.assertEqual(count,len(self.repo.get_models()))
self.assertTrue('variables' in self.repo.get_models())
def test_submit_model(self):
import tempfile
fn = self.repo.get_models()['variables']
dm = DispersalModel(fn)
temp_fn = tempfile.mktemp(suffix='.xml')
dm.set_name('variable_test')
dm.set_location('grass_location')
dm.save_model(temp_fn)
f= open(temp_fn)
import os.path
self.postmultipart('/models/',fields={},files=[('new_model',temp_fn,f.read())])
f.close()
os.remove(temp_fn)
self.assertTrue('variable_test' in self.repo.get_models())
r = self.urlopen('/models/variable_test/del',method='POST')
def test_add_model_to_repo(self):
import tempfile
fn = self.repo.get_models()['variables']
dm = DispersalModel(fn)
temp_fn = tempfile.mktemp(suffix='.xml')
dm.set_name('variable_test')
dm.set_location('grass_location')
dm.save_model(temp_fn)
f = open(temp_fn,'r')
data = f.read()
f.close()
webui.add_model_to_repo(data)
os.remove(temp_fn)
self.assertTrue('variable_test' in self.repo.get_models())
self.repo.remove_model('variable_test',force=True)
def test_add_and_delete_model(self):
import tempfile
fn = self.repo.get_models()['variables']
dm = DispersalModel(fn)
temp_fn = tempfile.mktemp(suffix='.xml')
dm.set_name('variable_test')
dm.set_location('grass_location')
dm.save_model(temp_fn)
f = open(temp_fn,'r')
data = f.read()
f.close()
webui.add_model_to_repo(data)
os.remove(temp_fn)
self.assertTrue('variable_test' in self.repo.get_models())
r = self.urlopen('/models/variable_test/del',method='POST')
self.assertEqual(r['code'],303)
self.assertTrue('variable_test' not in self.repo.get_models())
def test_run_command(self, rc_mock):
model_fn = self.repo.get_models()['lifestage_test']
model = DispersalModel(model_fn, setup=False)
i = model.get_instances()[0]
ac = AnalysisCommand("test")
# test when there are no times set for when to run command
self.assertRaises(Exception, ac.run_command, maps=[])
# test when the times are empty list
ac.times = []
output_file = ac.init_output_file(i)
ac.run_command([])
self.assertEqual(rc_mock.called, False)
# test when there are times
ac.times = [1990]
rc_mock.called = False
ac.run_command([])
self.assertEqual(rc_mock.called, True)
def migrate_repository(grassdb_dir):
mr = ModelRepository(grassdb_dir)
model_fns = mr.get_models()
for model in model_fns:
model_fn = model_fns[model]
# check for unseparated instances from main mapset
dm = DispersalModel(model_fn)
try:
instances = dm.get_instances()
for i in instances:
mapset = i.get_mapset()
if not check_instances_have_info_file(dm.get_instances()):
print "Model %s ok" % model
except DispersalInstanceException, e:
if not "no longer supports instances sharing one mapset" in str(e):
continue
# if so, fix them
print dm.get_mapset() + " not ok.. fixing"
split_instances_into_own_mapsets(dm)
def test_init_output_file(self, rm_mock, isfile_mock):
isfile_mock.return_value = True
mdig_config = config.get_config()
mdig_config.overwrite_flag = False
model_fn = self.repo.get_models()['lifestage_test']
model = DispersalModel(model_fn, setup=False)
i = model.get_instances()[0]
ac = AnalysisCommand("test")
self.assertRaises(mdig.OutputFileExistsException, ac.init_output_file,
i)
mdig_config.overwrite_flag = True
output_file = ac.init_output_file(i)
self.assertEqual(output_file.index("lifestage_test_region_a_i0"), 0)
# test with rep
isfile_mock.return_value = False
output_file = ac.init_output_file(i, i.replicates[0])
print output_file
self.assertEqual(output_file.index("lifestage_test_region_a_i0_rep_0"),
0)
def test_insert_output_into_cmd(self):
model_fn = self.repo.get_models()['lifestage_test']
model = DispersalModel(model_fn, setup=False)
i = model.get_instances()[0]
ac = AnalysisCommand("test")
# test exception for when no output file initialised
self.assertRaises(OutputFileNotSetException, ac.insert_output_into_cmd)
# check normal function works
output_file = ac.init_output_file(i)
self.assertEqual(output_file.index("lifestage_test_region_a_"), 0)
output_cmd = ac.insert_output_into_cmd()
self.assertEqual(output_cmd, "test >> " + output_file)
# check that file substitution works
ac.cmd_string = "test %f"
output_cmd = ac.insert_output_into_cmd()
self.assertEqual(output_cmd, "test " + output_file)
# check that it doesn't replaced escaped %
ac.cmd_string = "test %%f"
output_cmd = ac.insert_output_into_cmd()
self.assertEqual(output_cmd, "test %%f >> " + output_file)
def test_null_bitmask(self):
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['lifestage_test']
m = DispersalModel(fn)
for i in m.get_instances():
i.null_bitmask = Mock()
m.null_bitmask()
for i in m.get_instances():
self.assertEqual(i.null_bitmask.call_count, 1)
self.assertEqual(i.null_bitmask.call_args[0][0], True)
# check parameter is passed
m.null_bitmask(generate=False)
for i in m.get_instances():
self.assertEqual(i.null_bitmask.call_count, 2)
self.assertEqual(i.null_bitmask.call_args[0][0], False)
# check disabled instances are not touched
for i in m.get_instances():
i.enabled = False
m.null_bitmask()
for i in m.get_instances():
self.assertEqual(i.null_bitmask.call_count, 2)
def test_lifestage_model_missing_files(self, get_g):
self.make_grass_mock(get_g.return_value)
# Assume no appropriate files in tmp
c = config.get_config()
m = ModelRepository(self.temp_dir)
m2 = ModelRepository()
a_file = m2.get_models()['lifestage_test']
self.create_mock_location(self.temp_dir)
self.assertEqual(len(m.get_models()), 0)
# add location to model, save as new
dm = DispersalModel(a_file)
dm.set_location('grass_location')
temp_model_fn = os.path.join(self.temp_dir, "with_location_model.xml")
dm.save_model(filename=temp_model_fn)
# and then try to add
self.assertRaises(mdig.modelrepository.RepositoryException,
m.add_model, temp_model_fn)
self.assertEqual(len(m.get_models()), 0)
# more tests about lifestage resources?
self.remove_mock_location(self.temp_dir)
self.assertEqual(len(m.get_models()), 0)
# Try to add a model from one repository to the empty one
try:
self.remove_mock_location(self.temp_dir)
except OSError, e:
stre = str(e)
if 'No such file' not in stre and \
'system cannot find the path specified' not in stre:
raise e
m2 = ModelRepository()
a_file = m2.get_models()['variables']
self.create_mock_location(self.temp_dir)
# Add location to model
dm = DispersalModel(a_file)
dm.set_location('grass_location')
temp_model_fn = "with_location_model.xml"
dm.save_model(filename=temp_model_fn)
m.add_model(temp_model_fn)
self.assertEqual(len(m.get_models()), 1)
m.remove_model('variables', force=True)
self.assertEqual(get_g.return_value.remove_mapset.call_args[0][0],
'variables')
os.remove(temp_model_fn)
self.assertRaises(mdig.modelrepository.RepositoryException,
m.remove_model, 'non_existant')
self.remove_mock_location(self.temp_dir)
def test_model_constructor(self):
dm = DispersalModel(the_action=RunAction())
dm = DispersalModel(the_action=RunAction(), setup=False)
def test_empty_model(self):
dm = DispersalModel()
self.assertEqual(dm.model_file, None)
# Check root xml node has been created
self.assertEqual(dm.xml_model.tag, "model")
def test_log_instance_times(self):
mdig.repository = ModelRepository()
models = mdig.repository.get_models()
fn = models['lifestage_test']
m = DispersalModel(fn)
m.log_instance_times()
def test_check_info(self): #, m_remove_map, m_copy_map):
m_fn = self.models['variables']
dm = DispersalModel(m_fn)
g = grass.get_g()
check_instances_have_info_file(dm.get_instances())
