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 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 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 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_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_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_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_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_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_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 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_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_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])
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))))
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())
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
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_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())
