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