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