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_do_me(self):
ea = actions.ExportAction()
fn = mdig.repository.get_models()['variables']
m = DispersalModel(fn)
ea.parse_options([])
self.assertRaises(SystemExit,ea.do_me,m)
ea.options.output_map_pack = True
ea.do_instance = Mock()
ea.do_me(m)
self.assertEqual(ea.do_instance.call_count, 6)
ea.do_instance.call_count = 0
ea.options.instances = [0]
ea.do_me(m)
self.assertEqual(ea.do_instance.call_count, 1)
ea.do_instance.call_count = 0
ea.options.instances = [1231]
self.assertRaises(SystemExit,ea.do_me,m)
ea.do_instance.call_count = 0
ea.options.instances = ['monkey']
self.assertRaises(SystemExit,ea.do_me,m)
ea.options.output_image = True
ea.do_instance = Mock()
ea.options.instances = None
ea.do_me(m)
self.assertEqual(ea.do_instance.call_count, 6)
m.remove_log_handler()
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_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 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_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 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_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_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 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 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 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 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_do_instance_map_pack(self,m_rm,m_g):
m_g.return_value.grass_vars = {}
ea = actions.ExportAction()
fn = mdig.repository.get_models()['variables']
m = DispersalModel(fn)
ea.parse_options([])
ea.export_map = Mock()
ea.zip_maps = Mock()
# TODO create replicates so this all works
#instances = m.get_instances()
ea.options.reps=[0]
# No replicates in a fresh model
#self.assertRaises(InvalidReplicateException,ea.do_instance_map_pack,instances[0])
#ea.do_instance_map_pack(instances[0])
m.remove_log_handler()
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 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 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 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_do_instance_images(self,m_rm,m_g):
m_g.return_value.grass_vars = {}
ea = actions.ExportAction()
fn = mdig.repository.get_models()['variables']
m = DispersalModel(fn)
ea.parse_options([])
ea.create_frame = Mock()
ea.create_gif = Mock()
# TODO create replicates so this all works
# instances = m.get_instances()
ea.options.reps=[0]
# No replicates in a fresh model
# self.assertRaises(InvalidReplicateException,ea.do_instance_images,instances[0])
# create mock replicate
#instances[0].replicates = [Mock()]
#instances[0].replicates[0].get_saved_maps.return_value = {'1':'xx','2':'yy'}
#instances[0].replicates[0].get_base_filenames.return_value = {'1':'xx','2':'yy'}
# ea.do_instance_images(instances[0])
m.remove_log_handler()
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_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_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 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_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)
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 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_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_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_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 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_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_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_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 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_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 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_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")
class DispersalInstanceTest(unittest.TestCase):
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 tearDown(self):
self.m_variables.remove_log_handler()
self.m_variables_complete.remove_log_handler()
self.m_lifestage.remove_log_handler()
self.m_strategy.remove_log_handler()
@patch('mdig.grass.get_g')
def test_load_replicates(self,m_g):
m_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
# replicates loaded on init
self.m_lifestage.get_instances()
self.m_strategy.get_instances()
self.m_variables.get_instances()
@patch('mdig.grass.get_g')
def test_get_mapset(self,m_g):
m_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_lifestage.get_instances()[0]
self.assertEqual(i.get_mapset().find('lifestage_test_i'), 0)
mapset = i.node.attrib['mapset']
del i.node.attrib['mapset']
self.assertRaises(mdig.instance.DispersalInstanceException,i.get_mapset)
i.node.attrib['mapset'] = mapset
@patch('mdig.grass.get_g')
def test_set_mapset(self,m_g):
m_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_lifestage.get_instances()[0]
i.set_mapset('blah')
self.assertEqual(i.node.attrib['mapset'], 'blah')
@patch('mdig.grass.get_g')
def test_add_envelope(self,m_g):
m_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_variables.get_instances()[0]
i._add_envelope('test_envelope','all',1)
e = i.node.find('envelopes')
self.assertEqual(len(e),1)
# second add doesn't have to init xml structure
i._add_envelope('test_envelope','all',1)
self.assertEqual(len(e),1)
@patch('mdig.grass.get_g')
def test_update_xml(self,m_g):
m_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_variables.get_instances()[0]
i.enabled = False
i.update_xml()
self.assertEqual(i.node.attrib['enabled'],'false')
i.enabled = True
i.update_xml()
self.assertEqual(i.node.attrib['enabled'],'true')
@patch('mdig.grass.get_g')
def test_update_occupancy_envelope(self,m_get_g):
m_get_g.return_value.occupancy_envelope.return_value = "test_env"
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_variables.get_instances()[0]
self.assertRaises(InstanceIncompleteException,i.update_occupancy_envelope)
i = self.m_variables_complete.get_instances()[0]
i.update_occupancy_envelope()
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args[0][0]), 2)
self.assertEqual(call_args[0][1], 'variables_complete_region_a_i0_ls_all_t_5_prob')
#check existing aborts
m_get_g.return_value.occupancy_envelope.call_args = []
i.update_occupancy_envelope()
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args), 0)
#check overwrite maps works
m_get_g.return_value.occupancy_envelope.call_args = []
i.update_occupancy_envelope(force=True)
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args[0][0]), 2)
self.assertEqual(call_args[0][1], 'variables_complete_region_a_i0_ls_all_t_5_prob')
@patch('mdig.grass.get_g')
def test_listeners(self,m_get_g):
m_get_g.return_value.occupancy_envelope.return_value = "test_env"
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
i = self.m_variables_complete.get_instances()[0]
class l:
count = 0
def occupancy_envelope_complete(self,i,l,t): self.count+=1
i.listeners = [ l() ]
i.update_occupancy_envelope()
self.assertEqual(i.listeners[0].count, 6)
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args[0][0]), 2)
self.assertEqual(call_args[0][1], 'variables_complete_region_a_i0_ls_all_t_5_prob')
@patch('mdig.grass.get_g')
def test_update_occupancy_env_strategy(self,m_get_g):
# test with strategy
m_get_g.return_value.occupancy_envelope.return_value = "test_env"
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
m_get_g.return_value.occupancy_envelope.call_args = []
# check with strategy
i = self.m_strategy.get_instances()[1]
self.assertTrue(i.strategy is not None)
i.update_occupancy_envelope(force=True)
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args[0][0]), 2)
self.assertEqual(call_args[0][1], 'management_area_combine_region_a_i1_ls_all_t_5_prob')
@patch('mdig.grass.get_g')
@patch('mdig.replicate.Replicate.get_saved_maps')
def test_update_occupancy_env_missing_maps(self,m_get_maps,m_get_g):
# test without rep maps
m_get_g.return_value.occupancy_envelope.return_value = "test_env"
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
m_get_g.return_value.occupancy_envelope.call_args = []
m_get_maps.return_value = {}
i = self.m_variables_complete.get_instances()[0]
self.assertRaises(mdig.instance.DispersalInstanceException,
i.update_occupancy_envelope,force=True)
call_args = m_get_g.return_value.occupancy_envelope.call_args
self.assertEqual(len(call_args), 0)
#import pdb;pdb.set_trace()
m_get_maps.return_value = {1:'test1',222:'test2'}
self.assertRaises(mdig.instance.DispersalInstanceException,
i.update_occupancy_envelope,force=True)
@patch('mdig.grass.get_g')
def test_str(self,m_get_g):
# test with strategy
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
# check with no strategy
i = self.m_strategy.get_instances()[0]
self.assertTrue(len(str(i)) > 0)
self.assertTrue(len(i.long_str()) > 0)
i.enabled = False
self.assertTrue(len(str(i)) > 0)
self.assertTrue(len(i.long_str()) > 0)
i.enabled = True
i.activeReps = [1]
self.assertTrue(len(str(i)) > 0)
self.assertTrue(len(i.long_str()) > 0)
i.activeReps = []
# check with strategy
i = self.m_strategy.get_instances()[1]
self.assertTrue(len(str(i)) > 0)
self.assertTrue(len(i.long_str()) > 0)
@patch('mdig.grass.get_g')
@patch('os.path')
@patch('os.remove')
@patch('shutil.move')
def test_add_analysis_result(self,m_shutil,m_remove,m_path,m_get_g):
m_path.basename.return_value = 'test'
m_get_g.return_value.grass_vars = {'GISDBASE':self.gisdb}
# check with no strategy
i = self.m_strategy.get_instances()[0]
analysis_cmd = Mock()
analysis_cmd.cmd_string = 'wibble'
analysis_cmd.output_fn = 'wibble'
# Test with file existing
i.add_analysis_result('all',analysis_cmd)
# Test with overwrite
config.get_config().overwrite_flag = True
i.add_analysis_result('all',analysis_cmd)
# run again to check parsing existing lifestage analysis results
i.add_analysis_result('all',analysis_cmd)
config.get_config().overwrite_flag = False
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())
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()
class ReplicateTest(unittest.TestCase):
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 tearDown(self):
self.m_variables.remove_log_handler()
self.m_variables_complete.remove_log_handler()
self.m_lifestage.remove_log_handler()
def test_create_w_no_node(self):
i = self.m_lifestage.get_instances()[0]
r = Replicate(node=None, instance=i)
# TODO check effects
def test_create_w_no_instance(self):
i = self.m_lifestage.get_instances()[0]
self.assertRaises(ValueError, Replicate, node=None, instance=None)
def test_check_complete_on_creation(self):
config.get_config()['replicate']['check_complete'] = 'true'
i = self.m_variables.get_instances()[0]
r = Replicate(node=None, instance=i)
config.get_config()['replicate']['check_complete'] = 'false'
def test_check_complete(self):
i = self.m_variables.get_instances()[0]
r = Replicate(node=None, instance=i)
self.assertFalse(r.check_complete())
i = self.m_variables_complete.get_instances()[0]
self.assertTrue(i.replicates[0].check_complete())
r = i.replicates[0]
r.get_saved_maps = mock_get_saved_maps
self.assertFalse(i.replicates[0].check_complete())
global get_save_count
get_save_count = 0
@patch('mdig.grass.get_g')
def test_delete_maps(self, get_g):
i = self.m_variables_complete.get_instances()[0]
i.replicates[0].delete_maps()
self.assertEqual(get_g.return_value.remove_map.call_count, 6)
get_g.return_value.remove_map.call_count = 0
i = self.m_lifestage.get_instances()[0]
r = Replicate(node=None, instance=i)
r.delete_maps()
self.assertEqual(get_g.return_value.remove_map.call_count, 0)
r.get_saved_maps = mock_get_saved_maps
r.delete_maps()
self.assertEqual(get_g.return_value.remove_map.call_count, 0)
global get_save_count
get_save_count = 0
@patch('mdig.grass.get_g')
def test_null_bitmask(self, get_g):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
r.null_bitmask()
self.assertEqual(get_g.return_value.null_bitmask.call_count, 6)
def test_map_name_base(self):
i = self.m_variables_complete.get_instances()[0]
name = i.replicates[0].get_map_name_base()
self.assertEqual('variables_complete_region_a_i0_rep_0', name)
name = i.replicates[1].get_map_name_base()
self.assertEqual('variables_complete_region_a_i0_rep_1', name)
i = self.m_variables_complete.get_instances()[1]
name = i.replicates[0].get_map_name_base()
self.assertEqual('variables_complete_region_a_i1_rep_0', name)
def test_get_base_filenames(self):
i = self.m_variables_complete.get_instances()[0]
# return a dictionary of time:names
img_fns = i.replicates[0].get_base_filenames()
self.assertEqual(len(img_fns), 6)
# return a single filename
img_fn = i.replicates[0].get_base_filenames(single_file=True)
self.assertTrue(
'variables_complete_region_a_i0_rep_0_ls_all' in img_fn)
def test_get_initial_maps(self):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
self.assertEqual(r.get_initial_map('all'), None)
r.initial_maps = self.m_variables.get_initial_maps(i.r_id)
self.assertNotEqual(r.get_initial_map('all'), None)
def test_reset(self):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
old_xml_node = r.node
r.reset()
self.assertNotEqual(old_xml_node, r.node)
def test_record_maps(self):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
r.grass_i = Mock()
r.record_maps()
r.active = True
r.temp_map_names['all'] = ['tmap1', 'tmap2']
r.record_maps()
self.assertEqual(r.grass_i.copy_map.call_count, 1)
r.record_maps(remove_null=True)
self.assertEqual(r.grass_i.copy_map.call_count, 2)
self.assertEqual(r.grass_i.null_bitmask.call_count, 1)
self.assertTrue('all' in r.get_previous_map('all'))
def test_previous_maps(self):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
maps = r.get_previous_maps('all')
self.assertEqual(maps, [])
maps.append('test1')
maps.append('test2')
maps = r.get_previous_maps('all')
self.assertEqual(len(maps), 2)
a_map = r.get_previous_map('all')
self.assertEqual(a_map, 'test2')
a_map = r.get_previous_map('all', 2)
self.assertEqual(a_map, 'test1')
a_map = r.get_previous_map('all', 3)
self.assertEqual(a_map, None)
r.push_previous_map('all', 'freaky')
a_map = r.get_previous_map('all')
self.assertEqual(a_map, 'freaky')
def init_mock_grass(self, g):
g.return_value.init_map.return_value = ('mockstring', Mock())
g.return_value.get_mapset.return_value = 'mock_mapset'
g.return_value.generate_map_name.return_value = 'tempmapname'
g.return_value.get_range.return_value = ['thisr=10'] * 10
g.return_value.raster_value_freq.return_value = [(1, 1), (2, 1),
(3, 1)]
g.return_value.raster_to_ascii.return_value = ('file1', 'file2')
@patch('mdig.lifestage.Lifestage')
@patch('mdig.grass.get_g')
def test_run(self, m_g, m_ls):
self.init_mock_grass(m_g)
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
r.grass_i = Mock()
r.instance.experiment.save_model = Mock()
r.run()
@patch('mdig.lifestage.Lifestage')
@patch('mdig.grass.get_g')
def test_run_w_lifestage(self, m_g, m_ls):
self.init_mock_grass(m_g)
i = self.m_lifestage.get_instances()[0]
r = i.replicates[0]
r.grass_i = Mock()
r.instance.experiment.save_model = Mock()
r.instance.experiment.get_lifestage_transitions = Mock()
r.instance.experiment.get_lifestage_transitions.return_value = [Mock()]
r.run()
@patch('mdig.lifestage.Lifestage')
@patch('mdig.grass.get_g')
def test_run_w_management(self, m_g, m_ls):
self.init_mock_grass(m_g)
i = self.m_management.get_instances()[1]
r = Replicate(None, i)
r.grass_i = Mock()
r.instance.experiment.save_model = Mock()
r.run()
@patch('mdig.lifestage.Lifestage')
@patch('mdig.grass.get_g')
def test_run_w_analysis(self, m_g, m_ls):
self.init_mock_grass(m_g)
m = self.m_analysis
i = m.get_instances()[0]
r = Replicate(None, i)
r.grass_i = Mock()
r.instance.experiment.save_model = Mock()
r.run()
# Run again to ensure
self.assertRaises(mdig.analysis.AnalysisOutputFileExists, r.run)
def test_get_time_stamp(self):
i = self.m_variables_complete.get_instances()[0]
r = i.replicates[0]
import time
import datetime
self.assertTrue(r.get_time_stamp() < datetime.datetime.now())
t = time.time()
r.node.attrib['ts'] = str(t)
self.assertEqual(r.get_time_stamp(),
datetime.datetime.fromtimestamp(float(str(t))))
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_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())
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_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_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_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()
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)
@patch('mdig.grass.get_g')
@patch('__builtin__.raw_input')
