示例#1
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])
示例#2
0
 def test_get_output_filename_base(self):
     ac = AnalysisCommand("test %1")
     mdig_config = config.get_config()
     spam = "woooo"
     old_base = mdig_config.analysis_filename_base
     mdig_config.analysis_filename_base = spam
     self.assertTrue(spam in ac.get_output_filename_base())
     mdig_config.analysis_filename_base = old_base
示例#3
0
    def test_constructor(self):
        ac = AnalysisCommand("testing %1 %2")
        self.assertEqual(ac.get_earliest_time(), 2)

        ac2 = AnalysisCommand("testing")
        self.assertEqual(ac2.cmd_string, 'testing')
        self.assertEqual(ac.start_time, 0)
        self.assertEqual(ac.output_fn, None)
示例#4
0
 def test_get_output_filename_base(self):
     ac = AnalysisCommand("test %1")
     mdig_config = config.get_config()
     spam = "woooo"
     old_base = mdig_config.analysis_filename_base
     mdig_config.analysis_filename_base = spam
     self.assertTrue(spam in ac.get_output_filename_base())
     mdig_config.analysis_filename_base = old_base
示例#5
0
    def test_constructor(self):
        ac = AnalysisCommand("testing %1 %2")
        self.assertEqual(ac.get_earliest_time(), 2)

        ac2 = AnalysisCommand("testing")
        self.assertEqual(ac2.cmd_string, 'testing')
        self.assertEqual(ac.start_time, 0)
        self.assertEqual(ac.output_fn, None)
示例#6
0
 def test_get_earliest_time(self):
     # Test that normal use works
     ac = AnalysisCommand("test %1")
     self.assertEquals(ac.get_earliest_time(), 1)
     # Test that no time in command works == 0
     ac = AnalysisCommand("test")
     self.assertEquals(ac.get_earliest_time(), 0)
     # Test that % can be escaped
     ac = AnalysisCommand("test %% %1")
     self.assertEquals(ac.get_earliest_time(), 1)
     # Test that earliest map is found
     ac = AnalysisCommand("test %1 %2 %19 %1")
     self.assertEquals(ac.get_earliest_time(), 19)
     # Test that future maps don't work
     ac = AnalysisCommand("test %-1")
     self.assertEquals(ac.get_earliest_time(), 0)
示例#7
0
 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)
示例#8
0
    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)
示例#9
0
    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)
示例#10
0
 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)
示例#11
0
 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)
示例#12
0
 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)
示例#13
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)
示例#14
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])
示例#15
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)
示例#16
0
 def test_get_earliest_time(self):
     # Test that normal use works
     ac = AnalysisCommand("test %1")
     self.assertEquals(ac.get_earliest_time(), 1)
     # Test that no time in command works == 0
     ac = AnalysisCommand("test")
     self.assertEquals(ac.get_earliest_time(), 0)
     # Test that % can be escaped
     ac = AnalysisCommand("test %% %1")
     self.assertEquals(ac.get_earliest_time(), 1)
     # Test that earliest map is found
     ac = AnalysisCommand("test %1 %2 %19 %1")
     self.assertEquals(ac.get_earliest_time(), 19)
     # Test that future maps don't work
     ac = AnalysisCommand("test %-1")
     self.assertEquals(ac.get_earliest_time(), 0)